尚硅谷JAVA基础——分P笔记

做笔记的分P至少满足如下条件之一：

• 自认为有值得注意的点
• 理解起来有困难的
• 以前没接触过的知识点

P18（学习路线）

JAVA EE学习路线

P29（JDK、JRE、JVM）

JDK = JRE + JAVA开发工具包（javac.exe, java.exe, javadoc.exe）
JRE = JVM + JAVA类库

P37（文档注释）

/**
注释
*/

P38（基本java文件构建类规范）

1、一个.java文件里可以有多个class
2、但一个.java文件里只能有一个public声明的class，同时类名和文件名相同

P47（标识符命名规范）

• 包名：多单词组成时全小写——xxxyyyzzz
• 类名、接口名：多单词组成时，所有单词首字母大写——XxxYyyZzz
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写——xxxYyyZzz
• 常量名：所有字母大写，多单词组成时用下划线连接——XXX_YYY_ZZZ

P56（数据类型转换）

自动类型提升：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。（容量大小指表示树的范围的大和小，并非所占字节数。比如，float的容量大于long的容量）

赋值时，小的可以赋给大的，反之不可。

byte、char、short --> int --> long --> float --> double
当byte、char、short三种类型的变量做运算时（包括同类），结果为int型

P59（"+"含义）

当"+"左右含有String类型时，表示连接运算，否则表示加法运算

（’'表示字符，""表示字符串）

P73（运算符改变数据类型）

“++”、"–"、"+="（同类其他）都不会改变数据类型（short型），普通加减会改变

P80（&、&&，|、||区别）

&：前后表达式都判（逻辑与）
&&：如果前面表达式是false，后面表达式不执行（短路与）
|：前后表达式都判（逻辑或）
||：如果前面表达式是true，后面表达式不执行（短路或）

P103（swith、case）

switch后的表达式只能是六种数据类型之一：

• byte
• short
• int
• char
• 枚举
• String

case后只能是常量，不能是变量和范围

P140（数组不可随便增删）

数组长度一旦确定，不能增加与删除，也没有直接的API可以操作

（通常用List或者StringBuilder更灵活）

P144（数组默认初始值）

• 整型：0
• 浮点型：0.0
• char型：0或’\u0000’，不是’0’，输出就是空白（不是空格）
• boolean型：false
• String型：null

P146（一维数组内存解析）

P153（二维数组内存解析）

P170（排序算法复杂度汇总）

P183（内存区域概览）

P209（jdk1.5之后新特性：可变形参）

//接收多个参数，表现形式实际就是数组
String ... strs
int ... nums

P214（值传递）

注意，JAVA只有值传递！！
所有的函数传参，都是传的一份副本：

• 基本数据类型，副本与原数内容一致（方法中改变形参，实参无变化）
• 引用数据类型，副本与原数指向同一位置（赋的是地址值）

关于引用数据类型方法传参三个点：

1. 方法中改变形参指向的内容（如修改数组元素，类的属性等），实参指向的内容一并变化
2. 方法中给形参重新赋值，改变形参指向（如字符串重新赋值等），实参指向的内容无变化，因为实际改变的是副本的指向，而不是原实参的指向
3. 关于String，由于String本身是不可改变的，然后形参改变指向也不能改变原实参，因此涉及到String的传参，形参的改变都不会影响到实参；数组由于可以操作元素，所以会影响到实参！

P223（四种权限修饰符的使用范围）

P231（JavaBean）

P234（this调用构造器）

首先，this可以调用当前对象或当前正在创建对象的属性或方法。
其次，this还可以用于调用其他构造器，注意点如下：

P259（私有属性、私有方法的继承）

父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中的私有结构。只是因为封装性的影响，在子类中不能直接调用父类的结构而已。（子类中只能直接调用父类中公有的结构，父类中私有的结构可通过父类公有的方法来调用，从而使得子类可以间接调用到）

P272-274（重写）

