继承、super、this、抽象类【学习笔记总结】

一、继承
1.什么是继承？
就是让类与类之间产生了关系。子父类的关系！

2.继承如何实现？
    关键字： extends

3.继承中成员变量的访问特点
    访问特点：就近原则。
    优先查找子类局部变量，如果有就使用。如果没有就查找子类的成员变量，如果有就使用。
    如果没有，就继续查找父类的成员变量，如果父类中有，就使用父类的成员变量。
    如果父类也没有，那就报错了！

4.区分子父类变量重名如何使用
    如果想访问子类的局部变量，直接写
    如果想访问子类的成员变量，通过this
    如果想访问父类的成员变量，通过super
    注意事项：如果子类中没有成员变量，那么通过this访问的就是父类的成员变量

    //父类
        public class Fu {
            int num = 10;
        }

        //子类
        public class Zi extends Fu {
            int num = 20;
            public void method() {
                int num = 30;
                System.out.println(num); // 30，局部变量
                System.out.println(this.num); // 20，本类的成员变量
                System.out.println(super.num); // 10，父类的成员变量
            }
        }

        //测试类
        public class Demo01ExtendsField {
            public static void main(String[] args) {
                Zi zi = new Zi();

                zi.method();
            }
        }

5.子父类关系中成员方法的访问特点
    访问特点；就近原则
    如果子类中有成员方法，优先用子类的方法。如果子类中没有成员方法，
    向上查找，去父类中查找是否有这个方法，如果有就使用。如果父类也没有，就报错了


6.方法的重写和重载的区别
    重写：发生在子父类关系中。子类重写的方法要求和父类的方法声明必须完全一样
    重载：发生在当前类中。方法名相同，参数列表必须不同。与返回值类型无关
    示例代码：

        //父类
            public class Fu {
                public void methodFu() {
                    System.out.println("父类方法执行！");
                }

                public void method() {
                    System.out.println("父类重名方法执行！");
                }
            }

            //子类
            public class Zi extends Fu {
                public void methodZi() {
                    System.out.println("子类方法执行！");
                }


                public void method() {
                    System.out.println("子类重名方法执行！");
                }
            }

            //测试类
            public class Demo01ExtendsMethod {
                public static void main(String[] args) {
                    Zi zi = new Zi();

                    zi.methodFu();
                    zi.methodZi();

                    // 创建的是new了子类对象，所以优先用子类方法
                    zi.method();
                }
            }

7.方法重写的注意事项
    1. 必须保证父子类之间方法的名称相同，参数列表也相同。
    @Override：写在方法前面，用来检测是不是有效的正确覆盖重写。
    这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

    2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
    小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。

    3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
    小扩展提示：public > protected > (default) > private
    备注：(default)不是关键字default，而是什么都不写，留空。

8.方法重写的使用场景
    当父类的方法已经不能完全满足子类的要求的时候

    //父类
        public class Phone {
            public void call() {
                System.out.println("打电话");
            }

            public void send() {
                System.out.println("发短信");
            }

            public void show() {
                System.out.println("显示号码");
            }
        }

        //子类
        public class NewPhone extends Phone {
            @Override
            public void show() {
                super.show(); // 把父类的show方法拿过来重复利用
                // 自己子类再来添加更多内容
                System.out.println("显示姓名");
                System.out.println("显示头像");
            }
        }

        //测试类
        public class Demo01Phone {
            public static void main(String[] args) {
                Phone phone = new Phone();
                phone.call();
                phone.send();
                phone.show();
                System.out.println("==========");

                NewPhone newPhone = new NewPhone();
                newPhone.call();
                newPhone.send();
                newPhone.show();
            }
        }

9.继承中构造方法的执行特点
    1. 子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
    2. 子类构造可以通过super关键字来调用父类重载构造。
    3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
    总结：
    子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是在构造方法中的第一个。


10.super关键字
    super关键字代表的是父类的引用
    1. 在子类的成员方法中，访问父类的成员变量。
    2. 在子类的成员方法中，访问父类的成员方法。
    3. 在子类的构造方法中，访问父类的构造方法。

