java study 002 --inner class

import java.util.*;
public class Inerclasstest {

 
 public static void main(String[] args) {
  
  Outer out =new Outer();
 // out.print();
  
 //main 中直接访问内部类 
  //main 中不能直接产生innerd object,
  //Out.Inner in = new Out.Inner();(x)
  //通过在一个外部内中返回一个内部类对象去访问内部类成员
  
/*222  
  Outer.Inner in = out.getinner();
  in.print();
*/
  //方法三：通过外部内对象去产出一个内部类对象
  Outer.Inner in = out.new Inner();
  in.print();
  
  //内部类可以放在方法 条件等中去定义
 }
}

class Outer
{
private int index =100;
 
 //将内部类申明为protect 可以被外部类，同一个包中被访问
 //申明为privivate，则只能外部类反复问S
 protected class Inner
 {
  private int index =50;
  void print()
  {
   int index =30;
   System.out.println(index);
   System.out.println(this.index);
   System.out.println(Outer.this.index);
  }
 }
 
 void testinner(final int a)
 {
  final int b = 0;
  class Inner
  {
   private int index =50;
   void print()
   {
    int index =30;
    System.out.println(index);
    System.out.println(this.index);
    System.out.println(Outer.this.index);
    //在内部类中访问的变量需要申明为final
    System.out.println(a);
    System.out.println(b);
    
   }
  }
 }

 static int aa=5;
 static class testinner2
 {
  int bb=6;
  void print()
  {
   System.out.println(bb);
   System.out.println(Outer.aa);
  }
 }
 
 class testinner3
 {
  //内部类是不能定义静态方法
  /*static void print()
  {
   
  }*/
 }
 
 void print()
 {
  Inner in = new Inner();
  in.print();
 }
 
 Inner getinner()
 {
  return new Inner();
 }
}

 

 

import java.io.IOException;

class Car
{
 class Wheel
 {
  
 }
}

//不能直接继承内部对象
//继续时，先调用够着杉树，需要从外部类建立到内部类的联系
public class testinnerextend  extends Car.Wheel{

 //需要通过构造函数，传递外部类对象
 testinnerextend(Car car)
 {
   car.super();
 }
 public static void main(String[] args) throws IOException {
  
 // Car car = new Car();
  
  //testinnerextend t= new testinnerextend(car);
  
  Zoo z = new Zoo();
  Animal an = z.getAnnmal();
  an.eat();
  an.sleep();
 }
}

//内部类也可以实现接口
interface Animal
{
  void eat();
  void sleep();
  
}

class Zoo
{
 //内部类去实现接口
 class Tiger implements Animal
 {
  public void eat()
  {
   System.out.println("tiger eat");
  }

  @Override
  public void sleep() {
   // TODO Auto-generated method stub
   System.out.println("tiger sleep");
  }
 }
 /*
 Animal getAnnmal()
 {
  return new Tiger();
 }*/
 
 Animal getAnnmal()
 {
  //返回对象之前实现接口的方法
  //匿名的内部类
  return new Animal() {
   
   @Override
   public void sleep() {
    System.out.println("Animal sleep");
    
   }
   
   @Override
   public void eat() {
    // TODO Auto-generated method stub
    System.out.println("Animal eat");
   }
  };//注意分号，这是不能少的
 }
 
 
}

 

class Zoo
{
 //内部类去实现接口
 //class Tiger implements Animal
 //如果把内部类申明为私有的，则不能在其他地方可以用Outer.Inner去访问接口。
 //只能间接的使用内部类实现的接口去访问
 private class Tiger implements Animal
 {
  public void eat()
  {
   System.out.println("tiger eat");
  }

  @Override
  public void sleep() {
   // TODO Auto-generated method stub
   System.out.println("tiger sleep");
  }
 }
 
 Animal getAnnmal()
 {
  return new Tiger();
 }
 /*
 Animal getAnnmal()
 {
  //返回对象之前实现接口的方法
  //匿名的内部类
  return new Animal() {
   
   @Override
   public void sleep() {
    System.out.println("Animal sleep");
    
   }
   
   @Override
   public void eat() {
    // TODO Auto-generated method stub
    System.out.println("Animal eat");
   }
  };//注意分号，这是不能少的
 }
 */
 
 
}

 

 

 

class Zoo
{
 //内部类去实现接口
 //class Tiger implements Animal
 //如果把内部类申明为私有的，则不能在其他地方可以用Outer.Inner去访问接口。
 //只能间接的使用内部类实现的接口去访问
 private class Tiger implements Animal
 {
  public void eat()
  {
   System.out.println("tiger eat");
  }

  @Override
  public void sleep() {
   // TODO Auto-generated method stub
   System.out.println("tiger sleep");
  }
 }
 
 Animal getAnnmal()
 {
  return new Tiger();
 }
 /*
 Animal getAnnmal()
 {
  //返回对象之前实现接口的方法
  //匿名的内部类
  return new Animal() {
   
   @Override
   public void sleep() {
    System.out.println("Animal sleep");
    
   }
   
   @Override
   public void eat() {
    // TODO Auto-generated method stub
    System.out.println("Animal eat");
   }
  };//注意分号，这是不能少的
 }
 */
 
 
}