java学习（6）（内部类）

内部类

内部类分为静态的和非静态的，使用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;//可以访问外层类的私有成员x
        }
    }
    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();
        System.out.println(inner.calculate());//输出500
    }
}
//内部类编译后将单独生成一个类文件，上述编译后生成两个类文件OuterClass.class和OuterClass$InnerClass.class。

局部内部类

在方法体或语句块（包括方法、构造方法、局部块、初始化块、静态初始化块）内部定义的类。

局部内部类只对局部块有效，同局部变量一样，在块外完全不能访问，不能有任何访问修饰符。

public class OuterClass2{
    private String x="hello";
    public void makeInner(int param){
        final String y = "local variable";
        class InnerClass{//局部内部类
            public void seeOuter(){
                System.out.println("x="+x);
                System.out.println("y="+y);
                System.out.println("param="+param);
            }
        }
        new InnerClass().seeOuter();
    }
    public static void main(String[] args){
        OuterClass2 oc = new OuterClass2();
        oc.makeInner(47);
    }
}

• 局部成员内部类同方法局部变量一样，不能使用访问修饰符，也不能使用static修饰，但可以使用final或abstract修饰。

• 局部内部类可以访问外层类的成员，若要访问其所在方法的参数和局部变量，这些参数和局部变量不能修改。

• static方法中定义的局部内部类，可以访问外层类定义的static成员，不能访问外层类的实例成员。

匿名内部类

在定义类的同时创建一个实例，以这种方式定义的没有名字的类称为匿名内部类。

new TypeName(){

//TypeName:匿名内部类所继承的类或实现的接口。

//类体

}

匿名内部类继承一个类或实现一个接口不需要使用extends或implements关键字。不能同时继承一个类和实现一个接口，也不能实现多个接口。

匿名内部类不能定义构造方法，只能在定义类的同时用new关键字创建类的实例。

class Animal{
    public void eat(){
        System.out.println("I like eat anything.")
    }
}
public class AmimalTest{
    public static void main(String[] args){
        Animal dog = new Animal(){//继承Animal类
            @Override
            public void eat(){
                System.out.println("I like eat bones.");
            }
        };//赋值语句的结束
        dog.eat();
    }
}

静态内部类

用static修饰，也称嵌套类，顶层类。

静态内部类实际上时一种外部类，它不存在对外部类的引用，必须使用外层类名.内层类名创建对象。

类的内部可以定义内部接口（static的），嵌套的类或接口可以有任何的访问修饰符。

静态内部类与成员内部类的区别

• 静态内部类中可以定义静态成员，而成员内部类不能。

• 静态内部类只能访问外层类的静态成员，成员内部类可以访问外层类的实例成员和静态成员。

• 创建静态内部类的实例不需要先创建一个外层类的实例，相反，创建成员内部类实例，必须先创建一个外层类的实例。

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