继承 super关键字 导包 修饰符 多态

继承：是面向对象三大特征之一，可以是的子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。

继承格式

public class 子类名 extends 父类名{}

父类，也被称为基类和超类

子类，也被称为派生类

继承中子类的特点：

子类可以有父亲的内容；

子类还可以有自己特有的内容。

集成的优点和缺点：

优点：提高了代码的复用性（多个类相同的成员可以放到同一个类中）

        提高了代码的维护性（如果方法的代码需要修改，修改一处即可）

缺点：继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

什么时候使用继承？

我们有两个类AB当A是B的一种或者B是A的一种，这个时候可以考虑使用继承体现

继承中变量的访问特点：1.子类局部范围找2.子类成员范围找3.父类成员范围找4.如果都没有就报错（不考虑父亲的父亲）

（public static代表是静态方法，可以不通过创建所属对象进行访问；直接public代表是非静态方法，需要先new一个对象进行访问。）

super关键字：代表父类存储空间的标识（可用来访问父类的成员变量、构造方法、成员方法

super.成员变量、super(...)、super.成员方法（....））

this关键字：可用来访问本类的成员变量、构造方法、成员方法this.成员变量、this(...)、this.成员方法（....）

继承中构造方法的访问特点：子类中所有的构造方法默认都会访问父类中无参的构造方法

原因：因为子类会继承父类中的数据，可能还会使用父类的数据，所以子类初始化之前，一定要先完成父类数据的初始化        每一个子类构造方法的第一条语句默认都是super()

继承中成员方法的访问特点：1.子类成员范围找 2.父类成员范围找3.找不到就报错（不考虑父亲的父亲）        

方法重写：子类中出现了和父亲中一模一样的方法声明

方法重写的应用：当子类需要父类的功能，而功能主题子类有自己特有内容是，可以重写父类中的方法，这样，既沿袭了父亲的功能，又定义了子类特有的内容

@override：是一个注解

检查重写方法声的方法声明的正确性

方法重写的注意事项：1.私有方法不能被重写（父类私有成员子类是不能继承的）

                                    2.子类方法访问权限不能更低（public > 默认 > 私有）

java中继承的注意事项：1.java中类只支持单继承，不支持多继承

                                        2.java中类支持多层继承

导包：食用不同包下的类时，使用的时候要写清楚类的全路径，写起来太麻烦，为了简化带包的操作，java提供导包功能

格式：import包名；

权限修饰符：同一个类中 private、默认（void）、protected、public都可访问到

                        同一个包中子类无关类：默认、protected、public可访问到

                        不同包的子类：protected、public可访问到

                        不同包的无关类：public可访问到

状态修饰符：final（最终态）是最终的意思，可以修饰成员方法，成员变量，类

                被final修饰的方法是最终方法，不能被重写

                被final修饰的成员变量变为常量，值不能再改变

                类被final修饰不能作为父类被子类继承

                局部变量被final修饰，修饰基本类型，基本类型的数据值不能发生改变；修饰引用类型，引用类型的地址值不能发生改变，但是地址里面的内容可以发生改变

                    static关键字是静态的意思，可以修饰成员方法、成员变量。

static修饰特点：1.被所有对象共享（这也是我们判断是否使用静态关键字的条件）

                        2.可以通过类名调用，也可以通过对象名调用（推荐使用类名调用）

                        main是静态的

非静态的成员方法（可以访问静态的成员变量、非静态的成员变量、静态的成员方法、非静态的成员方法）

静态的成员方法（可以访问静态的成员方法、静态的成员变量）
总结：静态成员方法只能访问静态成员

多态：同一个对象，在不同时刻表现出来的不同形态

举例： 猫 cat = new 猫；

                动物 animal = new 猫；

这里猫在不同时刻表现出来的不同形态，这就是多态

多态的前提和体现

有/继承/实现关系

有方法重写

有父类引用指向子类

多态中成员访问特点

成员变量：编译看左边，执行看左边

成员方法：编译看左边，执行看右边

多态的好处：提高了程序的扩展性

                具体体现：定义方法时，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作

多态的弊端：不能使用子类的特有功能

多态中的转型

向上转型：（Animal a = new Cat；）从子到父；父类引用指向子类对象

向下转型：（Cat c = （Cat）a；）从父到子；父类引用转换为子类对象（方法重写快捷ctrl+o）

public class demo {
    public static void main(String[] args) {
        //创建猫类
        Animal a = new cat();
        a.setName("橘猫");
        a.setAge("5");
        System.out.println(a.getAge() + "," + a.getName());
        a.eat();
        a = new cat("5", "加菲");
        System.out.println(a.getAge() + "," + a.getName());
        a.eat();
        //创建狗类
        Animal b = new Dog();
        b.setName("柯基");
        b.setAge("2");
        System.out.println(b.getAge() + "," + b.getName());
        b.eat();

    }
}

public class Animal {
    //成员变量
    private String age;
    private String name;

    public String getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //构造方法


    public Animal() {
    }

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

    public void eat(){
        System.out.println("动物吃食物");
    }
}

public class cat extends Animal {
    public cat() {
    }

    public cat(String age, String name) {
        super(age, name);
    }

    @Override
    public void eat() {
        //super.eat();
        System.out.println("猫吃鱼");
    }
}

public class Dog  extends Animal{
    public Dog() {
    }

    public Dog(String age, String name) {
        super(age, name);
    }

    @Override
    public void eat() {
       // super.eat();
        System.out.println("狗吃肉");
    }
}