-- 基础 --

操作

• 注释：单行// 多行/* */ 文档注释/** */
• 变量声明:
  数据类型 identifier [ = value][, identifier [= value] ...] ;
var identitifier = value（var声明会自动判断数据类型, >java 10）
• 常量声明: final identifier [ = value][, identifier [= value] ...] ;
• 类型转换: (数据类型)数据
  浮点数->整数 舍弃小数 而非四舍五入
  字符->数字 使用ascii码对应数字
• 自动类型转换:
  运算时不同类型数据先转化为同一类型，然后进行运算(boolean 引用类型 无法转换)
  byte,short,char—> int —> long—> float —> double (转换从低级到高级)
• 循环:

while( 布尔表达式 ) {
//循环内容 
}
-- -- -- -- -- -- -- -- --
do {
       //代码语句
}while(布尔表达式);
-- -- -- -- -- -- -- -- --
for(初始化; 布尔表达式; 更新) {
//代码语句 
}
-- -- -- -- -- -- -- -- --
>=java5
for(声明语句 : 表达式) { //类似于foreach 
//声明语句声明新的局部变量，该变量的类型必须和数组元素的类型匹配,其作用域限定在循环语句块，其值与此时数组元素的值相等
//表达式是要访问的数组名，或者是返回值为数组的方法
//代码句子 
}
-- -- -- -- -- -- -- -- --
break 跳出最里层的一层循环
continue 跳转到下一次循环

• 条件语句

if(布尔表达式 1){ 
//如果布尔表达式 1的值为true执行代码 
}else if(布尔表达式 2){ 
//如果布尔表达式 2的值为true执行代码 
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码 
}else { 
//如果以上布尔表达式都不为true执行代码 
}
-- -- -- -- -- -- -- -- --
switch(expression){ 
    case value : 
    //语句 
    break; //可选,若没有break,会执行后面的case语句
    case value : 
    //语句 
    break; //可选,若没有break,会执行后面的default语句
    //你可以有任意数量的case语句 
    default : //可选 
    //语句 
}

概念

• 基本数据类型: byte short int long float double boolean char
  byte: 8位, 有符号, 默认值为0 -128(-2^7) ->127(2^7-1)
  short: 16位, 有符号, 默认值为0 -32768(2^15-1) -> 32767(2^15-1)
  int: 32位, 有符号, 默认值为0 -2^31 -> 2^31-1
  long: 64位, 有符号, 默认值为0L -2^63 -> 2^63-1
  float: 32位, 单精度, 默认值为0.0f
  double: 64位, 双精度, 默认值位0.0d
  boolean: 只有true和flase两个值, 默认值为false
  char: 储存单一16位Unicode字符, 默认值为 'u0000'
  注: long的值后面要加上l/L, float后要加上f/F, double后要加上d/D
注:整数的默认类型是int,小数默认是double
  声明但未初始化的变量的值为默认值，声明但未初始化的数组的元素值为默认值
• 引用类型: 对象 数组 (默认值为null)
• 传递：
  基本数据类型是值传递，
  引用类型变量传递的为本身的副本，但副本也指向同一个对象，本质也为值传递
  （Java中其实还是值传递的，只不过对于对象参数，值的内容是对象的引用）
• 变量: 局部变量 实例变量(非静态变量) 类变量(静态变量) 参数变量(即形参)
  局部变量: 在方法, 构造方法 或 语句块 中定义的变量
  在声明的方法、构造函数 或 块 执行结束后被销毁
  局部变量在声明时需要初始化，否则会导致编译错误
  实例变量: 声明在类中, 方法、构造函数 或 块之外的变量,
  在创建对象的时候实例化, 实例变量值不共享, 可被类中方法、构造方法 和 特定类的语句块 访问
  可不初始化, 会被赋予相关数据类型的默认值
  类变量: 类变量也声明在类中，方法、构造函数 或 块之外，但必须声明为 static 类型
  同一个类的所有实例共享同一个类变量的值, 可被类中方法、构造方法 和 特定类的语句块 访问
  可不初始化, 会被赋予相关数据类型的默认值
