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

总结下，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>>(){@Overridepublic int compare(Entry<String, Double> o1,Entry<String, Double> o2) {// TODO Auto-generated method stubreturn 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());}}}