黑马程序员技术交流社区

标题: 【厦门JavaEE基础13期—每日总结】多态&抽象类&接口 [打印本页]

---

作者: 厦门校区    时间: 2020-1-15 16:58
标题: 【厦门JavaEE基础13期—每日总结】多态&抽象类&接口
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?
2.多态的转型指的是什么?
3.什么是抽象类?它的特点是什么?
4.抽象类中的成员(属性,方法)有什么特点?
5.接口是什么?它有什么特点?
6.接口中的成员(属性,方法)有什么特点?
7.抽象类和接口有什么区别?类和接口有什么关系?
8.总结今天自己认为重要的点.

---

作者: 黄宏楷    时间: 2020-1-15 19:47
1.什么是多态?多态的好处和坏处分别是什么?
        对于同一个对象在不同时刻有不同的状态称为多态。
        好处：可以有效提高代码的拓展性，写一个父类然后不同的子类可以继承他，也有效的简化了代码的书写
        坏处：不能调用子类对象和特有的方法

2.多态的转型指的是什么?
        多态的转型分为向上转型和向下转型
        向上转型：父类引用子类对象其实就是向上转型。
        向下转型：向下转型又称强转，也就是将父类的对象强转为子类对象，然后改父类对象就可以调用子类对象和特有的方法。

3.什么是抽象类?它的特点是什么?
        一个子类重写了父亲的方法，在父类的方法体中没有方法体，那么这个父类就是抽象类
        特点：  抽象类和方法都必须要被abstract修饰
                抽象类中可以定义成员变量，可以定义方法，可以构造函数
                抽象类不一定含有抽象方法，有抽象方法的一定是抽象类
                抽象类必须有一个子类来继承
                抽象类不能直接实例化，只能通过父类引用子类来创建

4.抽象类中的成员(属性,方法)有什么特点?
        抽象方法必须有public或protected来修饰（private修饰的话该抽象方法就不能被继承）
        抽象类不能直接被实例化，只能通过向上转型的方式来处理
        抽象类必须要有一个子类来继承（extends），一个子类只能继承一个抽象类
        子类如果不是抽象类，就要重写父类所有的抽象方法 或者 把该子类也定义为抽象类，就不用重写


5.接口是什么?它有什么特点?
        接口就是一种公共的规范标准
        特点：  接口是通过public interface XX{}来定义的
                接口是通过public class XX implements  接口名{}来实现的
                接口不能被实例化，可以通过多态形式创建实现类对象
                接口的实现类如果不是抽象类的， 就要重写接口的所有抽象方法，如果是抽象类就不必

6.接口中的成员(属性,方法)有什么特点?
        接口里面可以定义常量值，抽象方法，静态方法，默认方法，私有方法


7.抽象类和接口有什么区别?类和接口有什么关系?
        成员区别：接口中只能有变量和抽象方法，抽象类中还可与有常量，构造方法，普通方法
        关系区别：他们之间实现可以单实现也可以多实现，接口继承一个类的同时也可以实现其他接口
        设计理念区别：抽象类完成的是一些共性功能的抽取    接口完成的是一些特性功能的抽取


8.总结今天自己认为重要的点.
什么是多态，多态的优缺点，访问特点，实现前提，转换有几种
抽象类的概述，书写格式，和普通的类的区别
接口的特点

---

作者: 林跃辉    时间: 2020-1-15 20:55
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?
   多态就是同一个对象有多种不同形态。
   好处：提高了代码的扩展性
   坏处：不能调用子类特有的方法
2.多态的转型指的是什么?
   向上转型： 子类对象赋值给父类对象（多态默认的）
   比如： Animal an = new Cat();
   向下转型：将多态的对象通过强转，转成子类对象
   比如： Animal an = new Cat(); Cat  cat = (Cat)an
   解决多态的缺点：不能访问子类的变量和特有方法
3.什么是抽象类?它的特点是什么?
   子类重写父类方法且父类方法没有方法体，那么父类就是抽象类。
   特点：用abstract修饰类；
             不一定要有抽象方法，且可以定义普通方法、成员变量和构造方法；
             必须要有子类；
             不能直接实例化。
4.抽象类中的成员(属性,方法)有什么特点?
   方法不能用private修饰，否则无法被子类重写；
   可以有变量和常量，可以有抽象、普通和构造方法。
5.接口是什么?它有什么特点?
   接口就是统一的规范，只要符合这个规范，就都可以使用这个接口。
   特点：接口的方法必须被子类实现；
             接口其实是特殊的抽象类，不能实例化，可通过子类对象的创建去实例化；
             如果子类实现接口，那子类要么实现接口里所有方法，要么子类也定义成接口，就不需重写父类接口方法。
6.接口中的成员(属性,方法)有什么特点?
   jdk8之前：只能定义常量值和抽象方法（常量值默认被public abstract修饰，抽象方法默认被public abstract修饰）
   jdk8之后：除了常量和抽象方法，还可以定义静态方法，默认方法，私有方法。
7.抽象类和接口有什么区别?类和接口有什么关系?
   区别：
   抽象类什么都可以定义，接口目前只能定义常量和抽象方法。
   子类继承抽象类，只能继承一个抽象类（单继承），子类实现接口，一个子类可以实现多个接口（多实现）。
   接口是对子类特定的行为进行约束，抽象类是对子类具有共同的属性和行为进行抽取。
8.总结今天自己认为重要的点.
（1）多态的概念和优缺点
（2）抽象类用来解决多态的缺点
（3）不同类之间关系建立方式的不同
（4）抽象类和接口的区别

