1. /**
    2.  * 1.类的组成：属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类
    3.  * 2.一个类TestOuter的内部的类SubTest叫内部类， 内部类 ：SubTest  外部类：TestOuter
    4.  * 3.内部类：成员内部类 (静态的，非静态的) 和  局部内部类（位置：方法内，块内，构造器内）
    5.  * 4.成员内部类:
    6.  *      里面属性，方法，构造器等
    7.  *      修饰符：private，default，protect，public，final,abstract
    8.  */
    9. public class TestOuter {
    10.     //非静态的成员内部类：
    11.     public class D{
    12.         int age = 20;
    13.         String name;
    14.         public void method(){
    15.             //5.内部类可以访问外部类的内容
    16.             /*System.out.println(age);
    17.             a();*/
    18.             int age = 30;
    19.             //8.内部类和外部类属性重名的时候，如何进行调用：
    20.             System.out.println(age);//30
    21.             System.out.println(this.age);//20
    22.             System.out.println(TestOuter.this.age);//10
    23.         }
    24.     }
    25.     //静态成员内部类：
    26.     static class E{
    27.         public void method(){
    28.             //6.静态内部类中只能访问外部类中被static修饰的内容
    29.             /*System.out.println(age);
    30.             a();*/
    31.         }
    32.     }
    33.     //属性：
    34.     int age = 10;
    35.     //方法：
    36.     public void a(){
    37.         System.out.println("这是a方法");
    38.         {
    39.             System.out.println("这是一个普通块");
    40.             class B{
    41.             }
    42.         }
    43.         class A{
    44.         }
    45.         //7.外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用
    46.         D d = new D();
    47.         System.out.println(d.name);
    48.         d.method();
    49.     }
    50.     static{
    51.         System.out.println("这是静态块");
    52.     }
    53.     {
    54.         System.out.println("这是构造块");
    55.     }
    56.     //构造器：
    57.     public TestOuter(){
    58.         class C{
    59.         }
    60.     }
    61.     public TestOuter(int age) {
    62.         this.age = age;
    63.     }
    64. }
    65. class Demo{
    66.     //这是一个main方法，是程序的入口：
    67.     public static void main(String[] args) {
    68.         //创建外部类的对象：
    69.         TestOuter to = new TestOuter();
    70.         to.a();
    71.         //9.创建内部类的对象：
    72.         //静态的成员内部类创建对象：
    73.         TestOuter.E e = new TestOuter.E();
    74.         //非静态的成员内部类创建对象：
    75.         //错误：TestOuter.D d = new TestOuter.D();
    76.         TestOuter t = new TestOuter();
    77.         TestOuter.D d = t.new D();
    78.     }
    79. }