一、继承
有些类在设计上是有关联的，比如我们定义了一个动物类：
class Animal {
public String name;
public int age;
public String sex;
public void eat() {
System.out.println("动物在eat");
}
}在定义一个猫类：
class Cat {
public String name;
public int age;
public String sex;
public void eat() {
System.out.println("猫在eat");
}
public void catSound() {
System.out.println("猫发出的声音是喵喵");
}
}? ? 我们发现：这两个类有很多的部分是重叠的。那么，能不能降低重叠的部分，把Animal类中的直接拿过来在Cat类中使用呢？面向对象思想中提出了继承的概念。
1、继承的概念
? ? 继承：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了 由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。简单来说，继承是is--a的关系：猫是一个动物。
2、定义继承
Java中要表示类的继承关系，需要extends（扩展）关键字。Cat如何继承Animal：
? ? 类只有两种访问修饰限定符：public和什么都不加的默认权限访问。一个Java文件中只能只能有一个public类。由于main方法所在的类有一个public，所以其他的类都是默认的访问修饰限定符。这里的Cat是子类（或者派生类），Animal是父类（或基类、超类）。中间的extends表示扩展、继承。
那么上面的两个类就可以写为：
class Animal {
public String name;
public int age;
public String sex;
public void eat() {
System.out.println("动物在eat");
}
}
class Cat extends Animal {
//Cat类继承了Animal类的属性和方法。
public void catSound() {
System.out.println("猫发出的声音是喵喵");
}
}现在我们以Base类（基类）和Derived类（派生类）来举例。
class Base {
public int data1 = 10;
public int data2 = 20;
public void baseMethod() {
System.out.println("父类方法");
}
}
class Derived extends Base {
public int data3 = 30;
public int data4 = 40;
public void derivedMethod() {
System.out.println("子类方法");
}
}访问子类和父类的属性或方法：
发现：实例化子类对象，红色的框中出现子类继承过来父类的一些属性。?
3、super关键字
? ? 现在在子类中写一个derivedBaseSameNameAttribute()方法表示出现子类和父类中变量名同名的情况，在Base类中加一个data5=51；Derived类中加一个data5=50，然后在这个方法中访问。
打印的是子类中的data5。要访问父类的data5，需要加super关键字。super表示父类对象的引用。
? ? super和this关键字的使用差不多。super和this一样有三种使用方法：super.data，表示调用父类的属性、super.func()表示调用父类的方法、super()表示调用父类中的构造方法。这里的super.data5就表示调用父类的属性。
如果是成员方法名相同：在Base类和Derived类中加一个derivedBaseSameNameMethod()方法。
? ? 打印的是子类的derivedBaseSameNameMethod()方法。在main方法中要打印父类的同名方法，加一个super是不行的（同名属性也不行）。要么在子类中写一个方法来间接调用、要么将父类的derivedBaseSameNameMethod()方法和子类的方法形成重构、要么实例化父类对象访问。
这里的参数没有意义，只是为了调用父类的构造方法。但是最好不要这样写没有意义的参数。
总结：
（1）在子类中，如果想要明确来访问父类中的成员时，需要super关键字就可以了。父类和子类中不重名的时候也可以使用this。
（2）重名的时候，编译器采用就近原则。先去子类中找，找不到就去父类（不能从父类到子类）。还找不到就报错。
（3）通过子类对象访问父类与子类同名方法时，如果父类和子类同名方法构成重载，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；如果父类和子类同名方法相同（方法名、参数列表等）则只能访问到子类的，父类的会被覆盖掉（构成重写），无法通过子类对象直接访问到。
（4）super关键字只能在非静态方法中使用。在子类方法中访问父类的成员。
super和this比较，相同点：
（1）都是Java中的关键字，只能在类的非静态方法中使用。
（2）用在构造方法中，都要放在相对的第一行。也就是说它们不能同时存在。
不同点：
（1）this是当前对象的引用，super是子类对象从父类中继承下来的成员的引用。也就是说，this一般用来访问子类的方法和属性，super用来访问父类的方法和属性。
（2）this是非静态成员方法的一个隐藏参数，super不是隐藏的参数。
（3）构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有。
4、子类构造方法
? ? 在没有继承的时候，对类中的成员变量进行初始化，有就地初始化、默认初始化，代码块初始化等、最重要的是用构造方法进行初始化。那么一个类被继承后，有没有什么变化呢？
在父类写出它的带参数的构造方法。
给子类也加一个构造方法。
? ? 我们知道，子类是继承了父类的。所以子类在进行构造的时候，应该要给父类也进行构造。所以子类在构造的时候，要先帮助父类进行构造，在调用子类的构造方法。使用super()就可以了。
带参数的构造方法：
不带参数的构造方法：
?总结：
（1）若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法。
（2）如果父类构造方法是带有参数的，此时编译器不会再给子类生成默认的构造方法，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
（3）super()和this()相似，都要放在构造方法中的第一行。也就是说，super()和this()不能同时使用。
5、protected关键字
? ? 当父类中的属性被private修饰的时候，只能在父类中使用。子类虽然是继承了父类，但是访问不到这个属性。
只需要将这个private改为protected（受保护的）权限就可以了。
? ? 我们知道，Java中权限有四种：private、默认、protected和public。private表示只能在当前类中使用。默认表示只能在同一个包中使用。protected是继承权限，范围比默认的要大，可以在不同的包中访问到。public是公共权限，在哪里都能访问。
? ? 类要尽量做到封装，隐藏内部实现细节，只留下必要的信息给类的调用者。因此，要使用比较严格的访问权限。能提供private的就不要提供protected权限。
6、继承方式
Java支持多种继承方式：
? ? Java不支持一个类继承多个类的继承方式。但是可以使用接口来实现。在继承关系中，一般不要超过三层的继承关系。如果一个类不想被继承，就可以使用final关键字来修饰。final可以用来修饰变量或字段，表示常量（不能被修改）；修饰类，表示这个类是一个密封类，不能被继承；修饰方法，表示这个方法不能被重写。
7、组合
? ? 继承是一种表达类之间关系的方式，组合也是一种表达类之间关系的方式。组合只是将一个类的实例作为另一个类的字段。
有三个类：学生类、老师类和学校类。要把他们组合起来，就是学校里面有学生，学校里面有老师。
这样创建之后是不能直接访问的，要对学生类和老师类进行实例化后才能访问。
? ? 其他的就和前面的语法没有什么区别。我们写课后作业的时候的测试类就是一个组合。继承是is--a的关系：猫是一个动物，而组合是has--a的关系：动物有猫这个物种。
二、多态
? ? 多态具体一点就是要去完成某个行为，不同的对象去完成，会产生不同的状态。比如考试，学霸考试得到高分，学渣考试得到混合双打，这是一种多态。
1、多态实现的条件
（1）必须要在继承的体系下。
（2）子类对父类中的方法进行重写。
（3）通过父类引用去调用子类重写的方法。
多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。下面对这些条件分别做介绍。
2、向上转型和向下转型
? ? 向上转型是实现多态的一部分条件，它在继承的体系下。多态中上指的是父类，下指的是子类。向上转型就是子类转型成父类。或者：父类引用，引用子类对象。只要记住父类引用，引用子类对象。这是从小的范围像大的范围转换。
class Base {
public int data1;
private int data2;
public void BaseMethod() {
System.out.println("父类方法");
}
}
class FirstDerived extends Base {
public int data3;
private int data4;
public void derivedMethod() {
System.out.println("子类方法");
}
}
public class test_04_03_04 {//本人的Java文件名
public static void main(String[] args) {
Base base = new FirstDerived();
base.BaseMethod();
}
}? ? 父类引用了子类对象，但是不能调用子类方法。这个derivedMethod()方法在父类中是没有的。向上转型有三种用法：直接赋值、作为参数传参、作为返回值。
直接赋值：
作为参数传参：在main方法中新写一个方法，用来传参数。
?作为返回值：写一个方法，返回值是Base类型。
这三种虽然用处不一样，但本质上还是父类引用，引用子类对象。
向上转型能够让代码实现更灵活，缺点是不能调用子类特有的方法。
向下转型是子类引用，引用父类方法。但是这意味着范围的缩小，所以它不安全。
图示：
3、重写方法
? ? 重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写，返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。
定义一个Animal类，Cat类和Dog类继承了Animal类。
class Animal {
public String name;
public int age;
public void eat() {
System.out.println(this.name + " 吃食物");
}
}
class Cat extends Animal {
public void catchingMice() {
System.out.println(this.name + " 抓老鼠");
}
}
class Dog extends Animal {
public void housekeeping() {
System.out.println(this.name + " 看家门");
}
}
public class test_04_03_05 {
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
}
}? ? 我们知道，猫是可以吃猫粮的，狗是可以吃狗粮的。所以，对父类中的eat()方法能不能改一下呢？可以改，但是不能直接在父类方法中改，并不是所有的动物都是吃猫粮的。为了代码的直观，删去了Cat类中的catchingMice()方法和Dog类中的housekeeping()方法。
? ? 这个时候，子类和父类的eat方法中：返回值相同、方法名相同、方法参数列表相同。这就构成了方法的重写：子类的eat()方法对父类的eat()方法进行了扩展或覆盖。我们在用向上转型去调用子类的eat()方法。?
发现这里的结果是调用了子类的eat()方法。为了让重写显着更清楚，可以加上@Override。
这样，不仅可以显示更清楚，而且如果变量名等写错，就可以提示出来。?
? ? 在编译的时候，eat()调用应该是父类的方法，结果运行的时候，调用的是子类的方法。这种情况是在运行的时候发生的，叫运行时绑定（动态绑定）。
? ? 动态绑定，也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用哪个类的方法。
重写要注意的几个点：
（1）子类在重写父类的方法时，一般必须与父类方法原型一致：修饰符 返回值类型 方法名(参数列表) 要完全一致。
（2）返回值可以不同，但是要形成父子关系，叫协变类型。
（3）子类的重写方法访问权限不能比父类低。如果父类时protected，子类就不能是?默认或private；如果父类是public，子类只能是public。
（4）父类静态的，private修饰的，final修饰的方法都不能重写。
（5）和重载的区别
方法的重载是一个类的多态的体现，方法的重写是子类和父类多态的体现。
? ? 现在，在主类中写一个方法，传进去不同的对象，?调用父类的eat()方法，显示因为传进去猫这个对象，打印吃猫粮，传进去狗这个对象，打印吃狗粮。
class Animal {
public String name;
public int age;
public void eat() {
System.out.println(this.name + " 吃食物");
}
}
class Cat extends Animal {
@Override
public void eat() {
System.out.println(this.name + " 吃猫粮");
}
}
class Dog extends Animal {
@Override
public void eat() {
System.out.println(this.name + " 吃狗粮");
}
}
public class test_04_03_05 {
public static void function(Animal animal) {
animal.eat();
}
public static void main(String[] args) {
Cat cat = new Cat();
cat.name = "mimi";
Dog dog = new Dog();
dog.name = "大黄";
function(cat);
function(dog);
}
}4、使用多态的优缺点
优点：
（1）提高了代码的可读性，避免了使用大量的if-else。
（2）可扩展能力更强。
比如，打印不同的图形，这样，使用多态直接扩展就可以了。
class Shape{
public void draw() {
System.out.println("打印图形");
}
}
class Cycle extends Shape {
@Override
public void draw() {
System.out.println("打印?");
}
}
class Rect extends Shape {
@Override
public void draw() {
System.out.println("打印?");
}
}
class Flower extends Shape {
@Override
public void draw() {
System.out.println("打印?");
}
}
public class test_04_04_04 {
public static void drawShapes() {
Shape[] shapes = {new Cycle(), new Rect(), new Flower()};
for (Shape shape : shapes) {
shape.draw();
}
}
public static void main(String[] args) {
drawShapes();
}
}缺点：代码的运行效率低，而且，不能使用子类的方法。