一、面向对象特征之二：继承性（Inheritance）
1、为什么要有继承？
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，
只要继承那个类即可。
此处的多个类称为子类(派生类)，单独的这个类称为父类(基类 或超类)。可以理解为:“子类 is a 父类”。
2、类继承语法规则
class Subclass extends SuperClass{ }
3、继承的作用
1. 继承的出现减少了代码冗余，提高了代码的复用性；
2. 继承的出现，更有利于功能的扩展；
3. 继承的出现让类与类之间产生了关系，提供了多态的前提;
4. 注意：不要仅为了获取其他类中某个功能而去继承。
4、继承的说明
1. 子类继承了父类，就继承了父类的方法和属性；
2. 在子类中，可以使用父类中定义的方法和属性，也可以创建新的属性和方法；
3. 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。
5、关于继承的规则
子类不能直接访问父类中私有的(private)的成员变量和方法。
6、Java只支持单继承和多层继承，不允许多重继承
1. 一个子类只能有一个父类；
2. 一个父类可以派生出多个子类
class SubDemo extends Demo{ } //ok
class SubDemo extends Demo1,Demo2...//error
二、方法的重写（Override/Overwrite）
定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，
子类的方法将覆盖父类的方法。
要求：
1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表；
2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型；
3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限，子类不能重写父类中声明为
private权限的方法；
5. 子类方法抛出的异常不能大于父类被重写方法的异常。
注意：
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。
因为static方法是属于类的，子类无法覆盖父类的方法。
三、四种访问权限修饰符
Java权限修饰符public、protected、 (缺省)、 private置于类的成员定义前，用来限定对象对该类成员的访问权限。
对于class的权限修饰只可以用public和default(缺省)。
public类可以在任意地方被访问。
default类只可以被同一个包内部的类访问。
四、关键字：super
在Java类中使用super来调用父类中的指定操作：
1. super可用于访问父类中定义的属性；
2. super可用于调用父类中定义的成员方法；
3. super可用于在子类构造器中调用父类的构造器。
注意事项：
1. 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员；
2. super的追溯不仅限于直接父类；
3. super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识。
调用父类的构造器
1. 子类中所有的构造器默认都会访问父类中无参数的构造器；
2. 当父类中没有无参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用
本类或者父类中相应的构造器。同时，只能”二选一”，且必须放在构造器的首行；
3. 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错。
this和super的区别
五、子类对象的实例化过程
六、面向对象特征之三：多态性
1. 多态性，是面向对象中最重要的概念，在Java中的体现：
对象的多态性：父类的引用指向子类的对象
可以直接应用在抽象类和接口上
2. Java引用变量有两个类型：编译时类型和运行时类型。
编译时类型：由声明该变量时使用的类型决定；
运行时类型：由实际赋给该变量的对象决定。
简称：编译时，看左边；运行时，看右边。
a). 若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
b). 多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法）
“看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
3. 对象的多态 —在Java中,子类的对象可以替代父类的对象使用
a). 一个变量只能有一种确定的数据类型。
b). 一个引用类型变量可能指向(引用)多种不同类型的对象。
Person p = new Student();
Object o = new Person(); // Object类型的变量o，指向Person类型的对象
o = new Student(); // Object类型的变量o，指向Student类型的对象
注：子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。
4. 一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中
添加的属性和方法
Student m = new Student();
m.school = “pku”; // 合法,Student类有school成员变量
Person e = new Student();
e.school = “pku”; // 非法,Person类没有school成员变量
说明原因：属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。
5. 方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法
public class Test {
public void method(Person e) {
// ……
e.getInfo();
}
public static void main(Stirng args[]) {
Test t = new Test();
Student m = new Student();
t.method(m); // 子类的对象m传送给父类类型的参数e
}
}
6. 虚拟方法调用(Virtual Method Invocation)
正常的方法调用
Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();
虚拟方法调用(多态情况下)
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据
赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。
Person e = new Student();
e.getInfo(); // 调用Student类的getInfo()方法
编译时类型和运行时类型
编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定
七、小结：方法的重载与重写
从编译和运行的角度看：
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的
名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的
重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。所以，对于重载而言，在方法调
用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。
八、多态小结
多态作用：
提高了代码的通用性，常称作接口重用
前提：
需要存在继承或者实现关系
有方法的重写
成员方法：
编译时：要查看引用变量所声明的类中是否有所调用的方法。
运行时：调用实际new的对象所属的类中的重写方法。
成员变量：
不具备多态性，只看引用变量所声明的类。
九、instanceof 操作符
x instanceof A：检验x是否为类A的对象，返回值为boolean型
要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
如果x属于类A的子类B，x instanceof A值也为true。
public class Person extends Object {…}
public class Student extends Person {…}
public class Graduate extends Person {…}
-------------------------------------------------------------------
public void method1(Person e) {
if (e instanceof Person) // 处理Person类及其子类对象
if (e instanceof Student) // 处理Student类及其子类对象
if (e instanceof Graduate) // 处理Graduate类及其子类对象
}
十、对象类型转换 (Casting )
基本数据类型的Casting：
自动类型转换：小的数据类型可以自动转换成大的数据类型
如：long g=20; double d=12.0f
强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型
如：float f=(float)12.0; int a=(int)1200L
对Java对象的强制类型转换称为造型
1. 从子类到父类的类型转换可以自动进行；
2. 从父类到子类的类型转换必须通过造型(强制类型转换)实现；
3. 无继承关系的引用类型间的转换是非法的；
4. 在造型前可以使用instanceof操作符测试一个对象的类型。
类型转换示意图
子类继承父类
若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里
的方法转移到子类中。
对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可
能覆盖父类中定义的实例变量。
十一、Object类的使用
1、Object类是所有Java类的根父类
如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
public class Person {
...
}
等价于：
public class Person extends Object {
...
}
例：
method(Object obj){…} // 可以接收任何类作为其参数
Person o=new Person();
method(o);
2、==操作符与equals方法
= =：
基本类型比较值:只要两个变量的值相等，即为true。
int a=5; if(a==6){…}
引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true。
Person p1=new Person();
Person p2=new Person();
if (p1==p2){…}
用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则编译出错。
equals()：所有类都继承了Object，也就获得了equals()方法，还可以重写。
只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。
格式:obj1.equals(obj2)
特例：当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象
原因：在这些类中重写了Object类的equals()方法。
当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等
3、重写equals()方法的原则
1. 对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”；
2. 自反性：x.equals(x)必须返回是“true”；
3. 传递性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”；
4. 一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”；
5. 任何情况下，x.equals(null)，永远返回是“false”； x.equals(和x不同类型的对象)永远返回是“false”。
4、==和equals的区别
1. "=="既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址;
2. equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是"==";我们可以看到
String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比
较值的错误观点;
3. 具体要看自定义类里有没有重写Object的equals方法来判断;
4. 通常情况下，重写equals方法，会比较类中的相应属性是否都相等。
十二、包装类(Wrapper)的使用
1. 针对八种基本数据类型定义相应的引用类型—包装类（封装类）
2. 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象
3. 基本数据类型包装成包装类的实例 —装箱
通过包装类的构造器实现：
int i = 500; Integer t = new Integer(i);
还可以通过字符串参数构造包装类对象：
Float f = new Float(“4.56”);
Long l = new Long(“asdf”); //NumberFormatException
4. 获得包装类对象中包装的基本类型变量 —拆箱
调用包装类的.xxxValue()方法：
boolean b = bObj.booleanValue();
5. 字符串转换成基本数据类型
通过包装类的构造器实现：
int i = new Integer(“12”);
通过包装类的parseXxx(String s)静态方法：
Float f = Float.parseFloat(“12.1”);
6. 基本数据类型转换成字符串
调用字符串重载的valueOf()方法：
String fstr = String.valueOf(2.34f);
更直接的方式：
String intStr = 5 + “”
十三、native关键的理解
使用 native 关键字说明这个方法是原生函数，也就是这个方法是用 C/C++等非Java 语言实现的，并且被
编译成了 DLL，由 java 去调用。
为什么要用 native 方法
java 使用起来非常方便，然而有些层次的任务用 java 实现起来不容易，或者我们对程序的效率很在意时，
问题就来了。例如：有时 java 应用需要与 java 外面的环境交互。这是本地方法存在的主要原因，你可以想
想 java 需要与一些底层系统如操作系统或某些硬件交换信息时的情况。本地方法正是这样一种交流机制：它
为我们提供了一个非常简洁的接口，而且我们无需去了解 java 应用之外的繁琐的细节。
native 声明的方法
对于调用者，可以当做和其他 Java 方法一样使用一个 native method 方法可以返回任何 java 类型，包括
非基本类型，而且同样可以进行异常控制。
native method 的存在并不会对其他类调用这些本地方法产生任何影响，实际上调用这些方法的其他类甚至
不知道它所调用的是一个本地方法。JVM 将控制调用本地方法的所有细节。如果一个含有本地方法的类被继承，
子类会继承这个本地方法并且可以用 java语言重写这个方法（如果需要的话）。
十四、垃圾回收机制关键点
1. 垃圾回收机制只回收JVM堆内存里的对象空间；
2. 对其他物理连接，比如数据库连接、输入流输出流、Socket连接无能为力；
3. 现在的JVM有多种垃圾回收实现算法，表现各异；
4. 垃圾回收发生具有不可预知性，程序无法精确控制垃圾回收机制执行；
5. 可以将对象的引用变量设置为null，暗示垃圾回收机制可以回收该对象；
6. 程序员可以通过System.gc()或者Runtime.getRuntime().gc()来通知系统进行垃圾回收，会有一些效果，
但是系统是否进行垃圾回收依然不确定；
7. 垃圾回收机制回收任何对象之前，总会先调用它的finalize方法（如果覆盖该方法，让一个新的引用变量
重新引用该对象，则会重新激活对象）；
8. 永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用；
对以前的知识回顾，加深基础知识！
学习来自：北京尚硅谷宋红康老师—Java核心基础2019年版
每天进步一点点，也许某一天你也会变得那么渺小！！！