java抽象类、接口、内部类专项

参考文献：

接口和抽象类有什么区别？

抽象类和接口的概念

抽象类

用abstract修饰，抽象类中可以没有抽象方法，但抽象方法肯定在抽象类中，且抽象方法定义时不能有方法体；抽象类不可以实例化只能通过继承在子类中实现其所有的抽象方法；抽象类如果不被继承就没有任何意义；抽象类为子类定义了一个公共类型，封装了子类中的重复内容。

接口

同Interface关键字定义接口，是特殊的抽象类,因为类中只包含抽象方法；接口中不能定义成员变量可以定义常量；接口是其通过其他类使用implements关键字定义实现类，一个类一旦实现接口就必须实现其中的所有抽象方法，一个类可以实现多个接口，接口名之间用逗号隔开即可；一个接口可以通过extends关键字继承另一个接口，与此同时继承了父类中的所有方法。
在接口中定义的方法除了default和static关键字修饰的方法拥有方法体，其他方法都应是没有方法体的抽象方法（JDK1.8以后）

抽象类与接口的区别

继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如狗是否能钻火圈，能则可以实现这个接口，不能就不实现这个接口。

抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它。
所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。

	抽象类	接口
继承类	可以继承普通类，实现多个接口	不能继承普通类，可以继承接口
构造函数	可以有	不能有
设计目的	代码复用	强制要求不同的类具有相同的行为
方法体	抽象类中的抽象方法没有方法体	java 8中接口可以包含具体的方法实现，方法实现必须default修饰
实例化	不能	不能
方法	可以有非抽象方法	在JDK1.8之前 接口中只能包括 常量 和抽象方法,在JDK1.8之后 接口不再纯洁了，新增了三种方法 ：默认方法 静态方法 私有方法
子类	抽象类的子类必须给出父类中的抽象方法的具体实现，除非该子类也是抽象类。	必须给出接口中的抽象方法的具体实现，除非该类也是抽象类。
成员变量	可以有	可以定义成员变量，但是这些成员变量默认都是public static final的常量
在代码书写方面	抽象类提高了类和类的内聚程度，减少了代码量	接口降低了类和类的耦合度，但是增加了代码量
方法的访问权限	JDK 1.8以前，抽象类的方法默认访问权限为protected。 JDK 1.8时，抽象类的方法默认访问权限变为default	JDK 1.8以前，接口中的方法必须是public的JDK 1.8时，接口中的方法可以是public的，也可以是default的JDK 1.9时，接口中的方法可以是private的
静态方法	可以有	jdk1.8之后可以有，但是要有方法体

1） 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错），所以不能含有静态代码块以及静态方法(用 static 修饰的方法)

2） 在jdk1.8中，接口里可以有静态方法，接口里的有静态方法 必须要有body。有静态方法不需要实现。

下图可能是针对jdk1.7以前吧
抽象类能继承一个普通类（或抽象类），实现多个接口。
抽象类和普通类相比只是不能被实例化，只能作为子类的超类。
抽象类是用来捕捉子类的通用特性的，被用来创建继承层级里子类的模板。
可以有默认的方法实现。
抽象类可以有构造方法。
可以有main方法。
不必须有抽象方法，但是包含抽象方法的类一定是抽象类。

接口
接口能实现多个其他接口。
接口是抽象方法的集合，一个类实现了某个接口就必须实现抽象方法。
接口抽象方法默认修饰符是public（可以不写），不能使用其他修饰符。
java 8中接口可以包含具体的方法实现，方法实现必须default修饰。

抽象类与接口的设计目的

接口的设计目的，是对类的行为进行约束（更准确的说是一种“有”约束，因为接口不能规定类不可以有什么行为），也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，但不对如何实现行为进行限制。对“接口为何是约束”的理解，我觉得配合泛型食用效果更佳。

而抽象类的设计目的，是代码复用。当不同的类具有某些相同的行为(记为行为集合A)，且其中一部分行为的实现方式一致时（A的非真子集，记为B），可以让这些类都派生于一个抽象类。在这个抽象类中实现了B，避免让所有的子类来实现B，这就达到了代码复用的目的。而A减B的部分，留给各个子类自己实现。正是因为A-B在这里没有实现，所以抽象类不允许实例化出来（否则当调用到A-B时，无法执行）。

