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

1.继承

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

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

Person.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

public class Student extends Person{
    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){
        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)

        //假如我们持有一个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操作符

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);
    }
}

使用instanceof修改向下转型代码

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关系

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

转载于:https://www.cnblogs.com/csj2018/p/10269267.html