内部类、接口、接口与抽象类的比较

一、内部类

内部类（当作类中的一个普通成员变量，只不过此成员变量是class的类型）：

•   一个java文件中可以包含多个class，但是只能有一个public class
  

•   如果一个类定义在另一个类的内部，此时可以称之为内部类
  

使用：

•   创建内部类的时候，跟之前的方法不一样，需要在内部类的前面添加外部类来进行修饰
  

•  InnerClassDemo.InnerClass inner = new InnerClassDemo().new InnerClass();
  

特点：

    1、内部类可以方便的访问外部类的私有属性
    2、外部类不能访问内部类的私有属性,但是如果创建了内部类的对象，此时可以在外部类中访问私有属性
    3、内部类中不能定义静态属性
    4、当内部类和外部类具有相同的私有属性的时候，在内部类中访问的时候，可以直接访问内部类的属性，
        如果需要访问外部类的属性，那么需要添加  外部类类名.this.属性。
分类：
    匿名内部类：当定义了一个类，实现了某个接口的时候，在使用过程中只需要使用一次，没有其他用途
           其实考虑到代码编写的简洁，可以考虑不创建具体的类，而采用new interface(){添加未实现的方法}就叫做匿名内部类；
    静态内部类：在内部类中可以定义静态内部类，使用static关键字进行修饰，使用规则：
            外部类.内部类 类的引用名称 = new 外部类.内部类（）；
    方法内部类：在外部类的方法中也可以定义类，此时叫做方法内部类（了解即可）
                使用的时候需要注意，只能在方法中创建对象，因为此class的作用域就是当前方法

public class InnerClassDemo {

    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void show(){
        System.out.println("show");
//        System.out.println(age);
        InnerClass inner = new InnerClass();
        System.out.println(inner.age);
    }

    class InnerClass{
        private int age;
//        static String name = "zhangsan";

        public void test(){
            System.out.println("test");
            System.out.println(id);
            System.out.println(name);
        }

        class InnerInner{
            private int id;
            public void print(){
                System.out.println("print");
            }
        }
    }

    public static void main(String[] args) {
        InnerClass innerClass = new InnerClassDemo().new InnerClass();
    }
}

二、接口

java中的继承关系是单继承，如果拥有多个父类的时候，可以考虑使用接口进行实现
用法：

•    使用interface来修饰
  

•    接口中可以包含多个方法，且方法跟抽象类中的抽象方法一致，可以不写实现，子类在实现的时候必须要实现代码逻辑
  

•    子类实现接口使用implements关键字
  

特征：

•       1、接口中的所有方法都是抽象方法，不能包含方法的实现
  

•       2、接口中的所有方法的访问修饰权限都是public，不写并不是默认访问权限，而是public
  

•       3、接口不能被实例化
  

•       4、接口的子类必须要实现接口中的所有方法，跟抽象类有所不同，抽象类中的抽象方法必须要被子类实现
  

•       5、子类可以拥有实现多个接口
  

•       6、接口中的变量都是静态常量,如果变量没有使用static关键字修饰，它也表示静态常量,不用final关键字修饰，也是常量
  

•       7、接口中的方法和常量无论是否添加public修饰，默认的权限有且仅有一个，就是public
  

接口的使用：

•       1、接口代表一种能力，接口中可以定义N多个方法，子类在进行实现的时候，必须要实现这些方法
  

•           将这些方法进行实现，就意味着具体了方法的能力
  

•           关心实现类有何能力，而不关心实现细节
  

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

•       1、抽象类中的方法可以有抽象方法，也可以有普通方法，但是接口中只能包含抽象方法
  

•       2、抽象类需要使用abstract关键字来修饰，而接受使用interface关键字来修饰
  

•       3、子类使用extends关键字来继承抽象类，使用implements来实现接口
  

•       4、子类继承抽象类的时候必须要实现所有的抽象方法，普通方法可以不重写，而接口中的所有方法必须实现
  

•       5、抽象类中可以定义成员变量，而接口中只能定义静态常量
  

•       6、抽象类在子类实现的时候是单继承，而接口时多继承
  

•       7、抽象类和接口都不能实例化，但是抽象类中可以有构造方法，而接口中不能有构造方法
  

•       8、抽象类中可以实现接口，并且不实现接口中方法，而接口只能继承接口，不能实现接口
  

•   注意：
  

•       在实际的项目开发过程中，如果可以使用接口，尽量使用接口，将单继承的父类留在最关键的地方