---

作者: 沈哲正    时间: 2020-1-15 20:57
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?
     多态是指一个对象在不同情况下的多种形态；
        好处：简化代码，提高代码的扩展性；
        缺点：不能调用子类对象特有的方法。
2.多态的转型指的是什么?
      向上转型：子类对象赋值给傅雷对象(多态默认的);
      向下转型:将多态的对象通过强转，转成子类对象;
3.什么是抽象类?它的特点是什么?
      如果子类重写了父类的方法，那么在父类的方法中，不用给方法体；这个定义的父类就是抽象类；定义的没有方法体的方法就是抽象方法。
         特点：
        ①.abstract class;
        ②.抽象类不一定有抽象方法
        ③.有抽象方法的类，一定是抽象类
        ④.抽象类可以定义普通方法
        ⑤.抽象类里面定义成员变量
        ⑥.抽象类里面定义构造方法
        ⑦.抽象类必须都有一个子类；
4.抽象类中的成员(属性,方法)有什么特点?
        方法不能被private修饰，否则不能被子类重写；
     成员变量：既可以是变量、也可以是常量
     构造方法：有构造方法，目的是给父类中成员初始化
     成员方法：既可以是抽象方法、也可以是普通方法
5.接口是什么?它有什么特点?
      接口就是统一的规范（准则），只要符合这个规范，那么都可以使用这个接口。
      特点：
        ①.接口中的方法，必须被子类实现
        ②.接口（“特殊”的抽象类）不能实例化（不能创建对象）
        ③.接口通过子类对象的创建，去实例化
        ④.如果子类实现接口了，那么该子类要么实现接口的所有方法，要么该子类也是一个接口，就不需要重写父接口的方法
6.接口中的成员(属性,方法)有什么特点?
       接口里面定义5部分：
        jdk8之前：只能定义常量值，抽象方法
        jdk8以后：静态方法，默认方法，私有方法（后面在讲解新特性）
      成员常量的特点：
          常量默认被 public static final修饰，在书写常量可写可不写。
       抽象方法特点：
         方法名称默认表public abstract修饰，在书写方法可写可不写。
7.抽象类和接口有什么区别?类和接口有什么关系?
     相同点：
        ①.接口和抽象类：里面都有抽象方法
        ②.它们两个都是抽象类（接口：接口中有抽象方法，所以把接口称之为抽象类）
        ③.它们两个都不能被创建对象
     不同点：
        ①.定义的代码不同
                抽象类：什么都可以定义，（定义抽象方法，可以写，也可以不写）
                接口：目前只能定义常量和抽象方法。
        ②.继承和实现的特点不同
                子类继承抽象类，只能继承一个抽象类（单继承）
                子类实现接口，一个子类可以实现多个接口（多实现）
        ③.接口的修饰和抽象类的修饰不同
                public interface  接口的名称{--}
                public abstract class 抽象类的名称{}
        ④.接口和抽象类的子类实现方式不同
                子类 implements  接口名称1,接口名称2{---}
                子类 extends 抽象类{---}
        ⑤.作用不同（设计模式的不同）
                接口：对子类特定的行为（方法）进行约束
                抽象类：对子类具有共同的属性和行为进行抽取
        ⑥.接口和抽象类里面方法的区别
                接口里面都是抽象方法
                抽象类里面可以有抽象方法，也可以没有，也可以有其它方法
        ⑦.接口和抽象类里面修饰符的区别
                接口里面的常量和抽象方法必须被public修饰
                抽象类里面的抽象方法必须被public修饰，其它无要求
8.总结今天自己认为重要的点.
①.抽象类和接口的区别，类和接口的联系
②.接口的特点
③.多态的转型
④.抽象类的特点
⑤.接口的语法格式
最重要的是要清楚明白抽象类，接口，继承，多态的概念，以及每一个的使用方法和应该注意的事项。比如抽象类里面可以有普通方法也可以有抽象方法，
但在普通类里面不能有抽象方法。

---

作者: 叶成凯    时间: 2020-1-15 20:59
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?
  多态：一个对象在不同情况下具有多种状态
  多态的好处：简化代码，提供代码的扩展性
  多态的坏处：不能调用子类对象特有的方法，不能解析子类的行为
2.多态的转型指的是什么?
  多态转型分为：
  1、向上转型：子类对象赋值给父类对象(多态默认的)
     比如：Animal an = new Cat();
  2、向下转型：将多态的对象通过强转，转成子类对象
     比如：Animal an = new Cat(); Cat cat = (Cat)an;
     解决开发中：多态的缺点即不能访问子类特有的属性和行为
3.什么是抽象类?它的特点是什么?
  在继承中，子类需要重写父类的方法，父类中的方法不用给出方法体，让子类自己实现方法体，那么将这个父类定义为抽象类，没有方法体的方法定义为抽象方法
  特点：
     1：用abstract修饰类名
     2：抽象类不一定要有抽象方法
     3：有抽象方法的类，一定是抽象类
     4：抽象类可以定义普通方法
     5：抽象类里面定义成员变量
     6：抽象类里面定义构造方法
     7：抽象类必须都有一个子类
  抽象方法必须为public或protected修饰，缺省情况下为public；
  抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
  抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
  子类(如果不是抽象类)则必须覆写抽象类中的全部抽象方法。
4.抽象类中的成员(属性,方法)有什么特点?
  抽象类中的属性和行为可以为普通属性和行为，也可以被abstract修饰的抽象方法
