java基础--内部类与匿名类

一）内部类

1、什么是内部类？有什么用？

       当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。
       在类内部定义的类为成员内部类，在方法里定义的类为局部内部类，被static修饰的为静态内部类。一个类中可有多个内部类。
       内部类主要作用：封装一个类的声明在类的内部，减少类的暴露！

2、内部类的实现方式？如何访问一个内部类？

       1）内部类的实例化：实例化时不需要出写对象，非要写的话为：

 new 外部类名．内部类名()；而不是外部类名．new 内部类名()。
       2）内部类的访问规则：内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用。

格式：外部类名．xxx，    外部类要访问内部类，必须建立内部类对象。

       3）当内部类定义在外部类的成员位置上，而且非私有，则在外部其他类中可以直接建立内部类对象。

格式：外部类名．内部类名 变量名 = 外部类对象．内部类对象；
Outer.Inner in = new Outer().new Inner();

       4）当内部类在成员位置上，就可以被成员修饰符所修饰。比如private：将内部类在外部类中进行封装。
           静态内部类：被static修饰后就具备了静态的特性。当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。
       ①在外部其他类中，如何直接访问static内部类的非静态成员呢？
            new Outer.Inner().function();
       ②在外部其他类中，如何直接访问static内部类的静态成员呢？
           Outer.Inner.function();
注意事项：
      当内部类中定义了静态成员，该内部类必须是static的。
      当外部类中的静态方法访问内部类时，内部类也必须是static的。

3、内部类与外部类的有什么关系，如何进行数据交互？

       1）内部类想调用外部类的成员，需要使用：外部类名．this．成员

即OutterClassName．this  表示外部类的对象。

      如果写this．成员= =成员，调用的还是内部类的成员（属性或方法）。

       2）Timer 和 TimerTask：继承TimerTask 重写run()方法，再用Timer类中的schedule方法定时调用，就能自动启用run()（不像以前似的要用 ．XXX 调用）。
     eg：内部类

<span style="font-size:14px;">    //实例不完整，可惜！
    class Xoo{   	   
    	Timer timer = new Timer();
    }
    public void start(){
		timer.schedule(new MyTask(), 0, 1000);//0表示立即开始，无延迟
 	    timer.schedule(new StopTask(), 1000*10);//在10秒以后执行一次 
 	    
    }
	class StopTask extends TimerTask{
   		 public void run()  {  
   			 timer.cancel();  
   			 }//取消timer上的任务 
   		 }
	class MyTask extends TimerTask {
    	int i=10;  
    	public void run(){ 
    		System.out.println(i--); 
    	} 
    	
    }

}  
    </span>

二）匿名类

1、什么是匿名类？匿名类是什么样子的？

       匿名内部类＝＝匿名类

    1）匿名内部类的格式： new 父类或者接口(){定义子类的内容}；

         如new Uoo(){……}就叫匿名内部类！

        是继承于Uoo类的子类或实现Uoo接口的子类，并且同时创建了子类型实例，其中{}是子类的类体，可以写类体中的成员。

    2）定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
    3）匿名内部类没有类名，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖，可以理解为带内容的对象。

2、匿名内部类可以继承外部类吗？可以实现接口吗？

        Nested Class（嵌套类）是静态（static）内部类：1）要创建嵌套类的对象，并不需要其外围类的对象： 2）不能从嵌套类的对象中访问非静态的外围类对象。
        Anonymous Inner Class （匿名内部类）：匿名的内部类是没有名字的内部类，匿名的内部类不能extends（继承）其它类，但一个内部类可以作为一个接口，由另一个内部类实现。
         嵌套类可以作为接口的内部类，正常情况下，你不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分，因为它是static 的。只是将嵌套类置于接口的命名空间内，这并不违反接口的规则。
         内部类被继承,由于内部类有一个指向外围类对象的秘密引用，所以在继承内部类的时候，该秘密引用必须被初始化。解决方法是enclosingClassReference.super();语法，看一下代码：

<span style="font-size:14px;">class Outer//外部类
{
     class Inner//内部类
      {
       }
}
class AnoClass extends Outer.Inner//内部类被继承
{
      AnoClass (Outer wi)
        {
              wi.super();
         }
}</span>

3、匿名类（Anonymous Class）
　　当一个内部类的类声名只是在创建此类对象时用了一次，而且要产生的新类需继承于一个已有的父类或实现一个接口，才能考虑用匿名类，由于匿名类本身无名，因此它也就不存在构造方法，它需要显示地调用一个无参的父类的构造方法，并且重写父类的方法。

<span style="font-size:14px;">    f.addMouseMotionListener(new MouseMotionAdapter(){ //匿名类开始
 　　　　　　　public void mouseDragged(MouseEvent e){
 　　　　　　　　String s="Mouse dragging: x="+e.getX()+"Y="+e.getY();
 　　　　　　　　tf.setText(s); }
 　　　　　　} ); //匿名类结束
</span>

存在它的原因是:
　　1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。即内部类实例对包含它的哪个类的实例来说，是特权的。
　　2.对于同一个包中的其他类来说,内部类能够隐藏起来,换句话说，内部类不管方法的可见性如何，那怕是public，除了包容类，其他类都无法使用它。
　　3.匿名内部类可以很方便的定义回调。
　　4.使用内部类可以非常方便的编写事件驱动程序。
其实它真正的目的仅仅为了定义回调－－进一步就是事件驱动

使用内部类注意事项：

　    ·匿名内部类不能有构造方法。
　　·匿名内部类不能定义任何静态成员、方法和类。
　　·匿名内部类不能是public,protected,private,static。
　　·只能创建匿名内部类的一个实例。
        ·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
　　·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

三）实例

1、匿名类格式： new <类或接口> <类的主体> 

<span style="font-size:14px;color:#330033;">return new Contents() { 
private int i = 11; 
public int value() { return i; } 
}; 
</span>

         这种奇怪的语法要表达的意思是：“创建从Contents衍生出来的匿名类的一个对象”。由new表达式返回的句柄会自动上溯造型成一个Contents句柄。

         匿名内部类的语法其实要表达的是：

<span style="font-size:14px;color:#330033;">    class MyContents extends Contents { 
    	private int i = 11; 
    	public int value() { return i; } 
    	} 
    	return new MyContents(); </span>

若试图定义内部类,并想使用在匿名内部类外部定义的一个对象,则编译器要求外部对象必须是final属性。

public class Parce { //不完整
    	  public Destination 
    	  dest(final String dest, final float price) { 
    	    return new Destination() { 
    	      private int cost; 
    	      // Instance initialization for each object: 
    	      { 
    	        cost = Math.round(price); 
    	        if(cost > 100) 
    	          System.out.println("Over budget!"); 
    	      } 
    	      private String label = dest; 
    	      public String readLabel() { return label; } 
    	    }; 
    	  } 
    	  public static void main(String[] args) { 
    	    Parce p = new Parce(); 
    	    Destination d = p.dest("Tanzania", 101.395F); 
    	  } 
    	}