OOP⑸

1.封装：

继承：　extends    java只支持单根继承！（一个类只能有一个直接的父类）
      是代码重用的一种方式！  将子类共有的属性和方法提取到父类中去！

Object：超类/基类==》java中所有类的父类！
Class: 所有类的实例都是Class类的对象！ 反射讲解！！！

我们随便创建任何一个类，都是Object类的子类！
那么Object类中的行为！我们创建的这个类也有！ 为什么？？
因为 继承！

子类中可以访问父类的：
所有不是private修饰的方法以及属性

如果一个类是由final修饰的！ 那么这个类不允许由子类！

super关键字：
只能出现在子类的方法或者构造方法中！
如果出现在了构造方法中，只能是第一句！
super.属性      访问父类的属性
super.方法      访问父类的方法

多重继承关系的初始化顺序：
01.父类的属性
02.父类的构造
03.子类的属性
04.子类的构造


方法的重写：
01.有继承关系
02.不同类！子类重写父类的方法！
03.方法名相同，参数列表相同
04.重写方法的访问修饰符不能严于父类！
05.如果父类的方法返回值 是一个父类！返回值类型可以是父类，也可以是子类！
06.父类的静态方法不允许被重写！但是子类中可以有同名的方法！
07.父类私有的方法 ，子类无法重写！

   例子：
     我要买小动物！
     我卖给你一个小猫咪！
     我卖给你一个小狗！
2.代码案例：

/**
 * Student 和 Teacher类的父类
 *
 *
 * 我们把两个子类中共有的属性和方法提取到父类中！
 *
 */
public class Person {
    private int age; // 年龄
    private String name; // 姓名
    private String address; // 地址

    /**
     * shift + alt +s +r  生成本类所有属性的set()和get
     */
    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    /**
     * @Override 重写父类的方法
     */
    @Override
    public String toString() {
        return "age:" + this.age + "name：" + this.name + "address："
                + this.address;
    }
}

 /**
  *  学生类
  *
  *  查看父类的信息：
  *  01.选中类名 F4
  *  02.shift+alt+s  之后选择 override/implments  methods  就会发现当前类所对应的父类
  *
  */
 public class Student extends Person {

 }

封装

/**
 * 教师类
 *
 * 我们发现   student类和 teacher类 都有共同的  age,name,address属性！
 *   如果我们又创建了一个Driver类 (司机类),应该也有 age,name,address属性！
 *
 * 这时候我们发现这些属性是不是都 重复了？？
 * 有没有一种方式可以优化一下？？？
 *  使用继承！！！！
 *
 */
public class Teacher extends Person {

}

封装

public class PersonTest {

    public static void main(String[] args) {
        // 创建了一个学生对象
        Student stu = new Student();
        stu.setName("张三");
        stu.setAge(50);
        stu.setAddress("天堂");
        /**
         *  输出学生对象
         *  cn.bdqn.bean.Student@2b0a141e
         *  cn.bdqn.bean.Student   全类名/完整限定名
         *  @2b0a141e   ？？？
         *
         *  只要是我们创建的一个类，默认都是继承Object！
         *  我们创建的类 是   引用数据类型！
         *
         *  我们通过类可以创建N个对象！
         *  如果我们直接输出了对象！
         *  那么就会默认执行Object类中的toString()
         */
        System.out.println(stu);

        // 创建一个教师对象
        Teacher tea = new Teacher();
        tea.setName("李四");
        tea.setAge(50);
        tea.setAddress("地域");
        // 输出教师对象
        System.out.println(tea);
    }

}

public class Student {

    private int age;
    private String name;

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public Student(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }

    public Student() {
        super();
    }

    /**
     * 重写Object类的方法
     */
    @Override
    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    }

    /**
     * 重写Object类中的equals
     * @param  obj   就是用户需要比较内容的对象
     */
    @Override
    public boolean equals(Object obj) {
        // 01.先判断内存地址是否一致
        if (this == obj) {
            return true;
        }
        // 02.判断obj的类型
        if (!(obj instanceof Student)) { // 说明obj根本不是Student类型
            return false;
        }
        // 03.向下转型
        Student stu = (Student) obj;
        // 04.开始判断两个对象的属性值是否一致
        if (stu.getAge() == this.age && stu.getName().equals(this.name)) {
            return true;
        }

        return false;
    }
}

重写Object类中的equals

public class StudentTest {

    /**
     * 基本数据类型   ==比较的是值！
     * 引用数据类型   ==比较的是内存地址！
     */
    public static void main(String[] args) {
        Student stu1 = new Student(25, "小黑");
        Student stu2 = new Student(25, "小黑");
        System.out.println(stu1 == stu2);
        /**
         * equals在object类中  执行的就是 == 比较的是内存地址!
         */
        System.out.println(stu1.equals(stu2));

    }

}

重写Object类中的equals

public class Animal {
    private int age;// 所有动物共有的！

    /**
     * 所有动物共同的方法
     */
    public void eat() {
        System.out.println("所有动物共同的吃饭");
    }

    /**
     * @return  购买小动物的方法
     */
    public Animal saleAnimal() {
        return new Animal();
    }

    /**
     * 验证父类的静态方法不允许被重写
     *
     * 在子类中使用shift +alt +s  override methods  不会看到这个sayHello()
     * 说明不能被重写
     */
    public static void sayHello() {
        System.out.println("所有小动物打招呼的方法");

    }

    public int getAge() {
        return age;
    }

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

}

/**
 * 小猫类
 */
public class Cat extends Animal {
    private String name; // 小猫特有的！！！！

    public String getName() {
        return name;
    }

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

    /**
     * 小猫吃鱼的方法
     */
    @Override
    public void eat() {
        System.out.println("小猫吃鱼的方法");
    }

    /**
     * 验证方法的返回值是父类也可以是子类
     */
    @Override
    public Cat saleAnimal() {
        return new Cat();
    }

    @Override
    public String toString() {
        return "Cat [name=" + name + "age=" + super.getAge() + "]";
    }

}

继承和方法的重写

/**
 * 小狗类
 */
public class Dog extends Animal {
    private String strain;// 小狗特有的！！！！

    public String getStrain() {
        return strain;
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }

    /**
     * 小狗在吃骨头的方法
     */
    @Override
    public void eat() {
        System.out.println("小狗在吃骨头！");
    }

    /**
     * 验证方法的返回值是父类也可以是子类
     */
    @Override
    public Dog saleAnimal() {
        return new Dog();
    }

    @Override
    public String toString() {
        return "Dog [strain=" + strain + "age=" + super.getAge() + "]";
    }

}

public class AnimalTest {

    public static void main(String[] args) {
        // 创建一个小猫咪和一个小狗狗
        Cat cat = new Cat();
        cat.setAge(20);
        cat.setName("小猫猫");
        cat.eat(); // 自己特有的

        Dog dog = new Dog();
        dog.setAge(25);
        dog.setStrain("藏獒");
        dog.eat();// 自己特有的

    }

}

继承和方法的重写