嵌套类

嵌套类分两类：带static关键字的静态嵌套类和不带static关键字的非静态嵌套类,第二种不带static关键字的非静态嵌套类也就是我们常说的内部类。

一、带static关键字的静态嵌套类(Static Nested Class)

静态嵌套类只可以访问外部类里的静态变量和静态方法，不可以访问非静态变量和非静态方法。

class OuterClass {
	static int static_number = 0;

	static void method1() {
	}

	static class StaticNestedClass {
		int a = 9;

		void test() {
			method1();
			System.out.println(static_number + "  " + a);
		}
	}
}

public class InnerTest1 {
	public static void main(String[] args) {
		OuterClass.StaticNestedClass innerObject =new OuterClass.StaticNestedClass();
		innerObject.test();
	}
}

二、非静态嵌套类或者内部类(Non-static Nested Class 或者 Inner Class)

因为内部类是与外部类的实例相关联的，所以内部类里不可以有静态变量和静态方法，同时 内部类可以访问外部类里的所有变量和方法，不论是静态的还是非静态的。

class OuterClass {
	static int static_number = 0;
	int number = 1;
	static void method1() {
	}
	void method2() {
	}
	
	class NestedClass {
		//static int static_number2 = 0;//编译错误
		static final int AGE = 2;
		int number2;
	  void test(){
		 method2();
		 method1();
		System.out.println(static_number + "  " + number);
	 }
	}
}

public class InnerTest1 {
	public static void main(String[] args) {
		OuterClass outerObject = new OuterClass();
		//内部类是与外部类的实例相关联的，                
                //所以创建内部类实例前必须先创建外部类实例
                //也正是因为这种关联，使得内部类里不可以有静态的变量与方法，常量除外(static final)
<pre name="code" class="java">          OuterClass.NestedClass innerObject = outerObject.new NestedClass();

innerObject.test();}}

三：内部类的两种特别情况：本地内部类和匿名内部类( local classes and anonymous classes)

本地内部类--通常将这种类写在方法内部,作为内部类的一种，本地内部类不可以有静态变量和静态方法，

public class LocalClassExample {
    static String regularExpression = "regularExpression";
    int index = 0;
        public static void validatePhoneNumber(final String phoneNumber1) {//因为这个参数被本地内部类使用，所以必须为final,JDK8以后不用必须声明final
            final int numberLength = 10;//因为这个变量被本地内部类使用，所以必须为final,JDK8以后不用必须声明final
            class PhoneNumber {//因为这个内部类位于静态方法内部，所以不可以访问外问类里的实例变量，即非静态变量
                String formattedPhoneNumber = null;
                //static int number = 1;
                PhoneNumber(String phoneNumber){
                        formattedPhoneNumber = phoneNumber;
                }

                public void print() {
                    System.out.println(numberLength + "  " + formattedPhoneNumber);
                    System.out.println(regularExpression);
                    //编译错误
                    //System.out.println(index);
                }
            }

            PhoneNumber myNumber1 = new PhoneNumber(phoneNumber1);
            myNumber1.print();
        }
        
        public void validatePhoneNumber2(final String phoneNumber1) {//因为这个参数被本地内部类使用，所以必须为final,JDK8以后不用必须声明final
            final int numberLength = 10;//因为这个变量被本地内部类使用，所以必须为final,JDK8以后不用必须声明final
            class PhoneNumber2 {//因为这个内部类位于非静态方法内部，所以可以访问外问类里的实例变量，即非静态变量
                String formattedPhoneNumber = null;
                //static int number = 1;
                PhoneNumber2(String phoneNumber){
                        formattedPhoneNumber = phoneNumber;
                }

                public void print() {
                    System.out.println(numberLength + "  " + formattedPhoneNumber);
                    System.out.println(regularExpression);
                    System.out.println(index);
                }
            }

            PhoneNumber2 myNumber2 = new PhoneNumber2(phoneNumber1);
            myNumber2.print();
        }

        public static void main(String[] args) {
            validatePhoneNumber("123-456-7890");
            
            LocalClassExample example = new LocalClassExample();
            example.validatePhoneNumber2("123-456-7890");
        }
    }

匿名内部类--它是一个表达式

public class HelloWorldAnonymousClasses {
	interface HelloWorld {
        public void greet();
    }
	
	public void sayHello() {
	 HelloWorld spanishGreeting = new HelloWorld() {
         public void greet() {
            System.out.println("hello");
         }
     };
     spanishGreeting.greet();
	}   
 	
	 public static void main(String[] args) {
	        HelloWorldAnonymousClasses myApp =new HelloWorldAnonymousClasses();
	        myApp.sayHello();
	    }     
}

匿名内部类可以访问它所在的外部类的方法和变量，当然，如果匿名内部类处于外部类的静态方法里时，则它只能访问外部类 的静态变量和方法。

当匿名内部类位于方法里面时，如果它要使用方法参数或者方法里的本地变量，则这些参数和变量必须声明成final类型（JDK1.8以后有所变化），匿名内部类作为内部类的一种，在类的内部自然也不可以有静态变量和静态方法。

四:同名变量

如果要访问内部类和外部类的同名变量时，请参照以下示例

public class ShadowTest {

    public int x = 0;

    class FirstLevel {

        public int x = 1;

        void methodInFirstLevel(int x) {
            System.out.println("x = " + x);
            System.out.println("this.x = " + this.x);//FirstLevel.x
            System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);//ShadowTest.x
        }
    }

    public static void main(String... args) {
        ShadowTest st = new ShadowTest();
        ShadowTest.FirstLevel fl = st.new FirstLevel();
        fl.methodInFirstLevel(23);
    }
}