廖雪峰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 ) + " ");

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

    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关系不能用继承