JavaSE 知识梳理（上）

1. Java语言的特性

简单性、面向对象、分布式、健壮性、安全性、体系结构中立、可移植性、解释性、高能效、多线程、动态性

2. JDK、JRE、JVM之间的关系

JDK(Java Development Kit):Java开发工具包，提供给Java程序员使用，包含了JRE，同时还包含了编译 器javac与自带的调试工具Jconsole、jstack等。

JRE(Java Runtime Environment):Java运行时环境，包含了JVM，Java基础类库。是使用Java语言编写程 序运行的所需环境。

JVM：Java虚拟机，运行Java代码

3.从键盘输出

使用 Scanner 读取字符串/整数/浮点数

import java.util.Scanner;//需要导入 util 包

Scanner sc = new Scanner(System.in);
System.out.println("请输入你的姓名：");
String name = sc.nextLine();

4.方法的使用

方法就是一个代码片段. 类似于 C 语言中的 "函数"

// 方法定义 修饰符 返回值类型 方法名称([参数类型 形参 ...]){

        方法体代码;

        [return 返回值];

}

【方法调用过程】

调用方法--->传递参数--->找到方法地址--->执行被调方法的方法体--->被调方法结束返回--->回到主调方法继续往下 执行

形参和实参：形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的。在Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体

方法的返回值是可选的. 有些时候可以没有的，没有时返回值类型必须写成void

5.方法的重载

在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了

1. 方法名必须相同

2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)

3. 与返回值类型是否相同无关

在同一个作用域中不能定义两个相同名称的标识符。方法签名即：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数列表+返回值类型，构成 方法完整的名字。

6.递归

一个方法在执行过程中调用自身, 就称为 "递归".

递归的必要条件：

1. 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同

2. 递归出口

7.数组

相同类型元素的一个集合

T[] 数组名 = new T[N];

T：表示数组中存放元素的类型   

T[]：表示数组的类型   

N：表示数组的长度

1. 动态初始化：在创建数组时，直接指定数组中元素的个数

int[] array = new int[10];

2. 静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定

T[] 数组名称 = {data1, data2, data3, ..., datan};

静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。

静态初始化时, {}中数据类型必须与[]前数据类型一致。

静态初始化可以简写，省去后面的new T[]。

如果没有对数组进行初始化，数组中元素有其默认值。如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值；如果数组中存储元素类型为引用类型，默认值为null。

数组中元素访问：数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过 下标访问其任意位置的元素。

1. 数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素

2. 下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常。

遍历数组：将数组中的所有元素都访问一遍, 访问是指对数组中的元素进行某种操作，可以使用循环来进行打印。在数组中可以通过 数组对象.length 来获取数组的长度

int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < array.length; i++){
    System.out.println(array[i]);
}

for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错

int[] array = {1, 2, 3};
for (int x : array) {
    System.out.println(x);
}

数组的运用场景：保存数据、作为函数的参数（参数传基本数据类型，参数传数组类型(引用数据类型)）、作为函数的返回值

数组拷贝：

import java.util.Arrays;
public static void func(){
    // newArr和arr引用的是同一个数组
    // 因此newArr修改空间中内容之后，arr也可以看到修改的结果
    int[] arr = {1,2,3,4,5,6};
    int[] newArr = arr;
    newArr[0] = 10;
    System.out.println("newArr: " + Arrays.toString(arr));

    // 使用Arrays中copyOf方法完成数组的拷贝：
    // copyOf方法在进行数组拷贝时，创建了一个新的数组
    // arr和newArr引用的不是同一个数组
    arr[0] = 1;
    newArr = Arrays.copyOf(arr, arr.length);
    System.out.println("newArr: " + Arrays.toString(newArr));

    // 因为arr修改其引用数组中内容时，对newArr没有任何影响
    arr[0] = 10;
    System.out.println("arr: " + Arrays.toString(arr));
    System.out.println("newArr: " + Arrays.toString(newArr));

    // 拷贝某个范围.
    int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
    System.out.println("newArr2: " + Arrays.toString(newArr2));
}

注意：数组当中存储的是基本类型数据时，不论怎么拷贝基本都不会出现什么问题，但如果存储的是引用数据类 型，拷贝时需要考虑深浅拷贝的问题。

8.初始JVM的内存分布

1. 程序运行时代码需要加载到内存

2. 程序运行产生的中间数据要存放在内存

3. 程序中的常量也要保存

4. 有些数据可能需要长时间存储，而有些数据当方法运行结束后就要被销毁

9.基本类型变量与引用类型变量的区别

基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值； 而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。

引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该 地址，引用变量便可以去操作对象

认识 null：在 Java 中表示 "空引用" , 也就是一个不指向对象的引用。null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操 作. 一旦尝试读写, 就会抛出 NullPointerException.

10.二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

    int[][] arr = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    for (int row = 0; row < arr.length; row++) {
        for (int col = 0; col < arr[row].length; col++) {
            System.out.printf("%d\t", arr[row][col]);
        }
    System.out.println("");
    }

11.类

面向对象：在面向对象的世界里，一切皆为对象。面 向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性，哪些功能，描述完成后计算机就可以识别了。

在java中定义类时需要用到class关键字

// 创建类

class ClassName{

        field; // 字段(属性) 或者 成员变量

        method; // 行为 或者 成员方法

}

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类 具有哪些功能，称为类的成员方法。

class PetDog {
    public String name;//名字
    public String color;//颜色
    // 狗的属性
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
    }
    // 狗的行为
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
    }
}

1. 一般一个文件当中只定义一个类

2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)

3. public修饰的类必须要和文件名相同

4. 不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改(给同学演示)。

类的实例化：用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象

