1.1. 1：接口(interface)(掌握)

        (1)接口的由来：当一个类中的方法都是抽象的时候，你没必要定义为抽象类，

                       定义为接口就可以了。

        (2)解决了java中只能单继承的问题。(对多继承进行了优化)

                A：类与类：只能是单继承。

                B：接口与接口：可以是单继承，也可以是多继承。

                C：类与接口：可以是单实现，也可以是多实现。

        (3)成员特点：

                A：只有成员变量和成员方法。

                B：成员变量 默认修饰符 public static final

                        **int x = 20;

                        **其实是这样的 public static final int x = 20;

                C：成员方法 默认修饰符 public abstract

                        **void show();

                        **其实是这样的 public abstract void show();

                建议：自己手动加上修饰符。

1.2. 演讲内容

        (4)接口特点：(掌握,演讲面试题)

                A：接口是对外暴露的规则

                B：接口是功能的扩展

                C：接口降低了程序的耦合性。

                        **内聚(自己实现功能的能力)

                        **高内聚，低耦合。

                举例：主板和CPU,USB接口,电源插座。

                D：扩展说了下接口的理解

                        **狭义的理解就是java中的接口。

                        **广义的理解就是：任何定义的规范都是接口。

        (5)接口和抽象类的区别：(掌握,演讲面试题)

                A：抽象类只能被单继承；接口可以被多实现。

                B：抽象类中的成员：

成员变量:可以是常量，也可以是变量。

                                   成员方法:可以是抽象的，也可以是非抽象的。

                                   构造方法:虽然不可以创建对象，但是可以给子类实例化用。

                   接口中的成员：

成员变量：只能是常量。默认修饰符 public static final

                                        成员方法：只能是抽象的。默认修饰符 public abstract

                C：抽象类中定义的是体系结构中的共性的内容。

                   接口中定义的是对象的扩展功能。

                D：抽象类被继承表示的是："is a"的关系。xx是yy中的一种。

                   接口被实现表示的是: "like a"的关系。xx像yy中的一种。

        (6)学生：Student

                A：属性：学号,姓名,年龄

                B：方法：学习(study),吃饭(抽象eat),抽烟或者不抽烟?(合适吗)

                发现：在学生中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。

                      但是发现，如果用一个类描述抽烟的功能后，SmokeStudent是不能继承多个类的。

                      这个时候，我们又得重写思考了。发现，抽烟的学生像一个抽烟的机器，所以，

                      我们定义一个接口来放抽烟这个功能。

                 interface Smoking

                {

                        public abstract void smoking();

                }

               

           描述的是抽烟的学生：SmokeStudent extends Student implements Smoking

                SmokeStudent ss = new SmokeStudent();

                ss.eat();

                ss.study();

                ss.smoking();

               

          老师：Teacher

                A：属性 教师编号,姓名,年龄

                B：方法 教书(teach),吃饭(吃饭eat),抽烟或者不抽烟?(合适吗)

                发现：在老师中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。

                      但是发现，如果用一个类描述抽烟的功能后，SmokeTeacher是不能继承多个类的。

                      这个时候，我们又得重写思考了。发现，抽烟的老师像一个抽烟的机器，所以，

                      我们定义一个接口来放抽烟这个功能。

                 interface Smoking

                {

                        public abstract void smoking();

                }

       

          描述的是抽烟的老师：SmokeTeacher extends Teacher implements Smoking

                SmokeTeacher st = new SmokeTeacher();

                st.eat();

                st.teach();

                st.smoking();

          最后，我们发现，这个代码还是存在着重复，比如说学生类和教师类中的属性姓名，年龄及方法吃饭。

          所以，我们进一步向上抽取。来了一个Person类

          Person：属性：姓名，年龄

                  行为：吃饭(抽象eat)

               

1.3. 2：多态(掌握)

        (1)某一类事物的多种存在形态。

                **方法重载(静态多态)

                **方法重写(动态多态,对象多态)

        (2)对象多态的前提

                A：类与类(或接口)要有继承(或实现)关系。

                B：一定要有方法的重写。

                C：一定要有父类或者接口的引用指向子类的对象。

        (3)多态思想：可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的问题简单化了。

                A：Animal Cat Dog

                        **method(Animal a){a.eat();}

                B：同学们吃饭

                C：士兵打仗(抬枪，瞄准，射击)。

        (4)多态中成员的特点：(我们只研究特殊的，就是说名字一样的东西)

                Fu f = new Zi();

                A：成员变量：编译和运行都看Fu。

                B：非静态方法：编译看Fu，运行看Zi。

                C：静态方法：编译和运行都看Fu。

               