1、子类重写的方法权限修饰符大于等于父类被重写的方法的权限修饰符（子类不能重写父类中用private修饰的方法）

2、返回值类型：
（1）父类 void或基本数据类型，子类必须保持一致
（2）父类是A类型，子类可以是A或A的子类
（3）父类若抛出异常是B类型，子类可以抛出B或B的子类

子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写，因为静态方法不能被覆盖，是随着类的加载而加载的）

P275（四种权限修饰符范围）

常用的就是public和private

不容易记的是protected，被其修饰的属性和方法可以在不同包的子类下被调用，非子类就不行了

P276-277（super注意点）

super调用属性和方法：
（1）子类中有和父类重名的属性时，用super.属性可以调用父类的属性
（2）父类中的方法被重写时，super.方法可以调用父类原来的方法

super调用构造器：
（1）super()必须在子类构造器首行
（2）this和super在同一个构造器中只能二选一，不能同时出现
（3）构造器首行如果没有显式声明super和this，则默认会有一个super()调用父类中的空参构造器
（4）在类的多个构造器中，至少有一个类的构造器中使用了super(形参列表)，要么就是显式调用了，要么就是第四点中的默认的

P280-283（多态性引入）

1. 什么叫多态性：父类的引用指向子类的对象
2. 多态的使用：编译期，只能调用父类中声明的方法；运行期，实际执行的是子类重写父类的方法（如果有的话）
3. 多态性的使用前提：

• 类的继承关系
• 方法的重写

4. 多态性只适用于方法，不适用于属性（父类引用通过.调用的一定是父类属性）

编译，看左边；运行，看右边（适用于方法）

多态是一种运行时行为

P287-289（向上转型和向下转型）

向上转型：把子类赋给父类（多态）
向下转型：把父类赋给子类（强制类型转换）

为什么要向下转型：通常是在使用了向上转型之后，为了再调用子类单独的属性或方法，所以要再向下转型

一定是先向上转型后，再向下转型，转回来了

Person p = new Man(); //向上转型
Man m = (Man)p; //向下转型

P295（==运算符含义）

• 如果比较的是基本数据类型变量，比较两个变量保存的数据是否相等（不一定要类型相同，但要能统一）
• 如果比较的是引用数据类型变量，比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实体

P296（euqals判相等）

• Object类中的equals（普通对象调用的）：和==作用一致
• String、Date、File、包装类等重写过，比较的是两个对象的实体内容是否相同，而不是比较地址
• equals方法的重写可以用编译器来生成

P303（单元测试）

专门写一个类（public，无参构造器）用于单元测试，直接写具体测试某个功能的函数，然后加注解@Test，直接自动导包，单独运行这个函数即可

P307（自动装箱与自动拆箱）

• 自动装箱（基本数据类型装到类里）：基本数据类型可以直接赋值给对应的包装类

int i = 1;
Integer j = i;

• 自动拆箱（从类里把基本数据类型拿出来）：包装类可以直接赋值给对应的基本数据类型

Integer j = 1;
int i = j;

P308（基本数据类型和String相互转换）

• 基本数据类型转String：

String.valueOf(基本数据类型);

• String转基本数据类型：

包装类.parseXxx(String);

P315-323（关于static）

静态变量：

1. 静态变量跟类挂钩，实例变量跟对象挂钩
2. 多个对象共享同一个静态变量，某一个对象修改静态变量，另一个对象再调用会发现已经被修改
3. 静态变量在内存中只会存在一份，在方法区的静态域中

静态方法：

1. 同上
2. 静态方法中，只能调用静态的方法或属性
3. 非静态方法中，静态和非静态的方法属性都可以调用（从生命周期的角度理解，静态长，实例短）

何时使用static：

1. 属性被多个对象共享
2. 类中的常量
3. 操作静态属性的方法
4. 工具类中的方法

P325-328（单例模式）

单例->单个实例->类只能创建一个实例供外部使用

