JAVA中的四个内部类-成员内部类，静态内部类，方法内部类，匿名内部类

本文链接：https://blog.csdn.net/neven7/article/details/40951093

总结下，JAVA类中的四个内部类

一.成员内部类

1.Inner类定义在Outer类的内部，类似于Outer类的一个成员变量，Inner类可以有任意访问控制符(public ,protected, private)。

2.Inner类中的方法可以直接使用Outer类中成员和方法(包括私有)，但Outer类是不能直接使用Inner类中成员和方法。

3.声明Inner类的对象必须先声明Outer类的对象： Outer ot = new Outer(); Inner inr = ot.new Inner();

4.Outer类与Inner类有同名的成员或方法，内部类默认返回自己的成员和方法，如使用外部类成员或方法时，需使用this: Outer.this.成员或方法名。

// OuterClass1为外部类
public class OuterClass1 {
	private int count = 10;
	private int num = 30;

	private void printString() {
		System.out.println("外部类");
	}

	private void printStr() {
		System.out.println("外部类2");
	}

	// InnerClass1为成员内部类
	public class InnerClass1 {
		private int count = 20;

		private void printString() {
			// 默认使用内部类的同名成员变量
			System.out.println("成员内部类中count值：" + count);
			// 使用外部类同名成员变量
			System.out.println("外部类中count值：" + OuterClass1.this.count);
			// 直接使用外部类成员变量
			System.out.println("外部类中num值：" + num);
			// 直接使用外部类方法
			printStr();
			// 使用外部类同名方法printString()
			OuterClass1.this.printString();

		}

		

	}

	public static void main(String[] args) {
		OuterClass1 otc1 = new OuterClass1();
	

		InnerClass1 ic1 = otc1.new InnerClass1();
		
		ic1.printString();

	}
}

输出结果：

成员内部类中count值：20

外部类中count值：10

外部类中num值：30

外部类2

外部类

二.静态内部类

1.静态内部类不能直接访问外部类的非静态成员

2.外部类静态成员与内部类静态成员重名时，可通过外部类名.静态成员访问

3.创建内部类实例：内部类对象名 = new 内部类();

public class OuterClass2{
        public static int num = 10;
        public int account = 100;

        public static class InnerClass2{
                public static int num = 20;
                public void print(){
                System.out.println("外部类静态成员num: " + OuterClass2.num);
                System.out.println("内部类静态成员num: " + num);
                System.out.println("外部类非静态成员account: " + new OuterClass2().account);
                }

        }

        public static void main(String[] args){
                InnerClass2 inc2 = new InnerClass2();
                inc2.print();
        }

}

输出结果：
外部类静态成员num: 10
内部类静态成员num: 20
外部类非静态成员account: 100

三.方法内部类

1.方法内部类就是定义在外部类的方法中，方法内部类只在该方法中可见（只能在该方法中使用）

2.方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和static修饰符

public class OuterClass3{
        int a = 40;
        public void show(){
                final int b = 50;
                int e = 60;
                class InnerClass3{
                        int c = 30;
                        public void print(){
                                System.out.println("外部类成员变量a: " + a);
                                //方法内部类，无法访问方法中的局部变量e
                                System.out.println("外部类的方法中的常量b: " + b);
                                System.out.println("内部类成员变量c: " + c);
                        }

                }

                InnerClass3 inc = new InnerClass3();
                inc.print();

        }

        public static void main(String[] args){
                OuterClass3 otc = new OuterClass3();
                otc.show();
        }

方法内部类只能使用外部方法final常量：拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变。

四.匿名内部类

1.使用匿名内部类时，必须是继承一个类或者实现一个接口
2.匿名内部类中是不能定义构造函数的
3.匿名内部类中不能存在任何的静态成员变量和静态方法
4.匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效
5.匿名内部类不能是抽象的，必须要实现继承的类或实现的接口中所有抽象方法

定义如下：

new 父类构造器（参数列表）| 实现接口(){  
     //匿名内部类的类体部分  
    }

实例：根据value值排序Map

public class SortValueMap {

	public static void main(String[] args) {
		Map<String, Double> map = new HashMap<String, Double>();
		map.put("包", 280.0);
		map.put("手表", 1000.0);
		map.put("计算机", 10000.0);
		
		System.out.println("原始map: ");
		List<Map.Entry<String, Double>> list = new ArrayList<Map.Entry<String, Double>>(map.entrySet());
		for(Iterator<Map.Entry<String, Double>> ite = list.iterator(); ite.hasNext(); ){
			Map.Entry<String, Double> mery = ite.next();
			System.out.println(mery.getKey() + " -> " + mery.getValue());			
		}
		// 匿名内部类，实现了Comparator接口
		Collections.sort(list, new Comparator<Map.Entry<String, Double>>(){
			@Override
			public int compare(Entry<String, Double> o1,
					Entry<String, Double> o2) {
				// TODO Auto-generated method stub
				return o1.getValue().compareTo(o2.getValue());
			}
			
		});
		
		System.out.println("sort value map: ");
		for(Iterator<Map.Entry<String, Double>> ite = list.iterator(); ite.hasNext(); ){
			Map.Entry<String, Double> mery = ite.next();
			System.out.println(mery.getKey() + " -> " + mery.getValue());			
		}
		
	}

}