1.1. 1：接口(interface)(掌握)

        (1)接口的由来：当一个类中的方法都是抽象的时候，你没必要定义为抽象类，

                       定义为接口就可以了。

        (2)解决了java中只能单继承的问题。(对多继承进行了优化)

                A：类与类：只能是单继承。

                B：接口与接口：可以是单继承，也可以是多继承。

                C：类与接口：可以是单实现，也可以是多实现。

        (3)成员特点：

                A：只有成员变量和成员方法。

                B：成员变量 默认修饰符 public static final

                        **int x = 20;

                        **其实是这样的 public static final int x = 20;

                C：成员方法 默认修饰符 public abstract

                        **void show();

                        **其实是这样的 public abstract void show();

                建议：自己手动加上修饰符。

1.2. 演讲内容

        (4)接口特点：(掌握,演讲面试题)

                A：接口是对外暴露的规则

                B：接口是功能的扩展

                C：接口降低了程序的耦合性。

                        **内聚(自己实现功能的能力)

                        **高内聚，低耦合。

                举例：主板和CPU,USB接口,电源插座。

                D：扩展说了下接口的理解

                        **狭义的理解就是java中的接口。

                        **广义的理解就是：任何定义的规范都是接口。

        (5)接口和抽象类的区别：(掌握,演讲面试题)

                A：抽象类只能被单继承；接口可以被多实现。

                B：抽象类中的成员：

成员变量:可以是常量，也可以是变量。

                                   成员方法:可以是抽象的，也可以是非抽象的。

                                   构造方法:虽然不可以创建对象，但是可以给子类实例化用。

                   接口中的成员：

成员变量：只能是常量。默认修饰符 public static final

                                        成员方法：只能是抽象的。默认修饰符 public abstract

                C：抽象类中定义的是体系结构中的共性的内容。

                   接口中定义的是对象的扩展功能。

                D：抽象类被继承表示的是："is a"的关系。xx是yy中的一种。

                   接口被实现表示的是: "like a"的关系。xx像yy中的一种。

        (6)学生：Student

                A：属性：学号,姓名,年龄

                B：方法：学习(study),吃饭(抽象eat),抽烟或者不抽烟?(合适吗)

                发现：在学生中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。

                      但是发现，如果用一个类描述抽烟的功能后，SmokeStudent是不能继承多个类的。

                      这个时候，我们又得重写思考了。发现，抽烟的学生像一个抽烟的机器，所以，

                      我们定义一个接口来放抽烟这个功能。

                 interface Smoking

                {

                        public abstract void smoking();

                }

               

           描述的是抽烟的学生：SmokeStudent extends Student implements Smoking

                SmokeStudent ss = new SmokeStudent();

                ss.eat();

                ss.study();

                ss.smoking();

               

          老师：Teacher

                A：属性 教师编号,姓名,年龄

                B：方法 教书(teach),吃饭(吃饭eat),抽烟或者不抽烟?(合适吗)

                发现：在老师中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。

                      但是发现，如果用一个类描述抽烟的功能后，SmokeTeacher是不能继承多个类的。

                      这个时候，我们又得重写思考了。发现，抽烟的老师像一个抽烟的机器，所以，

                      我们定义一个接口来放抽烟这个功能。

                 interface Smoking

                {

                        public abstract void smoking();

                }

       

          描述的是抽烟的老师：SmokeTeacher extends Teacher implements Smoking

                SmokeTeacher st = new SmokeTeacher();

                st.eat();

                st.teach();

                st.smoking();

          最后，我们发现，这个代码还是存在着重复，比如说学生类和教师类中的属性姓名，年龄及方法吃饭。

          所以，我们进一步向上抽取。来了一个Person类

          Person：属性：姓名，年龄

                  行为：吃饭(抽象eat)

               

1.3. 2：多态(掌握)

        (1)某一类事物的多种存在形态。

                **方法重载(静态多态)

                **方法重写(动态多态,对象多态)

        (2)对象多态的前提

                A：类与类(或接口)要有继承(或实现)关系。

                B：一定要有方法的重写。

                C：一定要有父类或者接口的引用指向子类的对象。

        (3)多态思想：可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的问题简单化了。

                A：Animal Cat Dog

                        **method(Animal a){a.eat();}

                B：同学们吃饭

                C：士兵打仗(抬枪，瞄准，射击)。

        (4)多态中成员的特点：(我们只研究特殊的，就是说名字一样的东西)

                Fu f = new Zi();

                A：成员变量：编译和运行都看Fu。

                B：非静态方法：编译看Fu，运行看Zi。

                C：静态方法：编译和运行都看Fu。