例子1：非靜態內部類訪問外部類的例項屬性
package cn.com.postel.wbb.crazyJava.innerClass;

public class Cow {
       private double weight ;
      
       public Cow() {}
      
       public Cow(double weight) {
             this.weight = weight;
      }
      
       public void test() {
            CowLeg cl = new CowLeg(1.12, "黑白相間" );
            cl.info();
      }
      
       public static void main(String[] args) {
            Cow cow = new Cow(378.9);
            cow.test();
      }
      
       //非靜態內部類
       private class CowLeg {
             private double length ;
             private String color ;
             public CowLeg(){}
            
             public CowLeg(double length, String color) {
                   this.length = length;
                   this.color = color;
            }
            
             public double getLength() {
                   return length ;
            }
            
             public void info() {
                  System. out.println("當前牛腿的顏色是：" + color + ",高：" + length);
                   //訪問外部類屬性
                  System. out.println("本牛腿所在奶牛重：" + weight);
            }
            
             public void setLength( double length) {
                   this.length = length;
            }
             public String getColor() {
                   return color ;
            }
             public void setColor(String color) {
                   this.color = color;
            }
      }
}


例子2：區分外部類、內部類、區域性變數同名的變數
class OutClass
{
    private String val = " 外部類屬性 ";
    class InnerClass
    {
        private String val = "內部類屬性 ";
        public void info()
       {
           String val = "區域性變數" ;
            //訪問外部類屬性使用類名 .this.屬性名
           System. out.println(OutClass.this.val);
            //訪問內部類屬性使用this.屬性名
           System. out.println(this.val);
            //訪問區域性變數
           System. out.println(val);
       }
    }
    public void test()
    {
       InnerClass in = new InnerClass();
       in.info();
    }
    
    public static void main(String[] args)
    {
       OutClass out = new OutClass();
       out.test();
    }
}

例子3：外部類訪問非靜態內部類類成員
package cn.com.postel.wbb.crazyJava.innerClass;

public class OutAcessInner {
       private String outParam = "HAHA";

       class Inner {
             private String name = "wbb";

             private void info() {
                   // 非靜態內部類可以直接訪問外部類的成員
                  System. out.println("外部類成員變數outParam的屬性值：" + outParam);
            }
      }

       public static void main(String[] args) {
            Inner inner = new OutAcessInner().new Inner();
             // 外部類不可直接訪問內部類的成員，下列輸出語句將發生變異錯誤
             // System.out.println(name);
             // 外部類訪問非靜態內部類類成員必須顯示建立內部類物件(首先要建立外部類的物件)
            System. out.println("內部類成員變數name的屬性值：" + inner.name);
            inner.info();
      }
}

例子4：靜態內部類不能訪問外部類的例項成員，只能訪問外部類的類成員。
package cn.com.postel.wbb.javaextends;

public class TestStaticInnerClass {
    private int param1 = 1;
    private static int param2 = 2;

    static class StaticInnerClass {
        // 靜態內部類可以包含靜態屬性
        private static int param3 = 3;

        // 訪問外部類屬性
        public void accessOuterParam() {
            // 靜態內部類可以訪問外部類的靜態屬性
           System. out.println(param2);
            // 靜態內部類不可以訪問外部類的例項屬性
            // System.out.println(param1);
            // 靜態內部類訪問外部類的例項屬性需要通過例項訪問
           System. out.println(new TestStaticInnerClass().param1);
       }
    }
}