Java的各种内部类

在Java中内部类主要分为成员内部类、静态内部类、匿名内部类、局部内部类。 1.内部类的基本结构--成员内部类（最基本的内部类）

class Out {
    private int age = 12;
     
    class In {
        private int age = 13;
        public void print() {
            int age = 14;
            System.out.println("局部变量：" + age);
            System.out.println("内部类变量：" + this.age);
            System.out.println("外部类变量：" + Out.this.age);
        }
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Out.In in = new Out().new In();
        in.print();
    }
}

运行结果：

局部变量：14  内部类变量：13  外部类变量：12

内部类在没有同名成员变量和局部变量的情况下，内部类会直接访问外部类的成员变量，而无需指定Out.this.属性名否则，内部类中的局部变量会覆盖外部类的成员变量而访问内部类本身的成员变量可用this.属性名，访问外部类的成员变量需要使用Out.this.属性名。在这个应用程序中，我们可以看到内部类In可以对外围类Out的属性进行无缝的访问，尽管它是private修饰的。这是因为当我们在创建某个外围类的内部类对象时，此时内部类对象必定会捕获一个指向那个外围类对象的引用，只要我们在访问外围类的成员时，就会用这个引用来选择外围类的成员。

2.静态内部类

关键字static中提到Static可以修饰成员变量、方法、代码块，其他它还可以修饰内部类，使用static修饰的内部类我们称之为静态内部类，不过我们更喜欢称之为嵌套内部类。静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：        

1、 它的创建是不需要依赖于外围类的。        

2、 它不能使用任何外围类的非static成员变量和方法。

class Out {
	private static int age = 12;

	static class In {
		public void print() {
			System.out.println(age);
		}
	}
}

public class Demo {
	public static void main(String[] args) {
		Out.In in = new Out.In();
		in.print();
	}
}

运行结果：12

可以看到，如果用static 将内部内静态化，那么内部类就只能访问外部类的静态成员变量，具有局限性 其次，因为内部类被静态化，因此Out.In可以当做一个整体看，可以直接new 出内部类的对象（通过类名访问static，生不生成外部类对象都没关系）。

3.匿名内部类

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中的方法在大括号中实现了，这样便可以省略一个类的书写。

4.局部内部类（方法内部类）

class Out {
	private int age = 12;

	public void Print(final int x) {
		class In {
			public void inPrint() {
				System.out.println(x);
				System.out.println(age);
			}
		}
		new In().inPrint();
	}
}

public class Demo {
	public static void main(String[] args) {
		Out out = new Out();
		out.Print(3);
	}
}

运行结果：3 12

我们将内部类移到了外部类的方法中，然后在外部类的方法中再生成一个内部类对象去调用内部类方法，如果此时我们需要往外部类的方法中传入参数，那么外部类的方法形参必须使用final定义。

5.私有内部类

class Out {
	private int age = 12;

	private class In {
		public void print() {
			System.out.println(age);
		}
	}

	public void outPrint() {
		new In().print();
	}
}

public class Demo {
	public static void main(String[] args) {
		// 此方法无效,无法访问到私有内部类
		/*
		 * Out.In in = new Out().new In(); 
		 * in.print();
		 */
		Out out = new Out();
		out.outPrint();
	}
}

运行结果：12

如果一个内部类只希望被外部类中的方法操作，那么可以使用private声明内部类。上面的代码中，我们必须在Out类里面生成In类的对象进行操作，而无法再使用Out.In in = new Out().new In() 生成内部类的对象，也就是说，此时的内部类只有外部类可控制。