接口，抽象类，内部类的区别

一.接口(interface)，接口是用来建立类与类之间关联的标准。

1.Java code

public interface ITest{
public void run();
}

public class TestImpI implements ITest{
public void run(){
System.out.println("testImpl run");
}
}

public class Main{
public static void main(String args[]){
TestImpI testImpI = new TestImpI();
testImpI.run();
}
}

二.抽象类(abstract class)，只要类中有一个抽象方法，此类就被标记为抽象类。实际上抽象类除了被继承之外没有任何意义。

1.Java code

public abstract class ATest{
abstract void run();
}

public class TestAbs extends ATest{ //抽象类继承也使用 extends关键字
void run(){
System.out.println("TestAbs run ");
}
}

public class Main(){
public static void main(String args[]){
System.out.println("执行抽象类的一个例子");
TestAbs abs = new TestAbs();
abs.run();
}
}

三.接口和抽象类的区别：

1.接口是公开(public)的，里面不能有私有的方法或变量,是用于让别人使用的,实现接口的一定要实现接口里定义的所有方法。而抽象类是可以有私有方法或私有变量的，实现抽象类可以有选择地重写需要用到的方法，但是必须实现里面所有的抽象方法。

2.抽象类在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface(java中实现多重继承的方法之一)。

3.抽象类中可以有自己的数据成员，也可以有非abstarct的成员方法。而在接口中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），而且所有的成员方法都是抽象的。

4.抽象类和接口所反映出的设计理念不同。其实abstract class表示的是"is-a"关系（属于的关系），interface表示的是"like-a"关系（相试关系）。（组合是"has a"关系）

5.1）在接口中：定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。

2）在抽象类中：定义的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

6.在一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现，另外不是很建议具体类直接实现接口的。还有一种设计模式是面向接口编程，而非面向实现编程。

7.接口其实是抽象类的延伸，可以将它看做是纯粹的抽象类，也就是说接口比抽象类还抽象。另外设计接口的目的就是为了实现C++中的多重继承，不过java团队设计的一样更有趣的东西来实现这个功能，那就是内部类(inner class)。

四.内部类(inner class)

1.Java code

public class OuterClass{ //外部类

String content;

public void print(){

System.out.println("print" + content);

}

private class InnerClass{ //内部类

private void innerTalk(){

System.out.println(" inner Talk");

}

protected void innerSay(){

System.out.println("inner say");

}

}

}

2.内部类的定义：

我们把放在一个类的内部的类称之为内部类。

3.内部类的作用：

1).内部类可以很好的实现隐藏,也就是封装性。一般的非内部类，是不允许有 private 与protected权限的，但内部类可以。

2.)内部类拥有外部类的所有元素（成员变量和成员函数）的访问权限。

3).可以实现多重继承(这个特点非常重要，个人认为它是内部类存在的最大理由之一)。

4.)可以避免修改接口而实现同一个类中两种同名方法的调用。

5）.可以通过内部类实现多重继承：

类一 Java code

public class Example1 {

public String getName(){

String name = "name";

return name;

}

}

2).类二 Java code

public class Example2{

public int getAge(){

int age = 25;

retrun age;

}

}

类三 Java code

public class MainExample{
public class Test1 extends Example1 { //内部类Test1
public String getName(){ //复写抽象类的方法
return super.getName();
}
}

public class Test2 extends Example2{
public int getAge(){ //复写抽象类的方法
return super.getAge();

}
}

public String showName(){ //使用内部类Test1中的方法getName
Test1 test1 = new Test1();
return test1.getName();
}

public int showAge(){ //使用内部类Test2中的方法getAge
Test2 test = new Test2();
return test.getAge();
}

public static void main(String args[]){
MainExample mainExample = new MainExample();
System.out.println("姓名" + MainExample.showName());
System.out.println("年龄" + MainExample. showAge());
}

}

在类三中，分别实现了两个内部类 Test1,和Test2 。Test1类继承了Example1，Test2继承了Example2，这样我们的类三MainExample就拥有了Example1和 Example2的方法和属性，也就间接地实现了多继承。