Day12继承、final、super、覆写、多态

1.继承(extends)
    1.1继承是什么？
        1.继承(extends)是从已有类中，派生出新的类，新的类拥有父亲的属性和行为，并且还能扩展新的属性和行为
            2.java中只支持单继承，不支持多继承，这样可以让java中的继承关系比较简单。
                一个类只能有一个父类，但是一个父类可以拥有多个子类，易于维护和管理。
                    为了解决单继承功能变弱的问题，java提出了接口，一个类可以实现多个接口
                        3.继承是可以传递的，A继承B,B继承C,这样A也会拥有C的功能。
                            4.私有属性和构造方法是不能被继承的。
                                5.如果一个类没有显示继承其他类，则该类继承Object
                                    java.lang.Object是java提供的根类。
        1.2继承能做什么？
            解决的问题：
                1.提高了代码的效率，避免了代码的重写，提高了代码重用性。
                    2.覆写
                        3.多态
        1.3继承怎么用?
            语法：{修饰符} class 子类名 extends 父类名{
            };
2. super
    1.1 super 是什么？
        super: 1.官方说法保存了父类型特征。
                    2.在有继承关系的体系中，可以通过 super 表示父类的数据。
    1.2 super 能做什么？
            1.区分父类和子类同名的数据
                2.不能用在静态方法中，可以用在成员/构造方法中。（同名后，子类优先级高，如果想使用父类，需要使用 super.xxx）//用在子类构造方法中，调用指定的父类构造方法
                    语法：
                        super(参数)，必须在子类构造方法第一行。
                    如果子类构造方法中，没有使用 this(xxx) 也没有使用 super(xxx) 则有一个 super()去调用父类的无参构造。
                    this(xxx)和 super(xxx) 不能同时出现。
    1.3 super 怎么用?
        1.3.1 区分子类和父类同名的变量。
            1.3.2 用在子类构造方法中，调用指定的父类构造方法

3. 方法覆写 (@override)-方法覆写注解 //是源码注解，编译后生成class文件后就会被去掉。
    1.1 覆写是什么？//覆写特指成员方法，除了成员方法，其他的都不能覆写
        1.什么时候需要对父类方法进行覆写？
            当父类的功能满足不了子类需求的时候。
        2.覆写的条件
            2.1 有继承关系的体系
                2.2 方法名必须一致，如果方法名不一致，就是两个方法了
                    2.3 参数列表必须一致，如果参数列表不一致，就变成了方法重载。
                        2.4 返回值必须一致
                            2.5 不能有更多的异常（异常只能越来越少）
                                2.6 不能有更低的访问权限
        3.覆写的意义
            1. 功能越来越强
                2.使用范围越来越广
                    3.错误越来越少
    1.2 覆写怎么使用？
        将父类中的方法直接复制过来，在父类的基础上进行功能修改。
4.final
    1.final 是什么？
        final 是修饰符，表示最后的，不可更改的。
            类： final 修饰的类不能被继承。
                变量： final 修饰的变量，没有默认值，不能二次赋值，必须显式赋值（不能有不赋值的情况    ）
                    方法： final 修饰的成员方法 不能被覆写。
        final 修饰的静态变量，一般被称为常量， public static final ；//常量名建议全部大写。
5.多态
        1.1软件设计六大原则
            1.单一职责原则
                原则思想：一个方法只做一件事，一个类只负责一个职责.
                    优点：降低类和类之间的耦合度，提高可读性，可维护性，可扩展性，降低可变性的风险。
                2.里氏替换原则
                    原则思想：能使用父类的地方，就一定可以使用子类。
                        子类可以扩展父类的功能，但是不能更改父类的功能，并且子类还可以有自己特有的功能。
                        优点：增强了程序的健壮性，即使有了新的子类，原子类不受影响。
                    3.依赖倒置原则
                        原则思想：高层次不应该依赖低层次，都应该依赖于抽象。
                            优点：拥抱多种变化，可以减少需求变化带来的工作量。
                                4.接口隔离原则
                                    原则思想：类和接口之间应该建立在最小接口上。
                                        5.迪米特法则
                                            原则思想：又称为最少知识原则，一个对象尽可能的少了解其他对象。一个类中尽量减少对其他类的依赖。
                                                .开闭原则
                                                        原则思想：对修改关闭，对扩展开放。
                                                            尽量通过扩展软件实体来解决需求的变化，而不是通过修改已有的代码来完成变化。
1.多态是什么？
    多态就是里氏替换原则的一种体现。
        能使用父类的地方就一定可以使用子类。
            
        多态就是 父类引用指向子类对象。
            父类引用： 使用父类类型创建的引用类型变量
                指向： 通过这个引用可以找到谁
                    通过父类创建的一个引用类型变量，找到了子类的对象。
                        父类类型 a = new 子类();
                        Animal a = new Animal();
                            Animal a = new Cat(); //多态
                有变量的地方，就能发生多态，并且多态发生在赋值的时候。
2.多态的几种形式？//多态怎么用？
    1. 直接多态 父类 变量 = new 子类();
        2.形参/实参： 参数列表 用父类声明。调用方法 传递子类对象。
            public void m1(Animal a)
                m1(new cat());
            3.返回值多态： 返回值类型是父亲类型，但是返回的对象 是子类对象
                public Animal m2(){
                    return new cat();
                }
3.为什么用多态？ 它有哪些优点
        程序扩展度高。
4.多态进行属性调用；
    1.父类没有的，都调用不了（因为多态缺点：丢失子类特有的属性）
        2.父类有的，子类没有的，执行父类。
            3.父类和子类都有的，除了成员方法执行子类的，其他的都执行父类的。（因为成员方法可以覆写）。