廖雪峰Java2面向对象编程-3继承和多态-1继承

1.继承

继承是一种代码复用的方式.
Student与Person有相同部分的代码。
Student可以从Person继承，这样Student获得了Person的所有功能，只需要编写新增的功能即可。通过继承，可以实现代码的复用。

继承使用关键字extends，一个类只能有一个父类。
如果没有写明继承类，编译器会自动指定该类继承于基类Object。
Person：超类super，父类，基类
Student：子类subclass，扩展类

Person.java
```#java
//默认继承Object
public class Person /*extends Object */{
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setAge(){
this.age = age;
}
public int getAge(){
return this.age;
}
public void run(){
System.out.println(name+" is running!");
};
}
```
Student.java
```#java
public class Student extends Person{
private int score;
public void setScore(int score){
this.score = score;
}
public int getScore(){
return this.score;
}
}
```
Hello.java
```#java
public class Hello {
public static void main(String[] args){
Person ming = new Person();
Student hong = new Student();
ming.setName("小明");
hong.setName("小红");
ming.run();
hong.run();
}
}
```

2.protected

上例中Person类定义的private字段无法被子类访问，用protected修饰的字段可以被子类访问。

protected把字段和方法的访问权限控制在继承树内部

Person.java

public class Person /*extends Object */{
    protected String name; //将name的修饰符更改为protected
    private int age;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public void setAge(){
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }
    public void run(){
        System.out.println(name+" is running!");
    };
}

Student.java

public class Student extends Person{
    private int score;
    public void setScore(int score){
        this.score = score;
    }
    public int getScore(){
        return this.score;
    }
    public String hello(){
        return "Hello, " + this.name; //引用name
    }
}

public class Hello {
    public static void main(String[] args){
        Person ming = new Person();
        Student hong = new Student();
        ming.setName("小明");
        hong.setName("小红");
        ming.run();
        System.out.println(hong.hello());//引用hello方法
        hong.run();
    }
}

3.继承关系中的构造方法

编写Person类时，可以编写构造方法，或由编译器自动生成构造方法。由于子类包含有父类的所有功能，必须手动调用父类的构造方法。

Java语言规定，子类的构造方法第一行语句必须调用父类的构造方法。调用方式是super();

如果我们没有写super()，编译器会自动生成super()。如果父类没有默认的构造方法，此时编译器自动生成的构造方法会报错，因为父类的构造方法必须传入参数。此时我们需要显式的写上super，传入参数。

Person.java

public class Person /*extends Object */{
    protected String name;
    private int age;
    public Person(){    //默认的构建方法
        this.name = "王重阳";
    }
    public Person(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }
    public void run(){
        System.out.println(name+" is running!");
    };
}

Student.java

public class Student extends Person{
    public Student(){
            //根据父类默认的构建方法，自动生成super();
    }
    public Student(String name){
        super(name);
    }
    private int score;
    public void setScore(int score){
        this.score = score;
    }
    public int getScore(){
        return this.score;
    }
}

Hello.java

public class Hello {
    public static void main(String[] args){
        Student p = new Student("林朝英");
        Student s = new Student();
        p.run();
        s.run();
    }
}

# 4.向上转型
定义一个类时，实际是定义一个数据类型；定义继承时，是在数据类型之间加上了继承的关系。
定义一个实例对象时，需要把它赋值给一个引用类型的变量，让这个变量指向实例对象。
向上转型把一个子类型安全地变为更加抽象的类型(父类型)。
反过来，即向下转型是把一个父类型(抽象)变成一个自类型(具体)。如把一个Person类型变量强制转型为Student类型变量。
可以对实例变量进行向上转型(upcasting)和向下转型(downcasting)
```#java
//假如我们持有一个Student对象实例，name我们可以保证Student包含Person类型的全部功能，因此把它看成一个Person类型对象是没有问题的。
Student s = new Student("jack");
Person ps = s;
Student s2 = (Student) ps;
s2.run();
```

        /*Person实例p可能指向Person实例，也可能指向Student实例。向下转型为Student很有可能报错。如果变量p指向的实际类型并不是Student实例，JVM运行时会抛出ClassCastException的错误。*/
        Person p = new Person("tom");
        Student s2 = (Student) p;
        s2.run();

## 4.1instanceof操作符
```#java
public class Hello {
public static void main(String[] args){
Person p = new Person("tom");
System.out.println(p instanceof Person);
System.out.println((p instanceof Student ) + "\n");

    Student s = new Student("jack");
    System.out.println(s instanceof Person);
    System.out.println((s instanceof Student) + "\n");

    Student n = null;
    System.out.println(n instanceof Object);
    System.out.println(n instanceof Person);
    System.out.println(n instanceof Student);
}

}

<img src="https://img2018.cnblogs.com/blog/1418970/201901/1418970-20190114213553125-21523129.png" width="500" />
使用instanceof修改向下转型代码
```#java
Person p = new Person("tom");
        Student s = new Student("jack");
        Person ps = s;
        if(p instanceof  Student) { //只在类型正确时转型，避免异常
            Student s2 = (Student) p;
            s2.run();
        }

# 5.继承和组合
组合和子类使用不会，需要翻书
Student可以持有一个Book实例
继承是is关系，组合是has关系
```#java
public class Student extends Person{
private Book book;
public Student(String name){
super(name);
}
private int score;
public void setScore(int score){
this.score = score;
}
public int getScore(){
return this.score;
}
...
}
```

6.总结：

继承是面向对象编程的一种代码复用方式。

Java只允许单继承

protected允许子类访问父类的字段和方法

子类的构造方法可以通过super()调用父类的构造方法

可以安全地向上转型为更为抽象的类型

可以强制向下转型，最好借助instanceof判断

子类和父类的关系是is，has关系不能用继承