public class Parcel1
{
  
  private Contents cCommon = null;
  private static  Contents cStatic = null;
  
  //显示初始化,可以正常使用内部类
  {
    Contents cTmp = new Contents(); //显示初始化中,正常使用内部类 类型
    cCommon = cTmp;
    Parcel1.Contents cc = cTmp;     
    // 也可以用这种方式使用内部类的类型,
    //和 直接使用 Contents 有什么不同?
    //答:貌似在定义内部类的类中可以用这中方式,
    //也可以直接使用内部类,
    //并且在定义内部类的外围类 以外(比如其他包里面的一个类)
    //也不需要使用这个方式(Parcel1.Contents)如下
/**
package holding;

import innerclasses.Parcel1;
import innerclasses.Parcel1.Contents;

public class TTTT
{
  public void test()
  {
    Parcel1 p = new Parcel1();
    Contents cc = p.new Contents();
  }
}
*/
  }
  
  //静态初始化,可以正常使用内部类类型
  static
  {
    //Contents c1 = new Contents(); //报错
    //必须有一个 外围类的引用,然后使用下面的方式创建才行
    Parcel1 p =new Parcel1();
    Contents cTmp = p.new Contents(); // 创建方式 p.new Contents();
    cStatic = cTmp;
  }
  /*
   * 为什么静态初始化中必须要有一个外围类对象p,
   * 而非静态的 可以直接使用Contents cTmp = new Contents();?
   * 答:因为,实例化一个内部类,必须要有一个外围类的对象,
   * 内部类实例的有一个域必须指向它的外围类对象
   * 非静态的Contents cTmp = new Contents();这个在初始化的时候,
   * 自动把当前的类对象this当成内部类对象的外围类对象了
   * 而,静态的cStatic没有this,所以必须要显示实例化一个内部类的外围类对象.
   */
  
  //定义一个内部类
  class Contents
  {
    private int i = 11;

    public int value()
    {
      return i;
    }
  }

  //另一个内部类
  class Destination
  {
    private String label;

    Destination(String whereTo)
    {
      label = whereTo;
    }

    String readLabel()
    {
      return label;
    }
  }

  // 在定义内部类的 类中, 在 非静态方法中 使用内部类的方式
  public void ship(String dest)
  {
    Contents c = new Contents();
    Destination d = new Destination(dest);
    System.out.println(d.readLabel());
  }
  
  public Contents getContent()
  {
    return new Contents();
  }
  
  /*
   * 第191页说: "如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象,
   * 那么必须 具体底指明这个对象的类型:OuterClassName.InnerClassName"
   * 这个说法貌似不对,下面代码,静态方法中 直接使用InnerClassName的,
   * Contents ccc = p.getContent(); //没有使用OuterClassName.InnerClassName方式.
   * 在定义内部类的外围类 之外 使用内部类,也不需要使用 OuterClassName.InnerClassName方式
   * 显示指定 内部类的名称,但是需要考虑访问权限,因为内部类之前可以使用下面的修饰符 修饰
   * (1)public(任何地方可用), 
   * (2)private(只在定义内部类的外围类中使用), 
   * (3)protected(在外围类已经外围类的子类中使用) 
   * (4)空(friend,在外围类已经与外围类 在同一个包中的其他类中使用 )
   */
  public static void setStatic()
  {
    Parcel1 p = new Parcel1();
    Contents ccc = p.getContent();
  }

  //在外围类的静态方法中,使用内部类
  public static void main(String[] args)
  {
    Parcel1 p = new Parcel1();
    p.ship("Tasmania");
  }

本文固定链接: https://www.jack-yin.com/coding/thinking-in-java/2385.html | 边城网事