public class Main{
    public static void main(String[] args) {
        PetDog dogh = new PetDog(); //通过new实例化对象
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
        PetDog dogs = new PetDog();
        dogs.name = "阿黄";
        dogs.color = "黑黄";
        dogs.barks();
        dogs.wag();
    }
}

new 关键字用于创建一个对象的实例. 使用 . 来访问对象中的属性和方法. 同一个类可以创建对个实例

类和对象的说明

1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.

2. 类是一种自定义的类型，可以用来定义变量.

3. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

4. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东 西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空 间

this引用：指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。

public class Date {
    public int year;
    public int month;
    public int day;
    public void setDay(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(this.year + "/" + this.month + "/" + this.day);
    }
}

  this引用的是调用成员方法的对象。 

public static void main(String[] args) {
    Date d = new Date();
    d.setDay(2020,9,15);
    d.printDate();
}

this的特性

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型

2. this只能在"成员方法"中使用

3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象

4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法 对象的引用传递给该成员方法，this负责来接收

12.初始化对象

构造方法：也称为构造器，是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且 在整个对象的生命周期内只调用一次。

public class Date {
    public int year;
    public int month;
    public int day;
    // 构造方法：
    // 名字与类名相同，没有返回值类型，设置为void也不行
    // 一般情况下使用public修饰
    // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
    public Date(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("Date(int,int,int)方法被调用了");
    }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    public static void main(String[] args) {
        // 此处创建了一个Date类型的对象，并没有显式调用构造方法
        Date d = new Date(2021,6,9); // 输出Date(int,int,int)方法被调用了
        d.printDate(); // 2021-6-9
    }
}

1. 名字必须与类名相同

2. 没有返回值类型，设置为void也不行

3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)

4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载

5.如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的，一旦用户定义，编译器则不再生成。

6.构造方法中，可以通过this调用其他构造方法来简化代码。this(...)必须是构造方法中第一条语句且不能形成环。

7. 绝大多数情况下使用public来修饰，特殊场景下会被private修饰(后序讲单例模式时会遇到)

默认初始化

在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下：

1. 检测对象对应的类是否加载了，如果没有加载则加载

2. 为对象分配内存空间

3. 处理并发安全问题 比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突

4. 初始化所分配的空间 即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值

5. 设置对象头信息

6. 调用构造方法，给对象中各个成员赋值

就地初始化

在声明成员变量时，就直接给出了初始值。

13.封装

将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认 知，而访问权限用来控制方法或者字段能否直接在类外使用。

public：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了

private：只有自己知道，其他人都不知道

protected主要是用在继承中

default权限指：什么都不写时的默认权限

访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

一般情况下成员变量设置为private，成员方法设置为public

封装扩展之包：为了更好的管理类，把多个类收集在一起成为一组，称为软件 包。包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式。在同一个工程中允许存在相同名称的类，只要处在 不同的包中即可。

使用 import语句导入包.可以使用 java.util.Date 导入 java.util 这个包中的 Date 类.更建议显式的指定要导入的类名.可以使用import static导入包中静态的方法和字段

自定义包：

在文件的最上方加上一个 package 语句指定该代码在哪个包中.

包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).

包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储 代码.

如果一个类没有 package 语句, 则该类被放到一个默认包中.

14.static成员

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对 象，是所有对象所共享的。

static修饰成员变量：static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共 享的。

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

static修饰成员方法：被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过 静态方法来访问的。

【静态方法特性】

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者

3. 不能在静态方法中访问任何非静态成员变量

static成员变量初始化：

1. 就地初始化：在定义时直接给出初始值

2. 静态代码块初始化

15.代码块

使用 {} 定义的一段代码称为代码块，普通代码块 构造块 静态块 同步代码块

普通代码块：定义在方法中的代码块，直接使用{}定义，普通方法块

{ //直接使用{}定义，普通方法块
    int x = 10 ;
    System.out.println("x1 = " +x);
}

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

{
    this.name = "bit";
    this.age = 12;
    this.gender = "man";
    System.out.println("I am instance init()!");
}

静态代码块：使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量

static {
    classRoom = "bit306";
    System.out.println("I am static init()!");
}

静态代码块不管生成多少个对象，其只会执行一次

静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)

实例代码块只有在创建对象时才会执行

16.内部类

可以将一个类定义在另一个类或者一个方法的内部， 前者称为内部类，后者称为外部类

public class OutClass {

        class InnerClass{

         }

}

// OutClass是外部类

// InnerClass是内部类

1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类

2. 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

根据内部类定义的位置不同，一般可以分为以下几种形式：

1. 成员内部类(普通内部类：未被static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)

2. 局部内部类(不谈修饰符)、匿名内部类，使用最多

实例内部类：未被static修饰的成员内部类。

1. 外部类中的任何成员都可以在实例内部类方法中直接访问

2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束

3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名 称.this.同名成员 来访问

4. 实例内部类对象必须在先有外部类对象前提下才能创建

5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用

6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

静态内部类：被static修饰的内部成员类称为静态内部类

1. 在静态内部类中只能访问外部类中的静态成员

2. 创建静态内部类对象时，不需要先创建外部类对象

局部内部类：定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用

1. 局部内部类只能在所定义的方法体内部使用

2. 不能被public、static等修饰符修饰

3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class

4. 几乎不会使用

匿名内部类：匿名：没有名字的意思。内部类：写在其他类内部的类

父类/接口  对象 = new 父类/接口（）{   重写父类/接口中的方法   }；  

对象的打印：如果想要默认打印对象中的属性，只需重写toString方法即可。

public class Person {
    String name;
    String gender;
    int age;
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
    @Override
    public String toString() {
        return "[" + name + "," + gender + "," + age + "]";
    }
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
    }
}