由于字数限制，只能两次写完！内容纯属个人总结，如有不完善之处，还请指明！谢谢！

继承小结：
        class Student{
                private String name;
                private int age;
                public void setName(String name){
                        this.name = name;
                }
                public void setAge(int age){
                        this.age = age;
                }
                public String getName(){
                        return name;
                }
                public int getAge(){
                        return age;
                }
        }
        class Worker{
                private String name;
                private int age;
                public void setName(String name){
                        this.name = name;
                }
                public void setAge(int age){
                        this.age = age;
                }
                public String getName(){
                        return name;
                }
                public int getAge(){
                        return age;
                }
        }
        //对比发现
        /*
                1，当定义很多类时，发现这些类中有很多共性的描述,如果每一个类中都有的话，就会很麻烦，而且会浪费内存空间
        
                那么怎么解决呢？
        
                所以：将学生和工人的共性描述抽取出来，单独进行描述，只要让学生和工人与单独描述的这个类有关系，就可以了！
        这种关系就称为继承！
        
        继承的描述：
                1，多个类中存在相同属性和行为时，将这些内容抽取到单独的一个类中，那么多个类无论谁
                再定义这些属性和行为，只要继承单独的那个类即可。
                2，多个类可以称为子类，单独的这个类称为父类或者超类。
                3，子类可以直接访问父类中的**非私有**的属性和行为。（注意，是非私有的属性和行为）
                4，通过extends关键字让类与类之间产生继承关系。
                        eg：class SubDemo extends Demo{}
                        
        继承的好处：
                5，继承的出现提高了代码的复用性
                6，继承的出现让类与类之间产生了关系，提供了多态的前提。
               
        注意：千万不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系才可以继承，
                所属关系：A is a sth,即A是sth的一种
        */
                //如此，以上代码就可以简化为：
                class Person        //人类，
                {
                        private String name;
                        private int age;
                        /**
                         * 给name赋值
                         * @param name
                         */
                        public void setName(String name){
                                this.name = name;
                        }
                        /**
                         * 设置年龄
                         * @param age
                         */
                        public void setAge(int age){
                                this.age = age;
                        }
                        /**
                         * 取得name
                         * @return
                         */
                        public String getName(){
                                return name;
                        }
                        /**
                         * 取得 age
                         * @return
                         */
                        public int getAge(){
                                return age;
                        }
                }
                class Student extends Person        //Student类是Person类的子类，Person类称为父类
                {//此时，该类自动有了name，age属性
                        
                }
                class Worker extends Person{//此时，该类自动有了name，age属性
                        
                }
        
        /*但是：
         *        在java语言中：java只支持单继承，不支持多继承，即：一个子类只能有一个父类。但一个父类可有多个子类
         *         java中，一个孩子只能有一个父亲！哈哈！就像人一样
         *         如：学生类，只能继承Person一个类，不能同时再继承其他类
         *         因为多继承容易带来安全隐患：当多个父类中定义了相同功能，且功能内容不同时，子类对象不能确定要运行那一个！
         *         但是java保留了这种机制，并用另一种体现形式来完成表示，**多实现**。（接口）
         *
         *         但是java支持多层继承。也就是一个继承体系。
         *         如：class C{}
         *         class B extends C{}
         *         class A extends B{}        
         *
         **那么如何使用继承体系呢？
         *        想要使用体系，
         *                先查阅体系父类的描述，因为父类中定义的是该体系中的共性功能。（也是最基本的功能）
         *                 通过了解共性功能，就可以知道该体系的基本功能
         *                 这个体系就基本可以使用了。
         *                 在具体调用时，要创建最底层子类的对象。为什么呢？
         *        一是，因为父类不能创建对象（抽象类）；
         *            二是，创建子类对象可以使用更多的功能，包括基本的，也包括特有的，包括继承的，可以扩展功能
         *
         *         简而言之：查阅父类功能，创建子类对象使用功能
        */
        
        /*
         *        事物间聚集关系与聚合关系，组合关系
         *         聚集：A has a B，就是A里有一个B。
         *         组合：事物的联系程度更紧密。如：手是人身体的一部分。
         *                如：b和c组成a，那么b，c就是组合关系，a和b，a和c就是聚集关系
        */
        
      

