Day11

面向对象的特征：继承性

• 继承性的好处
  
  ①减少代码的冗余、提高了代码的复用性
  ②便于功能的扩展
  ③为之后多态的使用，提供了前提
  
• 继承性的格式:

class A extends B{}

其中A为B的子类，B为父类

①体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响，使得子类不能直接调用父类的结构而已。

②子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。子类和父类的关系，不同于子集和集合的关系。

• Java中关于继承性的规定：
  
  ①一个类可以被多个子类继承。
  ②Java中类的单继承性：一个类只能有一个父类
  ③子父类是相对的概念。
  ④子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
  ⑤子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
  
• 如果我们没有显示声明一个类的父类，则此类继承于java.lang.Object类
• 所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
• 意味着，所有的java类具有java.lang.Object类声明的功能。

Day12

• 方法的重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
• 应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
  ①重写的规定：
  方法的声明： 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{}

约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法

①子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
②子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

特殊情况：子类不能重写父类中声明为private权限的方法
为什么不能:
在一个软件系统中，子类应该可以替换任何基类能够出现的地方，
并且经过替换以后，代码还能正常工作
假设一个父类 A 拥有的方法 public void setXxx() {} 
可以被其他任意对象调用，
这个方法被子类 B 重写后为 void setXxx() {} 
即默认的访问权限只能被自己和本包所访问。
get(A a) {
	a.setXxx();
}
而此时传入的对象为 B 类对象，假设为b，
此时 b 将转型为 a 但是 b 中的 setXxx() 访问权限已经被缩小了，
这将造成错误。

③返回值类型：

    ①父类被重写的方法的返回值类型是void，
    则子类重写的方法的返回值类型只能是void
    ②父类被重写的方法的返回值类型是A类型，
    则子类重写的方法的返回值类型可以是A类或A类的子类
    ③父类被重写的方法的返回值类型是基本数据类型(比如：double)，
    则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)

④子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）

子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），
要么都声明为static的（不是重写），这分别为父类和子类自己的类方法。

super关键字的使用

• super理解为：父类的
• super可以用来调用：属性、方法、构造器
• super的使用：调用属性和方法
  ①我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
  ②特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
  ③特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法
• super调用构造器
  ①我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
  ②"super(形参列表)"的使用，必须声明在子类构造器的首行！
  ③我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)“只能二选一，不能同时出现
  ④在构造器的首行，没有显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()
  ⑤在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)”，调用父类中的构造器

子类对象实例化的全过程

• 从结果上看：（继承性）
  ①子类继承父类以后，就获取了父类中声明的属性或方法。
  ②创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。
• 从过程上来看：
  ①当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，…
  ②直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用

明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。

面向对象特征之三：多态性

• 理解多态性：可以理解为一个事物的多种形态。
• 何为多态性：

对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
多态的使用：虚拟方法调用

有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
总结：编译，看左边；运行，看右边。

• 多态性的使用前提： ① 类的继承关系 ② 方法的重写
• 对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

Day13

instanceof的使用和向下转型

x instanceof A
检验x是否为类A的对象，返回值为boolean型

使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

如果 a instanceof A返回true,则 a instanceof B也返回true.其中，类B是类A的父类。

• 多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 —虚拟方法调用
• 有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。

如何才能调用子类特有的属性方法？–向下转型：使用强制类型转换符。

Man m1=(Man) p2;

java.lang.Object类

• Object类是所有Java类的根父类
• 如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
• Object类中的功能(属性、方法)就具有通用性。

属性：无
方法：equals() / toString() / getClass() /hashCode() / 
clone() / finalize() / wait() 、 notify()、notifyAll()

• Object类只声明了一个空参的构造器

equals()

• 回顾 == 的使用：

1、可以使用在基本数据类型变量和引用数据类型变量中
2、如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。
（不一定类型要相同）
3、如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.
即两个引用是否指向同一个对象实体
补充： == 符号使用时，必须保证符号左右两边的变量类型一致。

• equals()方法的使用：

1、是一个方法，而非运算符
2、只能适用于引用数据类型
3、Object类中equals()的定义：
	public boolean equals(Object obj) {
    	return (this == obj);
	}

说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

• 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
• 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写。

重写原则：比较两个对象的实体内容是否相同

Object类中toString()的使用：

• 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
• Object类中toString()的定义：

public String toString() {
    return getClass().getName() + "@" + 
    Integer.toHexString(hashCode());
 }

• 像String、Date、File、包装类等都重写了Object类中的toString()方法。使得在调用对象的toString()时，返回"实体内容"信息
• 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容”

包装类

• java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
• 掌握的：基本数据类型、包装类、String三者之间的相互转换
  基本数据类型 —>包装类：调用包装类的构造器
  基本数据类型:调用包装类Xxx的xxxValue()
  JDK 5.0 新特性：自动装箱 与自动拆箱
  基本数据类型、包装类—>String类型：调用String重载的valueOf(Xxx xxx)
  String类型 —>基本数据类型、包装类：调用包装类的parseXxx(String s)