要实现这个要求，记住3点：

1. 私有构造器（保证外部不能new，不然就有多个实例）
2. 类内部创建一个实例（保证要有一个实例供使用。必须是static，因为第三点中的方法要调它）
3. 声明一个public、static的返回当前类实例的方法（保证能获取到该实例。如果不是static，外部就必须new对象才能调该方法，但外部不能new，矛盾！）

---

饿汉式vs懒汉式：

• 饿汉式是提前把对象new好，使用时直接返回；
• 懒汉式是先给对象赋值null，使用时临时new（判null，只new第一次）
• 饿汉式线程安全，但对象在内存中存留时间过长
• 懒汉式线程不安全

P330-332（代码块）

//静态代码块，随着类的加载而执行，且只执行一次
static{

}
//非静态代码块，随着对象的创建而执行；每创建一个对象，就执行一次 
{

}

作用：

• 静态——初始化类的信息
• 非静态——创建对象时，初始化对象的属性
• 总的来说——在创建类或创建对象前，需要一些代码来完成操作，但没地方可写，就放代码块里

通常情况下不会使用多个静态代码块或多个非静态代码块（都集中写在一个里）

创建对象时，代码执行顺序：

由父及子，静态先行（父类静态代码块->子类静态代码块->父类非静态代码块->父类构造器->子类非静态代码块->子类构造器）

实际开发基本不用代码块，但要能读懂别人写的

P334（关于final）

final + 类：该类不能被继承
final + 方法：该方法不能被重写
final + 变量：该变量不能再被改变，只能初始化一次（常量）（显式初始化、代码块初始化、构造器初始化；不能在方法中初始化）

static + final：全局常量

P343-349（抽象类——abstract）

为什么要有抽象类？

• 某个类已经不再需要实例化，操作均可由诸多子类完成时，该类可以声明为抽象类。
• 父类无法确定如何实现，子类中提供具体实现时

abstract + 类：

• 该类不能实例化

abstract + 方法：

• 含有抽象方法的类一定是抽象类
• 抽象方法都是通过子类重写来完成操作，必须把父类的抽象方法全部重写完的子类才可实例化

abstract不能用来修饰：

• 私有方法（不能重写）
• 静态方法（不能重写）
• final的方法（不能重写）
• final的类（不能被继承）

匿名子类（new了没有东西接收就叫匿名对象，类没有单独用class结构体写出就叫匿名类）

//匿名子类的非匿名对象
Person p = new Person(){
	Person类中需要重写的方法
};

//匿名子类的匿名对象
func(new Person(){
	Person类中需要重写的方法
});

P350-360（接口——interface）

继承父类——是不是
实现接口——能不能（如果你要…，必须能…）

1、接口弥补了Java中没有多重继承的局限性
2、Java类可以实现多个接口
3、接口和接口之间可以继承，而且可以多继承
4、接口的使用一般都通过多态性体现（形参是接口类型声明，传进来是具体的实现该接口的类）
5、匿名实现类
6、代理模式，代理类帮被代理类做很多事，代理类中传入被代理类的对象
7、工厂模式，创建者和调用者分离，代码复用（后续高级部分再看，这里仅作了解）

JDK8新特性：
1、可以写静态方法和默认方法
2、静态方法只能通过接口调用，不能通过实现类的实例调用，默认方法可以调
3、父类和接口中有同名同参数的默认方法， 且子类中没有重写，优先调用父类中的方法（类优先原则）
4、类实现了多个接口，各接口中有同名同参数的默认方法， 且子类中没有重写，则会报错（接口冲突），此时必须在实现类中重写该方法
5、实现类中已经重写了接口的默认方法，但又想调用接口原来的默认方法，通过接口.super.方法来调用

P361-365（内部类）

用的比较少，知识点如下：

需要关注的点：
1、如何实例化成员内部类的对象

//静态内部类
Person.Dog dog = new Person.Dog();

