Java基础之内部类

从字面上理解内部类就是一个类定义在另一个类里面，内部类一般包括四种：成员内部类、局部内部类、匿名内部类和静态内部类。
成员内部类
首先看代码：
Circle.java

public class Circle {//外部类
    private double radius = 0;
    public static int count = 1;
    private int number = 1;

    public Circle(double radious) {
        this.radius = radious;
    }

    private Draw getDrawInstance() {
        return new Draw();
    }

    class Draw {//内部类
        private int number = 2;

        public void drawShape() {
            System.out.println(radius);//访问外部类的private成员
            System.out.println(count);//访问外部类的静态成员
            System.out.println(number);//内部类的number
            System.out.println(Circle.this.number);//外部类的number
        }
    }

    public static void main(String[] args) {
        //成员内部类的创建
        Circle circle = new Circle(10);
        //方式一
        Circle.Draw draw = circle.new Draw();
        draw.drawShape();

        //方式二
        Circle.Draw draw2 = circle.getDrawInstance();
        draw2.drawShape();
    }
}

1）成员内部类与成员属性及方法类似，有private、public、protected、default访问权限；
2）内部类可以访问所有外部类的成员；
3）外部类访问内部类的成员时，需要先创建一个内部类对象才可以。
局部内部类
先看代码：
People.java

public class People {
    public People() {
    }

}

class Man {
    public Man() {
    }

    public People getWoman(boolean isWoman) {
        //定义在域内的局部内部类
        if(!isWoman) {
            class Gay extends People {
                public Gay() {
                    System.out.println("gay....");
                }
            }
            return new Gay();
        }
        //定义在方法内的局部内部类
        class Woman extends People {
            int age = 18;
            public Woman() {
                System.out.println("My woman " + age + " years old!");
            }
        }
        return new Woman();
    }
}

1）局部内部类是定义在一个方法或者一个作用域里面的类
2）局部内部类就跟方法里面的变量一样，是不能有public、protected、private以及static修饰符的。
匿名内部类
匿名内部类是我们接触到的最多的，先看代码：
Animal.java

public abstract class Animal {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract String eatFood();
}

Test.java

public class Test {
    public void test(Animal animal) {
        System.out.println(animal.getName()+"吃的是："+animal.eatFood());
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.test(new Animal() {//匿名内部类
            public String eatFood() {
                return "狗粮";
            }

            public String getName() {
                return "狗";
            }
        });
    }
}

运行结果：

狗吃的是：狗粮

1）匿名内部类只能使用一次；
2）匿名内部类必须继承或者实现一个（只能是一个）接口，具体形式如下：

new 父类构造器（参数列表）|实现接口（）  
    {  
     //重写方法
     //其它类体部分  
    }

3）不能定义构造函数，不能有静态方法和静态变量；
4）属于局部内部类，局部内部类的限制同样适用于匿名内部类。
静态内部类
Test1.java

public class Test1 {
    public static void main(String[] args) {
        //创建静态内部类的方式
        Outter.Inner inner = new Outter.Inner();
    }
}

class Outter {
    int a = 8;
    static int b =9;

    public Outter() {
    }

    static class Inner {
        public Inner() {
            //不能使用外部类的非静态成员
//          System.out.println(a);//这里会报错
            System.out.println(b);
        }
    }
}

1）与静态属性和方法类似，它属于外部类本身，不属于类的实例；
2）不能访问外部类的非static成员。