11.this关键字
    1. 在本类的成员方法中，访问本类的成员变量。
    2. 在本类的成员方法中，访问本类的另一个成员方法。
    3. 在本类的构造方法中，访问本类的另一个构造方法。
    在第三种用法当中要注意：
    A. this(...)调用也必须是构造方法的第一个语句，唯一一个。
    B. super和this两种构造调用，不能同时使用。

12.this和super关键字的图解
    略~~~

13.java中的继承特点
    java语言只支持单继承。不支持多继承！但是支持多层继承。

14.继承的案例

        //父类
        public class Animal {
            //成员变量
            private String name;        // 名称
            private int age;            // 年龄
            private String color;       // 颜色

            public Animal() {

            }

            public Animal(String name, int age, String color) {
                this.name = name;
                this.age = age;
                this.color = color;
            }

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }

            public int getAge() {
                return age;
            }

            public void setAge(int age) {
                this.age = age;
            }

            public String getColor() {
                return color;
            }

            public void setColor(String color) {
                this.color = color;
            }

            //父类的中的私有成员子类无法继承使用
            /*private void method(){
                System.out.println("父类的私有方法");
            }*/

            @Override
            public String toString() {
                return "Animal{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        ", color='" + color + '\'' +
                        '}';
            }

            //吃饭
            public void eat(){
                System.out.println("吃...");
            }
        }

        //子类
            public class Dog extends Animal {
                //特有的成员变量-腿的个数
                private int legCount;

                public Dog() {
                    super();
                }

                public Dog(String name, int age, String color,int legCount) {
                    super(name, age, color);
                    this.legCount = legCount;
                }

                @Override
                public String toString() {
                    return "Dog{" +
                            "name='" + getName() + '\'' +
                            ", age=" + getAge() +
                            ", color='" + getColor() + '\'' +
                            ", legCount='" + legCount + '\'' +
                            '}';
                }

                public int getLegCount() {
                    return legCount;
                }

                public void setLegCount(int legCount) {
                    this.legCount = legCount;
                }

                //重写eat方法
                @Override
                public void eat(){
                    System.out.println("狗吃肉");
                }

                //狗看家
                public void lookHome(){
                    System.out.println("狗看家");
                }
            }



        public class Cat extends Animal {

            public Cat(){
                super();
            }

            public Cat(String name,int age,String color){
                //将子类有参构造方法接收到的参数继续传递给父类的有参构造
                super(name,age,color);
            }

            @Override
            public String toString() {
                return "Cat{" +
                        "name='" + getName() + '\'' +
                        ", age=" + getAge() +
                        ", color='" + getColor() + '\'' +
                        '}';
            }

            //重写父类中的eat方法
            @Override
            public void eat(){
                System.out.println("猫吃鱼");
            }

            //猫抓老鼠
            public void catchMouse(){
                System.out.println("猫抓老鼠");
            }
        }

        //测试类
        public class Test01 {
            public static void main(String[] args) {
                Cat c2 = new Cat("波斯猫",4,"花色");
                System.out.println(c2);

                System.out.println("==================");

                Dog d2 = new Dog("金毛",1,"黄色",4);
                System.out.println(d2);

                System.out.println("===================");



                //创建猫类对象
                Cat c = new Cat();
                c.setName("加菲猫");
                c.setAge(2);
                c.setColor("金色");
                System.out.println(c.getName() + ":" + c.getAge() + ":" + c.getColor());
                c.eat();
                c.catchMouse();

                System.out.println("==========================");

                //创建狗类对象
                Dog d = new Dog();
                d.setName("哈士奇");
                d.setAge(3);
                d.setColor("黑白色");
                System.out.println(d.getName() + ":" + d.getAge() + ":" + d.getColor());
                d.eat();
                d.lookHome();
            }
        }


