接口和内部类为我们提供了接口与实现分离的更加结构化的方法
1. abstract class和interface的定义和区别?
含有abstract修饰符的class即为抽象类,abstract类不能创建的实例对象。含有一个或多个abstract方法的类必须定义为abstract class(不然会编译报错),abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现,所以,不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法,那么子类也必须定义为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类型。
2.接口和实现类用到策略模式和适配器模式(详情看23种设计模式总结),完全解耦
3.一个类可以实现(implements)多个接口,可以达到多重继承的需求
4.接口的嵌套
接口可以嵌套到内部类或接口中
class A {
interface B {
void f();
}
public class BImp implements B {
public void f() {
}
}
private class BImp2 implements B {
public void f() {
}
}
public interface C {
void f();
}
class CImp implements C {
public void f() {
}
}
private class CImp2 implements C {
public void f() {
}
}
private interface D {
void f();
}
private class DImp implements D {
public void f() {
}
}
public class DImp2 implements D {
public void f() {
}
}
public D getD() {
return new DImp2();
}
private D dRef;
public void receiveD(D d) {
dRef = d;
dRef.f();
}
}
interface E {
interface G {
void f();
}
// Redundant "public":
public interface H {
void f();
}
void g();
// Cannot be private within an interface:
// ! private interface I {}
}
public class NestingInterfaces {
public class BImp implements A.B {
public void f() {
}
}
class CImp implements A.C {
public void f() {
}
}
// Cannot implement a private interface except
// within that interface's defining class:
// ! class DImp implements A.D {
// ! public void f() {}
// ! }
class EImp implements E {
public void g() {
}
}
class EGImp implements E.G {
public void f() {
}
}
class EImp2 implements E {
public void g() {
}
class EG implements E.G {
public void f() {
}
}
}
public static void main(String[] args) {
A a = new A();
// Can't access A.D:
// ! A.D ad = a.getD();
// Doesn't return anything but A.D:
// ! A.DImp2 di2 = a.getD();
A.DImp2 di2 = (A.DImp2) a.getD();
// Cannot access a member of the interface:
// ! a.getD().f();
// Only another A can do anything with getD():
A a2 = new A();
a2.receiveD(a.getD());
}
} // /:~
总结:
很多时候,用接口开发程序已经被滥用了,开发的优先选择其实是使用类开发,使用接口来开发程序并不是最理想的选择,会增加程序复杂度,只有真的需要用到接口再重构为接口,如果只是为了以防万一而加上了接口来开发,那这样设计是不够完美的.