5.接口是什么?它有什么特点?
  接口：一种行为规范，类名被interface修饰，调用需要用到implement，默认用public abstract修饰的无方法体的方法
  特点：
    接口中的变量会被隐式地指定为public static final变量，并且只能是public static final变量，用private修饰会报编译错误，而方法会被隐式地指定为public abstract方法且只能是public abstract方法，用其他关键字，比如private、protected、static、 final等修饰会报编译错误，并且接口中所有的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。
6.接口中的成员(属性,方法)有什么特点?
  接口中的成员常量默认被public static final修饰，在书写常量时可写可不写
  接口中的抽象方法名称默认被public abstract修饰，在书写方法时可写可不写
7.抽象类和接口有什么区别?类和接口有什么关系?
  抽象类和接口的区别：
  语法层面上的区别
    1、一个类只能继承一个抽象类，而一个类却可以实现多个接口；
    2、抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；
    3、接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
    4、抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；
    5、抽象类的抽象方法可以是public，protected，default类型，而接口的方法只能是public。
  设计层面上的区别
    1、抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。
继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。
    2、设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。
  
  类和接口的关系：
  普通类或抽象类可以调用接口，将接口中的方法在本类中实现，抽象类和接口都不能被创建对象来使用
8.总结今天自己认为重要的点.
  -继承与多态的区分和联系
  -多态的转型
  -抽象类的使用
  -抽象类的使用限制
  -抽象类的应用——模版设计模式
  -接口和抽象类的区别和联系

---

作者: L丶wei    时间: 2020-1-15 20:59
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?
答:某一类的事物的多种存在形态
    好处是提高程序的扩展性
    坏处是不能使用子类的特有成员
2.多态的转型指的是什么?
答:父类引用指向子类对象就是向上转型
    子类型 对象名 = (子类型)父类引用就是向下转型
3.什么是抽象类?它的特点是什么?
答:当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！
    特点是:抽象类和抽象方法必须使用 abstract 关键字修饰
              抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
              抽象类不能实例化
              抽象类的子类要么重写抽象类中的所有抽象方法要么是抽象类

4.抽象类中的成员(属性,方法)有什么特点?
答:成员变量
- 既可以是变量
- 也可以是常量
成员方法
- 抽象方法
- 普通方法

5.接口是什么?它有什么特点?
答:接口就是一种公共的规范标准，只要符合规范标准大家都可以通用,Java中的接口更多的体现在对行为的抽象！
    特点:接口用关键字interface修饰
           类实现接口用implements表示
           接口不能实例化
           接口的子类要么重写接口中的所有抽象方法要么子类也是抽象类
6.接口中的成员(属性,方法)有什么特点?
答:成员变量只能是常量 ,默认修饰符：public static final
成员方法只能是抽象方法,默认修饰符：public abstract
7.抽象类和接口有什么区别?类和接口有什么关系?
答:1.定义的代码不同
      抽象类：什么都可以定义，（定义抽象方法，可以写，也可以不写）
       接口：目前只能定义常量和抽象方法。
    2. 继承和实现的特点不同
      子类继承抽象类，只能继承一个抽象类（单继承）
      子类实现接口，一个子类可以实现多个接口（多实现）
    3 接口的修饰和抽象类的修饰不同
       public interface  接口的名称{--}
       public abstract class 抽象类的名称{}
    4.接口和抽象类的子类实现方式不同
      子类 implements  接口名称1,接口名称2{---}
      子类 extends 抽象类{---}
    5.作用不同（设计模式的不同）
      接口：对子类特定的行为（方法）进行约束
      抽象类：对子类具有共同的属性和行为进行抽取
    6 接口和抽象类里面方法的区别
      接口里面都是抽象方法
      抽象类里面可以有抽象方法，也可以没有，也可以有其它方法
    7. 接口和抽象类里面修饰符的区别
      接口里面的常量和抽象方法必须被public修饰
      抽象类里面的抽象方法必须被public修饰，其它无要求
     类和接口是实现关系
8.总结今天自己认为重要的点.
答:接口和抽象类

---

作者: 潘辉    时间: 2020-1-15 20:59
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?

        多态：一个对象在不同情况下的多种形态
        多态的好处：简化代码，提高代码的扩展性
        多态的坏处：不能调用子类对象特有的方法


2.多态的转型指的是什么?

        向上转型： 子类对象赋值给父类对象（多态默认的）
        比如： Fu fu = new Zi();
        向下转型：将多态的对象通过强转，转成子类对象
        比如： Fu fu = new Zi(); Zi  zi = (Zi)fu
        解决开发中：多态的缺点，不能访问子类的变量和特有方法


3.什么是抽象类?它的特点是什么?

        抽象类：如果子类重写了父类的方法，那么在父类的方法中，不用给方法体，
                那个定义的这个父类就是抽象类
        抽象类特点：1）、  abstract  class
                                2）、  抽象类不一定有抽象方法
                                3）、  有抽象方法的类，一定是抽象类
                                4）、  抽象类可以定义普通方法
                                5）、  抽象类里面定义成员变量
                                6）、  抽象类里面定义构造方法
                                7）、  抽象类必须都有一个子类


4.抽象类中的成员(属性,方法)有什么特点?

        抽象类中的成员（属性、方法）和普通类是一样的
        只是抽象类中可以多定义一种方法：抽象方法
       

