Java 继承和方法重写（简单易理解,建议收藏）

继承

• 集成的本质是对某一批类的抽象，从而实现对现实世界更好的建模

• extends的意思是“扩展”。 子类是父类的扩展

• Java中只有单继承，没有多继承

• 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等

• 继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示

• 子类和父类之间，从意义上讲应该具有“is a”的关系

• 方法一般使用public，属性一般使用private

• ctrl + H 打开继承树

• object类

• super

public class Application {
    
    public static void main(String[] args) {
        Student student = new Student();
​
        //student.test("落花");
        student.test1();
    }
}

//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
    
    private String name = "luohua";
​
    public void print(){
        System.out.println("Student");
    }
​
    public void test1(){
       print();         //Student
       this.print();    //Student
       super.print();   //Person
    }
​
​
    public void test(String name){
        System.out.println(name);   //落花
        System.out.println(this.name);  //luohua
        System.out.println(super.name); //无痕
    }
}

/Person 人：父类
public class Person {
    
    protected String name = "无痕";
​
​
    public void print(){
        System.out.println("Person");
    }
​
    /*
    私有的可以被继承，但不能被直接访问，可以间接访问
    private void print(){
        System.out.println("Person");
    */
}

public class Application01 {
    
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
    }
}

//老师 is 人：派生类，子类
public class Teacher extends Person01{
    
    public Teacher() {
        //隐藏代码；调用父类的无参构造，不写为默认调用父类的无参
        //super();    //调用父类的构造器，必须要在子类构造器的第一行
​
        System.out.println("Teacher无参执行了");
    }
}

public class Person01 {
    
    //调用一个对象，会先默认走无参构造器
    public Person01() {
        System.out.println("Person01无参执行了");
    }
}

• 方法重写

super注意点

1. super 调用父类的构造方法，必须在构造方法的第一个

2. super 必须只能出现在子类的方法或者构造方法中

3. super 和 this 不能同时调用构造方法

Vs this：

代表的对象不同

this：本身调用者这个对象

super：代表父类对象的引用

前提

this：没有继承也能使用

super：只能在继承条件下才可以使用

构造方法

this（）：本类的构造

super（）：父类的构造

方法重写

• 需要有继承关系，子类重写父类的方法！

  • 方法名必须相同

  • 参数列表必须相同

  • 修饰符 ：范围可以扩大但不能缩小： public>Protected>Default>private

  • 抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大)

重写：子类的方法和父类必须要一致；方法体不同！

为什么需要重写：

父类的功能，子类不一定需要，或者不一定满足！

-- 静态方法

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

//继承
public class A extends B{
    public static void say(){
        System.out.println("A ==> say()");
    }
}
​

//重写都是方法的重写，与属性无关
public class B {
    public static void say(){
        System.out.println("B ==> say()");
    }
}
​

• 非静态方法

public class Application {
​
    //静态的方法和非静态的方法区别很大！
        //静态方法：方法调用只和左边定义的数据类型有关
​
    //非静态：重写
    public static void main(String[] args) {
​
        //方法调用只和左边定义的数据类型有关
        A a = new A();
        a.say();//A
​
        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.say();//A
    }
​

//继承
public class A extends B{
    //Override 重写
    @Override //注解：有功能的注释
    public void say() {
        System.out.println("A ==> say()");
    }
}
​

//重写都是方法的重写，与属性无关
public class B {
    public void say(){
        System.out.println("B ==> say()");
    }
}
​

即b是A new出来的对象，因此调用了A的方法

因为静态方法是类的方法而非静态是对象的方法

有static时，b调用了B类的方法，因为b是用b类定义的

没有static时，b调用的是对象的方法，而b是用A类new的

重写的方法只能是public，而不能是private

重写方法快捷键：Alt + inser