//非静态内部类
Person p = new Person();
Person.Brid bird = p.new Person.Bird();

2、成员内部类中调用外部类结构（同名时）

//内部类结构
this.name

//外部类结构
Person.this.name;

3、开发中局部内部类的使用
通常都是从一个方法中获取一个对象（就获取这一次，所以使用内部类，写外边儿就太影响整体代码布局了）

4、额外注意点：在局部内部类的方法中，如果要使用局部内部类本身所在的方法（外边）中的局部变量时，要求此局部变量必须声明为final（规定）

P371-385（异常处理）

1、Error——栈溢出、内存溢出
2、编译时异常——编译时就必须捕获，不然无法通过编译；运行时异常——能通过编译，运行时报错
3、try里放可能出现异常的代码，catch里放出现异常后执行的代码，finally里放无论如何都会执行的代码
4、finally什么时候用：数据库连接、输入输出流、网络编程Socket等资源，JVM不能自动回收，我们需要进行资源释放。此时的资源释放，就需要声明在finally里。
5、运行时异常，开发中通常就不用try-catch-finally来捕获了，因为捕获了也没用，还是要回来改代码。编译时异常，需要用，不然编译都过不了！
6、子类重写的方法抛出的异常类型一定不大于父类原方法抛出的异常类型（否则多态调用的时候，根据父类设计的try-catch就罩不住子类的异常类型范围了）
7、如果父类中被重写方法没有throws处理异常，则子类中重写的方法也不能使用throws，必须用try-catch-finally处理
8、有递进关系的几个方法依次被调用，使用throws方式处理，外层方法上用try-catch-finally
9、throw是手动生成一个异常，throws是在处理异常（抛出给外层来使用try-catch解决）

P415-（多线程）

1、进程、线程简单的概念要知道

• 进程：程序的一次执行
• 线程：程序内部的一条执行路径（可以有多条）

2、并行、并发

• 并行：同时处理多个任务
• 并发：具有一段时间内处理多个任务的能力，但不一定同时
• 区别：是否同时。并行是多个CPU同时执行多个线程，并发是一个cpu轮流切换着执行多个线程。

3、多线程java使用

1. 创建方式1——继承Thread类，重写run()，创建实例对象，start()（或者用匿名子类匿名对象）
2. 创建方式2——实现Runnable接口，实现run()，创建实例对象，创建Thread对象并传入实例对象，start()
3. 开发中优先选择方式2：（1）方式2没有类的单继承的局限性（某个类已有父类，则不能再继承Thread开线程）。（2）方式2更适合处理多个线程有共享数据的情况（单个类开多个线程）。
4. 常用方法
5. 高优先级的线程不一定就先执行，只是概率高（误区：高优先级的先执行完才执行低优先级的）

4、同步机制

1. synchronized(锁)，需要同步的多个线程必须是同一把锁！对于继承Thread类的实现方式，这个锁写成当前类.class（类广义上来说也是一个对象），不能写成this，对象不唯一，但使用的类唯一；对于实现Runnable接口的方式，这个锁写成this，因为只创建了一个实现类对象，唯一！
2. 同步方法，继承Thread类的实现方式需要写成静态方法（保证同一个锁）。非静态的同步方法，同步监视器是this；静态的同步方法，同步监视器是当前类本身。
3. 懒汉单例线程安全问题的解决

//线程安全的懒汉式单例模式写法
class Bank{
    private Bank(){

    }

    private static Bank instance = null;

    public static Bank getInstance(){
        //效率更高，只有前几个同时进入的线程需要同步
        if(instance == null){
            synchronized (Bank.class){
                if(instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

5、线程通信

1. wait()、notify()、notifyAll()三个方法必须使用在同步代码块或同步方法中（注意，ReetranLock不是用这一套东西）
2. 上述三个方法的调用者必须是同步代码块或者同步方法中的锁（同步监视器），否则会出现IllegalMonitorStateException异常