Java语言中类的继承是单继承原因是：当子类重写父类方法的时候，或者隐藏父类的成员变量以及静态方法的时候，JVM使用不同的绑定规则。如果一个类有多个直接的父类，那么会使绑定规则变得更复杂。为了简化软件的体系结构和绑定机制，java语言禁止多继承。

接口可以多继承，是因为接口中只有抽象方法，没有静态方法和非常量的属性，只有接口的实现类才会重写接口中方法。因此一个类有多个接口也不会增加JVM的绑定机制和复杂度。
对于已经存在的继承树，可以方便的从类中抽象出新的接口，但是从类中抽象出新的抽象类就不那么容易了，因此接口更有利于软件系统的维护和重构。

子类的权限不能比父类更低
JAVA 子类重写继承的方法时,不可以降低方法的访问权限，子类继承父类的访问修饰符要比父类的更大，也就是更加开放，假如我父类是protected修饰的，其子类只能是protected或者public，绝对不能是friendly(默认的访问范围)或者private，当然使用private就不是继承了。还要注意的是，继承当中子类抛出的异常必须是父类抛出的异常的子异常，或者子类抛出的异常要比父类抛出的异常要少。

含有abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

接口方法默认是public abstract的，且实现该接口的类中对应的方法的可见性不能小于接口方法的可见性
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
下面比较一下两者的语法区别：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然
eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。

1.java支持单继承，却可以实现多个接口。
2.接口没有构造方法，所以不能实例化，抽象类有构造方法，但是不是用来实例化的，是用来初始化的。
3.抽象类可以定义普通成员变量而接口不可以，但是抽象类和接口都可以定义静态成员变量，只是接口的静态成员变量要用 public static final 来修饰

1、抽象类可以有构造，只不过不能new。
2、接口中可以有变量，但是无论你怎么写，最后都是public static final的。
3、抽象类中可以有静态方法，接口中也可以有。（

1） 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错），所以不能含有静态代码块以及静态方法(用 static 修饰的方法)

2） 在jdk1.8中，接口里可以有静态方法，接口里的有静态方法 必须要有body。有静态方法不需要实现。）

扩展：
1、接口中可以有非抽象的方法，比如default方法（Java 1.8）。
2、接口中可以有带方法体的方法。（Java 1.8）
3、接口中的方法默认是public的。

接口为什么不能有构造函数？

首先你要明白构造函数的作用，构造函数就是初始化class的属性或者方法，在new的一瞬间自动调用，那么问题来了Java和PHP的接口，都不能new那么要构造函数干嘛呢?根本就没法调用，但是实现接口是要实现接口中的所有方法的，不能实例对象，就不能调用构造函数

abstract与static不能连用修饰方法

abstract：用来声明抽象方法，抽象方法没有方法体，不能被直接调用，必须在子类overriding后才能使用。
static：用来声明静态方法，静态方法可以被类及其对象调用。
用static声明方法表明这个方法在不生成类的实例时可直接被类调用，而abstract方法不能被调用，两者矛盾。所以，abstract与static不能连用来修饰方法

子类重写父类方法时，方法的访问权限不能小于原访问权限，在接口中，方法的默认权限就是public，所以子类重写后只能是public

1、接口是一种约束和规范，是一种更加更高级的抽象类，抽象类的方法必须是公开的，因为要给人继承和使用啊，不用public，别人怎么看得到，所以在接口实现时，定义的方法修饰符必须是public；因此子类在实现接口重写方法时的修饰符必须是public。
2、另外再扩展一下，接口中没有变量（既然是约束和规范，怎么能够定义一个大家都可以改的东西呢？），只能是常量，接口中定义常量默认的修饰符为public static final。

接口的方法都是 public abstract 变量都是public static final的
jdk8之后，接口可以定义 static方法 与 default方法。 static方法只能通过接口调用，不能通过实现类调用。default只能通过接口实现类调用，不能通过接口名调用。

先谈interface和class的区别，在C++里本来是没有interface，一个class可以从多个class派生。问题来了，当两个parent class都有相同方法时，调用这个class的方法会调用哪个parent class方法呢？这就是二义性问题。（Multiple inheritance）

Java于是禁止class的多重继承，引入了interface的概念，interface只是定义了行为特性的规约，没有实现，因此不会有二义性。

