继承与抽象类与接口

1.继承
概述:在开发中,我们发现多个类具有很多相似的功能,于是我们就把这些相似的功能放到一个类中,然后让这多个类和这个类产生一个关系,
这个关系就叫做继承

    关键字: extends

    语法:
        public class A类 extends B类{
        }

    认识:
        A类: 子类,派生类

        B类: 父类,基类,超类


    特点:
        1.子类继承父类,只能单继承,不能多继承,但是可以多层继承
        2.子类继承父类,就拥有父类里面的非私有属性\方法

    继承中成员变量的访问特点:
        使用变量遵循"就近原则", 先在局部位置找, 有就使用, 没有就去本类的成员位置找, 

      * 有就使用, 没有就去父类的成员位置找,有就使用, 没有就报错.

    注意事项:
         * 1.子类继承父类,不能继承父类的私有属性和私有方法
         * 2.子类继承父类,不能继承父类的构造方法,但是可以使用
         *      关键字: super
         *      调用父类的空参构造方法: super();
         *      调用父类的有参构造方法: super(参数);
         * 
         *      直接调用父类的普通方法; super.方法名();
         *      直接访问父类的属性: super.属性名
         * 3.不要为了继承而继承
         *      Dog 属性:姓名   年龄
         *          方法: 吃东西
         * 
         *      Person 属性: 姓名  年龄
         *              方法: 吃东西
         * 
         *      程序员:
         *          属性: 姓名  工号     薪资
         *          方法; 写代码
         *      
         *      项目经理:
         *          属性:姓名   工号  薪资  奖金
         *          方法: 写代码 审计代码
         * 4. 满足 is a 的关系
         *      学生 属于 人类
         *      子类  属于  父类

    方法的重写:
        概述: 子类出现和父类一模一样的方法

        为什么要重写方法?
            1.父类的功能无法满足子类的需求
            2.当子类具有特有的功能的时候


        重写的注意事项:
            1.父类的私有方法不能重写
            2.子类重写父类的方法,重写的方法的访问权限不能低于父类的访问权限
                private(本类) < protected(同一个包) < 默认(本类和子类) <  public(当前项目中)

            3.静态方法严格意义上来讲不是方法的重写(只是表现形式和方法的重写意义)


    方法的重载:
        概述: 方法名一致,方法的参数不一致(参数的数据类型不一致,参数的个数不一致)


    final 关键字
        1.修饰类
            被final修饰的类不能被子类继承

        2. 修饰方法
            被fianl修饰的方法不能被子类重写

        3. 修饰变量
            被final修饰的变量会变成一个常量,常量只能赋值一次

2. 多态
    多态指的是: 同一种行为,对于不同的事物具有不同的表现形式。 这就叫做多态。 
        医生          咔           动手术

        理发师         咔           剪头发

        演员          咔           停止了

    程序中的多态:不同的对象  以 自己的方式响应    相同名称方法的能力称为多态 

        Dog             吃               吃骨头 

        Cat             吃               鱼

        Monkey          吃               香蕉

    多态的条件:
        1. 继承
        2. 方法的重写
        3. 父类的引用指向子类的对象


    多态的使用\好处:
        1. 开发中使用父类的类型作为方法的参数类型声明，那么以后不管传入任意的子类对象,都可以接收。
        2.在调用方法的时候，调用的是子类的方法，前提是父类必须要有该方法，不然会编译不通过。

    多态成员访问特点:
        多态的成员访问特点:
            成员变量: 编译看左边,运行看左边
            成员方法:
                静态方法: 编译看左边,运行看左边
                非静态方法: 编译看左边,运行看右边
        总结: 除了非静态方法是编译看左边,运行看右边,其他情况都是编译看左边,运行看左边


    向下转型:
        Animal anl = new Dog();// 向上转型
        Dog dog = (Dog)animal;// 向下转型
        dog.lookHome();



3.抽象类:
    抽象方法: 没有方法体的方法就是抽象方法 一般用 abstract
    抽象类: 用 abstract修饰的类就是抽象类, 有抽象方法的类一定是抽象类

    特点:
        1.有抽象方法的类一定是抽象类
        2.不能创建对象,通过其子类来创建对象
        3.可以有构造方法,但是不能用来创建对象,
                用于子类对象访问父类数据之前,对父类的属性初始化
        3.子类:
            普通类: 必须要实现父类的抽象方法
            抽象类: 不一定要实现父类的抽象方法


4.接口:
    概述:用 Interface 定义的就是接口

    实现:

        public class 类A implements  接口{
        }

        public class 类A extends 类B implements  接口{
        }

    特点:
        1. 定义接口 使用的关键字是 Interface

        2. 实现接口 使用的关键字是 implements

        3. 不能有构造方法,也不能创建对象,通过实现类来创建对象

        4. 实现类:
            普通类: 一定要实现接口中的抽象方法

            抽象类: 不一定要实现接口中的抽象方法


    成员特点:

        JDK1.7及以前的:
            成员变量: 默认修饰符 public static final

            成员方法: 只能是抽象方法  默认修饰符 public abstract


        JDK1.8:

            成员变量:默认修饰符 public static final

            成员方法: 增加了有方法体的方法,非静态方法,需要加 default 修饰,静态方法就直接写


    接口:

    类:


    类和类的关系: 继承关系    单继承\多层继承

    类和接口的关系: 实现关系   单实现\多实现

    接口和接口的关系:   继承关系    单继承\多继承\多层继承

    接口和抽象类的区别:  
        1. 都不能创建对象,都可以写抽象方法
        2. 定义的关键字不一样
        3. 抽象类里面可以有构造方法,接口不可以有
        4. 接口1.8之后才可以写有方法体的方法,并且非静态方法需要加 default 
        5. 接口中的成员变量是常量,而抽象类不是