类的继承extends_extends 实现一个类继承

        当一个类包含另一个类已有的字段与方法，同时还符合逻辑上的is关系，就可以让前者继承后者。

目录

1.实现：

2.private

3.Object类

3.super限定

6.阻止继承

7.向上转型

8.向下转型（引用类型之间的强制转换）

---

1.实现：

        使用extends关键字实现

修饰符 class SubClass extends SuperClass{
    //类定义部分
}

2.private

        子类无法访问父类private修饰的字段/方法，可将private-->protected

3.Object类

        任何类，除Object类，都会继承自某个类。（Object是始祖）。

        可以覆写Object类，如toString(),equals(),hashCode();

import java.util.Objects;
 
public class Main {
    public static void main(String[] args) {
        SubClass s=new SubClass();
        s.name=888;
        s.secret=1332;
        System.out.println(s.equals(s));
        System.out.println(s.toString());
        System.out.println(s.hashCode());
    }
}
class SubClass{
    int name;
    int secret;
    //toString() 返回该对象的字符串表示
    @Override
    public String toString(){
        return "name of the instance:"+name;
        //覆写，返回可以表述该对象信息的字符串
    }
    //equals(Object obj)判断对象相等,通常没什么用
    @Override
    public boolean equals(Object obj){
        if(obj instanceof SubClass){
            SubClass s=(SubClass) obj;
            //向下转型
            return Objects.equals(this.name, s.name);//当name相等时，返回true
        }
        return false;
    }
    //hashCode() 返回对象的hash值，默认根据地址计算。
    @Override
    public int hashCode(){
        //hash算法
        int hash=secret/2;
        return hash;
    }
}

3.super限定

        super指向父类，一般情况super.x        this.x        x  效果是一样的。

1. 调用父类被覆写的方法，可通过super调用
2. 任意类的构造方法中，第一个语句必须调用父类构造器。默认为super()无参
3. 调用父类构造器用super(...);注意参数列表

 #当父类中没有默认的无参构造器时，必须在子类的构造器中调用父类中的有参构造器

class SuperClass{
    protected int num;
    protected String name="name";
    public SuperClass(int num,String name){
        this.name=name;
        this.num=num;
    }
}
class SubClass extends SuperClass{
    char c;
    public SubClass(int num,String name,char c){
        super(num,name);
        this.c=c;
    }
}

6.阻止继承

        final修饰的class，无法被继承。但可以继承其他类

7.向上转型

 子类类型可以安全的为父类类型赋值，即向上转型。season：子类是父类的扩展

#此时，通过sup调用的方法是子类 覆盖/继承 的父类方法，同时无法调用子类特有的字段/方法。

#sup的实例变量为SuperClass类的实例变量，不是子类的。

#子类可以给方法参数列表中的父类形参 传参 (大大滴有用，可以让代码更简洁）

public class Main {
    public static void main(String[] args) {
        //SubClass sub=new SuperClass(666,"name");//NO
        SuperClass sup=new SubClass(666,"name",'A');//YES
        System.out.println(sup.name);//父类sup中的name
        sup.test();//子类覆写父类方法
    }
}
 
class SuperClass{
    protected int num;
    protected String name="sup";
    public SuperClass(int num,String name){
        this.name=name;
        this.num=num;
    }
    public void test()
    {
        System.out.println("父类方法");
    }
}
class SubClass extends SuperClass{
    char c;
    protected String name="sub";
    public SubClass(int num,String name,char c){
        super(num,name);
        this.c=c;
    }
    public void test()
    {
        System.out.println("子类覆写父类方法");
    }
}

8.向下转型（引用类型之间的强制转换）

        将父类类型强制转化为子类类型。

        引用类型之间的强制转换只能发生在父类和子类之间。

#意义：向上转型无法访问子类特有的特有成员/方法。

instanceof 判断前面的对象是否是后面的类/子类。

public class Main {
    public static void main(String[] args) {
        Animal A=new Cat();
        Animal B=new Dog();
        Call(A);//喵喵喵
        Call(B);//汪汪汪
    }
    public static void Call(Animal A){
        if(A instanceof Cat)
        {
            ((Cat) A).Call();
        }
        if(A instanceof Dog)
        {
            ((Dog) A).Call();
        }
    }
}
class Animal{
    String name;
}
class Cat extends Animal{
    public void Call()
    {
        System.out.println("喵喵喵");
    }
}
class Dog extends Animal{
    public void Call()
    {
        System.out.println("汪汪汪");
    }
}