5.接口是什么?它有什么特点?

        接口：接口就是统一的规范（准则），只要符合这个规范，那么都可以使用这个接口。
        特点：1. 接口中的方法，必须被子类实现
                  2. 接口（“特殊”的抽象类）不能实例化（不能创建对象）
                  3. 接口通过子类对象的创建，去实例化
                  4. 如果子类实现接口了，那么该子类要么实现接口的所有方法
                     要么该子类也是一个接口，就不需要重写父接口的方法



6.接口中的成员(属性,方法)有什么特点?

        特点：
                jdk8之前：只能定义常量值，抽象方法

                jdk8以后：静态方法，默认方法，私有方法



7.抽象类和接口有什么区别?类和接口有什么关系?

        抽象类和接口的区别：
                A、定义的代码不同
                        抽象类：什么都可以定义，（定义抽象方法，可以写，也可以不写）
                        接口：目前只能定义常量和抽象方法。
                B、继承和实现的特点不同
                        子类继承抽象类，只能继承一个抽象类（单继承）
                        子类实现接口，一个子类可以实现多个接口（多实现）
                C、接口的修饰和抽象类的修饰不同
                        public interface  接口的名称{...}
                        public abstract class 抽象类的名称{...}
                D、接口和抽象类的子类实现方式不同
                        子类 implements  接口名称1,接口名称2{...}
                        子类 extends 抽象类{...}
                E、作用不同（设计模式的不同）
                        接口：对子类特定的行为（方法）进行约束
                        抽象类：对子类具有共同的属性和行为进行抽取
                F、接口和抽象类里面方法的区别
                        接口里面都是抽象方法
                        抽象类里面可以有抽象方法，也可以没有，也可以有其它方法
                G、接口和抽象类里面修饰符的区别
                        接口里面的常量和抽象方法必须被public修饰
                        抽象类里面的抽象方法必须被public修饰，其它无要求

8.总结今天自己认为重要的点.

        1、多态的访问特点
                - 成员变量
                编译看父类，运行看父类（调用属性时，多态表示的是父类对象）
                - 成员方法
                编译看父类，运行看子类（调用方法时，多态表示的是子类对象）
        2、父类对象指向子类对象的引用
                Fu fu = new Zi();
        3、抽象类的特点7个
        4、抽象类的使用原则
        5、接口的特点
        6、接口的成员特点
        7、接口和抽象类的区别和联系

---

作者: 于铭源    时间: 2020-1-15 20:59
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?
答：
多态概念：多态指的是一个对象在不同情况下的多种形态。
多种形态：
        情况一：在调用属性时，对象指的是父类对象，即成员变量：编译看父类，运行看父类
        情况二：在调用方法时，对象指的是子类对象，即成员方法，编译看父类，运行看子类（因为有方法重写）
多态的形成条件及前提：
        *要有继承或实现关系
        *要有方法的重写
        *要有父类引用指向子类对象（格式：父类 父类引用 = new 子类型（））

多态的好处和弊端：
好处：
提高程序的扩展性，定义方法的时候，使用父类作为参数，在使用的时候，使用具体的子类型参与操作
弊端：
不能使用子类的特有成员（想使用子类特有的成员，就得创建专门的子类对象，那与多态就没有关系了）


2.多态的转型指的是什么?
答：
向上转型：父类引用指向子类对象就是向上转型
向下转型：格式：子类型 对象名 = （子类型）父类引用（这是一种强转）


3.什么是抽象类?它的特点是什么?
答：
抽象类的概念：
当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

抽象类的特点：
*抽象类和抽象方法必须使用abstract关键字修饰
*抽象类中不一定有抽象方法，但类中如果有抽象方法，这个类一定是抽象类
*抽象类不能实例化（可以使用多态，通过子类对象实例化，即抽象类多态）
*抽象类的子类，要么重新给抽象类中的方法，要么自己就是抽象类

4.抽象类中的成员(属性,方法)有什么特点?
答：
抽象类中成员的特点：
成员变量：
        既可以是变量
        也可以是常量
构造方法：
        可以有空参构造
        可以有有参构造
成员方法：
        可以有抽象方法
        可以有普通方法


5.接口是什么?它有什么特点?
答：
接口的概念：
*接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
*Java中的接口更多的体现在对行为的抽象！

接口的特点：
*接口用关键字interface修饰：public interface 接口名 {}
*类若想实现接口，需使用implements：public class 类名 implements 接口名 {}
*接口不能实例化（因为接口实际是一种特殊的抽象类，可以通过多态的方式实例化）
*接口的子类（同抽象类）：要么重写接口中的所有抽象方法，要么子类也是抽象类

6.接口中的成员(属性,方法)有什么特点?
答：
*成员属性：只能是常量，默认修饰符：public static final（因为有final不能修改，所以不可能是变量）
*构造方法：没有，因为接口主要是为了实现扩展功能，而没有具体的存在
*成员方法：只能是抽象方法，默认修饰符：public abstract
注意：关于接口中的方法，JDK8和JDK9中有一些新特性，暂做了解

7.抽象类和接口有什么区别?类和接口有什么关系?
答:
##抽象类和接口的区别：
成员区别：
        *抽象类
         变量，常量；有构造方法；有抽象方法，也有非抽象方法
        *接口
         常量；抽象方法
关系区别：
        *类与类
         继承，单继承
        *类与接口
         实现，可以单实现，也可以多实现
        *接口与接口
         继承，单继承，多继承
设计理念区别：
        *抽象类
         对类抽象，包括属性、行为
        *接口
         对行为抽象，主要是行为

