day-12 final 覆写 多态

1方法覆写

1.1是什么

        Override 方法覆写

                子类覆写父类的方法

                        方法名 参数列表 返回值 必须相同

                        不能比原方法有更低的访问权限 权限控制必须大于等于原方法

                        不能比原方法有更宽泛的异常 异常小于等于原方法

                        前提 必须有继承的关系

        

        Overload 方法重载  方法名相同 参数列表不同 列表可以是个数不同或者类型不同

        当父类功能无法满足子类的需求的时候 子类对父类功能进行方法重写

        一般是父类提供方法没有方法体  子类实现

1.2 怎么用

        

1.3 @Override

        @Override 是注解 源码注解 编译后就没了

        可以写可以不写 是一种提醒机制 

        加上之后如果 覆写失败则会提升

2 final

        2.1 是什么

                final是修饰符 是最终的 不可修改的

        2.2 能做什么

                final修饰的类 不能被继承

                final修饰的成员方法 不能被覆写

                final修饰的变量不能被二次赋值 没有默认值 必须一开始赋值

                一般把final修饰的静态变量叫做 常量 publIc static final 数据类型 数据名 = 值；

        2.3怎么用

                

                

  2.4 final修饰的引用类型        

        final修饰的引用类型变量 变量值不能修改 但是变量指向的对象中的值 如果没有final修饰

        是可以修改的

        

        

                     

  3 多态

        3.1 是什么

                 多态
 *     polymorphic 多种形态 相同功能 不同的对象有不同的状态
 *     父类引用指向子类对象
 *     父类就是长辈 只要是祖宗都行
 *     引用 指的引用数据类型
 *     使用父类类型创建的引用型变量 可以找到子类对象
         * 父类 变量名 = new 子类（）；

        3.2 相关知识 

          里氏替换原则 能使用父类的地方就一定可以使用子类
         * 软件设计六大原则

软件设计六大原则_程序猿S先森丶的博客-CSDN博客

       3.3 应用场景

                只要是一种情况对应多种不同的实现方式 一定使用多态

        3.4优点

                降低耦合度,扩展性、替换性、维护性、灵活性增强

        3.5 缺点

                使用多态进行属性调用：

                1 子类特有的 调用不了 因为多态的缺点是丢失子类特有的属性

                2 成员方法 如果子类覆写了父类的成员方法 则调用子类的成员方法       

                3 非成员方法 调用父类的

                

   3.6 Instanceof

         判断 某个对象是否由这个类实例化而来

        防止强制类型转换出现错误

        java.lang.ClassCastException 类型转换异常

        

        3.8 多态的几种形式

                

        3.9 隐式多态

                通过子类对象 调用继承父类的成员方法，此时上下文环境是多态环境

        public static void main(String[] args) {
        /*
        Sup4 sup4=new Sub4();
        System.out.println(sup4.age);//2
        sup4.m1();//父类m1 子类没有
        sup4.m2();//子类m2 覆写
        Sub4 sub4=(Sub4) sup4;
        System.out.println(sub4.age);//1
        sub4.m1();//父类 继承
        sub4.m2();
        sub4.m3();    */
        Sub4 sub4=new Sub4();
        sub4.m1();
        System.out.println(sub4);
        
    }
}
class Sup4{
    int age=2;
    int saaaa=20;
    public void m1(){
        /**
         * this 是对象中第一个成员变量保存当前对象的内存地址
         * this 既然保存当前对象内存地址 那么this类型可以是当前类型 可以是父类类型
         * this写在那个类 那个类就是当前类 所以Sup4父类是Object
         * 因为this能调用当前类所有的属性并没有丢失 因此this是Sup4当前类类型
         * Sup4 this；
         * this 那个对象调用这个成员方法 this代表的就是谁
         * 最终Sub4调用m1方法 因此this指向Sub4
         * Sup4 this=Sub1；
         * 
         */
        System.out.println(this);//sub4的内存地址
        System.out.println(this.age); //2
        System.out.println(this.saaaa);//20
        System.out.println(age);//2
        m2(); //子类 覆写
        //System.out.println("父类m1");
        // m3(); 报错 父类没有
        
    }
    public void m2(){
        System.out.println("父类m2");
    }
}
class Sub4 extends Sup4{
    int age=1;
    public void m2(){
        System.out.println("子类m2");
    }
    public void m3(){
        System.out.println("子类m3");
    }