• 修饰符:
  default(即什么也不写): 在同一包内可见
  使用对象：类、接口、变量、方法
  private : 在同一类内可见
  使用对象：变量、方法  注意：不能修饰类（外部类）
  public : 对所有类可见
  使用对象：类、接口、变量、方法
  protected : 对同一包内的类和所有子类可见
  使用对象：变量、方法 注意：不能修饰类（外部类）
• final关键字：
  可使用对象：变量（包括类属性、对象属性、局部变量和形参）,方法（包括类方法和对象方法）和类
  修饰类：类不能被继承
  修饰方法：方法不能被子类重写
  修饰变量：定义常量
• static关键字：
  可使用对象：类属性 类方法 代码块 import导入 内部类
  修饰类属性(静态变量)：使属性属于类，可通过类名直接访问，该类创建的所有实例共享该变量的值
  修饰方法(静态方法)：可通过类名直接访问，在静态方法中只能访问静态成员，且无法使用this关键字，直接用对应名称即可(可以通过实例来访问静态方法，但不推荐)
  修饰代码块(静态代码块)：用于初始化静态变量，在类加载时执行一次(会在任何静态方法或静态变量被访问之前执行), 且无法使用this关键字，直接用对应名称即可
  修饰import：可导入特定/全部的静态成员
  修饰内部类：使内部类可以访问外部类的静态变量与静态方法
• instanceof运算符
  ( Object reference variable ) instanceof (class/interface type)
  若运算符左侧变量所指的对象, 是操作符右侧类或接口(class/interface)的一个对象, 那么结果为真

源文件

• 源文件与类: 文件中只能有一个public类(且该类的名称与文件要相同)，可以有多个非public类
• 源文件程序开始：java都从文件的 public 类的main方法开始执行
• 源文件编译: javac 文件名 编译后生成 .class 文件, 时 java 的字节码文件
• 源文件执行: java 文件名
• 命令行参数：储存在args[]数组中, 使用args[]以调用

类与对象

• 创建类: [修饰符] class 类名{}
• 继承:
  [修饰符] class 类名 extends 要继承的类名{}
[修饰符] class 类名 implements 接口,... { }
  特点: 不支持多继承, 一次只能继承一个类(用extends), 但可做到多继承接口(用implements)
  特点: 继承父类非private的属性和方法
  特点: 所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承 Object
  特点：不会继承父类的构造方法，但调用子类构造函数时，会自动调用父类的无参数构造方法，再执行子类构造方法的内容，若在子类构造函数中用super()关键词，可改变所调用的父类的构造方法与调用的时间
• 构造方法：
  名字：必须与类同名
  特点：创建对象时，若没有显式地定义构造方法，编译器将会为该类提供一个默认的构造方法
  构造方法链: 可在构造方法中用this(参数)来调用其它构造方法, 使得创建对象时使用多个构造方法
• 方法重载: 同一个类中可设定多个同名方法, 但形参列表不同(数据类型 顺序或数量不同), 访问方法时会根据传入的实参(数据类型 顺序或数量)来自动判断运用哪个方法（类的方法也可在子类中被重载）
• 方法重写: 在方法前一行加上@Override,子类中可重新定义继承自父类的同名方法
  条件: 方法名相同 参数列表相同 返回类型必须相同或为父类返回类型的子类型(<=java5) 返回值可以不同(>=java7)
  访问修饰符不能比父类方法更严格 不能抛出比父类方法更广泛的检查异常
  final方法不能被重写，static方法无法被重写但能被再次声明
  无法重写构造方法(因为不会继承构造方法)
• 父类引用指向子类对象: 父类名 变量1 = new 子类();
  特点: java 中可以用 父类 引用指向 子类对象, 也可以指向子类的子类 ...
  特点:使得 可以通过该引用 访问 子类从父类继承的 成员变量 与 方法, 而不能访问子类特有的 成员变量 与 方法
  特点: 对于被子类重写后的方法, 通过该引用 访问的是 重写后的方法
  特点: 可通过 子类名 变量2 = (子类名)变量1; 来再将类型变回子类引用