#类和接口的关系
*类与类的关系
        继承关系，只能单继承，但可以多层继承
*类与接口的关系
        实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
*接口与接口的关系
        继承关系，可以单继承，也可以多继承
  


8.总结今天自己认为重要的点.
上边我说的都很重要，能写上去的我都写上去了，好好看，别再问了。

---

作者: 游涛    时间: 2020-1-15 20:59
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?
多态就是同一个对象在不同时刻表现出来的不同形态；好处是提高了程序的拓展性，坏处是不能使用子类的特有成员。
2.多态的转型指的是什么?
多态的转型指向上转型和向下转型。
向上转型是多态默认的，就是子类对象赋值给父类对象
父类名        对象名  =  new  子类名();
向下转型是强制转型的，就是将多态的对象通过强转，转成子类对象
父类名  对象名A  =  new  子类名();
子类名  对象名B  =  (子类名)  对象名A；
3.什么是抽象类?它的特点是什么?
抽象类就是子类重写父类的方法，父类的方法中没有方法体，这个父类就是抽象类。抽象类的特点：①必须被abstract修饰；②抽象类可以定义抽象方法,其他和普通类一样。
4.抽象类中的成员(属性,方法)有什么特点?
①成员变量可以是变量也可以是常量；②构造方法可以创建有参构造和无参构造；③成员方法可以定义抽象方法和普通方法。
5.接口是什么?它有什么特点?
接口就是一种规则，符合这个规则就能用这个接口；
特点：①必须被interface修饰；②实现接口用implement；③接口不能直接实例化，得通过子类对象去实例化；④如果子类实现接口了，那么子类就要实现接口的所有方法，要么该子类也是一个接口，就不用重写父接口的方法。
6.接口中的成员(属性,方法)有什么特点?
只能定义常量和抽象方法，常量默认被public、static、final修饰，书写常量时可以不写，抽象方法默认被public  abstract修饰，书写方法时可以不写。在JDK8及以上的版本还有一些新特性。
7.抽象类和接口有什么区别?类和接口有什么关系?
区别：①定义的代码不同；②继承和实现的特点不同；③修饰不同；④子类实现方法不同；⑤作用不同；⑥方法不同；⑦修饰符不同
关系：①都有抽象方法；②都是抽象类；③都不能被创建对象
8.总结今天自己认为重要的点.
理解多态、抽象类和接口

---

作者: 柯淇丰    时间: 2020-1-15 21:03
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?
多态就是一个类多种体现方式。提高程序的扩展性   坏处是不能使用子类的特有成员。
2.多态的转型指的是什么?
指的是向上转型跟向下转型 父类引用指向子类对象就是向上转型   父类引用强转成子类引用就是向下转型。
3.什么是抽象类?它的特点是什么?
有abstract修饰的类就是抽象类  他的特点是抽象类不能实例化， 抽象类的子类要重写抽象类的抽象方法
4.抽象类中的成员(属性,方法)有什么特点?
abstract修饰的方法不能用private修饰。 可以有常量变量  无参构造有参构造   普通方法跟抽象方法
5.接口是什么?它有什么特点?
接口是一种公共的规范标准。    他的特点是被interface修饰  接口不可以实例化  接口的子类需要重写接口定义的抽象方法
6.接口中的成员(属性,方法)有什么特点?
可以有常量跟抽象方法   成员方法只能是抽象方法  没有构造方法
7.抽象类和接口有什么区别?类和接口有什么关系?
抽象类的属性和行为都可以写  但是接口只可以写常量跟抽象方法 抽象类只能单继承  接口可以多实现  抽象类是为了强调父子类关系   接口是为了规范行为
8.总结今天自己认为重要的点.
都特别重要 需要多复习

---

作者: 王林全    时间: 2020-1-15 21:06
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?
答：同一个对象，在不同时刻表现出来的不同形态
好处：提高程序的扩展性。
坏处：不能使用子类的特有成员
2.多态的转型指的是什么?
答：- 向上转型
          父类引用指向子类对象就是向上转型
- 向下转型
          格式：子类型 对象名 = (子类型)父类引用;
3.什么是抽象类?它的特点是什么?
答：如果 子类重写了父类的方法，那么在父类的方法中，不用给方法体，那个定义的这个父类就是抽象类
特点：* 1.  abstract  class
         *  2.  抽象类不一定有抽象方法
         *  3.  有抽象方法的类，一定是抽象类
         *  4.  抽象类可以定义普通方法
         *  5.  抽象类里面定义成员变量
         *  6.  抽象类里面定义构造方法
         *  7.  抽象类必须都有一个子类
4.抽象类中的成员(属性,方法)有什么特点?
答：（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺  省情况下默认为public；
      （ 2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
      （3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
      （4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；
5.接口是什么?它有什么特点?
答：接口就是统一的规范（准则）
特点：1. 接口中的方法，必须被子类实现
          2. 接口（“特殊”的抽象类）不能实例化（不能创建对象）
          3. 接口通过子类对象的创建，去实例化
          4. 如果子类实现接口了，那么该子类要么实现接口的所有方法，要么该子类也是一个接口，就不需要重写父接口的方法
6.接口中的成员(属性,方法)有什么特点?
答：- 成员常量的特点
  常量默认被 public static final修饰，在书写常量可写可不写。
- 抽象方法特点
  方法名称默认表public abstract修饰，在书写方法可写可不写。
