Java中内部类使用

Posted 2021-05-23 nuist__NJUPT

Java中内部类使用

• Java语言允许在一个类的内部定义另一个类(接口，枚举或注解)，
• 这种类称为内部类或者嵌套类，允许内部类的目的是增强两个类之间的联系，并且可以使程序代码清晰简介
• 有多种类型的内部类，大致可以分为：成员内部类，局部内部类，匿名内部类和静态内部类
• 成员内部类是没有用static修饰且定义在外层类的类体中
• 成员内部类中不能定义static变量和static方法
• 成员内部类中可以使用abstract和final修饰
• 成员内部类还可以使用private,public,protected等访问修饰符

public class OuterClass {
    private int x = 200 ;
    public class InnerClass{ //成员内部类
        int y = 300 ;
        public int calculate(){
            return x + y ; //成员内部类可以访问外层类的成员
        }
    }
    public void makeInner(){
        InnerClass ic = new InnerClass() ; //创建内部类对象
        System.out.println(ic.calculate()) ; //使用成员内部类对象，调用内部类中的方法
    }
    public static void main(String[] args){
        OuterClass outer = new OuterClass() ; //创建一个外部类对象
        OuterClass.InnerClass inner = outer.new InnerClass() ;//通过外部类对象创建内部类对象
    }
}

• 在方法体或者语句块中定义的类叫做局部内部类，局部内部类不能视作外部类的成员，
• 只对局部块有效，同局部变量一样，在说明它的块之间完全不能访问，因此不能带有任何访问修饰符
• 局部内部类也不能使用static修饰，可以使用final和abstract修饰，
• 局部内部类可以访问外层类的成员，若要访问其所在方法的参数和局部变量，这些参数不能修改
• static 方法中定义的局部内部类，可以访问外层类定义的static成员，不能访问外层类的实例成员

public class OuterClass2 {
    private String x = "hello" ;
    public void makeInner(int params){  //普通方法
            String y = "local variable" ;
            class InnerClass{ //局部内部类
                public void seeOuter(){ //局部内部类中的方法
                    System.out.println("x = " + x) ;
                    System.out.println("y = " + y) ;
                    System.out.println("params = " + params) ;
                }
            }
            new InnerClass().seeOuter() ; //调用内部类的方法
    }

    public static void main(String[] args){
        OuterClass2 oc = new OuterClass2() ; //创建外部类实例化对象
        oc.makeInner(68) ; //调用带一个参数的方法
    }
}

• 定义类的最终目的是创建一个类的实例，如果某个类的实例只使用一次，可以将类的定义和实例的创建在一起完成，在定义类的同时就创建一个实例
• 这样定义的一个没有名字的类叫做匿名内部类
• 匿名内部类可以继承一个类或者实现一个接口，不需要使用extends或implements关键字
• 匿名内部类不能同时定义一个类或者实现一个接口，也不能实现多个接口
• 匿名内部类没有名字，所以在类体中不能定义构造方法
• 下面创建的匿名内部类继承了Animal类，是Animal的子类，并覆盖了Animal中的eat()方法
• 同时创建一个匿名内部类的实例，并用dog指向它

class Animal{
    public void eat(){
        System.out.println("I like eat anything.") ;
    }
}
public class AnimalTest {
    public static void main(String[] args){
       Animal dog = new Animal(){ //创建实例化对象时，同时定义一个没有名字的类
           @Override
           public void eat() { //重写eat()方法
               System.out.println("I like eat bones") ;
           }
       } ;
       dog.eat() ;
    }
}

• 下面程序中程序中的匿名内部类实现了一个Printable接口

/**
 * 下面程序中程序中的匿名内部类实现了一个Printable接口
 */
interface Printable{
    public abstract void print(String message) ;
}
public class PrintableTest {
    public static void main(String[] args){
        Printable printable = new Printable(){ //匿名内部类实现一个接口，并重写接口中的方法
            @Override
            public void print(String message) {
                System.out.println(message) ;
            }
        } ;
    }
}

• 与类的其它成员类似，静态内部类使用static修饰，静态内部类也称为嵌套类
• 静态内部类与成员内部类的行为完全不同
• 1.静态内部类可以定义静态成员，而成员内部类不能
• 2.静态内部类只能访问外层类的静态成员，成员内部类可访问外层类的实例成员和静态成员
• 创建静态内部类的实例不需要先创建一个外部类的实例，创建成员内部类的实例，必须创建一个外外层类的实例

public class MyOuter {
    private static int x = 100 ;
    public static class MyInner{ //静态内部类
        private String y = "hello" ;
        public void innerMethod(){
            System.out.println("x  = " + x) ; //可以访问外层类的静态成员
            System.out.println("y = " + y) ;
        }
    }
    public static void main(String[] args){
        //不需要创建外部类的实例就可以创建一个静态内部类实例
        MyOuter.MyInner snc = new MyOuter.MyInner() ;
        snc.innerMethod();
    }
}

• 静态内部类实际上是一种外部类，它存在对外部类的引用
• 不通过外部类的实例就可以创建一个对象，静态内部类也称为顶层类
• 静态内部类具有对任何外层类实例的引用，静态内部类的方法不能this关键字访问外层类的实例成员

public class MyOuter2 {
    String s1 = "hello" ;
    static String s2 = "World" ;
    interface MyInterface{ //内部接口的声明
        void show() ;
    }
    static class MyInner2 implements MyInterface { //静态内部类实现接口，并重写接口中的方法
        @Override
        public void show() {
            System.out.println("s1 = " + new MyOuter2().s1) ;
            System.out.println("s2 = " + s2)  ; //可以访问外层类的static变量
        }
    }
    public static void main(String[] args){
        MyOuter2.MyInner2 inner2 = new MyOuter2.MyInner2() ;//创建静态内部类实例
        inner2.show();
    }
}