• super关键字：在方法重载的方法中使用super(实参)可调用被重写的父类的方法
• 访问类: this.成员 引用当前对象的成员
• 实例化: 类名 变量 = new 类名(形参)
• 访问实例: 实例变量.成员
• 抽象类/方法: 通过在类/方法的定义前(修饰符后)加上 abstract 关键词以声明
  抽象类特点: 抽象类 不能用 new 创建对象(实例化), 必须被继承, 才能被使用
  抽象类的方法: 抽象类 中可以有 构造方法 正常方法 与 抽象方法
  抽象方法特点: 抽象方法不包含方法体(即没有花括号即其内的内容), 且只能存在于 抽象类中, 构造方法 与 类方法 不能声明为 抽象方法
  抽象方法的实现: 抽象方法所在抽象类的子类 必须为 抽象类 或 重写了所有从 父类继承来的抽象方法(抽象方法的实现)
• 多态: 概念, 同一个接口, 使用不同的实例而执行不同操作(功能), 常用 继承 重写 父类引用指向子类对象 接口 抽象类/方法 来实现
• 封装: 概念, 将对象的 成员变量 私有化(private), 在对象外部通过公共(public)方法访问 这些成员变量

方法

• 定义: [修饰符] 返回值类型 方法名(参数数据类型 形参名){方法体}
[修饰符] abstact 返回值类型 方法名(参数数据类型 形参名) (抽象方法)
  返回值类型写 void 表示无返回值
• 可变参数(JDK>=1.5): 在指定参数类型后加一个省略号(...)
  限制: 一个方法中只能指定一个可变参数，且它必须是方法的最后一个参数
  特点: 可变参数意味着调用该方法时可传入符合数据类型 零个或多个实参, 而形参会变为储存所有实参值的数组

接口

• 声明: [修饰符] interface 接口名{接口体}
• 特点:
  接口与抽象类 类似, 接口内也能定义方法, 接口是抽象的, 不能实例化对象, 并且也没有构造方法
  接口是 隐式 抽象的, 无需使用 abstract 关键字
• 方法:
  接口内的方法 都会被 隐式地 指定为 public abstract
  不能显示地指定 public abstract 以外的方法
  java>8 后, 可以使用 default 显式地定义非抽象的方法
• 成员变量(字段):
  接口内的变量 都会被 隐式地 指定为 public static final
  不能显示地指定 public static final 以外的变量
• 接口的实现:
  接口由类来实现, 类通过继承的方式来实现接口
  类实现接口时, 必须实现接口中的所有方法 或者 声明为抽象类
• 继承: [修饰符] interface 接口名 [extends 其它接口名,...]{接口体}
  接口可以同时继承多个接口
• 特点
  类在实现接口的方法时, 不能抛出强制性异常, 只能在接口中, 或者继承接口的抽象类中抛出该强制性异常
  一个类可以同时实现多个接口, 但只能继承一个类

包装类

• 作用: 为方便, 有时我们需要使用对象, 而不是内置数据类型, 而Java 语言为每一个内置数据类型提供了对应的包装类, 使得可以将基础数据类型的值转化为对象
• 使用(装箱): 将基础数据类型的值转化为对象
  包装类 变量 = new 包装类(基础数据类型的值) 基础操作
  var 变量 = new 包装类(基础数据类型的值) 会自动判断数据类型
  包装类 变量 = 基础数据类型的值 会自动转化为对象
• 使用(拆箱): 将对象转化为基础数据类型的值
  基础数据类型 变量 = 对象 基础操作

包装类 与对应 基础数据类型
Byte-byte   Short-short  Integer-int  Long-long  
Float-float  Double-double  Boolean-boolean  Character-char

• 包装类 Integer Long Byte Double Float Short 是抽象类 Number 的子类, Number 类属于 java.lang 包
• Number 类及子类使用方法是直接 类.方法() 无需加入参数, 而 Math 类使用方法 是 Math.方法(数值)

包

• 包名(全限定名): 包名通常使用小写字母, 并使用点号分隔, 包名通常与目录结构对应(包括内部包和外部包)
• package 语句: 声明类所在的包, 若使用, 它应该是 Java 源文件中的第一个语句（除了注释）
• import 语句: 导入其他包中的类, 使得可以在当前文件中使用这些类而不需要写出它们的完全限定名
  import 包名.类名,... 导入类 import 包名.* 导入所有类
  import 语句，应该放在 package 和类定义之间, 没有 package，那么 import 应该在最前面
  只能引入编译后的 .class 文件
• 系统包
  java.lang - 基础的类
  java.io - 包含输入输出功能的函数