由于字数限制，只能两次写完！内容纯属个人总结，如有不完善之处，还请指明！谢谢！

继承小结：
        class Student{
                private String name;
                private int age;
                public void setName(String name){
                        this.name = name;
                }
                public void setAge(int age){
                        this.age = age;
                }
                public String getName(){
                        return name;
                }
                public int getAge(){
                        return age;
                }
        }
        class Worker{
                private String name;
                private int age;
                public void setName(String name){
                        this.name = name;
                }
                public void setAge(int age){
                        this.age = age;
                }
                public String getName(){
                        return name;
                }
                public int getAge(){
                        return age;
                }
        }
        //对比发现
        /*
                1，当定义很多类时，发现这些类中有很多共性的描述,如果每一个类中都有的话，就会很麻烦，而且会浪费内存空间
        
                那么怎么解决呢？
        
                所以：将学生和工人的共性描述抽取出来，单独进行描述，只要让学生和工人与单独描述的这个类有关系，就可以了！
        这种关系就称为继承！
        
        继承的描述：
                1，多个类中存在相同属性和行为时，将这些内容抽取到单独的一个类中，那么多个类无论谁
                再定义这些属性和行为，只要继承单独的那个类即可。
                2，多个类可以称为子类，单独的这个类称为父类或者超类。
                3，子类可以直接访问父类中的**非私有**的属性和行为。（注意，是非私有的属性和行为）
                4，通过extends关键字让类与类之间产生继承关系。
                        eg：class SubDemo extends Demo{}
                        
        继承的好处：
                5，继承的出现提高了代码的复用性
                6，继承的出现让类与类之间产生了关系，提供了多态的前提。
               
        注意：千万不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系才可以继承，
                所属关系：A is a sth,即A是sth的一种
        */
                //如此，以上代码就可以简化为：
                class Person        //人类，
                {
                        private String name;
                        private int age;
                        /**
                         * 给name赋值
                         * @param name
                         */
                        public void setName(String name){
                                this.name = name;
                        }
                        /**
                         * 设置年龄
                         * @param age
                         */
                        public void setAge(int age){
                                this.age = age;
                        }
                        /**
                         * 取得name
                         * @return
                         */
                        public String getName(){
                                return name;
                        }
                        /**
                         * 取得 age
                         * @return
                         */
                        public int getAge(){
                                return age;
                        }
                }
                class Student extends Person        //Student类是Person类的子类，Person类称为父类
                {//此时，该类自动有了name，age属性
                        
                }
                class Worker extends Person{//此时，该类自动有了name，age属性
                        
                }
        
        /*但是：
         *        在java语言中：java只支持单继承，不支持多继承，即：一个子类只能有一个父类。但一个父类可有多个子类
         *         java中，一个孩子只能有一个父亲！哈哈！就像人一样
         *         如：学生类，只能继承Person一个类，不能同时再继承其他类
         *         因为多继承容易带来安全隐患：当多个父类中定义了相同功能，且功能内容不同时，子类对象不能确定要运行那一个！
         *         但是java保留了这种机制，并用另一种体现形式来完成表示，**多实现**。（接口）
         *
         *         但是java支持多层继承。也就是一个继承体系。
         *         如：class C{}
         *         class B extends C{}
         *         class A extends B{}        
         *
         **那么如何使用继承体系呢？
         *        想要使用体系，
         *                先查阅体系父类的描述，因为父类中定义的是该体系中的共性功能。（也是最基本的功能）
         *                 通过了解共性功能，就可以知道该体系的基本功能
         *                 这个体系就基本可以使用了。
         *                 在具体调用时，要创建最底层子类的对象。为什么呢？
         *        一是，因为父类不能创建对象（抽象类）；
         *            二是，创建子类对象可以使用更多的功能，包括基本的，也包括特有的，包括继承的，可以扩展功能
         *
         *         简而言之：查阅父类功能，创建子类对象使用功能
        */
        
        /*
         *        事物间聚集关系与聚合关系，组合关系
         *         聚集：A has a B，就是A里有一个B。
         *         组合：事物的联系程度更紧密。如：手是人身体的一部分。
         *                如：b和c组成a，那么b，c就是组合关系，a和b，a和c就是聚集关系
        */