内部类：定义在一个类内部的类 成为内部类 （只有在外部类调用的时候进行实例化）
静态内部类：定义在一个类内部的类 并且被static修饰的类 称为静态内部类 （使用时才加载）
public class OutterClass {
//外部类的静态变量
private static int a = 0;
//外部类的成员变量
private int b = 0;
public static void staticVoid() {
System.out.println("外部类的StaticVoid");
}
public void notStaticVoid() {
System.out.println("外部类的notStaticVoid");
}
//return 内部类
public InnerClass getInnerClass() {
return new InnerClass();
}
//内部类
class InnerClass{
private String s1;
//private static String s2; //内部类不能有静态的变量
private static final String s2 = "Liming";
private void str2() {}
public void name() {
System.out.println("内部类");
System.out.println(a); //内部类可以访问外部类的静态变量
System.out.println(b);
staticVoid();
notStaticVoid();
}
// 编译报错 内部类不能有静态的方法
/*public static void ssss() {
}*/
//内部类的内部类
class InnerClassInnerClass{
public void name() {
System.out.println("内部类的内部类");
staticVoid();
notStaticVoid();
}
}
//内部类的静态内部类------》 不存在的 ， static 修饰的属于类 在类加载的时候初始化， 内部类的内部类在 new 的时候初始化， 如果静态内部类成立，这不就矛盾了吗？
/* static class InnerClassStaticInnerClass2{
public void name() {
//静态内部类可以访问外部类的静态变量，以及方法
staticVoid();
System.out.println(a);
//System.out.println(b); //不能访问非静态成员
System.out.println("静态内部类方法");
new OutterClass().notStaticVoid();
}
}*/
}
//静态内部类
public static class StaticInnerClass{
private String s1;
private static String s2;
private void str2() {}
public void name() {
//静态内部类可以访问外部类的静态变量，以及方法
staticVoid();
System.out.println(a);
//System.out.println(b); //不能访问非静态成员
System.out.println("静态内部类方法");
new OutterClass().notStaticVoid();
}
public static void names() {
//静态内部类可以访问外部类的静态变量，以及方法
staticVoid();
System.out.println(a);
//System.out.println(b); //不能访问非静态成员
System.out.println("静态内部类方法");
new OutterClass().notStaticVoid();
}
class StaticInnerClassInnerClass{
public void name() {
// System.out.println(b); 不能访问外部类的非静态成员
System.out.println("静态内部类的内部类");
//静态内部类的内部类可以访问静态内部内的方法
new OutterClass.StaticInnerClass().name();
//可以方法外部类的静态 方法 和 静态啊变量
new OutterClass().notStaticVoid();
staticVoid();
System.out.println(a);
}
}
}
public static void main(String[] args) {
//实例化外部类
OutterClass out = new OutterClass();
/************************** 内部类 *********************************/
//调用方法一 在外部类中 通过一个方法返回一个内部类对象
InnerClass innerClass = new OutterClass().getInnerClass();
//调用方法二
OutterClass.InnerClass inner = out.new InnerClass();
inner.name();
inner.str2(); // 外部类可以方位内部类私有的方法
//内部类的内部类
OutterClass.InnerClass.InnerClassInnerClass in2 = inner.new InnerClassInnerClass();
in2.name();
//继续调用里面的类部类，也可以继续在内部内里面返回一个内部类的方法
InnerClass.InnerClassInnerClass i2 = innerClass.new InnerClassInnerClass();
i2.name();
/************************** 静态内部类 *********************************/
//调用静态内部类
OutterClass.StaticInnerClass s = new OutterClass.StaticInnerClass();
s.name(); //静态内部类方法
s.str2(); //外部类 可以访问 静态内部类私有方法
//静态内部类的内部类
StaticInnerClassInnerClass staticInnerClassInnerClass = s.new StaticInnerClassInnerClass();
staticInnerClassInnerClass.name(); //静态内部类的内部类
}
}
外部类访问内部类和静态内部类：
1 首先实例化外部类 2 实例化内部类 外部类 . 内部类 xx = 外部类的引用 . new 内部类();
1 外部类访问静态内部类 外部类 xx = new 外部类() . 静态内部类();
访问外部类总结：
1 内部类可以访问外部类的 静态成员 和 静态变量 ， 静态方法（外部类 . 的形式）和非静态方法（直接访问）
2 静态内部类 只能访问外部类 静态变量 ， 静态方法（外部类 . 的形式），外部类非静态方法(直接访问)
方法，成员变量和静态变量：
1 外部类 可以访问 “内部类” 或者 “ 静态内部类” 的 私有的方法
2 内部类， 静态内部类 都可以有 “ 成员变量 ” ，3 内部类不能有静态的方法，以及静态变量 （内部类只有在实例化也就是外部类调用的时候初始化，所以不能有static）
4 静态内部类 只能访问外部类的静态方法，静态内部类可以包含静态和非静态方法 以及 变量。
