【OO面向对象基础】继承、super、重写、引用类型数组、null

Post author:xfxia
Post published:2023年9月7日
Post category:其他

目录

1、继承：

2、super：指代当前对象的超类对象

3、方法的重写(override/overriding)：重新写、覆盖

补充：

泛化：从程序设计角度而言叫泛化，从代码实现角度而言叫继承，泛化就是继承

继承要符合is(是)的关系

继承的是超类的成员变量和普通方法，不包括超类的构造方法，超类的构造方法是被派生类通过super()来调用的，而不是继承的

1、继承：

作用：代码复用

通过extends实现继承

超类/基类/父类：共有的属性和行为

派生类/子类：特有的属性和行为

派生类可以访问：超类的+派生类的，超类不能访问派生类的

一个超类可以有多个派生类，一个派生类只能有一个超类———单一继承

具有传递性

java规定：构造派生类之前必须先构造超类

在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法

在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

注意：super()调用超类构造方法，必须位于派生类构造方法中的第1行

public class Person {
    String name;
    int age;
    String address;
    Person(String name,int age,String address){
        this.name = name;
        this.age = age;
        this.address = address;
    }

    void eat(){
        System.out.println(name+"正在吃饭...");
    }
    void sleep(){
        System.out.println(name+"正在睡觉...");
    }
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
    }
}

public class Student extends Person{
    String className;
    String stuId;
    Student(String name,int age,String address,String className,String stuId){
        super(name,age,address); //传递的是name/age/address的值
        this.className = className;
        this.stuId = stuId;
    }

    void study(){
        System.out.println(name+"正在学习...");
    }
}

public class Teacher extends Person{
    double salary;
    Teacher(String name,int age,String address,double salary){
        super(name,age,address);
        this.salary = salary;
    }

    void teach(){
        System.out.println(name+"正在讲课...");
    }
}

public class Doctor extends Person {
    String title;
    Doctor(String name,int age,String address,String title){
        super(name,age,address);
        this.title = title;
    }
    void cut(){
        System.out.println(name+"正在做手术...");
    }
}

public class ExtendsTest {
    public static void main(String[] args) {
        Student zs = new Student("张三",25,"廊坊","jsd2302","001");
        zs.eat();
        zs.sleep();
        zs.sayHi();
        zs.study();

        Teacher ls = new Teacher("李四",35,"佳木斯",6000.0);
        ls.eat();
        ls.sleep();
        ls.sayHi();
        ls.teach();

        Doctor ww = new Doctor("王五",46,"山东","主任医师");
        ww.eat();
        ww.sleep();
        ww.sayHi();
        ww.cut();
    }
}

2、super：指代当前对象的超类对象

super.成员变量名————————-访问超类的成员变量

当超类成员变量和派生类成员变量同名时，super指超类的，this指派生类的

若没有同名现象，则写super和this是一样的

super.方法名()——————————调用超类的方法

super()—————————————-调用超类的构造方法

public class SuperDemo {
    public static void main(String[] args) {
        Boo o = new Boo();
    }
}


//在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供
class Coo{
    Coo(int a){
    }
}
class Doo extends Coo{
    Doo(){
        super(5);
    }
    /*
    //如下代码为默认的
    Doo(){
        super();
    }
     */
}

class Aoo{
    Aoo(){
        System.out.println("超类构造方法");
    }
}
class Boo extends Aoo{
    Boo(){
        super(); //默认的，调用超类的无参构造方法
        System.out.println("派生类构造方法");
    }
}

3、方法的重写(override/overriding)：重新写、覆盖

发生在父子类中，方法名相同，参数列表相同

重写方法被调用时，看对象的类型—————new谁就调谁的，这是规定

class 餐馆{
    void 做餐(){ 做中餐 }
}
//1)我还是想做中餐----------------------不需要重写
class Aoo extends 餐馆{
}
//2)我想改做西餐------------------------需要重写
class Boo extends 餐馆{
    void 做餐(){ 做西餐 }
}
//3)我想在中餐基础之上加入西餐------------需要重写(先super中餐，再加入西餐)
class Coo extends 餐馆{
    void 做餐(){
        super.做餐();
        做西餐
    }
}

public class Person {
    String name;
    int age;
    String address;
    Person(String name,int age,String address){
        this.name = name;
        this.age = age;
        this.address = address;
    }

    void eat(){
        System.out.println(name+"正在吃饭...");
    }
    void sleep(){
        System.out.println(name+"正在睡觉...");
    }
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
    }
}

public class Student extends Person{
    String className;
    String stuId;
    Student(String name,int age,String address,String className,String stuId){
        super(name,age,address); //传递的是name/age/address的值
        this.className = className;
        this.stuId = stuId;
    }

    void study(){
        System.out.println(name+"正在学习...");
    }
    
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address+"，所在班级为:"+className+"，学号为："+stuId);
    }
}

public class Teacher extends Person{
    double salary;
    Teacher(String name,int age,String address,double salary){
        super(name,age,address);
        this.salary = salary;
    }

    void teach(){
        System.out.println(name+"正在讲课...");
    }
    
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address+"，工资为:"+salary);
    }
}

public class Doctor extends Person {
    String title;
    Doctor(String name,int age,String address,String title){
        super(name,age,address);
        this.title = title;
    }
    void cut(){
        System.out.println(name+"正在做手术...");
    }
}

public class ExtendsTest {
    public static void main(String[] args) {
        Student zs = new Student("张三",25,"廊坊","jsd2302","001");
        zs.eat();
        zs.sleep();
        zs.sayHi();
        zs.study();

        Teacher ls = new Teacher("李四",35,"佳木斯",6000.0);
        ls.eat();
        ls.sleep();
        ls.sayHi();
        ls.teach();

        Doctor ww = new Doctor("王五",46,"山东","主任医师");
        ww.eat();
        ww.sleep();
        ww.sayHi();
        ww.cut();
    }
}

补充：

泛化：从程序设计角度而言叫泛化，从代码实现角度而言叫继承，泛化就是继承

继承要符合is(是)的关系

继承的是超类的成员变量和普通方法，不包括超类的构造方法，超类的构造方法是被派生类通过super()来调用的，而不是继承的

class Aoo{
    int a;
    Aoo(){
    }
    void show(){
    }
}
class Boo extends Aoo{
    继承了Aoo类的a+show()，并没有继承Aoo类的构造方法
}

版权声明：本文为qq_36028783原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/qq_36028783/article/details/129167868