几种内部类

//成员内部类，就是作为外部类的成员，可以直接使用外部类的所有成员和方法，即使是private的。
//同时外部类要访问内部类的所有成员变量/方法，则需要通过内部类的对象来获取。
public class Outer {	
	public class Inner{
//		成员内部类里面不能含有static的变量和方法
//		static int a = 1 ;
		public void test() {
			System.out.println("I am man");
		}
		public Outer getOuter() {
//		在成员内部类要引用外部类对象时，使用outer.this来表示外部类对象；
			return Outer.this;		
		}
	}
	public Inner getInner() {
		return new Inner();
	}
	public static void main(String[] args) {
		Outer outer = new Outer();
// 		构造成员内部类的对象的第一种方法
		Outer.Inner inner = outer.new Inner();
		inner.test();
//		构造成员内部类的对象的第二种方法
		inner = outer.getInner();
		outer = inner.getOuter();
	}
}

//局部内部类是定义在一个方法或者一个作用域里面的类，
//它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
class People{
	public People() {
		
	}
}
class Man{
	public Man() {
		
	}
	public People getWoman() {
//		局部内部类就像是方法里面的一个局部变量一样，
//		是不能有public、protected、private以及static修饰符的。
		class Woman extends People{ //局部内部类
			int age = 1 ;
		}
		return new Woman();
	}
	
}

//静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。
//静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，
//并且它不能使用外部类的非static成员变量或者方法，这点很好理解，
//因为在没有外部类的对象的情况下，可以创建静态内部类的对象，
//如果允许访问外部类的非static成员就会产生矛盾，
//因为外部类的非static成员必须依附于具体的对象。
class Outter {
    public Outter() {
         System.out.println("Outter constructor.");
    }
     
    static class Inner { //静态内部类
        public Inner() {
            System.out.println("Inner constructor.");             
        }
    }
}

四、匿名内部类
（一）定义
顾名思义，匿名内部类是没有名字的内部类。
因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。
使用匿名内部类有个前提条件：必须继承一个父类或实现一个接口。
（二）例子
例1:不使用匿名内部类来实现抽象方法

abstract class Person {
    public abstract void eat();
}
 
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

运行结果：eat something
可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用。
但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？
这个时候就可以考虑引入匿名内部类。
例2：匿名内部类的基本实现

abstract class Person {
    public abstract void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

运行结果：eat something
可以看到，我们直接将抽象类Person中的方法在大括号中实现了。这样便可以省略一个类的书写。
匿名内部类还能用于接口上。
例3：在接口上使用匿名内部类

interface Person {
    public void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

运行结果：eat something
匿名内部类最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或者实现Runnable接口。
例4：Thread类的匿名内部类实现

public class Demo {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        t.start();
    }
}

运行结果：1 2 3 4 5
例5：Runnable接口的匿名内部类实现

public class Demo {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        Thread t = new Thread(r);
        t.start();
    }
}

运行结果：1 2 3 4 5

（三）作用
1）一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是覆盖。
2）只是为了获得一个对象实例，不需要知道其实际类型。
3）类名没有意义，也就是不需要使用到。