7.抽象类和接口有什么区别?类和接口有什么关系?
答：* 接口和抽象类的不相同点
    * 定义的代码不同
      抽象类：什么都可以定义，（定义抽象方法，可以写，也可以不写）
      接口：目前只能定义常量和抽象方法。
    * 继承和实现的特点不同
      子类继承抽象类，只能继承一个抽象类（单继承）
      子类实现接口，一个子类可以实现多个接口（多实现）
    * 接口的修饰和抽象类的修饰不同
      public interface  接口的名称{--}
      public abstract class 抽象类的名称{}
    * 接口和抽象类的子类实现方式不同
      子类 implements  接口名称1,接口名称2{---}
      子类 extends 抽象类{---}
    * 作用不同（设计模式的不同）
      接口：对子类特定的行为（方法）进行约束
      抽象类：对子类具有共同的属性和行为进行抽取
    * 接口和抽象类里面方法的区别
      接口里面都是抽象方法
      抽象类里面可以有抽象方法，也可以没有，也可以有其它方法
    * 接口和抽象类里面修饰符的区别
      接口里面的常量和抽象方法必须被public修饰
      抽象类里面的抽象方法必须被public修饰，其它无要求
类和接口的关系：接口是特殊的抽象类。
8.总结今天自己认为重要的点.
答：多态的使用及，抽象的使用，接口的使用。

---

作者: 黑马13期李松    时间: 2020-1-15 21:07
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?
同一个对象，在不同时刻表现出来的不同形态。多态的好处提高了代码的扩展性。定义方法时，如果将父类型作为参数，在使用方法时，可以传递任意子类对象。
多态的弊端，不能使用子类特有的成员。
2.多态的转型指的是什么?
多态中的向上转型，父类引用指向子类对象其实就是向上转型。多态中的向下转型，将父类型的引用转换成具体的子类对象。

3.什么是抽象类?它的特点是什么?
使用abstract关键字来修饰类称为抽象类。1.抽象类和抽象方法必须使用abstract关键字修饰。2.抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
3.抽象类不能实例化，但是可以通过多态的方式创建子类对象。4.抽象类的子类，要么重写抽象父类中所有的抽象方法，要么子类本身也是一个抽象类。

4.抽象类中的成员(属性,方法)有什么特点?
抽象类中的成员特点
     1.成员变量
          既可以是变量、也可以是常量
     2.构造方法
          有构造方法，目的是给父类中成员初始化
     3.成员方法
          既可以是抽象方法、也可以是普通方法
                  
5.接口是什么?它有什么特点?
接口就是一种公共的规范标准，只要符合规范标准，都可以使用。
接口的特点
      1.如何定义接口
           public interface 接口名{}
      2.如何实现接口
           public class 类名 implements 接口名{}
      3.接口不能被实例化，可以通过多态形式创建实现类对象
      4.接口的实现类
           要么重写接口中所有的抽象方法
           要么实现类定义为抽象类

6.接口中的成员(属性,方法)有什么特点?
接口的成员特点
      1.成员变量
           只能是常量，默认修饰符为：public static final
      2.构造方法
           接口中没有构造方法
      3.成员方法
           接口中可以有抽象方法，默认修饰符为：public abstract
           JDK8以后可以有静态方法(后面学)
           JDK9以后可以有默认方法(后面学)

7.抽象类和接口有什么区别?类和接口有什么关系?
抽象类和接口的区别
     1.成员区别
          抽象类：变量、常量、构造方法、普通方法、抽象方法
          接口：常量、抽象方法
     2.关系区别
          类和类：继承关系，单继承
          类和接口：实现关系，单实现、多实现
          接口和接口：继承关系，单继承、多继承
      3.设计理念区别
          抽象类：完成的是一些共性功能的抽取
          接口：完成的是一些特性功能的抽取

8.总结今天自己认为重要的点.
多态的前提条件是 要有继承/实现关系 要有方法重写  要有父类引用指向子类对象。

---

作者: 郭加妙    时间: 2020-1-15 21:18
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?
答：多态指的一个对象在不同情况下的多种形态。
- 优点: 简化代码，提高代码的扩展性
- 缺点：不能调用子类对象特有的功能。

2.多态的转型指的是什么?
答：- 向上转型： 子类对象赋值给父类对象（多态默认的）
         比如： Animal an = new Cat();
      - 向下转型：将多态的对象通过强转，转成子类对象
       比如： Animal an = new Cat(); Cat  cat = (Cat)an


3.什么是抽象类?它的特点是什么?
答：用abstract,修饰的类就是抽象类。
特点 抽象类不一定有抽象方法
*      有抽象方法的类，一定是抽象类
*      抽象类可以定义普通方法
*      抽象类里面定义成员变量
*      抽象类里面定义构造方法
*      抽象类必须都有一个子类

4.抽象类中的成员(属性,方法)有什么特点?
答：抽象方法必须为public或者protected

5.接口是什么?它有什么特点?
答：  在java开发中，接口对特定行为的规范（约束）
接口就是统一的规范（准则），只要符合这个规范，那么都可以使用这个接口

特点：- *. 接口中的方法，必须被子类实现
  *. 接口（“特殊”的抽象类）不能实例化（不能创建对象）
  *. 接口通过子类对象的创建，去实例化
  *. 如果子类实现接口了，那么该子类要么实现接口的所有方法
     要么该子类也是一个接口，就不需要重写父接口的方法
  - 接口（特殊的抽象类）与接口（特殊的抽象类）
    extends建立关系： public interface A  extends BInterface{}
  - 类与接口
    implements建立关系： public  class A  implements BInterface{}
  - 类与类
    extends建立关系： public class  A  extends B{}

