继承

继承

• 继承的本质是对某一批类的抽象
• extends的意思是扩展。子类是父类的扩展
• Java只有单继承，没有多继承
• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
• 子类和父类的关系，从意义上讲应该具有“子类 是 父类”的关系
• 子类继承父类，就会拥有父类的全部属性和方法（修饰符为public）
• 父类属性一般为private，方法为public
• Java中，所有的类，都默认直接或间接继承object类
• 修饰符
  • public
  • protected
  • default（默认）
  • private

super

• super指代当前类的父类

1. super调用父类的构造器，必须在子类构造器的第一行
2. super只能出现在子类的方法或构造器中
3. super和this不能同时调用构造器

public class Demo01 {
    public static void main(String[] args) {
        Student s = new Student();
        s.say();//继承
        s.setMoney(10_0000);
        System.out.println(s.getMoney());

        s.test1("JavaKami");
        s.test2();
    }
}
//人
class Person {
    public Person() {
        System.out.println("Person无参");
    }

    private int money;
    protected String name = "Kami";

    public void say(){
        System.out.println("说了一句话");
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }

    public void print() {
        System.out.println("Person");
    }
}
//学生 是 人
class Student extends Person {
    public Student() {
        //编译器默认调用了父类的无参构造器
        super();//调用父类的构造器，必须要在子类的第一行
        System.out.println("Student无参");
    }

    private String name = "kami";

    public void print() {
        System.out.println("Student");
    }
    public void test1(String name) {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);//super指代父类
    }
    public void test2() {
        this.print();
        super.print();
    }
}
//教师 是 人
class Teacher extends Person {

}

方法重写

• 重写都是方法的重写，与属性无关
• 重写需要有继承关系，子类重写父类的方法

1. 方法名必须相同
2. 参数列表必须相同
3. 方法体不同
4. 修饰符：范围可以扩大但不能缩小 public > protected > default > private
5. 抛出异常：范围可以缩小但不能扩大 ClassNotFoundException --> Exception(大)

• 为什么需要重写：父类的功能，子类不一定需要，或者不一定满足

public class Demo02 {
    public static void main(String[] args) {
        //静态方法的的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();//A
        //父类的引用指向子类
        B b = new A();
        b.test();//B

        //非静态方法的调用：重写
        C c = new C();
        c.test();//C
        //子类重写了父类的方法
        D d = new C();
        d.test();//C
    }
}
class A extends B {
    public static void test() {
        System.out.println("A.test");
    }
}
class B {
    public static void test() {
        System.out.println("B.test");
    }
}

class C extends D {
    public void test() {
        System.out.println("C.test");
    }
}
class D {
    public void test() {
        System.out.println("D.test");
    }
}