java学习第七天

2019独角兽企业重金招聘Python工程师标准>>>

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

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

接口 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();


}
}