JavaSE（一）

前言

java基础(Java SE)。【自用】
在线中文文档

---

一、基础奠基

1、JDK、JRE

1. JDK，全称叫Java开发工具包，jdk=jre+java的开发工具【java，javac等】。
2. JRE，全称叫Java运行环境，jre=jvm+Java的核心类库。
   注：若想运行一个开发好的Java程序，只需要jre即可。每个包 包含类、接口、异常、枚举。

---

2、配置环境变量path

1. 我的电脑–属性–高级系统配置–环境变量
2. 增加JAVA_HOME环境变量
3. 编辑path环境变量，增加%JAVA_HOME%\bin
4. 打开DOS命令行，任意目录下输入javac，出现javac的参数信息，配置成功。

---

3、初始代码

1. 编译：javac xxx.java
2. 运行：java xxx（主类）

public class Test {
    public static void main(String[] args) {
        System.out.println("hello world!");
    }
}

---

4、java文档注释

javadoc -d 文件夹名 -xx -yy xxx.java 【文件夹名：生成的地方 -xx：选择生成的属性】
例：javadoc -d e://demo -author -version Test.java

---

5、快捷键

1. 整体右移 table
2. 整体左移 shift table
3. 查看当前目录内容 dir
4. 切换盘符 cd xx
5. 切换到上一级 cd …
6. 切换到根目录 cd \
7. 清屏 cls
8. 退出 exit

---

二、基本构成

1、数据类型

• 注意：（两数相减小于xxx即可认为两数相等。）

  double num1 = 8.1 / 3;
  System.out.println(num1);
  // 输出2.6999999999999997
  

• char底层其实是数字，存储时是按照数字的二进制存的，输出时会找数字对应的编码表，输出字符。
• (byte、short) 和 char之间不会相互自动转换。
• byte、short、char 三者之间可以计算但计算时会先转换为int类型。(只要有其中一个即可。)
• 自动提升原则：表达式结果的类型会自动提升为操作数中最大的类型。

1.1、基本数据类型和String类型转换

1. 基本数据类型转String类型
   基本类型+“”
2. String类型转基本数据类型
   通过基本数据类型的包装类调用parseXX方法。
   - Integer.parseInt(“xxxx”);
   - Double.parseDouble(“xxx”);
   - Float.parseFloat(“xxx”);
   - " ".charAt(xxx);【String转字符类型】

2、运算符

2.1、算数运算符

• % 的本质，用公式计算是： a%b = a - a / b * b 【最后结果的符号和除数的符号保持一致。】

2.2、关系运算符

2.3、逻辑运算符

• 逻辑与(或)和短路与(或)用法一样，但短路与(或)可能存在短路现象，短路会先判断第一个，若不正确则直接结束，不再判断第二个。

2.4、赋值运算符

2.5、三元运算符

语法：条件表达式？表达式1 ：表达式2;
若表达式为true，运算结果为表达式1，否则为表达式2。

2.6、运算符优先级

• 上表优先级由高到低。

3、输入类

		Scanner scanner = new Scanner(System.in);
        String name = scanner.next();
        int number = scanner.nextInt();

4、位运算(补码运算和二进制)

• 按位与【&】
• 按位或【|】
• 按位异或【^】
• 按位取反【~】(符号位也变。)
• 算术左移【>>】
• 算术右移【<<】
• 逻辑右移【>>>】(无逻辑左移即<<<)

---

三、基础语法

1、分支控制

if(条件表达式){
     代码块;
}else {
     代码块;
}

---------------------------------------

if(条件表达式){
      代码块;
}else if (条件表达式){
      代码块;
}else {
      代码块;
}

---------------------------------------

switch (表达式){//表达式返回值必须是：byte、short、int、char、enum、String
    case 常量: //不能是变量，只能是常量或者常量表达式。
        代码块;
        break;
    case 常量:
        代码块;
        break;
    default:
        代码块;
        [break;]
}

2、循环控制

for (循环变量初始化;循环条件;循环变量迭代){
    代码块;
}

------------------------------------------------------------------------

