面向对象的三大特征—继承,this、super关键字,方法重写,以及方法重写与重载的区别

  • 面向对象的三大特征—继承

  • ​ 抽象类

继承

继承后的特点—成员方法
成员方法不重名

​ 如果子类父类中出现不重名的成员方法,这时的调用是没有【任何影响的】,对象调用方法时,会先在子类中查找有没有对应的方法,若子类中存在该方法那么就执行子类中的方法,若子类当中不存在该方法那么会执行父类当中的成员方法。

public class Fu {
     int num = 10; 
    // 展示
     public void show() {
         System.out.println("Fu类中show方法在执行!");
         System.out.println("Fu类中的成员变量num:" + num)
     }
}
public class Zi extends Fu {
    int num = 20;
    // 展示
    public void show2() {
        System.out.println("Zi类中的show方法在执行!");
        System.out.println("Zi类中的成员变量num:" +num);
    } 
}
public class TestExtends {
    
    public static void main(String[] args) {
        // 构建子类对象
        Zi zi = new Zi();
        zi.show();// 调用父类当中的show方法   Fu类中show方法在执行!  10 
        zi.show2();// 调用子类当中的show2方法 Zi类中的show方法在执行!20 
    }  
}
成员方法重名-----重写(Override)

​ 如果父子类中出现了重名的成员方法,这时的访问是一种特殊情况。叫做方法重写(Override)。

  • 方法重写:子类中出现与父类一模一样的方法时(返回值类型,方法名和参数列表),会出现覆盖效果,也称为重写或者复写,简称“【声明不变,重新实现】”。

    示例代码:

    public class Fu {
        int num = 10;
        public void show() {
            System.out.println("Fu show()方法在执行!");
            System.out.println("Fu 成员变量num:" + num);
        }
    }
    public class Zi extends Fu {
        int num = 20;
        public void show() {
            System.out.println("Zi show()方法在执行!");
            System.out.println("Zi 成员变量num:" + num);
        }
    }
    public class TestExtendsDemo02 {
        public static void main(String[] args) {
            // 先构建一个子类的对象
            Zi zi = new Zi();
            // 调用show方法
            // 子类中有show()方法,执行的是重写后的show()
            zi.show();//  Zi show()方法在执行!  20    
        }
    }
    
    
    重写的应用

    ​ 子类可以根据需要,定义特定于自己的行为,既沿袭了父类的功能名称,又根据子类的需要重新实现父类方法,从而进行功能扩展。

    public class Phone {
        // 打电话
        public void call(){
            System.out.println("打电话!");
        }
        // 发短信
        public void sendMessage(){
            System.out.println("发短信!");
        }
        // 来电显示
        public void show() {
            System.out.println("来电显示电话号码!");
        }
    }
    public class IPhone12 extends Phone {
        // 重写父类当中的来电显示功能,并增加自己的显示姓名和显示头像功能
        public void show() {
            // 父类当中的功能保持不变
            super.show();
            // 新增新功能
            System.out.println("显示姓名!");
            System.out.println("显示头像!");
        }    
    }
    public class TestExtendsDemo03 {
        public static void main(String[] args) {
            // 创建一个子类对象
            IPhone12 iphone = new IPhone12();
            //调用父类当中的打电话
            iphone.call();
            // 调用重写之后的来电显示功能
            iphone.show(); //显示电话号码  显示姓名  显示头像
        }
    }
    
    

    重写:方法的名称一样,参数列表【一样】,返回值类型【也一样】,重写前提有继承关系

    重载:方法的名称一样,参数列表【不一样】,返回值类型无要求,在本类中。

​ 注意事项:

  • ​ 子类方法重写父类方法,必须要保证权限要大于等于父类权限
  • ​ 子类方法覆盖父类方法,返回值类型、方法名称和参数列表必须要一模一样。
继承后的特点-----构造方法

​ 先回忆下构造方法的定义和作用:

  1. ​ 构造方法的名字和类名要保持一致,所以子类是无法继承父类当中的构造方法

  2. ​ 构造方法的作用一般是用来初始化成员变量,所以子类在初始化的过程中,必须先执行父类中的初始化动作。子类的构造方法当中默认有一个super()方法,表示调用的父类的构造方法,父类的成员变量初始化之后,才可以给子类使用。

    public class Fu {
        private int n;
        public Fu(){
            System.out.println("Fu()");
        }  
    }
    public class Zi extends Fu {
        public Zi() {
            // super() 调用父类中的构造方法  隐式调用
            System.out.println("Zi()");
        }  
    }
    public class TestExtendsDemo04 {
        
        public static void main(String[] args) {
            Zi zi = new Zi();      
        }  
    }
    // 输出结果
    // Fu()
    // Zi()
    
    super 和 this

    ​ 父类空间优先于子类对象产生

    ​ 在每次创建子类对象的时候,先初始化父类空间,再创建子类对象。目的在于子类对象中包含了其对应的父类空间,便可以包含父类的成员,如果父类成员非私有,则子类可以随意使用父类成员,代码体现在子类的构造方法调用时,会先调用父类的构造方法。

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值