6.接口中的成员(属性,方法)有什么特点?
答：  在接口中定义：常量，抽象方法（jdk8以下版本的要求）
jdk8,jdk9以上版本：在接口里面可以定义静态方法，定义默认方法，私有方法。
接口里面定义5部分：
jdk8之前：只能定义常量值，抽象方法
jdk8以后：静态方法，默认方法，私有方法
- 成员常量的特点
  常量默认被 public static final修饰，在书写常量可写可不写。
- 抽象方法特点
  方法名称默认表public abstract修饰，在书写方法可写可不写。

7.抽象类和接口有什么区别?类和接口有什么关系?
答：接口和抽象类的相同点

    == 接口和抽象类：里面都可以写抽象方法

    == 它们两个都是抽象类（接口：接口中有抽象方法，所以把接口称之为抽象类）

    == 它们两个都不能被创建对象

  * 接口和抽象类的不相同点

    * 定义的代码不同

      抽象类：什么都可以定义，（定义抽象方法，可以写，也可以不写）

      接口：目前只能定义常量和抽象方法。

    * 继承和实现的特点不同

      子类继承抽象类，只能继承一个抽象类（单继承）

      子类实现接口，一个子类可以实现多个接口（多实现）

    * 接口的修饰和抽象类的修饰不同

      public interface  接口的名称{--}

      public abstract class 抽象类的名称{}

    * 接口和抽象类的子类实现方式不同

      子类 implements  接口名称1,接口名称2{---}

      子类 extends 抽象类{---}

    * 作用不同（设计模式的不同）

      接口：对子类特定的行为（方法）进行约束

      抽象类：对子类具有共同的属性和行为进行抽取

    * 接口和抽象类里面方法的区别

      接口里面都是抽象方法

      抽象类里面可以有抽象方法，也可以没有，也可以有其它方法

    * 接口和抽象类里面修饰符的区别

      接口里面的常量和抽象方法必须被public修饰

      抽象类里面的抽象方法必须被public修饰，其它无要求
8.总结今天自己认为重要的点.
抽象类和接口各自的使用场景。

---

作者: 汪宇豪    时间: 2020-1-15 21:22
    implements建立关系： public  class A  implements BInterface{}
  - 类与类
    extends建立关系： public class  A  extends B{}

6.接口中的成员(属性,方法)有什么特点?
答：  在接口中定义：常量，抽象方法（jdk8以下版本的要求）
jdk8,jdk9以上版本：在接口里面可以定义静态方法，定义默认方法，私有方法。
接口里面定义5部分：
jdk8之前：只能定义常量值，抽象方法
jdk8以后：静态方法，默认方法，私有方法
- 成员常量的特点
  常量默认被 public static final修饰，在书写常量可写可不写。
- 抽象方法特点
  方法名称默认表public abstract修饰，在书写方法可写可不写。

7.抽象类和接口有什么区别?类和接口有什么关系?
答：接口和抽象类的相同点

    == 接口和抽象类：里面都可以写抽象方法

    == 它们两个都是抽象类（接口：接口中有抽象方法，所以把接口称之为抽象类）

    == 它们两个都不能被创建对象

  * 接口和抽象类的不相同点

    * 定义的代码不同

      抽象类：什么都可以定义，（定义抽象方法，可以写，也可以不写）

      接口：目前只能定义常量和抽象方法。

    * 继承和实现的特点不同

      子类继承抽象类，只能继承一个抽象类（单继承）

      子类实现接口，一个子类可以实现多个接口（多实现）

    * 接口的修饰和抽象类的修饰不同

      public interface  接口的名称{--}

      public abstract class 抽象类的名称{}

    * 接口和抽象类的子类实现方式不同

      子类 implements  接口名称1,接口名称2{---}

      子类 extends 抽象类{---}

    * 作用不同（设计模式的不同）

      接口：对子类特定的行为（方法）进行约束

      抽象类：对子类具有共同的属性和行为进行抽取

    * 接口和抽象类里面方法的区别

      接口里面都是抽象方法

      抽象类里面可以有抽象方法，也可以没有，也可以有其它方法

    * 接口和抽象类里面修饰符的区别

      接口里面的常量和抽象方法必须被public修饰

      抽象类里面的抽象方法必须被public修饰，其它无要求点.

---

作者: 赖君皇    时间: 2020-1-15 21:37
今日整理:
1.什么是多态?多态的好处和坏处分别是什么?
一个对象在不同情况下的多钟形态；优点：简化代码，提高代码的扩展性。缺点：不能调用子类对象的特有方法
2.多态的转型指的是什么?
向上：把子类对象赋值给父类对象；向下：将多态的对象通过强转，转成子类对象
3.什么是抽象类?它的特点是什么?
如果子类重写了父类的方法，那么父类的方法中，不用给方法体，那个定义的这个父类就是抽象类，那么定义的没有方法体的方法就是抽象方法。
1. abstract  class
2.  抽象类不一定有抽象方法
3.  有抽象方法的类，一定是抽象类
4.  抽象类可以定义普通方法
5.  抽象类里面定义成员变量
6.  抽象类里面定义构造方法
7.  抽象类必须都有一个子类
4.抽象类中的成员(属性,方法)有什么特点?
抽象类必须被abstract修饰
抽象类可以定义抽象方法
其他无异
5.接口是什么?它有什么特点?
统一的规范或准则，只要符合这个规范，就可以使用这个接口
6.接口中的成员(属性,方法)有什么特点?
1. 接口中的方法，必须被子类实现
2. 接口（“特殊”的抽象类）不能实例化（不能创建对象）
3. 接口通过子类对象的创建，去实例化
4. 如果子类实现接口了，那么该子类要么实现接口的所有方法
   要么该子类也是一个接口，就不需要重写父接口的方法
