Java的内部类和匿名内部类

1.内部类

2.访问内部类

3.匿名内部类

1.内部类

1.内部类就是一个类定义在另一个类中。

2.A类要直接访问B类的成员时，可以将A类定义在B类中。哪怕访问的是B类的私有成员也可以。

3.规则：内部类可以直接访问外部类的成员，但外部类要想访问内部类的成员，只能通过创建内部类的对象来访问。

4.内部类相当于外部类的一个成员。可以被成员修饰符修饰。如 public，private，static等等。如果内部类的权限是非私有的，就可以被外部的用户程序访问到。

5.非静态的内部类中不能定义静态的变量，若非要用static修饰，就得同时用final修饰，表示静态常量。

6.为什么内部类可以直接访问外部类的成员？因为内部类持有了外部类的引用----- 外部类名.this 。但内部类是静态时就不持有外部类的引用了。

2.访问内部类

1.外部类访问内部类成员

2.外部用户程序访问内部类

3.静态非私有的内部类访问方法

1.外部类访问内部类成员：

只能通过创建内部类对象。那怎么创建呢？就是在外部类中定义一个方法，new一个内部类，再用其引用来访问内部类的成员。

class Outer //外部类
{
    class inter //内部类
    {
        int num = 5;
    }
    public void method()  //用于创建内部类对象
    {
        inter in = new inter();
        System.out.println(in.num); //访问内部类的num变量
    }
}

public class Main
{
    public static void main(String []args)
    {
        Outer out = new Outer();
        out.method();
    }
}
//打印结果：5

2.外部用户程序访问内部类成员

class Outer //外部类
{
    class inter //内部类
    {
        int num = 5;
    }
    public void method()  //用于创建内部类对象
    {
        inter in = new inter();
        System.out.println(in.num); //访问内部类的num变量
    }
}

public class Main
{
    public static void main(String []args)
    {
        Outer.inter in = new Outer().new inter();   //只要内部类不是私有的，就能通过用户程序创建其对象。
        System.out.println(in.num);
    }
}
//打印结果：5

3.静态非私有的内部类访问方法

        Outer.inter in = new Outer.inter();
        System.out.println(in.num);

跟上面的访问非静态的内部类不同，创建对象时不需要顺带创建外部类的对象。因为static静态修饰的东西不需要对象就可以调用。

class outer
{
    static class inter
    {
        int num = 5;
    }
}
public class Main
{
    public static void main(String[] args)
    {
        outer.inter in = new outer.inter();
        System.out.println(in.num);
    }
}
//打印结果：5

3.匿名内部类

匿名内部类用于简化代码。

匿名内部类一般用于实现抽象类的方法或者实现接口。

匿名内部类只调用一次。

使用匿名类的前提条件：必须继承一个抽象父类或者实现一个接口

没有使用匿名内部类的代码：

abstract class Person
{
    public abstract void show();
}

class Man extends Person
{
    public void show()
    {
        System.out.println("this is man");
    }
}

public class Main
{
    public static void main(String []args)
    {
        Person p = new Man();
        p.show();
    }
}
//打印结果：this is a man

可以看出，代码是实现多态的一个代码。Man类继承Person类后，随后就通过 Person p = new Man() 向上提升为Person对象。然后用户操作的其实就是person的引用p。那么Man类实际上就是用了一次，作用就是用来实现Person类的抽象方法而已。那岂不浪费？如果使用匿名内部类的哈，完全就不需要敲Man类的定义代码了。

如：

abstract class Person
{
    public abstract void show();
}

public class Main
{
    public static void main(String []args)
    {
        Person p = new Person(){
            public void show()
            {
                System.out.println("this is a man");
            }
        };
        p.show();
    }
}
//打印结果：this is a man