Java三大体系之继承

Java三大特性之 继承

面对对象有三大特性：
1.封装
2.继承
3.多态
现在我们来讲第二个特性：继承

为什么要继承

如果我们定义了一个Person类：

class Person {
    private String name;
    private int age;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}

接下来我们定义一个Student类：

class Student {
    private String name;
    private int age;
    private int score;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
    public int getScore() { … }
    public void setScore(int score) { … }
}

我们发现Student类包含Person类的所有字段，我们是否可以不重复地写？

这时候 继承 就起到了作用

用 继承 可以让Student类继承Person类，再添加其他功能的字段即可

代码如下：

class Person {
    protected String name;
   protected int age;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}
//不需要重复地定义Person中的字段
class Student extends Person {
    protected int score;

    public int getScore() { … }
    public void setScore(int score) { … }
}

protected关键字

是用于同一个包下的类使用，可以很好地限制字段和方法的访问权限于一个继承树内。

super关键字

super关键字表示父类（超类），可以用super来引用父类的字段

class Student extends Person{
	public String getHellow(){
		return "Hellow"+super.name;
		}
	}

由于继承，这里用name，super.name，this.name效果均一样

但是 如果要运用父类的构造方法，特别是父类中无无参构造时，需要加上super关键字：

class Student extends Person {
    protected int score;
	public Person ( String name,int age,int score){
		super(name,age);
		this.score = score;
		}    
}

思考

子类不会继承父类的构造方法，我们平时的构造方法时编译时自动加上了super()。

向上转型

如果一个引用变量的类型是Student，那么它可以指向一个Student类型的实例,如果一个引用变量的类型是Person，那么它可以指向一个Person类型的实例:

Student student = new Student();
Person person = new Person();

我们还可以引用变量的类型是Person，但指向一个Student类型的实例:

Person student = new Student();

这是因为Student继承于Person，拥有Person的全部功能，所以可以将子类转变为更抽象的父类。

继承树关系：Student<Person<Object ：我们甚至可以转变为Object类型。

向下转型

与向上转型相反，向下转型是将抽象的父类强制转型为子类。

instanceof操作符

有些时候由于父类无子类的方法，向下转型会出现错误：

Person p1 = new Student(); 
Person p2 = new Person();
Student s1 = (Student) p1; // ok
Student s2 = (Student) p2; // runtime error! ClassCastException!

这时候我们可以用instanceof操作符进行判断

Person p = new Person();
System.out.println(p instanceof Person); // true
System.out.println(p instanceof Student); // false

扩展

Java14之后instanceof操作符可以直接转换为指定类型

 Object obj = "hello";
        if (obj instanceof String s) {
           ....// 可以直接使用s。
        }

（Something interesting) 阻止继承

如果一个类没有被final所修饰，理论上能被任何类所继承

如过我们用sealed修饰，并且permits指出希望被继承的类，则可以做到一个类只被指定的类所继承。

public sealed Person permits Man,Women,Student{
	...
	}

则只有Man，Women，Student,可以继承，其他类想继承会报错。

随便一写

public class jicehng {
    public static void main(String[] args) {
        Longs p = new Longs("squrt is ",18);
        System.out.println(p.name+p.longs);
    }
}

sealed class Shape permits Longs,Weight{
   protected String name;
    protected Shape(String name){
        this.name = name;
    }
}

final class Longs extends Shape{
    public int longs;
    public Longs(String name,int longs){
        super(name);
        this.longs = longs;
    }
}

final class Weight extends Shape{
    String shape;
    public Weight(String name,String shape){
        super(name);
        this.shape = shape;
    }
}