while (循环条件){
    代码块;
    循环变量迭代;
}

------------------------------------------------------------------------

do {
    代码块;//一定会运行1次。
    循环变量迭代;
} while (循环条件);

3、break、continue、return

• break：终止某个语句块的执行，一般用于switch或循环for、while、do-while。
• continue：结束本次循环，继续执行下一次循环。
• return：使用在方法，表示跳出所在的方法。

---

四、数组

1、一维数组

数据类型[]  数组名= {};//静态初始化     

----------------------------------------------------------

数据类型 数组名[] = new 数据类型[大小]; //2种都可，动态初始化。
数据类型[] 数组名 = new 数据类型[大小]; 

数组求长度：xxx.length;
数组有默认值：

• int/short/byte/long:0
• double/float:0.0
• char:\u0000
• boolean:false
• String:null

注：基本数据类型赋值方式为值拷贝，引用数据类型赋值方式为地址拷贝。

2、二维数组

数据类型[][]  数组名= {{},{},{}};//静态初始化     

----------------------------------------------------------

数据类型 数组名[][] = new 数据类型[大小][大小]; //2种都可，动态初始化。
数据类型[][] 数组名 = new 数据类型[大小][大小]; //第二个中括号可以不写。

xxx.length;：二维数组中一维数组的个数。
xxx[xxx].length;：二维数组中每个一维数组元素的个数。

---

五、面向对象

1、类

class xxx{//类
    //属性
    //成员方法
}
XXX xxx = new XXX();

1.1修饰符

• public：可以在其他任何类中使用，默认为统一包下的任意类。
• abstract：抽象类，不能被实例化，可以包含抽象方法，抽象方法没有被实现，无具体功能，只能衍生子类。
• final：不能被继承。

2、变量

2.1、访问修饰符

2.2、非访问修饰符

• static：静态域修饰符
• final：最终域修饰符
• volatile：易失 ( 共享 ) 域修饰符
• transient：暂时性域修饰符

3、成员方法

访问修饰符 返回数据类型 方法名(形参列表...){//成员方法
	代码块;
	return 返回值;
}

3.1、访问修饰符

3.2、非访问修饰符

• abstract：抽象方法控制符
• static：静态方法控制符
• final：最终方法控制符
• native：本地方法控制符
• synchronized：同步方法控制符

3.3、传参机制

基本数据类型：传递的是值(值拷贝)，形参的任何改变不影响实参。
引用数据类型：传递的是地址，可以通过形参影响实参。

4、方法重载

java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！

1. 方法名：必须相同。
2. 参数列表：必须不同，包括类型、个数或顺序，至少有一个不同。
3. 返回类型：无要求。

5、可变参数

访问修饰符 返回类型  方法名(数据类型...  形参名){ // 参数：0-多个
	代码块;
}

访问修饰符 返回类型  方法名(int num, 数据类型...  形参名){ // 参数：0-多个
	代码块;
}

6、作用域

• 全局变量不赋初值可以使用，局部变量不赋初值直接使用会报错。
• 访问时遵循就近原则。
• 局部变量不可以加修饰符。

7、构造器

[修饰符] 方法名(形参列表){
	代码块;
}

• 修饰符可以是默认，也可以是public，protected，private
• 构造器没有返回值。
• 方法名和类名字必须一样。
• 参数列表 和 成员方法一样的规则。
• 构造器的调用系统完成。

8、this使用

this,代表当前对象。（哪个对象调用，this就代表哪个对象。）

• this关键字可以用来访问本类的属性、方法、构造器。
• this用于区分当前类的属性和局部变量。
• 访问成员方法的语法：this.方法名(参数列表);
• 访问构造器语法：this(参数列表); 注：只能在构造器中这么使用且放在第一条语句。
• this不能在类定义的外部使用，只能在类定义的方法中使用。

---

六、IDEA快捷键