类与接口
        implements建立关系： public  class A  implements BInterface{}
接口（特殊的抽象类）与接口（特殊的抽象类）
        extends建立关系： public interface A  extends BInterface{}
类与类
        extends建立关系： public class  A  extends B{}
7.抽象类和接口有什么区别?类和接口有什么关系?
不同
        定义的代码不同
                接口：目前只能定义常量和抽象方法
                抽象类：什么都能定义
        继承和实现的特点不同
                子类实现接口，一个子类可以实现多个接口（多实现）
                子类继承抽象类，只能继承一个抽象类（单继承）
        接口和抽象类的子类实现方式不同
                public abstract class 抽象类的名称{}
                public interface  接口的名称{--}
        接口的修饰和抽象的修饰不同
                子类 implements  接口名称1,接口名称2{---}
                 子类 extends 抽象类{---}
        作用不同
                接口：对类特点的行为（方法）进行约束
                抽象类：对子类具有共同的属性和行为进行抽取
        接口和抽象类里面方法的区别
                接口里面都是抽象方法
                抽象类：可以有抽象方法，也可以没有，也可以有其它方法
        接口和抽象类里面修饰符的区别
                接口：常量和抽象方法必须被publ修饰
                抽象类：抽象方法必须被public修饰，其他无要求
关系：都是抽象方法；都不能被创建对象
8.总结今天自己认为重要的点.
①子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；
②抽象类和接口的区别：定义的代码不同
                接口：目前只能定义常量和抽象方法
                抽象类：什么都能定义
        继承和实现的特点不同
                子类实现接口，一个子类可以实现多个接口（多实现）
                子类继承抽象类，只能继承一个抽象类（单继承）
        接口和抽象类的子类实现方式不同
                public abstract class 抽象类的名称{}
                public interface  接口的名称{--}
        接口的修饰和抽象的修饰不同
                子类 implements  接口名称1,接口名称2{---}
                 子类 extends 抽象类{---}
        作用不同
                接口：对类特点的行为（方法）进行约束
                抽象类：对子类具有共同的属性和行为进行抽取
        接口和抽象类里面方法的区别
                接口里面都是抽象方法
                抽象类：可以有抽象方法，也可以没有，也可以有其它方法
        接口和抽象类里面修饰符的区别
                接口：常量和抽象方法必须被publ修饰
                抽象类：抽象方法必须被public修饰，其他无要求

---

作者: 黄毅眀    时间: 2020-1-15 23:40
1.多态指的一个对象在不同情况下的多种形态。好处：可以优化代码，提高代码的扩展性；坏处：不能
  调用子类对象的特有的方法
2.指的是由子类对象赋值给父类对象（默认的向上转型）和由父类对象强转转为子类对象（向下转型）
3.如果 子类重写了父类的方法，那么在父类的方法中，不用给方法体，那定义的这个父类就是抽象类。
     特点：
        *  1.  定义的类必须加abstract ，如：abstract  class
        *  2.  抽象类不一定有抽象方法
        *  3.  有抽象方法的类，一定是抽象类
        *  4.  抽象类可以定义普通方法
        *  5.  抽象类里面定义成员变量
        *  6.  抽象类里面可以定义构造方法
        *  7.  抽象类如果有定义抽象方法必须都有一个子类
4.抽象类中的属性与一般类中无差别，普通方法也与普通类中无差别，但是如果是定义的抽象方法，则只能用public
  或者protected修饰，不能用private
5.接口就是统一的对特定行为的规范（约束），
  特点：
        *  1. 接口中的方法，必须被子类实现
        *  2. 接口（“特殊”的抽象类）不能实例化（不能创建对象）
        *  3. 接口通过子类对象的创建，去实例化
        *  4. 如果子类实现接口了，那么该子类要么实现接口的所有方法
           要么该子类也是一个接口，就不需要重写父接口的方法
6.在接口中定义：常量，抽象方法（jdk8以下版本的要求）
   jdk8,jdk9以上版本：在接口里面可以定义静态方法，定义默认方法，私有方法。
7.  定义的代码不同

      抽象类：什么都可以定义，（定义抽象方法，可以写，也可以不写）

      接口：目前只能定义常量和抽象方法。

    * 继承和实现的特点不同

      子类继承抽象类，只能继承一个抽象类（单继承）

      子类实现接口，一个子类可以实现多个接口（多实现）

    * 接口的修饰和抽象类的修饰不同

      public interface  接口的名称{--}

      public abstract class 抽象类的名称{}

    * 接口和抽象类的子类实现方式不同

      子类 implements  接口名称1,接口名称2{---}

      子类 extends 抽象类{---}

    * 作用不同（设计模式的不同）

      接口：对子类特定的行为（方法）进行约束

      抽象类：对子类具有共同的属性和行为进行抽取

    * 接口和抽象类里面方法的区别

      接口里面都是抽象方法

      抽象类里面可以有抽象方法，也可以没有，也可以有其它方法

    * 接口和抽象类里面修饰符的区别

      接口里面的常量和抽象方法必须被public修饰

      抽象类里面的抽象方法必须被public修饰，其它无要求
8.都好重要啊，给我听蒙了都

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2