内部类

首先，把内部类作为外部类的一个特殊的成员来看待，因此它有类成员的封闭等级：private ,protected,默认(friendly),public
它有类成员的修饰符: static,final,abstract
2.非静态内部类nested inner class,内部类隐含有一个外部类的指针this,因此，它可以访问外部类的一切资源（当然包括private）
外部类访问内部类的成员，先要取得内部类的对象,并且取决于内部类成员的封装等级。
非静态内部类不能包含任何static成员.
3.静态内部类：static inner class,不再包含外部类的this指针，并且在外部类装载时初始化.
静态内部类能包含static或非static成员.
静态内部类只能访问外部类static成员.
外部类访问静态内部类的成员，循一般类法规。对于static成员，用类名.成员即可访问，对于非static成员，只能
用对象.成员进行访问
4.对于方法中的内部类或块中内部类只能访问块中或方法中的final变量。
类成员有两种static , non-static，同样内部类也有这两种
non-static 内部类的实例，必须在外部类的方法中创建或通过外部类的实例来创建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),并且可直接访问外部类的信息,外部类对象可通过OuterClassName.this来引用
static 内部类的实例, 直接创建即可，没有对外部类实例的引用。
内部类不管static还是non-static都有对外部类的引用
non-static 内部类不允许有static成员
方法中的内部类只允许访问方法中的final局部变量和方法的final参数列表，所以说方法中的内部类和内部类没什麽区别。但方法中的内部类不能在方法以外访问，方法中不可以有static内部类
匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数
匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递

//new qw().get();//局部内部类在普通方法下，可通过new外部类对象.内部类所在的方法
// // （内部类所在的方法必须为有创建内部类对象并且使用的代码）
// //局部内部类在静态方法下
// qw.get();//类名.调用（内部类所在的方法必须为有创建内部类对象并且使用的代码）

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
import org.w3c.dom.ls.LSOutput;

public class Test114 {
public static void main(String[] args) {
System.out.println("===================以下为普通成员内部类测试");
asd.asdf asdf1 = new asd().new asdf();//普通成员内部类可以外部创建实例化对象。执行构造代码块输出100
System.out.println(asdf1.a);//输出0
System.out.println(asdf1.b);//输出10

    asd asd = new asd();//也可以先new外部类，然后调用外部类的方法执行方法里的内部类的实例化，从而起到在外部操作的作用
    asd.get();//输出100，o

    System.out.println("===================以下为私有成员内部类测试");
    // new asdd().new asdff        //报错，私有成员内部类无法在外部创建实例化对象
    asdd asdd = new asdd();私有只可new外部类，然后调用外部类的方法执行方法里的内部类的实例化，从而起到在外部操作的作用
    asdd.get();

    System.out.println("===================以下为静态成员内部类测试");
   // new asddd().new //报错，静态成员内部类不能对象.的方式在外面创建实例化对象
    asddd.asdfff asdfff1 = new asddd.asdfff();//静态成员内部类能通过外部类名.内部类目（）.的方式在外面创建实例化对象
    System.out.println(asdfff1.a);//输出100,0
    asddd asddd1 = new asddd();//也可以先new外部类，然后调用外部类的方法执行方法里的内部类的实例化，从而起到在外部操作的作用
    asddd1.get();//输出100，0


    System.out.println("以下为局部内部类的测试");
    new qw().get();//局部内部类在普通方法下，可通过new外部类对象.内部类所在的方法
    // （内部类所在的方法必须为有创建内部类对象并且使用的代码）
    //局部内部类在静态方法下
    
    new er(){//匿名内部类
        public void get(){
            System.out.println(111111);
        }
    }.get();
    er A = new er(){//匿名内部类//多态写法
        public void get(){
            System.out.println(111111);
        }
    };
    A.get();
}

}
class asd {//普通成员内部类
int a = 0;
int b = 10;
static String c1 = “100”;

public void get(){//new普通成员内部类的方法不能是静态的
    System.out.println(c1);
     int aa = 0;

    asdf asdf1 = new asdf();//new内部类时，里面的构造代码块再一次输出，因为这个创建的类和外部直接创建的类不是同一个
    System.out.println(asdf1.a);
}

class asdf {//普通成员内部类
    int a = 0;//内部类的属性和外部类的属性不冲突
    int b = 10;
    //    static String d = "100";//普通成员内部类里面无法定义静态资源
    {
        System.out.println(c1);//普通内部类使用构造代码块也依然第一个执行，可以使用外部类所有资源；包含静态资源
    }
}

}

class asdd {//私有成员内部类
int a = 0;
int b1 = 10;
static String c1 = “100”;
public void get(){//new私有成员内部类的方法不能是静态的

    asdff asdff1 = new asdff();//new内部类时，里面的构造代码块再一次输出，因为这个创建的类和外部直接创建的类不是同一个
    System.out.println(asdff1.a);
}
private class asdff {//私有成员内部类
    int a = 0;//内部类的属性和外部类的属性不冲突
    int b = 10;
    //   static String d = "100";//私有内部类里面无法定义静态资源
    {
        System.out.println(c1);//私有可以使用外部类所有资源；包含静态资源
    }
}

}

class asddd {//静态成员内部类
int a = 0;
int b1 = 10;
static String c1 = “100”;

public static void get() {//new静态内部类的方法可以是静态方法。
    asdfff asdfff1 = new asdfff();//new内部类时，里面的构造代码块再一次输出，因为这个创建的类和外部直接创建的类不是同一个
    System.out.println(asdfff1.a);
    System.out.println(asdfff.c);//可以类名访问
    get1();
    System.out.println(c1);
}
public static void get1() {

}
static class asdfff {//静态成员内部类
    int a = 0;//内部类的属性和外部类的属性不冲突
    int b = 10;
    static String c = "100";//静态成员内部类可以定义静态资源

    {
        System.out.println(c);//静态成员内部类可以使用外部类所有资源；包含静态资源
    }
    {
        get1();
    }
  }
  }