java零基础 kotlin java零基础入门

JAVA零基础入门基础知识整理

• 语言基础：

• 1.java开发环境
• 2.变量
• 3.运算符
• 4.分支结构
• 5.循环结构
• 6.数组
• 7.方法：

• 五要素

• 面向对象

• 1.类和对象
• 2.方法的重载
• 3.构造方法
• 4.this
• 5.引用类型数组
• 6.继承
• 7.super
• 8.向上造型
• 9.方法的重写
• 10.package和import
• 11.访问控制修饰符
• 12.static:静态的
• 13.final：最终的，不可改变的
• 14.static final常量
• 15.抽象方法
• 16.抽象类
• 17.成员内部类
• 18.匿名内部类
• 19.接口
• 20.多态
• 21.内存管理
• 22.面向对象总结
• 23.String入门
• 24.String常用方法：
• 25.StringBuilder类：

语言基础：

1.java开发环境

java是一款开源跨平台的编程语言

• JVM：称为java虚拟机，加载并运行.class字节码文件
• JRE：java运行环境 ，JRE=JVM+java系统类库
• JDK：java开发工具，JDK=JRE+编译命令等开发工具

2.变量

可以改变的量称为变量
八种基本类型：

• baye：短整型，适用于整数，范围-128–127，1字节。
• short：短整型，适用于整数，范围-32768–32767，2字节。
• int：整型，适用于整数，范围-21个多亿–21个多亿（2^31）,4字节。
• long：长整型，适用于整数，范围-（2^63）–(263)-1,8字节。
• float：单精度浮点数，适用于小数，但精度方面不足，范围很大，4字节。
• double：双精度浮点数，适用于小数，大概是flout精度的2倍，范围非常大，8字节。
• boolean：布尔型，输出结果只能为ture或false，1字节。
• char： 字符型，采用unicode字符，编码格式用单引号表示，2字节

类型之间的转换：
baye–>short–>char–>int–>long–>float–>double
从小到大，系统自动进行类型之间转换
从大道小，需要强制类型转换。（发生强制类型转换时，注意发生范围溢出）

注1：整数直接量直接给baye，short，char赋值即可。
注2：baye，short，char型进行运算时，系统会自动进行转换int操作。

3.运算符

算数运算符：+，-，*，/，%  (加，减，乘，除，取余)
    比较运算符：>,<,>=,<=,==   (大于，小于，大于等于，小于等于，相等)
    逻辑运算符：||,&&,!=       (或，且，非) 
         赋值：=，+=，-=，*=，/=，%=
    字符串连接：+
      条件三目：boolean ？数1：数2 （true时输出数1，false时输出数2）

4.分支结构

• if语法结构：

• 单路分支：if（条件） {语句块}；
• 双路分支：if（条件） {语句块1}else{语句块2}；
• 多路分支：

• if（条件1）{语句块1}else if(条件2){语句块2}else{语句块3};
  ……
• switch（整数条件）{（整数条件是为了选择一个入口进入，然后一直执行到底）
  case0：语句
  case1：语句
  case2: 语句 }

5.循环结构

• 循环三要素：
  循环变量初始化，循环条件，循环变量的改变

• for循环：

• 语法：
  for（初始化；条件；改变）{语句块循环体}

• while循环：

• 语法：
  while（boolean）{语句块循环体}

• do……while循环：

• 语法：
  do{循环体}while（boolean）

关键字： break：跳出循环（仅跳出当前循环）
continue：跳过循环体中剩余部分进入下一次循环。
嵌套循环：循环中套循环（外层走一次，内层走全部）

6.数组

数组是一种引用类型 相同数据类型的集合称为数组

• 数组的创建：
  int[] a = new int[5];
  int[] a = {1,2,3,4,5};
• 数组的遍历：
  for(int i=0;i<a.length;i++){System.out.println(a[i])};
• 用字符串输出查看数组内容：
  import java.util.Arrays;
  System.out.println(Arrays.toString(a));
• 数组的扩容与缩减：
  import java.util.Arrays;
• 扩容：
  int[] a = new int[5];
  a=Arrays.copyof(a,a.length+1);
• 缩减：
  a=Arrays.copyof(a,a.length-1);

7.方法：

五要素

• 定义方法：
  修饰词 返回值类型 方法名（参数列表）{方法体}
• 方法的调用：
  无返回值：方法名（有参传参）
  有返回值：数据类型变量 = 方法名（有参传参）
  方法的结束：
  return； 结束方法的执行；
  return 返回值； 结束方法并返回值；

面向对象

1.类和对象

• 定义：

• 类：类型，代表一个类的整体。
• 对象：软件中真实存在的单个个体/东西。
• 关系：类是对象的模子，对象是类的具体的实例。

• 类中可以包含：

