java 继承

Posted 2020-12-21 shangjinshuai

继承的特点 ---》 成员方法
    成员方法不重名：
        如果子类父类中出现不重名成员方法，这时得调用是没有【任何影响的】，对象调用方法时，会先在子类中查找有没有对应的方法，
        若子类中存在该方法那么久执行该方法，若子类当中不存在该方法那么就会执行父类当中的成员方法
        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();//调用的是Fu类中的show方法 10
                zi.show2();//调用的是Zi类中的show2方法 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();//调用的是Fu类中的show方法 20
                        zi.show2();//调用的是Zi类中的show2方法 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 extend 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.子类方法覆盖父类方法，返回值类型、方法名称和参数列表必须一模一样
    继承后的特点---》构造方法
        先回忆一下构造方法的定义和作用：
            1.构造方法的名字和类名要保持一致，所以子类是无法继承父类当中的构造方法
            2.构造方法的作用一般是用来初始化对象的成员变量，所以子类在初始化的过程中，
                必须先执行父类中的初始化动作子类的构造方法当中默认有一个super()方法 ，
                表示调用的父类的构造方法，父类的成员变量初始化之后才可以给子类使用.
                public class Fu{
                    provate int n;
                    public Fu(){
                        System.out.println("Fu()");
                    }
                }
                public class Zi extends Fu{
                    public Zi(){
                        //super() 调用父类中的构造方法  隐式调用
                        System.out.println("Zi()");
                    }
                }
                public class TestExtendsDemo03{
                    public static void main(String[] args){
                        //构建子类对象
                        Zi zi = new Zi();
                        
                    }
                }
                //输出结果
                //Fu()
                //Zi()
    super和this
        父类空间优先于子类对象的产生
            在每次创建子类对象的时候，先初始化父类空间，再创建子类对象.目的在于子类对象中包含了其对应的父类空间，
                便可以包含父类的成员，如果父类成员非私有，则子类就可以随意使用父类成员，代码体现在子类的构造方法调用时，
                会先调用父类的构造方法.

　　普通方法重写 想要调用父类被重写的方法 需要显式的定义super.被重写方法（才会压栈执行）否则不会