<span style="font-family:Comic Sans MS;font-size:18px;">package com.test; 
public class Cow 
{ 
  private double weight; 
  // 外部类的两个重载的构造器 
  public Cow(){} 
  public Cow(double weight) 
  { 
    this.weight = weight; 
  } 
  // 定义一个非静态内部类 
  private class CowLeg 
  { 
    // 非静态内部类的两个实例变量 
    private double length; 
    private String color; 
    // 非静态内部类的两个重载的构造器 
    public CowLeg(){} 
    public CowLeg(double length , String color) 
    { 
      this.length = length; 
      this.color = color; 
    } 
    // 下面省略length、color的setter和getter方法 
    public void setLength(double length) 
    { 
      this.length = length; 
    } 
    public double getLength() 
    { 
      return this.length; 
    } 
    public void setColor(String color) 
    { 
      this.color = color; 
    } 
    public String getColor() 
    { 
      return this.color; 
    } 
    // 非静态内部类的实例方法 
    public void info() 
    { 
      System.out.println("当前牛腿颜色是：" 
        + color + ", 高：" + length); 
      // 直接访问外部类的private修饰的成员变量 
      System.out.println("本牛腿所在奶牛重：" + 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(); 
  } 
} 
</span> 

<span style="font-family:Comic Sans MS;font-size:18px;">package com.test; 
public class Outer 
{ 
  private int outProp = 9; 
  class Inner 
  { 
    private int inProp = 5; 
    public void acessOuterProp() 
    { 
      // 非静态内部类可以直接访问外部类的private成员变量 
      System.out.println("外部类的outProp值:" 
        + outProp); 
    } 
  } 
  public void accessInnerProp() 
  { 
    // 外部类不能直接访问非静态内部类的实例变量, 
    // 下面代码出现编译错误 
    // System.out.println("内部类的inProp值:" + inProp); 
    // 如需访问内部类的实例变量，必须显式创建内部类对象 
    System.out.println("内部类的inProp值:" 
      + new Inner().inProp); 
  } 
  public static void main(String[] args) 
  { 
    // 执行下面代码，只创建了外部类对象，还未创建内部类对象 
    Outer out = new Outer();   //① 
    out.accessInnerProp(); 
  } 
} 
</span> 

<span style="font-family:Comic Sans MS;font-size:18px;">package com.test; 
public class StaticInnerClassTest 
{ 
  private int prop1 = 5; 
  private static int prop2 = 9; 
  static class StaticInnerClass 
  { 
    // 静态内部类里可以包含静态成员 
    private static int age; 
    public void accessOuterProp() 
    { 
      // 下面代码出现错误： 
      // 静态内部类无法访问外部类的实例变量 
      System.out.println(prop1); 
      // 下面代码正常 
      System.out.println(prop2); 
    } 
  } 
} 
</span> 

<span style="font-family:Comic Sans MS;font-size:18px;">package com.test; 
interface Product 
{ 
  public double getPrice(); 
  public String getName(); 
} 
public class AnonymousTest 
{ 
  public void test(Product p) 
  { 
    System.out.println("购买了一个" + p.getName() 
      + "，花掉了" + p.getPrice()); 
  } 
  public static void main(String[] args) 
  { 
    AnonymousTest ta = new AnonymousTest(); 
    // 调用test()方法时，需要传入一个Product参数， 
    // 此处传入其匿名实现类的实例 
    ta.test(new Product() 
    { 
      public double getPrice() 
      { 
        return 567.8; 
      } 
      public String getName() 
      { 
        return "AGP显卡"; 
      } 
    }); 
  } 
} 
</span>