而abstract class是有一些class仅仅作为parent使用，留有一些method给出了定义（在其他method中通常会调用），但没有实现，由不同的sub class来实现。这些method被标明为abstract（就不用提供mehod body），以便sub class要么实现这些方法，要么也作为abstract class。这样的class是无法被实例化的，因此需要标明为abstract class，以便编译时刻，编译器可以提示编译错误。

接口是对动作的抽象，而抽象类是对根源的抽象
对于抽象类，比如男人，女人这两个类，那我们可以为这两个类设计一个更高级别的抽象类–人。对于接口，我们可以坐着吃饭，可以站着吃饭，可以用筷子吃饭，可以用叉子吃饭，甚至可以学三哥一样用手抓着吃饭，那么可以把这些吃饭的动作抽象成一个接口–吃饭。所以在高级语言中（如Java,C#），一个类只能继承一个抽象类（因为你不可能同时是生物又是非生物）。但是一个类可以同时实现多个接口，比如开车接口，滑冰接口，啪啪啪接口，踢足球接口，游泳接口。

1、抽象类和接口都不能被直接实例化，如果二者要实例化，就涉及到多态，不懂多态的参见我的回答JAVA的多态用几句话能直观的解释一下吗？ - 知乎。如果抽象类要实例化，那么抽象类定义的变量必须指向一个子类对象，这个子类继承了这个抽象类并实现了这个抽象类的所有抽象方法。如果接口要实例化，那么这个接口定义的变量要指向一个子类对象，这个子类必须实现了这个接口所有的方法。

2、抽象类要被子类继承，接口要被子类实现。

3、接口里面只能对方法进行声明，抽象类既可以对方法进行声明也可以对方法进行实现。

4、抽象类里面的抽象方法必须全部被子类实现，如果子类不能全部实现，那么子类必须也是抽象类。接口里面的方法也必须全部被子类实现，如果子类不能实现那么子类必须是抽象类。

5、接口里面的方法只能声明，不能有具体的实现。这说明接口是设计的结果，抽象类是重构的结果。

6、抽象类里面可以没有抽象方法。

7、如果一个类里面有抽象方法，那么这个类一定是抽象类。

8、抽象类中的方法都要被实现，所以抽象方法不能是静态的static，也不能是私有的private。

9、接口（类）可以继承接口，甚至可以继承多个接口。但是类只能继承一个类。

10、抽象级别（从高到低）：接口>抽象类>实现类。

11、抽象类主要是用来抽象类别，接口主要是用来抽象方法功能。当你关注事物的本质的时候，请用抽象类；当你关注一种操作的时候，用接口。

12、抽象类的功能应该要远多于接口，但是定义抽象类的代价较高。因为高级语言一个类只能继承一个父类，即你在设计这个类的时候必须要抽象出所有这个类的子类所具有的共同属性和方法；但是类（接口）却可以继承多个接口，因此每个接口你只需要将特定的动作方法抽象到这个接口即可。也就是说，接口的设计具有更大的可扩展性，而抽象类的设计必须十分谨慎。

====================================
A类继承了B抽象类表示它“是什么”！
A类实现了C接口表示它“有什么功能”！
接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。
类可以实现很多个接口，但是只能继承一个抽象类
Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。
接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。

在编程领域，好的设计模式能够让我们的代码事半功倍。在使用接口的时候，经常会用到三种模式，分别是策略模式、适配器模式和工厂模式。

尽管接口使得抽象更进一步，但任何抽象性都应该根据真正的需求而产生，因此恰当的原则是优先选择类而不是接口，只有在真正需要接口的时候再重构代码。

1）策略模式

策略模式的思想是，针对一组算法，将每一种算法封装到具有共同接口的实现类中，接口的设计者可以在不影响调用者的情况下对算法做出改变。

示例如下：

// 接口：教练
interface Coach {
    
    
    // 方法：防守
    void defend();
}

// 何塞·穆里尼奥
class Hesai implements Coach {
    
    

    @Override
    public void defend() {
    
    
        System.out.println("防守赢得冠军");
    }
}

// 德普·瓜迪奥拉
class Guatu implements Coach {
    
    

    @Override
    public void defend() {
    
    
        System.out.println("进攻就是最好的防守");
    }
}

public class Demo {
    
    
    // 参数为接口
    public static void defend(Coach coach) {
    
    
        coach.defend();
    }
    
