JAVA 面向对象-2-继承(Inheritance)

i.继承(Inheritance)

1.继承的概念

继承：在面向对象编程的过程中，通过扩展一个已有的类，并继承该类的属性和行为，来创建一个新的类。

继承是面向对象编程最重要的特征之一。

继承的优点：
1). 避免大量的重复代码。 
2). 继承是功能的拓展，使得结构清晰。 更容易维护和修改。

父类：之前已有的类，也可以称基类、超类（superClass）
子类：新生的类，也可以叫派生类。

1.子类会继承父类的一切（不包括private修饰的私有类）方法和属性。
2.Java中只能单继承，通过extends进行继承。

测试设计：一个对象有（has a）一个属性，一个对象执行（does）一个行为。

2.使用“is a”关系判断继承

当使用继承时，如果说，子类“is a（是一个）”父类，成立。那么继承关系就是对的。

3.类的继承(extends)

"3W" , "1H":

What:在java中对父类方法和属性的继承 —— 功能拓展
Where:出现大量重复代码的时候
Why:避免大量重复代码，使代码结构清晰，更容易维护和修改。
How: 使用关键字extends继承父类。

1)父类（基类/superClass）：为子类提供可继承的属性和方法。

代码示例：

public class Pet {
    String name;
    int age;
    String color;
    public Pet(){
        System.out.println(处在构造函数中);
    }
/**带入参数的形式：
*   public Pet(String name){
*       System.out.println(name);
*   }
*/
    public void show() {
    }
}

2)子类：子类会继承父类的一切（不包括private修饰的私有类）方法和属性。

代码示例：

public class Cat extends Pet{
    public Cat(){
        super();   // ---------------------  调用父类的无参构造函数
        //或者 super(name);   ------------   调用父类的有参构造函数
        System.out.println("喵喵要吃鱼");
    }
    @Override
    public void show(){
        System.out.println(name+","+age);
        System.out.println("喵喵喵");
    }
}　

1.Java中只能单继承，通过extends进行继承。

2.如果父类有参数，子类也必须有参数，并返回给父类。否则无法程序执行

3.this();与super(); 是冲突的，它们都必须放在第一行才能生效。

4.单继承与多继承

某些OOP语言，如C++，允许多个继承。
但是Java中只能允许单继承，通过extends进行继承。
所以，每个Java类只有一个父类。

5.所有类的根类

java语言API中有一个特殊类Object，是整个Java类层次中的根类。
Object类是每一个Java类的父类（直接父类或者间接父类）。所以，不管什么类类型，Object中的方法都可以被任何对象调用。

6.方法的重载与重写

1）重载：只与参数的个数和类型有关。构造函数也能重载

代码示例：

public void show(int a){
  System.out.println(a);
}
public void show(int a,int b){
  System.out.println(a+b);
}
public void show(int a,double b){
  System.out.println(a+b);
}　　

重载可以针对同种行为的不同情况，方便处理。

2）重写：子类可以重写从父类继承的方法，从而允许子类添加或者改变父类中方法的行为，是OOP特征之一。

◇规则：

a. 子类的方法的返回值类型、方法名和形式参数列表，必须和父类相同。
b. 访问修饰符必须不小于父类的访问修饰符。
c. 子类中重写的异常不能抛出比父类更多的异常。

public class Pet {
    String name;
    int age;
    String color;
    public Pet(){
        System.out.println(处在构造函数中);
    }
/**带入参数的形式：
*   public Pet(String name){
*       System.out.println(name);
*   }
*/
    public void show() {
    }
}

public class Cat extends Pet{
    public Cat(){
        super();    //  -----------------------  调用父类的无参构造函数
        //或者 super(name);   ------------   调用父类的有参构造函数
        System.out.println("喵喵要吃鱼");
    }
    @Override
    public void show(){
        System.out.println(name+","+age);
        System.out.println("喵喵喵");
    }
}

1.重写的方法名字和参数必须一模一样。一定发生在父类和子类之间。 
2.当父类的方法不适合子类时，就需要重写。

7.super关键字

1）this引用：每个对象都有一个对自身的引用，this引用。
2）super引用：一个类则可以使用super关键字显式引用从父类继承的成员变量和方法。同时如果有参数，会将参数传递给父类。

1.在子类重写父类方法的时候，如果需要调用父类的方法，就需要使用super关键字。 
2.this和super关键字都必须写在代码第一行，所以只能选择一个。

8.final关键字

1）final常量：不能修改其中的值。

2）final类：一个类可以声明为最终类。最终类不能被其他类继承。

public final class Dog extends Pet{}

3）final方法：一个方法可以声明为最终方法。最终方法不能被重写。

public class Pet{
    String name;
    int age;
    public final void show(){}
    System.out.println(name+“, ”+age);
}　

9.实例化的过程

当一个对象被实例化时：
1）new运算符调用子类的构造器
2）子类会用this关键字调用子类的其他构造器。最后，子类中的第一行代码中不是this（）的构造器将被调用。 
3） 在子类的构造器中的任何语句执行前，父类的构造器必须用super关键字调用。如果没用显式使用super调用，编译器会用super（）调用无参数的父类构造器。 
4）如果父类也是另一类的子类，那么在父类的构造器中的任何语句执行前，父类构造器必须使用super调用更高一层父类的构造器。 
5）本过程继续执行，直到到达类层次树的顶部，即Object类。
6）Object类中的构造器执行，然后控制流程转到继承层次树中Object下面的类的构造器中。
7）构造器沿着继承层次树向下执行，最后一个要执行的构造器，实际上是第一步中先调用的那个构造器。

在每个构造器中，如果要调用super（）或this（），那么调用代码必须是构造器的第一行代码