• 对象的属性/特征------成员变量
• 对象的行为/动作------方法
• 一个类可以创建多个对象

2.方法的重载

• 定义：
  发生在同一类中，方法名相同，参数列表不同。
  编译器在编译时会根据方法名的签名自动绑定方法。

3.构造方法

• 定义：
  与类同名，没有返回值类型（连void都没有）
• 作用：给成员变量赋初始值。

注：在创建（new）对象时被自动调用
若自己没有写构造方法，则编辑器默认提供一个无参构造方法；
若直接写了构造方法，则不在默认提供。

4.this

• this：指代当前对象，哪调用就指哪。

• 用法：this.成员变量名------访问成员变量

注：当成员变量名与局部变量名一样时，若想访问成员变量，则this不能省略）
解释成员变量与局部变量：
成员变量：写在类中，方法外……有默认值。
局部变量：写在方法中……………没有默认值。

5.引用类型数组

引用类型数组与基本类型数组的区别：
给数组元素赋值必须new一下。
若想访问对象数据必须通过数组元素打点。

6.继承

• 作用：实现代码复用。
• 使用方法：通过extends来实现继承
• 超类：共有的属性和行为。
• 派生类：特有的属性和行为。

解释说明：
1）派生类既可以访问自己的也可以访问超类的，但超类不能访问派生类的。
2）一个超类可以有多个派生类，一个派生类只能有一个超类。—单一继承原则
3）超类和派生类----具有传递性。
4）java规定：构造派生类之前必须先构造超类。

7.super

• super：指代当前对象的超类对象
• 用法：
  1）super.成员变量名--------访问超类的成员变量
  2）super.方法名（）--------调用超类方法
  3）super（）---------------调用超类的构造方法

注：
1.在派生类的构造方法中若没有调用超类的构造方法，则默认super（）调用超类的无参构造方法。
在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供
2.super（）调用超类构造方法，必须位于派生类构造方法的第一行

8.向上造型

• 超类型的引用指向派生类的对象。
• 能点出来什么，看引用的类型。

9.方法的重写

• 定义：发生在父子类中，方法名相同，参数列表相同。
  重写遵循"两同两小一大"原则
  两同：
  1）方法名相同
  2）参数列表相同
  两小：1）派生类方法的返回值类型小于或等于超类方法的
  1.void和基本类型时，必须相等
  2.引用类型时，小于或等于

派生类方法抛出的异常小于或等于超类方法抛出的异常。

一大：派生类方法的访问权限大于或等于超类方法的访问权限。

10.package和import

package：声明包

避免类的命名冲突；同包中的类不能同名，但不同包中的类可以同名；
类的全称：包名.类名；
包中常常用层次结构，建议所有字母小写
import：导入类
同包中的类可以直接访问，不同包中的类不能直接访问；
若想访问：先import声明类，在访问类

11.访问控制修饰符

• 作用：保护数据的安全。
• public：公开的，任何类
• protected：受保护的，本类，派生类，同包类
• 默认的：什么也不写，本类，同包类
• private：私有的，本类

解释说明：
—类的访问权限只能是public或默认
—类中成员的访问权限如上4中都行
—访问权限由高到低依次是：
public->protected->默认->private

12.static:静态的

• 静态变量：由static修饰；属于类，存储在方法区，只有一份；常常通过类名点来访问。
• 静态方法：由static修饰；属于类，存储在方法区，只有一份；常常通过类名点来访问，静态方法中没有隐式this传递，不能直接访问实例变量。
• 静态块：由static修饰；属于类，在类被加载期间自动执行，一个类只被加载一次，
  所以静态块只执行一次。

13.final：最终的，不可改变的

• 修饰变量：变量不能被更改。
• 修饰方法：方法不能被重写。
• 修饰类：类不能被继承。

14.static final常量

• 必须声明同时初始化。
• 类名点来访问，不能被改变

建议：
常量名所以字母都大写，多个单词用_分隔
编译器在编译时会将常量直接替换为具体的数，效率高。
何时用：数据永远不变，并且经常使用。

15.抽象方法

由abstract修饰；只有方法的定义没有具体的实现（连{}都没有）

16.抽象类

• 由abstract修饰；
• 包含抽象方法的类必须是抽象类
• 抽象类不能被实例化（new对象）；
• 抽象类是需要被继承的—派生类–重写所以抽象方法–变不完整为完整
  –也声明为抽象类
• 抽象类的意义：

• 封装共有的属性和行为----代码复用
• 为所有派生类提供统一的类型----向上造型
• 可以包含抽象方法，为所有派生类提供统一的入口（能点出来）
• 派生类的行为不同，但入口是一致的，同时相当于定义了一个标准（强制重写）

17.成员内部类

• 类中套类，外面的称为外部类，里面的称为内部类；
• 内部类通常只服务于外部，对外不具备可见性；
• 内部类对象通常是在外部类中创建的；
• 内部类中可以直接访问外部类的成员（包括私有的）。

