java基础-内部类之实例内部类1

1 内部类

内部类可分为成员内部类，局部内部类，成员内部类又可以分为静态和非静态的内部类。

2 任何内部类不能和外部内重名。

3 实例内部类的特点：

  (1) 在创建内部类的实例时，外部类的实例必须存在。

  (2) 实例内部类自动持有外部类的引用。在内部中，可以直接访问外部类的所有成员方法和成员变量。

  (3)在多重内部类嵌套中，内部类可以访问所有外部内的成员属性和方法。

class Outer {
    private String name="outer";
    public int num=10;
    //公开的内部类
    public class InnerTool {
       //定义一个内部类的静态常量PI
       public static final float PI=3.1415f;
       private int num=20;

       public int add(int a, int b) {
           System.out.println("访问外部内的私有成员属性,name="+name);
           System.out.println("访问内部类成员属性num="+this.num);
           System.out.println(Outer.this.num);
           return a + b;
       }
    }
    //私有的内部类成员变量
    private InnerTool innerTool = new InnerTool();
    public int area(int h,int w)
    {
       //获得PI常量
       return (int) (h*w*InnerTool.PI);
    }
    public int add(int a, int b) {
       return this.innerTool.add(a, b);
    }
}

class OuterA {
    public int a1;//公开
    private int a2;//私有
    static int a3;//静态

    public OuterA(int a1, int a2) {
       this.a1 = a1;
       this.a2 = a2;
    }
    protected int methodA() {
       return (int) (a1 * a2*InnerB.PI);
    }

    class InnerB {
       // 访问外部内的成员属性和方法
       static final float PI=3.14f;
       int b1 = a1;
       int b2 = a2;
       int b3 = a3;
       int b4 = new OuterA(3, 4).a1;
       int b5 = methodA();
       protected class InnerC
       {
           // static int cc=0; // 不能在内部类中定义静态的变量
           final static String name="InnerC";//可以定义静态的常量
           private void methodC()
           {
              methodA();//调用外部方法
           }
       }
    }
}

public class TestInner2 {
    public static void main(String[] args) {
       OuterA.InnerB ib =new OuterA(2,3).new InnerB();
       System.out.println("访问常量:"+OuterA.InnerB.PI);
       System.out.println("访问常量:"+OuterA.InnerB.InnerC.name);
       System.out.println("ib.b1="+ib.b1);
       System.out.println("ib.b2="+ib.b2);
    }
}

 

(4)外部类实例和内部类实例之间是一对多的关系，一个内部类只会引用一个外部类实例，

而一个外部类实例对应0个或多个内部内实例。在外部类中不能直接访问内部类的成员，必须通过内部类的实例去访问。

package innerclass;
import innerclass.A.B.C;
class A {
    static int C=0;
    class B {
       private int b1=1;
       private int b2=2;
       class C
       {
       }
    }
    public void test()
    {
       //int v1=b1;//不能直接访问Inner Class 的成员变量
       //int v2=b2;//不能直接访问Inner Class 的成员变量
       //B.C c1=new C();//不能访问内部类B的内内部类C
       B b =new B();
       int b1 =b.b1;
       int b2=b.b2;

       C c = b.new C();

       C c2= new B().new C();
    }
}

 

在以上类B中还有类C 类A 不能直接方法类C应该通过类B去访问类C。

(5) 在实例内部类中不能定义静态成员变量，可以定义常量.可以定义实例成员。

(6) 如果实例内部类B与外部内包含同名的属性v，那么在类B中,this.v表示B的成员，

A.this.v表示类A的成员.