    public static void main(String[] args) {
    
    
        // 为同一个方法传递不同的对象
        defend(new Hesai());
        defend(new Guatu());
    }
}

Demo.defend() 方法可以接受不同风格的 Coach，并根据所传递的参数对象的不同而产生不同的行为，这被称为“策略模式”。

2）适配器模式
适配器模式的思想是，针对调用者的需求对原有的接口进行转接。生活当中最常见的适配器就是HDMI（英语：High Definition Multimedia Interface，中文：高清多媒体接口）线，可以同时发送音频和视频信号。适配器模式的示例如下：

interface Coach {
    
    
    void defend();
    void attack();
}

// 抽象类实现接口，并置空方法
abstract class AdapterCoach implements Coach {
    
    
    public void defend() {
    
    };
    public void attack() {
    
    };
}

// 新类继承适配器
class Hesai extends AdapterCoach {
    
    
    public void defend() {
    
    
        System.out.println("防守赢得冠军");
    }
}

public class Demo {
    
    
    public static void main(String[] args) {
    
    
        Coach coach = new Hesai();
        coach.defend();
    }
}

Coach 接口中定义了两个方法（defend() 和 attack()），如果类直接实现该接口的话，就需要对两个方法进行实现。

如果我们只需要对其中一个方法进行实现的话，就可以使用一个抽象类作为中间件，即适配器（AdapterCoach），用这个抽象类实现接口，并对抽象类中的方法置空（方法体只有一对花括号，就不是抽象方法啦），这时候，新类就可以绕过接口，继承抽象类，我们就可以只对需要的方法进行覆盖，而不是接口中的所有方法。

3）工厂模式
所谓的工厂模式理解起来也不难，就是什么工厂生产什么，比如说宝马工厂生产宝马，奔驰工厂生产奔驰，A 级学院毕业 A 级教练，C 级学院毕业 C 级教练。示例如下：

/ 教练
interface Coach {
    
    
    void command();
}

// 教练学院
interface CoachFactory {
    
    
    Coach createCoach();
}

// A级教练
class ACoach implements Coach {
    
    

    @Override
    public void command() {
    
    
        System.out.println("我是A级证书教练");
    }
    
}

// A级教练学院
class ACoachFactory implements CoachFactory {
    
    

    @Override
    public Coach createCoach() {
    
    
        return new ACoach();
    }
    
}

// C级教练
class CCoach implements Coach {
    
    

    @Override
    public void command() {
    
    
        System.out.println("我是C级证书教练");
    }
    
}

// C级教练学院
class CCoachFactory implements CoachFactory {
    
    

    @Override
    public Coach createCoach() {
    
    
        return new CCoach();
    }
    
}

public class Demo {
    
    
    public static void create(CoachFactory factory) {
    
    
        factory.createCoach().command();
    }
    
    public static void main(String[] args) {
    
    
        // 对于一支球队来说，需要什么样的教练就去找什么样的学院
        // 学院会介绍球队对应水平的教练。
        create(new ACoachFactory());
        create(new CCoachFactory());
    }
}

有两个接口，一个是 Coach（教练），可以 command()（指挥球队）；另外一个是 CoachFactory（教练学院），能 createCoach()（教出一名优秀的教练）。然后 ACoach 类实现 Coach 接口，ACoachFactory 类实现 CoachFactory 接口；CCoach 类实现 Coach 接口，CCoachFactory 类实现 CoachFactory 接口。当需要 A 级教练时，就去找 A 级教练学院；当需要 C 级教练时，就去找 C 级教练学院。

依次类推，我们还可以用 BCoach 类实现 Coach 接口，BCoachFactory 类实现 CoachFactory 接口，从而不断地丰富教练的梯队。

抽象类：有抽象方法的类一定是抽象类 抽象类不一定有抽象方法

抽象类就是要被继承 要不然就失去了意义

抽象类要用abstract修饰

抽象方法也要用abstract修饰

抽象类不能创建对象

如果一个类继承抽象类 那么它必须重写抽象类中的抽象方法，否则该类也必须定义为抽象类

接口体现的是“规范思想”，是更加彻底的抽象。

实现接口的类必须重写接口中的全部抽象方法

在JDK1.8之前 接口中只能包括 常量 和抽象方法