18.匿名内部类

大大简化代码
若想创建一个类(派生类)的对象，并且对象只创建一次，建议做匿名内部类。
匿名内部类默认外面的变量是final的。
每一个类都有独立的.class字节码文件。

19.接口

是一种引用数据类型，由interface定义，只能包含常量和抽象方法，
接口不能被实例化(new对象)，接口是需要被实现/继承的。
实现类/派生类：必须重写所有抽象方法；一个类可以实现多个接口，用逗号分隔，
若又继承又实现时，应先继承后实现；接口可以继承接口。
接口的意义：实现多继承；制定了一套标准、规则。

20.多态

• 意义：
  同一类型的引用指向不同的对象时，有不同的实现–所有抽象方法都是多态的
  同一个对象被造型为不同的类型时，有不同的功能–所有对象都是多态的
  向上造型/自动类型转换：超类型的引用指向派生类的对象；能点出来什么，看引用的类型；
  能造型成为的数据类型有：超类+所实现的接口；
• 关系：
  类和类-------继承extends
  接口和接口—继承extends
  类和接口-----实现implements

注： （强制类型转换，成功的条件：引用所指向的对象；引用所指向的对象，实现了该接口或继承了该类
强转时若不符合条件，则发生ClassCastException类型转换异常；建议在强转之前先通过instanceof判断引用的对象是否是该类型）

21.内存管理

由JVM来管理

• 堆：存储new出来的对象(包括实例变量)
• 垃圾：没有任何引用所指向的对象；
• 垃圾回收器(GC)不定时到内存中清扫垃圾，回收过程是透明的(看不到的)，
  不一定一发现垃圾就立刻回收，通过调用System.gc()可以建议JVM尽快调度GC回收。
• 实例变量的生命周期：

• 创建(new)对象时存储在堆中，对象被回收时一并被回收。
• 内存泄漏：不再使用的对象没有被及时的回收，严重的泄漏会导致系统的崩溃。
  注：（建议：不再使用的对象应及时将引用设置为null）
• 栈：存储正在调用的方法中的局部变量(包括方法的参数)。
  调用方法时，会在栈中为该方法分配一块对应的栈帧，
  栈帧中存储局部变量(包括方法的参数)，方法调用结束时，
  栈帧被自动清除，局部变量一并被清除。
• 局部变量的生命周期：调用方法时存储在栈中，方法调用结束时与栈帧一并被清除。
• 方法区：存储.class字节码文件(包括静态变量、所有方法)；方法只有一份，通过this来区分具体的访问对象。

22.面向对象总结

• 面向对象三大特征：
  1）封装：
  类：封装的是对象的属性和行为。
  方法：封装的是具体的业务逻辑功能实现。
  访问控制修饰符：封装的是具体的访问权限，以保护数据的安全。
  2）继承：
  作用：代码复用。
  超类：所有派生类所共有的属性和行为。
  接口：部分派生类所共有的属性和行为。
  派生类：派生类所特有的属性和行为。
  单一继承、多接口实现，具有传递性。
  3）多态：
  行为多态：所有抽象方法都是多态的(通过方法的重写实现的)
  对象多态：所有对象都是多态的(通过向上造型来实现)
  向上造型、强制类型转换、instanceof判断

23.String入门

String：字符串类型；
java.lang.String使用final修饰，不能被继承。
java中的String在内存中采用Unicode编码方式，任何一个字符占用两个字节的编码。
字符串底层封装的是一个字符数组。
字符串一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值—不变对象。

24.String常用方法：

• ength()：获取字符串的长度(字符个数)
• trim()：去除当前字符串两边的空白字符。
• toUpperCase()和toLowerCase()：将当前字符串中的英文部分转为全大写/全小写。
• startsWith()和endsWith()：判断当前字符串是否是以给定的字符串开始/结尾的。
• charAt()：返回当前字符串指定位置上的字符—根据下标找字符。
• indexOf()和lastIndexOf()：检索给定字符串在当前字符串中的开始位置—根据字符串找位置。
• substring()：截取当前字符串中指定范围内的字符串。
• String的静态方法valueOf()：将其它数据类型转换为String。

25.StringBuilder类：

由于String是不变对象，每次修改内容要创建新对象，因此String不适合做频繁修改操作，
为了解决这个问题，java提供了StringBuilder类。
StringBuilder是专门用于修改字符串的一个API，内部维护一个可变的char数组，
修改都是在这个数组上进行的，修改速度、性能优秀，并且提供了修改字符串的常见的方法：增、删、改、插。

• StringBuilder常用方法：

• append()：追加内容
• replace()：替换部分内容
• delete()：删除部分内容
• insert()：插入内容
• reverse()：翻转内容