内部类

1 内部类可以直接访问外部类的成员，包括私有
2 外部类要使用内部类成员，必须通过内部类对象
3 普通类不能被static修饰，但内部类可以使用static修饰，表示内部类是外部类的静态数据类型，这样在其他类中就可以使用内部类来创建对象,但static内部类就不能访问外部类的飞非静态方法
例如class A{
static class B{}}
main(){A.B b=new A.B new();}
4 内部类中不能有static成员

二、匿名内部类
A:是局部内部类的简化形式
B:前提
存在一个类或者接口
C:格式:
new 类名或者接口名() {
重写方法;
}
D:本质：
其实是继承该类或者实现接口的子类匿名对象
2匿名内部类在开发中的使用
我们在开发的时候，会看到抽象类，或者接口作为参数。
而这个时候，我们知道实际需要的是一个子类对象。
如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

interface Person{
    public abstract void study();
}
class Student implements Person
{
    public void study(){
        System.out.println("好好学习");
    }
}
class Persontest{
    public void method(Person p){
        p.study();
    }
    /*public void method() {//另外

        new Inter() {
            public void show() {
                System.out.println("show");
            }
        }***.show();***
        */
}

public class Test{
    public static void main(String[] args) {
        **Persontest p=new Persontest();
        Person p1=new Student();
        p.method(p1);
        System.out.println("----------------------------");
        p.method(new Person(){
            public void study(){
                System.out.println("Good study");
            }
        });**

    }
}
结果
好好学习
----------------------------
Good study

第一种更好理解，但第二种更好，在安卓里用的多，用完后匿名类会及时回收，但只能用一次
另外
interface inter{
abstract void show();
abstract void show2();

}
class t{
public void method(){//匿名内部类本质是一个继承了该类或者实现了该接口的子类匿名对象。
inter i=new inter()
{
public void show(){
System.out.println(“朱绍祥”);
}
public void show2(){
System.out.println(“朱绍祥2”);
}
};//因为本质是对象，所以要有;
i.show();
i.show2();

}

}

public class Test{
public static void main(String[] args) {

t tt=new t();
tt.method();
}

}

```
三经典题目

interface Person{
public abstract void study();
}
class Persontest{
//补充代码
}

public class Test{
public static void main(String[] args) {

    //Student.s a=new Student.s();
    Persontest.method().study();

}

}

public static Person method()
{
return new Person()
{
public void study(){
System.out.println(“学习1”);
}
};
}

答案：

interface Person{
public abstract void study();
}
class Student implements Person
{
public void study(){
System.out.println(“学习”);
}
}
class Persontest{
//补充代码
}

public class Test{
public static void main(String[] args) {

    Persontest.method().study();

}

}

分析：
Persontest类直接调用方法，所以方法为静态，另外还调用study（），所以method（）有返回值为接口，在method()中对接口方法重写
答案

public static Person method()
{
return new Person()
{
public void study(){
System.out.println(“学习1”);
}
};
}

```

结果：学习1

*三局部内部类访问局部变量的注意事项?
A:局部内部类访问局部变量必须用final修饰
B:为什么呢?
因为局部变量num2随方法的消失而消失，但new的类对象（对地址）不是立即消失，所以，我们加final修饰。加入final修饰后，这个变量就成了常量。既然是常量。你消失了。我在内存中存储的是数据20，所以，我还是有数据在使用。*

class Outer {
    private int num  = 10;

    public void method() {
        int num2 = 20;
        //final int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                //从内部类中访问本地变量num2; 需要被声明为最终类型
                System.out.println(num2);//访问局部变量出错
            }
        }

        //System.out.println(num2);

        Inner i = new Inner();
        i.show();
    }
}

class InnerClassDemo5 {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}