Java接口中的内部类

接口中的内部类

如果想要创建某些公共代码,使得他们可以被某个接口的所有不同实现所共用,那么接口内部的嵌套类会显得比较方便,也就是说在接口中可以含有内部类。
例子

  1. 首先创建接口,接口中定义类普通内部类InnerClass和抽象内部类AbIunnerClass

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23

    public interface IOuterInterface
    int TEMP = 100;
    void abMethod();//抽象方法
    public default void deMethod(){//jdk1.8后可以添加
    System.out.println("接口中的默认方法");
    }


    public static void setMethod(){ //jdk1.8后可以添加
    System.out.println("接口中的静态方法");
    }

    public class InnerClass{
    public void show(){
    System.out.println("接口中的普通内部类");
    }
    }
    public abstract class AbInnerClass{
    public abstract void abInfo();
    public void info(){
    System.out.println("接口中可以定义抽象内部类");}
    }
  2. 普通成员内部类的实例化
    创建接口的实现类ClassDemo

1
2
3
4
5
6
7
8
9
10
public class ClassDemo implements IOuterInterface{
@Override
public void abMethod(){
System.out.println("实现类");
}
//获取接口中内部类方法
public InnerClass getInner(){
return new InnerClass();
}
}
  1. 获取普通内部类对象,调用方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Test{

public static void main(String[] args){
//第一种实例化对象方式:通过接口名.类名 进行实例化
IOuterInterface.InnerClass inner = new IOuterInterface.InnerClass();
inner.show();


//第二种实例化对象的方式:
//通过在实现类中创建接口中内部类获取方法 用实现类对象调用获取方法
ClassDemo demo = new ClassDemo();
demo.getInner().show();

//第三种实例化对象的方式:将内部类导入后直接实例化
InnerClass innerTwo = new InnerClass();
innerTwo.show();
}
}
  1. 抽象成员内部类的实例化
    创建接口的实现类AbClassDemo
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class AbClassDemo implements IOuterInterface{
    @Override
    public void abMethod(){
    }

    //继承抽象类AbInnerClass
    public class AbDemo extends AbInnerClass{
    @Override
    public void abInfo(){
    System.out.println("重写接口中抽象类的中的抽象方法");
    }
    }

获取抽象内部类对象,调用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class TestOne{

public static void main(String[] args){
//第一种实例化对象方法:
//通过接口名.类名进行实例化
//但是对于抽象类而言,不能直接进行实例化,所以是用匿名内部类的方式
IOuterInterface.AbinnerClass abInner = new IOuterInterface.AbInnerClass(){
public void abInfo(){
System.out.println("重写抽象类中的抽象方法");
}
};
abInner.anInfo();
abInner.info();
//第二种实例化方法
//在实现类中定义内部类继承接口中的抽象内部类
IOuterInterface.AbInnerClass abInnerOne = new AbClassDemo().new AbDemo();
abInner.anInfo();
abInner.info();
}

-------------End Of This ArticleThank You For Reading-------------