在JDK1.8之后 接口不再纯洁了，新增了三种方法 ：默认方法 静态方法 私有方法

注意：接口中 抽象方法的修饰符 public abstract 可省略，常量 public static final 可省略

默认方法要用default修饰 只能用实现类的对象来调用

私有方法使用private修饰 供接口中的默认方法和私有方法来调用

静态方法只能通过接口名称调用

实现接口的关键字:implements

优先级问题

当一个类继承了一个父类 又实现了一个接口时 接口和父类中默认方法重名 子类对象就近执行父类的成员方法。

类与类是单继承

接口与接口是多继承

类与接口是多实现

内部类

(1)把类定义在另一个类的内部，该类就被称为内部类。
举例：把类B定义在类A中，类B就被称为内部类。
(2)内部类的访问规则
A:可以直接访问外部类的成员，包括私有
B:外部类要想访问内部类成员，必须创建对象
(3)内部类的分类
A:成员内部类
B:局部内部类
C:匿名内部类
(4)成员内部类访问规则
成员内部类不是静态的：
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
成员内部类是静态的：
外部类名.内部类名 对象名 = new 外部类名.内部类名();
(5)局部内部类
(6)匿名内部类(掌握)

内部类可以是静态static的，也可用public，default，protected和private修饰，
外部类的修饰符只能是public，abstract，final
static修饰的为类成员,会随着类的加载而加载,比如静态代码块,静态成员,静态方法(这里只是加载,并没有调用)等等,可以想象一下,如果把一个Class文件中的外部类设为static,目的难道是让这个类随着应用的启动而加载吗？如果在这次使用过程中根本没有使用过这个类,那么是不是就会浪费内存。这样来说设计不合理,总而言之,设计不合理的地方,Java是不会让它存在的。
而为什么内部类可以使用static修饰呢,因为内部类算是类的成员了,如果没有使用静态来修饰,那么在创建内部类的时候就需要先有一个外部类的对象,如果我们一直在使用内部类,那么内存中就会一直存在外部类的引用,而我们有时候只需要使用内部类,不需要外部类,那么还是会浪费内存,甚至会造成内存溢出。使用static修饰内部类之后,内部类在创建对象时就不需要有外部类对象的引用了。
最终结论就是:static可以用来修饰内部类,但是不可以用来修饰外部类

接口中的所以方法都是抽象的-方法定义

接口中的值都是public static final的-常量值

1，抽象类中可以有抽象方法，也可以没有抽象方法。
2，抽象类当然可以被继承，因为它就是用来继承的，
3，继承抽象类，若有抽象方法，则子类必须将其抽象方法实现，
4，抽象类中的非抽象方法可以被重写。

总的来说一下内部类吧：

1. 静态内部类：
   1. 静态内部类本身可以访问外部的静态资源，包括静态私有资源。但是不能访问非静态资源，可以不依赖外部类实例而实例化。
2. 成员内部类：
   1. 成员内部类本身可以访问外部的所有资源，但是自身不能定义静态资源，因为其实例化本身就还依赖着外部类。
3. 局部内部类：
   1. 局部内部类就像一个局部方法，不能被访问修饰符修饰，也不能被static修饰。
   2. 局部内部类只能访问所在代码块或者方法中被定义为final的局部变量。
4. 匿名内部类：
   1. 没有类名的内部类，不能使用class，extends和implements，没有构造方法。
   2. 多用于GUI中的事件处理。
   3. 不能定义静态资源
   4. 只能创建一个匿名内部类实例。
   5. 一个匿名内部类一定是在new后面的，这个匿名类必须继承一个父类或者实现一个接口。
   6. 匿名内部类是局部内部类的特殊形式，所以局部内部类的所有限制对匿名内部类也有效。

A.抽象类可以有构造方法,只是不能直接创建抽象类的实例对象而已
B.在接口中 不可以有构造方法,在接口里写入构造方法时，编译器提示：Interfaces cannot have constructors。
C.Java不允许类多重继承
D.jdk1.8后接口中的方法可以有方法体，jdk1.8之前不可以有方法体

JDK1.8后，接口中可以有静态方法，静态方法必须有方法体。

java为单继承，多实现。可以实现多个接口。
接口允许定义成员，但必须是常量。
抽象类和接口类的无法实例化，任何编译器中直接使用new会报错。
单继承，多实现。