• 删除当前行：ctrl + y
• 复制当前行，自己配置：ctrl + alt + 向下光标
• 补全代码：alt + /
• 添加注释和取消注释：ctrl + /
• 导入该行需要的类 先配置auto import，然后使用alt + enter即可
• 快速格式化代码：ctrl + alt+ L
• 快速运行程序，自己定义：alt + R
• 生成构造器：alt + insert
• 查看一个类的层级关系：ctrl + H
• 将光标放在一个方法上，输入ctrl + B,可以定位到方法
• 自动的分配变量名，通过在后面加 .var
• 自定义模板：file => settings =>editor =>live templates

---

七、面向对象编程三大特征

1、封装

定义：封装就是把属性和方法封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的方法，才能对数据进行操作。

2、继承(extends)

作用：解决代码复用，当多个类存在相同的变量和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。

class 子类 extends 父类{ // 子类就会自动拥有父类定义的属性和方法。
}

细节：

1. 子类继承了所有的属性和方法，非私有属性和方法能在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问。
2. 子类必须调用父类的构造器完成父类的初始化。
3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。
4. 如果希望指定去调用父类的某个构造器，则显式的调用一下：super(参数列表);
5. super在使用时，必须放在构造器第一行（super只能在构造器中使用。）。
6. super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器。
7. java所有类都是Oblject类的子类，即Object是所有类的基类。
8. 父类构造器的调用不限于直接父类，将一直往上追溯直到Object类（顶级父类。）。
9. 子类最多只能继承一个父类(指直接继承)，即java中是单继承机制。
10. 不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系。

 访问父类非私有属性：super.属性     访问父类非私有方法：super.方法名(参数列表)

方法重写(覆盖)：
定义：子类有一个方法，和父类的某个方法的名称、返回类型、参数一样。
重写要求：

1. 子类的方法的参数、方法名称要和父类方法的参数、名称完全一样。
2. 子类的返回类型和父类方法返回类型一样或者是父类返回类型的子类，比如父类Object，子类是String。
3. 子类方法不能缩小父类方法的访问权限。

3、多态

/*
*	编译类型不能改变，运行类型是可以变化的。
*	编译类型看  等号的左边，运行类型看  等号的右边.
*/
Animal animal = new Dog();// animal的编译类型：Animal；运行类型：Dog
animal = new Cat(); 

多态注意事项： 前提—>两个对象（类）存在继承关系。

3.1、多态的向上转型

1. 本质：父类的引用指向子类的对象。
2. 语法：父类类型 引用名 = new 子类类型();
3. 特点：编译类型看左边，运行类型看右边；可以调用父类中的所有成员(需遵守访问权限)，不能调用子类中特有成员；最终运行效果看子类的具体实现。

3.2、多态的向下转型

1. 语法：子类类型 引用名 = (子类类型)父类引用;
2. 只能强转父类的引用，不能强转父类的对象。
3. 要求父类的引用必须指向指向的是当前目标类型的对象。
4. 向下转型后，可以调用子类类型中所有的成员。

属性没有重写之说，属性的值看编译类型。

3.3、instanceof

作用：用于判断对象的运行类型是否为XX类型或XX类型的子类型。

xx instanceof XX //判断xx的运行类型是否为XX类型或XX类型的子类型

3.4、动态绑定机制

1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定。
2. 当调用对象属性的时候，没有动态绑定机制，哪里声明，哪里使用。

3.5、多态数组

定义：数组的定义类型为父类类型，里面保存的实际元素类型为子类型。

3.6、多态参数

方法定义的形参类型为父类类型，实参类型允许为子类类型。

4、Object类

定义：Class Object是类Object结构的根。 每个班都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法。

==：

1. 既可以判断基本类型，又可以判断引用类型。
2. 如果判断基本类型，判断的是值是否相等；如果判断引用类型，判断的是地址是否相等。

equals：

1. 只能判断引用类型。
2. 默认判断的是地址是否相等，子类中往往需要重写该方法，用于判断内容是否相等，比如String。

5、断点调试

• F7(跳入)，跳入方法内。
• F8(跳过)，逐行执行代码。
• shift + F8(跳出)，跳出方法。
• F9(resume,执行到下一个断点)

---