• 路径: 类目录的绝对路径叫做 class path, 设置在系统变量CLASSPATH中
  编译器和 java 虚拟机通过将 package 名字加到 class path 后来构造 .class 文件的路径
• 注意: import 和 package 对源文件中定义的所有类都有效,同一源文件中,不能给不同的类不同的包声明

反射

• 介绍: 反射提供了一种动态操作类的能力, 允许程序在运行时查询 访问和修改类 接口 字段和方法的信息
• 核心类与接口
  java.lang.Class: 表示类的对象, 提供了方法来获取类的字段 方法 构造函数
  java.lang.reflect.Field: 表示类的属性, 提供了访问和修改字段的能力
  java.lang.reflect.Method: 表示类的方法, 提供了调用方法的能力
  java.lang.reflect.Constructor: 表示类的构造函数, 提供了创建对象的能力
  注: Java 默认自动导入 java.lang 包, 但不会自动导入 java.lang.reflect 包
• java.lang.Class
  简介: 每个类都有一个 Class 对象, 通过 类.class 或 实例对象.class 或 Class.forName(类的全限定名) 来获取
  getFields()：获取所有公共字段
  getDeclaredFields()：获取所有声明的字段，包括私有字段 (返回的是 Field 对象)
  getMethods()：获取所有公共方法 (返回的是 Method 对象)
  getDeclaredMethods()：获取所有声明的方法，包括私有方法
  getConstructors()：获取所有公共构造函数(返回的是 Constructor 对象)
  getDeclaredConstructors()：获取所有声明的构造函数，包括私有构造函数
  getSuperclass()：获取类的父类
  getInterfaces()：获取类实现的所有接口
• java.lang.reflect.Field
get(Object obj)：获取指定对象的字段值
  set(Object obj, Object value)：设置指定对象的字段值
  getType()：获取字段的数据类型
  getModifiers()：获取字段的修饰符（如 public、private）
  getName(): 获取字段的名称
  setAccessible(boolean flag): 将此反射对象的可访问性标志设置为指定的布尔值, 为 true 时, 允许访问私有字段, 为 false 时，恢复正常的访问控制
• java.lang.reflect.Method
invoke(Object obj, Object... args)：调用指定对象的方法
  getReturnType()：获取方法的返回类型
  getParameterTypes()：获取方法的参数类型
  getModifiers()：获取方法的修饰符（如 public、private）
• java.lang.reflect.Constructor
newInstance(Object... initargs)：创建一个新实例，使用指定的构造函数参数
  getParameterTypes()：获取构造函数的参数类型
  getModifiers()：获取构造函数的修饰符（如 public、private）

String 类 与 字面量字符串

• 字面量字符串: String 变量 = "字符串内容"
• String类: String 变量 = new String("字符串内容")
• 共同点: 两种字符串都是对象, 且都一旦创建就无法改变, 相关方法只是生成新的对象
• 区别: 字面量字符串 在 编译期 被当做对象放入公共池(相同的字面量字符串会被当成同一个对象), 而String 类会在创建时建立在堆上(每个都是不同的对象)
• 多行字面量字符串：使用"""内容""", 多行字符串每行行首会去掉等量的空格，去掉的量以行首空格数最少的一行为准，末尾会加上\n
• 字符串连接：使用+号连接

StringBuffer类 与 StringBuilder类

• 特点: 可以对 其对象本身 进行修改, 而不是产生新的对象
• 区别: StringBuilder 的方法不是线程安全的（不能同步访问）
  由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类

数组 与 Arrays 类

• 声明：数据类型[] 数组变量;或数据类型 数组变量[];
• 初始化：数组变量 = new 数据类型[大小]; 数组变量 = {值1,...};
  声明与初始化可以用一句话完成, 两个[]可定义二维数组
• Arrays类初始化: 数组变量 = new Arrays(数组);
• 区别: Arrays类有许多方便的方法

Object 类

• 简介: Object 类是所有类的父类, 只要类没有明确继承一个父类, 该类就会自动继承 Object
• 位置: Object 类位于 java.lang 包中

系统方法

Object 类方法

Number & Math 类方法

Character 方法

String

StringBuffer类 与 StringBuilder类

• 两个类的方法相同

Arrays 类