1、一个类可以有多个接口；
2、一个类只能继承一个父类；
3、接口中可以不声明任何方法，和成员变量
interface testinterface{

}
4、抽象类可以不包含抽象方法，但有抽象方法的类一定要声明为抽象类
abstract class abstclass{
abstract void meth();
}

1 下列哪个类的声明是正确的？D

abstract final class HI{
    
    }

abstract private move(){
    
    }

protected private number;

public abstract class Car{
    
    }

A只能有final和abstract的一个，因为final是最终类，不能继承，必须可以创建实例，而abstract是抽象类，只能继承，不能有实例。冲突了，所以不对。
B是抽象方法，不能有方法体。所以末尾不是{}而是；才对
C中 访问修饰符只能有一个，而且对象没有类型。
D正确，这是抽象类。

抽象方法不能有方法体也就是说不能有花括号，但是抽象类可以有花括号，不能混淆

A选项，final是最终类，不能被继承；abstrct类是抽象类，只能被继承，两者冲突。 B选项，private修饰符定义的属性及方法不能被子类实现，而抽象类的子类必须实现所有的抽象方法。两者冲突。 C选项，修饰符重复，而且没有定义数据类型。 D选项，正确。

2 下面字段声明中哪一个在interface主体内是合法的? （B）

private final static int answer = 42;

public static int answer = 42;

final static answer = 42;

int answer;

在接口中，属性都是默认public static final修饰的，所以：
A（错误）：不能用private修饰；
B（正确）：在接口中，属性默认public static final，这三个关键字可以省略；
C（错误）：没写属性的类型；
D（错误）：final修饰的属性必须赋值；

接口中的属性在不提供修饰符修饰的情况下，会自动加上public static final
注意（在1.8的编译器下可试）：
（1）属性不能用private，protected,default 修饰，因为默认是public
（2）如果属性是基本数据类型，需要赋初始值，若是引用类型，也需要初始化，因为默认有final修饰，必须赋初始值；
（3）接口中常规的来说不能够定义方法体，所以无法通过get和set方法获取属性值，所以属性不属于对象，属于类（接口），因为默认使用static修饰。

1. 抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。（static表示是静态的方法，随着类的加载而加
5. 载，则该方法不需要在子类中去实现，这与abstract关键字矛盾）

6. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

3 以下关于 abstract 关键字的说法，正确的是（D）

abstract 可以与final 并列修饰同一个类。

abstract 类中不可以有private的成员。

abstract 类中必须全部是abstract方法。

abstract 方法必须在abstract类或接口中。

1abstract类不能与final,static使用。final修饰方法，子类可以调用，但不能覆盖。
2最好不要有private因为私有和抽象放在一起，子类如果想重写父类的私有方法根本继承不过来，也就无法重写
3抽象类中可以有非抽象方法
4抽象类中可以都是非抽象的，但是抽象方法一定要在类和接口中

abstract是需要被继承使用的，所以它不能被final使用，所以A错，也可以有private属性，B错，也可以有普通方法 甚至所有都可以是普通方法，当然这样也就失去了abstract类的意义，C错，interface属于特殊的abstract类，也是abstract类，所以D对

4 对接口的描述正确的是(A)

一个类可以实现多个接口

接口可以有非静态的成员变量

在jdk8之前，接口可以实现方法

实现接口的任何类，都需要实现接口的方法

A，一个类只能有一个直接父类，但是继承是有传递性的。一个类可以实现多的接口。一个接口可以继承多个类。
B，接口中没有普通变量（普通成员变量），接口中都是常量，默认修饰符：public static final
C，JDK8之前，接口中的方法都是默认public abstract的，JDK8之后，接口中可以有static、default的修饰的方法，一旦被修饰，方法必须有方法体（抽象方法可是没有方法体的），接口中的方法都不能被private和protected修饰，同时外部接口、类只能被public修饰或者不写，但是内部接口、类可以被四个访问修饰符修饰。
D， 实现接口，其实就是需要重写接口中的abstract方法，一旦实现的类没有重写完，那么这个类必须是个抽象类（抽象类中可以没有抽象方法，但是有抽象方法的类必须是抽象类）。

对于选项D：
实现接口类如果是抽象类，那么可以选择性的实现接口中的方法。