一篇文章说明白继承、封装、多态

  某公园出台新政策不让宠物狗进入园区，需要立一个牌子，那牌子上写的绝对是“宠物狗禁止入内”，而不是“泰迪不能入内”，更不应该是“张三家的那条棕色的会打滚的泰迪不得入内”。

  如果我们将宠物狗理解成为一种事物，那它既可以是泰迪，也可以是阿拉斯加，他一样可以是“张三家的那条棕色的会打滚的泰迪”。

  我们进行一次归纳，首先肯定的是“张三家的那条棕色的会打滚的泰迪”是泰迪，当然泰迪也是狗，对吧！这些东西本应就是理所应当，谁都知道的事情。而在我们java的世界里恰恰正是利用这种简单的思想把面向对象使用的极其灵活。在java里泰迪是“张三家的那条棕色的会打滚的泰迪”的父类，狗是泰迪的父类，反之我们称之为子类。众所周知，“张三家的那条棕色的会打滚的泰迪”他一定拥有泰迪这个品种所共有的的特征和能力，而泰迪一样拥有狗这种事物所共有的能力和特征。

总结一下：

1、子类拥有父类一切的特征和能力，我们将这种情况称之为继承。

举例：

  宠物狗能汪汪叫，泰迪一定也能。

public class Dog {
    //名字
    private String name = "狗";
    //狗叫
    public void bark(){
        System.out.println("【"+ this.name + "】在汪汪汪叫");
    }

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

//定义泰迪
public class Teddy extends Dog {
    //玩耍
    public void play(){
        System.out.println("【"+ getName() + "】会打滚！！");
    }
}

public class Test {
    public static void main(String[] args) {
        Teddy teddy = new Teddy();
        //以下两个方法泰迪都没有，但是父类有，他拥有父类的一切，所以他能调用
        //也可以这么说，有一哥们问你借钱，你发现自己没有，于是说我看看我爸有没有，有的话借给你
        teddy.setName("小黑");
        teddy.bark();
        //除了父类的方法，泰迪还能有自己的特有的方法
        teddy.play();
    }
}

结果：
【小黑】在汪汪汪叫
【小黑】会打滚！！

但是泰迪的叫可能又和一般的狗都不一样，不一样怎么办，我们就要把狗的叫声重新实现一下，这叫个过程叫重写，重写是重写父类的方法，是使他拥有和父类名字一样，实现不一样的方法,那么以后调用条件的叫的方法时就是泰迪叫，而非狗叫。

public class Teddy extends Dog {
    @Override
    public void bark(){
          System.out.println("【"+ this.name + "】在泰迪叫");
    }
}

2、因为子类拥有父类一切的能力，子类就能当父类用，你定义一个父类，就能使用一个子类的实例去帮助他完成工作（父类引用指向子类对象），反之不可以。多种子类使用不同的实现方式完成同一种功能时，叫做多态。也就是不同的子类调用相同的方法产生不同的结果，就叫做多态。

思考：我这么说，有条金毛犬（new 出来的）即是金毛犬类，又是狗类对不对。
既然我金毛犬类的引用可以指向这个实例，因为这个实例就是金毛。
那狗类的引用当然能指向这个实例，因为这个实例就是个狗。
反之不然。

举例：

public class Cibotium extends Dog {
     @Override
    public void bark(){
          System.out.println("【"+ this.name + "】在金毛叫");
    }
}

public static void main(String[] args) {
    //大概的意思就是子类泰迪能当成狗来用
    Dog dog = new Teddy();          //父类引用指向子类对象
    dog.setName("小泰迪");
    dog.bark();
    //大概的意思就是子类金毛能当成狗来用
    Dog dog1 = new Cibotium();
    dog1.setName("小金毛");
    dog1.bark();

    //两种狗因为重写了父类的方法，导致都在叫，但是叫的方式不一样了。
}

结果：
【小泰迪】在泰迪叫
【小金毛】在金毛叫

3、面向对象还有一个重要思想，叫封装。我觉得一句话解释就是所有高级的东西都是由简单的事物封装而成。

  类就是一种封装，java里有狗吗？没有。有泰迪吗？依然没有。那我们所写的类本身就是利用基础类型，方法，以及包括其他的类共同组织打包封装而成的，所以每一个类都是一种封装。封装的目的是让事物更高级，人用起来更简单。java里没有什么就封装一个，什么类不好用就进一步封装。

例子：

  我们使用基本类型int ,引用类型String,以及方法封装一个学生类，然后使用学生加其他封装一个班级类，再使用班级类进一步封装学校类。我们可以使用班级或学校作为整体进行操作。

public class Student {
    private String name;
    private int age;

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

    public void say(String words){
        System.out.println("【" + this.name + "】说：“"+ words +"”");
    }
}

public class MyClass {

    private String myClassName;
    private List<Student> students = new ArrayList<>();

    public MyClass(String myClassName) {
        this.myClassName = myClassName;
    }

    public void play(){
        for (Student student : students) {
            student.say(myClassName+"组织的活动真好玩！");
        }
    }

    public void addStudent(Student student){
        this.students.add(student);
    }

    public List<Student> getStudents(){
        return this.students;
    }
}

public class School {

    private String schoolName;
    private List<MyClass> myClasses = new ArrayList<>();

    public School(String schoolName) {
        this.schoolName = schoolName;
    }

    //学校组织娱乐活动
    public void play(){
        for (MyClass myClass : myClasses) {
            for (Student student : myClass.getStudents()) {
                student.say(schoolName+"组织的活动真好玩！");
            }
        }
    }

    public void addClass(MyClass myClass){
        this.myClasses.add(myClass);
    }

    public List<MyClass> getMyClass(){
        return this.myClasses;
    }

    public int classSize(){
        return this.myClasses.size();
    }
}

public class Test {
    public static void main(String[] args) {
        Student lucy = new Student("lucy",18);
        Student jerry = new Student("Jerry",16);
        Student david = new Student("David",18);
        Student bill = new Student("Bill",14);

        MyClass myClassOne = new MyClass("一年级一班");
        MyClass myClassTwo = new MyClass("二年级二班");
        myClassOne.addStudent(lucy);
        myClassOne.addStudent(jerry);
        myClassOne.play();
        System.out.println("--------------------------------------------");
        myClassTwo.addStudent(david);
        myClassTwo.addStudent(bill);
        myClassTwo.play();
        System.out.println("--------------------------------------------");
        School school = new School("实验小学");
        school.addClass(myClassOne);
        school.addClass(myClassTwo);
        school.play();
    }
}

结果：
【lucy】说：“一年级一班组织的活动真好玩！”
【Jerry】说：“一年级一班组织的活动真好玩！”
--------------------------------------------
【David】说：“二年级二班组织的活动真好玩！”
【Bill】说：“二年级二班组织的活动真好玩！”
--------------------------------------------
【lucy】说：“实验小学组织的活动真好玩！”
【Jerry】说：“实验小学组织的活动真好玩！”
【David】说：“实验小学组织的活动真好玩！”
【Bill】说：“实验小学组织的活动真好玩！”