public void test3() {
    Integer i = new Integer(1);
    Integer j = new Integer(1);
    System.out.println(i == j);//false

//Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],
//保存了从-128~127范围的整数。如果我们使用自动装箱的方式，
//给Integer赋值的范围在
//-128~127范围内时，可以直接使用数组中的元素，不用再去new了。
//目的：提高效率

Integer m = 1;
Integer n = 1;
System.out.println(m == n);//true

Integer x = 128;//相当于new了一个Integer对象
Integer y = 128;//相当于new了一个Integer对象
System.out.println(x == y);//false


}

Day14

static关键字的使用

• static:静态的
• static可以用来修饰：属性、方法、代码块、内部类
• 使用static修饰属性：静态变量（或类变量）

属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)

实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。
当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。

静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。
当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，
是修改过了的。

• static修饰属性的其他说明：
  ①静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
  ②静态变量的加载要早于对象的创建
  ③由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
  ④类：类变量（√） 实例变量（×）
  ⑤对象：类变量（√） 实例变量（√）

• 静态属性举例：System.out; Math.PI;

• 使用static修饰方法：静态方法
  ①随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
  ②类：静态变量（√） 非静态变量（×）
  ③对象：静态变量（√） 非静态变量（√）
  ④静态方法中，只能调用静态的方法或属性；非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

• static注意点：
  ①在静态的方法内，不能使用this关键字、super关键字
  ②关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。

• 开发中，如何确定一个属性是否要声明为static的？

    属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
    类中的常量也常常声明为static
    
    开发中，如何确定一个方法是否要声明为static的？
   
    操作静态属性的方法，通常设置为static的
    工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、
    Collections

单例设计模式：

• 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
• 如何实现？

饿汉式 vs 懒汉式

区分饿汉式 和 懒汉式

饿汉式：
	坏处：对象加载时间过长
	好处：饿汉式是线程安全的
懒汉式：
	好处：延迟对象的创建。
	目前的写法坏处：线程不安全。--->到多线程内容时，再修改

public class SolutionTest {
    public static void main(String[] args) {
        Solution1 s1=Solution1.getInstance();
        Solution1 s2=Solution1.getInstance();
        System.out.println(s1==s2);//true

        Solution2 s3=Solution2.getInstance();
        Solution2 s4=Solution2.getInstance();
        System.out.println(s3==s4);//true
    }
}
//饿汉式
class Solution1{
    private Solution1(){

    }
    private static Solution1 solution1=new Solution1();
    public static Solution1 getInstance(){
        return solution1;
    }
}
//懒汉式
class Solution2{
    private Solution2(){

    }
    private static Solution2 solution2=null;
    public static Solution2 getInstance(){
        if(solution2==null){`在这里插入代码片`
            solution2=new Solution2();
        }
        return solution2;
    }
}

main()方法的使用说明：

• main()方法作为程序的入口
• main()方法也是一个普通的静态方法
• main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）

类的成员之四：代码块（或初始化块）

• 代码块的作用：用来初始化类、对象
• 代码块如果有修饰的话，只能使用static.
• 分类：静态代码块 vs 非静态代码块
• 静态代码块

    内部可以有输出语句
    随着类的加载而执行,而且只执行一次
    作用：初始化类的信息
    如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
    静态代码块的执行要优先于非静态代码块的执行
    静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

• 非静态代码块

    内部可以有输出语句
    随着对象的创建而执行
    每创建一个对象，就执行一次非静态代码块
    作用：可以在创建对象时，对对象的属性等进行初始化
    如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
    非静态代码块内可以调用静态的属性、静态的方法，
    或非静态的属性、非静态的方法

• 对属性可以赋值的位置：

①默认初始化
②显式初始化/⑤在代码块中赋值
③构造器中初始化
④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
执行的先后顺序：① - ② / ⑤ - ③ - ④

final关键字

• final可以用来修饰的结构：类、方法、变量
• final 用来修饰一个类:此类不能被其他类所继承。比如：String类、System类、StringBuffer类
• final 用来修饰方法：表明此方法不可以被重写。比如：Object类中getClass();
• final 用来修饰变量：此时的"变量"就称为是一个常量
• final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
• final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。

public void show(final int num){
    //num = 20;//编译不通过
    System.out.println(num);
}
//不可以在方法内赋值，只有在调用时赋值，如test.show(10);

static final 用来修饰属性：全局常量

Day15

abstract关键字的使用

• abstract:抽象的
• abstract可以用来修饰的结构：类、方法
• abstract修饰类：抽象类

    此类不能实例化
    抽象类中一定有构造器，便于子类实例化时调用
    （涉及：子类对象实例化的全过程）
    开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

