内部类
       在类的内部也可以定义另一个类

------------------------------------------------------------
//类嵌套类,类中带有类
//内部类跟方法一样，可以使用全部的访问权限修饰符,用法是一样的

接口 InterInner
public interface InterInner {
 public void method();
}

实现接口 InterInnerImpl

public class InterInnerImpl implements InterInner {

 @Override
 public void method() {
 }

}

 

普通类  Outer

public class Outer{
      private int intField;

       //第一种：成员内部类,跟成员属性(方法同级),可以类比成员属性

       class Inner1{}     //Innerl、Inner2、Inner3都是成员内部类
      
       class Inner2{}

       class Inner3{}

      //编译后的表现格式:Outer$2Inner4.class
      public void method1(){
         int a = 0;
          //第二种：局部内类
      //跟局部变量同级，用法类别局部变量，不能使用修饰符

        class Inner4{}
                      //Inner4、Inner5都是局部内 类
        class Inner5{}
}
       //第三种: 静态内部类  可以类比  静态属性
        static class Inner6{}

      //第四种: 匿名内部类
       //因为InterInner interinner = new InterInner() 编译不能通过
      //抽象类 不能实例化
    //所以
      InterInner interinner = new InterInner(){

      @Override
       public void  method(){}  };

    public static void main(String[] args){
       //第一种:成员内部类  创建 对象的 格式
       Outer outer = new Outer();
       Outer.Inner inner1 = outer.new Inner();
       Outer.Inner2 inner2 = new Outer().new Inner2();

       //第二种：局部内部类
      //无法通过普通new进行创建，可以通过继承/实现接口的方式进行

     //第三种：静态内部类
      Outer.Inner5 inner5 = new Outer.Inner5();
    
     //第四种：匿名内部类

     InterInner interImp1 = new InterInnerImp1();
   
    //匿名内部类创建对象方式:等价于 InterInner interImp1 = new InterInnerImp1();

   //不一样的地方是:没有类名

   //1、继承某一个类
   //2、实现某一个接口
    

}

}

----------------------------------------------------------------
普通类 InnerFather

public class InnerFather {

}

接口  InnerInterface

public interface InnerInterface {

}

 

普通类 MemberOuter

public class MemberOuter{
    private int privateField = 1;
    public static int staticField = 3;
    public int a = 1;

  //内部类跟普通类是一样的，普通类能干什么，内部类就可以干什么
  //比如：继承  实现接口
  //可以帮助外部类实现多继承的功能
  //成员内部类运用场景：
  //1、通过内部类可以实现类的多继承
  //2、如果外部类是一个 逻辑非常复杂的一个类，需要操作很多属性
  //或方法 这个时候，可以对功能进行拆分让某个或多个内部类，帮忙处理

   class Inner extend InnerFather implements InnerInterface{

      public Inner(){}

      public int a=2;

/*Outer 对象 --》Inner 对象 --》内部成员

  外部类 --》Inner 类 --》静态成员
    Inner 类 静态成员 --》常量

   因为访问成员内部类中属性 需要通过外部类的对象，进行内部类对象的创建
然后通过内部类的对象进行访问。如果 在内部类中声明 静态属性 那么只能
通过内部类的 类名进行访问 此时 如果内部类是成员内部类时 那么外部类
不能通过 外部类名.内部类名 访问内部类静态成员属性 所以 要么把内部类变成
静态内部类 要么把 静态成员 属性变成 常量(常量表达式)

 

//成员内部类中 不能定义静态的属性
public static final int innerStaticField = 1; //常量表达式
public static final String stringInnerStaticField = "aaa";

//同名属性的情况下访问
public void method(){
int a = 3;
//如果没有特殊指定：this 或Outer.this
//那么访问顺序跟子类属性访问规则一致
//先局部（内部类） -- 成员(内部类) -- 外部
//就近原则

System.out.println("a:" + a);
System.out.println("a:" + this.a);
//内部类访问外部类属性的方法Outer.this.属性
System.out.println("a:" + MemberOuter.this.a);
}
 
//外部类访问控制
public void method2(){
//可以访问外部类的私有属性
System.out.println("outer 私有属性" + privateField);
//可以访问外部类的静态属性

System.out.println("outer 私有属性" + staticField);
}

//普通方法
public void method(){
Inner inner = new Inner();
inner.method();
}

public static void method2(){

//外部类静态方法中不能使用成员内部类，如果要调用 就把成员内部类定义成
静态
//可以类比静态方法调用非静态属性
//Inner inner = new Inner();
}

public static void main(String[] args){
MemberOuter.Inner inner = new MemberOuter().new Inner();
  //inner.method();
  //inner.method2();
  
  
  MemberOuter outer = new  MemberOuter();
  
  outer.method();
 }
 
}

-------------------------------------------------------------------
public class StaticOuter {
 
 private static int staticField = 1;
 public int intField = 2;
 
 static class Inner{
  public int innerField = 1;
  public static int  innerStaticField = 2;
  //可以定义非静态方法
  //静态内部类：
  //非静态方法，可以访问内部中静态/非静态成员，可以访问外部类的静态成员，无法访问，外部类非静态成员
  //原因：StaticOuter.Inner inner = new StaticOuter.Inner();
  //创建静态内部类对象时候，没有创建外部的对象，
  //此时，不是通过外部类对象访问非静态属性，所以不能访问
  public void method(){
   //非静态方法中可以访问外部类静态属性，但不能非静态属性
   //Cannot make a static reference to the non-static field intField
   ///System.out.println("outer 非静态属性：" + intField);
   System.out.println("outer 静态属性：" + staticField);
   
   //可以访问内部类定义的静态属性 ，也可以访问非静态属性
   System.out.println("inner 静态属性：" + innerStaticField);
   System.out.println("inner 非静态属性：" + innerField);
  }
  
  //静态方法
  //静态内部类：
  //静态方法只能访问静态属性或方法，不能访问非静态方法或/属性，不管是外部还是内类
  public static void  method2(){
   //Cannot make a static reference to the non-static field intField
   //System.out.println("outer 非静态属性：" + intField);
   System.out.println("outer 静态属性：" + staticField);
   //可以访问内部类定义的静态属性 ，也可以访问非静态属性
   System.out.println("inner 静态属性：" + innerStaticField);
   //Cannot make a static reference to the non-static field innerField
   //System.out.println("inner 非静态属性：" + innerField);
  }
 }
 public static void main(String[] args) {
  //成员内部类
  //MemberOuter.Inner inner = new MemberOuter().new Inner();
  //静态内部类
  StaticOuter.Inner inner = new StaticOuter.Inner();
  inner.method();
  
  
 }
}