二、抽象类
    1.什么是抽象类和抽象方法
        当我们在进行向上抽取的时候，有一些共性的功能可以先做声明。但是具体的实现功能都不太一样。那么这个时候，
        此功能就可以被定义成抽象的了！
        java中使用abstract来修饰抽象的意思。
    2.抽象方法如何调用
        注意事项：抽象类是不能直接创建对象的
        A：定义一个子类，继承抽象的父类
        B：在子类中重写父类的抽象方法
        C：创建子类对象，调用重写后的方法即可

        //抽象父类
        public abstract class Animal {
            // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。
            public abstract void eat();
        }

        //子类
        public class Cat extends Animal {
            @Override
            public void eat() {
                System.out.println("猫吃鱼");
            }
        }

        //测试类
        public class DemoMain {
            public static void main(String[] args) {
        //      Animal animal = new Animal(); // 错误写法！不能直接创建抽象类对象
                Cat cat = new Cat();
                cat.eat();
            }
        }

    3.抽象类的成员特点
        A：抽象类不能直接创建对象
        B：抽象类中可以有构造方法
        C：抽象类中既可以有抽象方法、也可以有普通方法
        D：抽象方法所在的那个类，一定要是一个抽象类
        E：如果想使用抽象类中的抽象方法，必须定义一个子类，重写抽象的方法。(特例：除非子类也是一个抽象类。那么可以不用重写抽象方法)
        F：抽象类中可以有成员变量

    4.抽象类的案例
        //抽象父类
        public abstract class Animal {
            //成员变量
            private String name;        // 名称
            private int age;            // 年龄
            private String color;       // 颜色

            public Animal() {

            }

            public Animal(String name, int age, String color) {
                this.name = name;
                this.age = age;
                this.color = color;
            }

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }

            public int getAge() {
                return age;
            }

            public void setAge(int age) {
                this.age = age;
            }

            public String getColor() {
                return color;
            }

            public void setColor(String color) {
                this.color = color;
            }

            //父类的中的私有成员子类无法继承使用
            /*private void method(){
                System.out.println("父类的私有方法");
            }*/

            @Override
            public String toString() {
                return "Animal{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        ", color='" + color + '\'' +
                        '}';
            }

            //吃饭
            public abstract void eat();
        }

        //子类
        public class Dog extends Animal {
            //特有的成员变量-腿的个数
            private int legCount;

            public Dog() {
                super();
            }

            public Dog(String name, int age, String color,int legCount) {
                super(name, age, color);
                this.legCount = legCount;
            }

            @Override
            public String toString() {
                return "Dog{" +
                        "name='" + getName() + '\'' +
                        ", age=" + getAge() +
                        ", color='" + getColor() + '\'' +
                        ", legCount='" + legCount + '\'' +
                        '}';
            }

            public int getLegCount() {
                return legCount;
            }

            public void setLegCount(int legCount) {
                this.legCount = legCount;
            }

            //重写eat方法
            @Override
            public void eat(){
                System.out.println("狗吃肉");
            }

            //狗看家
            public void lookHome(){
                System.out.println("狗看家");
            }
        }


        public class Cat extends Animal {
            public Cat(){
                super();
            }

            public Cat(String name,int age,String color){
                //将子类有参构造方法接收到的参数继续传递给父类的有参构造
                super(name,age,color);
            }

            @Override
            public String toString() {
                return "Cat{" +
                        "name='" + getName() + '\'' +
                        ", age=" + getAge() +
                        ", color='" + getColor() + '\'' +
                        '}';
            }

            //重写父类中的eat方法
            @Override
            public void eat(){
                System.out.println("猫吃鱼");
            }

            //猫抓老鼠
            public void catchMouse(){
                System.out.println("猫抓老鼠");
            }
        }

        //测试类
        public class Test01 {
            public static void main(String[] args) {
                Cat c2 = new Cat("波斯猫",4,"花色");
                System.out.println(c2);

                System.out.println("==================");

                Dog d2 = new Dog("金毛",1,"黄色",4);
                System.out.println(d2);

                System.out.println("===================");


                //创建猫类对象
                Cat c = new Cat();
                c.setName("加菲猫");
                c.setAge(2);
                c.setColor("金色");
                System.out.println(c.getName() + ":" + c.getAge() + ":" + c.getColor());
                c.eat();
                c.catchMouse();

                System.out.println("==========================");

                //创建狗类对象
                Dog d = new Dog();
                d.setName("哈士奇");
                d.setAge(3);
                d.setColor("黑白色");
                System.out.println(d.getName() + ":" + d.getAge() + ":" + d.getColor());
                d.eat();
                d.lookHome();
            }
        }