• abstract修饰方法：抽象方法

    抽象方法只有方法的声明，没有方法体
    
    包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
    
    若子类重写了父类中的所有的抽象方法后，此子类方可实例化；
    若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，
    需要使用abstract修饰

abstract使用上的注意点：

• abstract不能用来修饰：属性、构造器等结构
• abstract不能用来修饰私有方法、静态方法、final的方法、final的类

接口的使用

• 接口使用interface来定义
• Java中，接口和类是并列的两个结构
• 如何定义接口：定义接口中的成员
• JDK7及以前：只能定义全局常量和抽象方法

    全局常量：public static final的.但是书写时，可以省略不写
    抽象方法：public abstract的

• JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）
• 接口中不能定义构造器的！意味着接口不可以实例化
• Java开发中，接口通过让类去实现(implements)的方式来使用.如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化；如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
• Java类可以实现多个接口 —>弥补了Java单继承性的局限性格式：class AA extends BB implements CC,DD,EE
• 接口与接口之间可以继承，而且可以多继承
• 接口的具体使用，体现多态性
• 接口，实际上可以看做是一种规范

抽象类与接口有哪些异同？

• 接口使用上也满足多态性
• 接口，实际上就是定义了一种规范
• 开发中，体会面向接口编程！

类的内部成员之五：内部类

• Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
• 内部类的分类：成员内部类（静态、非静态） vs 局部内部类(方法内、代码块内、构造器内)
• 成员内部类：

一方面，作为外部类的成员：
    调用外部类的结构
    可以被static修饰
    可以被4种不同的权限修饰
另一方面，作为一个类：
    类内可以定义属性、方法、构造器等
    可以被final修饰，表示此类不能被继承。言外之意，
    不使用final，就可以被继承
    可以被abstract修饰

• 关注如下的3个问题

如何实例化成员内部类的对象
如何在成员内部类中区分调用外部类的结构
开发中局部内部类的使用 见《InnerClassTest1.java》
//创建Dog实例(静态的成员内部类):
Person.Dog dog = new Person.Dog();
dog.show();
//创建Bird实例(非静态的成员内部类):
//Person.Bird bird = new Person.Bird();//错误的
Person p = new Person();
Person.Bird bird = p.new Bird();
bird.sing();

Day16

Error:

Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError和OOM。

一般不编写针对性的代码进行处理。

java.lang.Throwable

• java.lang.Error:一般不编写针对性的代码进行处理。
• java.lang.Exception:可以进行异常的处理

编译时异常(checked)

IOException
FileNotFoundException
ClassNotFoundException
。。。

运行时异常(unchecked,RuntimeException)

NullPointerException
ArrayIndexOutOfBoundsException
ClassCastException
NumberFormatException
InputMismatchException
ArithmeticException

异常的处理：抓抛模型

过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象,并将此对象抛出。一旦抛出对象以后，其后的代码就不再执行。

关于异常对象的产生： ① 系统自动生成的异常对象 ② 手动的生成一个异常对象，并抛出（throw）

过程二：“抓”：可以理解为异常的处理方式：① try-catch-finally ② throws

try-catch-finally的使用

try{
        //可能出现异常的代码
}catch(异常类型1 变量名1){
//处理异常的方式1
}catch(异常类型2 变量名2){
//处理异常的方式2
}catch(异常类型3 变量名3){
//处理异常的方式3
}
....
finally{
//一定会执行的代码
}

说明：

• finally是可选的。
• 使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配
• 一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（在没有写finally的情况）。继续执行其后的代码
• catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。 catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错
• 常用的异常对象处理的方式： ① String getMessage() ② printStackTrace()
• 在try结构中声明的变量，再出了try结构以后，就不能再被调用
• try-catch-finally结构可以嵌套
  ①体会1：使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
  ②体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。针对于编译时异常，我们说一定要考虑异常的处理。

try-catch-finally中finally的使用：

• finally是可选的
• finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch中有return语句等情况。
• 像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的释放。此时的资源释放，就需要声明在finally中。

异常处理的方式二：throws + 异常类型

• "throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码，就不再执行！
• 体会：try-catch-finally:真正的将异常给处理掉了。throws的方式只是将异常抛给了方法的调用者,并没有真正将异常处理掉。
• 开发中如何选择使用try-catch-finally 还是使用throws？
  ①如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理。
  ②执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。

方法重写的规则之一： * 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

如何自定义异常类？

• 继承于现有的异常结构：RuntimeException 、Exception
• 提供全局常量：serialVersionUID
• 提供重载的构造器

以上内容主要参考了以下博客，在此感谢前辈的整理。自己主要承担搬运的任务，整理内容留作以后复习用。

https://www.cnblogs.com/kylinxxx/p/13165333.html