（2.1.5）内部类和匿名内部类

内部类

内部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。

*内部类可以是静态static的，也可用public，default，protected和private修饰。（而外部顶级类即类名和文件名相同的只能使用public和default）。

静态方法可以理解为独立出的内存，静态类也是独立出去的共享类

【静态内部类】内部类B为静态时： 可以不依赖于外部类而被直接实例化、不能与外部类同名，不能访问外部类普通成员变量，可访问静态变量

（1）外部类静态方法创建内部类：B b

（2）外部类非静态方法创建内部类：B b

（3）内部类的静态方法创建外部类： A a=new A()

【普通内部类】内部类B为非静态时： 外部类被实例化后才能借助实例化、可以访问外部类的任何成员

（1）外部类静态方法创建内部类： A a=new a();   A.B b=a.new B();

（2） 外部类非静态方法创建内部类：B b

（3）内部类的静态方法创建外部类： A a=new A()

（4）内部类的非静态方法创建外部类： A a=A.this

【匿名内部类】内部类没有类名：

（1）不能使用关键字class、entends、implements

（2）只能创建一个实例

（3）不能定义静态成员方法和类

（4）不能有构造函数

（5）一定跟在一个new后面，这个匿名类必须继承一个父类或实现一个接口

1.1、内部类非静态：在外部类的非静态方法中创建内部类的实例。

[java]  view plain copy

1. public class InnerClass {  
2.     class A{  
3.         int a = 10;  
4.         void b(){  
5.             System.out.println("this is A.b()!");  
6.         }  
7.     }  
8.       
9.     void build(){  
10.         A a = new A();  
11.         a.b();  
12.     }  
13.       
14.     public static void main(String[] args) {  
15.         InnerClass ic = new InnerClass();  
16.         ic.build();  
17.     }  
18. }  

 1.2、内部类非静态：在外部类的静态方法中创建内部类的实例。

[java]  view plain copy

1. public class InnerClass {  
2.     class A{  
3.         int a = 10;  
4.         void b(){  
5.             System.out.println("this is A.b()!");  
6.         }  
7.     }  
8.       
9.     public static void main(String[] args) {  
10.         InnerClass ic = new InnerClass();  
11.         InnerClass.A aa = ic.new A();  
12.         aa.b();  
13.     }  
14. }  

2、内部类静态：在外部类的静态方法中创建内部类的实例。

[java]  view plain copy

1. public class InnerClass {  
2.     static class A{  
3.         int a = 10;  
4.         void b(){  
5.             System.out.println("this is A.b()!");  
6.         }  
7.     }  
8.       
9.     public static void main(String[] args) {  
10.         InnerClass.build();  
11.     }  
12.       
13.     static void build(){  
14.         A a = new A();  
15.         a.b();  
16.     }  
17. }  

3、在内部类的非静态方法中创建外部类的实例。（使用外部类.this来创建外部类的实例）

[java]  view plain copy

1. public class InnerClass {  
2.     class A{  
3.         int a = 10;  
4.         void build(){  
5.             InnerClass ic = InnerClass.this;  
6.             ic.a();  
7.         }  
8.     }  
9.       
10.     void a(){  
11.         System.out.println("this is InnerClass.a()!");  
12.     }  
13. }  

4、在内部类的静态方法中创建外部类的实例。（直接通过new来创建）

[java]  view plain copy

1. public class InnerClass {  
2.     static class A{  
3.         int a = 10;  
4.         static void build(){  
5.             InnerClass ic = new InnerClass();  
6.             ic.a();  
7.         }  
8.     }  
9.       
10.     void a(){  
11.         System.out.println("this is InnerClass.a()!");  
12.     }  
13. }  

5、在其它类中创建内部类实例。（重点）

[java]  view plain copy

1. public class InnerClass {  
2.     class A{  
3.         void a(){  
4.             System.out.println("this is A.a()!");  
5.         }  
6.     }  
7.     static class C{  
8.         void c(){  
9.             System.out.println("this is C.c()!");  
10.         }  
11.     }  
12. }  
13. class B{  
14.     public static void main(String[] args){  
15.         /*创建非静态内部类*/  
16.         InnerClass ic = new InnerClass();  
17.         A a = ic.new A();  
18.         a.a();  
19.           
20.         /*创建静态内部类*/  
21.         C c = new C();  
22.         c.c();  
23.     }  
24. }  

匿名内部

使用匿名内部类应该注意：

a)        匿名内部类不能有构造方法

b)        匿名内部类不能定义任何静态成员、方法和类。

c)         匿名内部类不能是public,protected,private,static。

d)        只能创建匿名内部类的一个实例。

e)        一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

f)         因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

java中的匿名内部类总结

匿名内部类也就是没有名字的内部类

正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写

但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

 

实例1:不使用匿名内部类来实现抽象方法

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

abstract  class  Person {      public  abstract  void  eat(); }   class  Child  extends  Person {      public  void  eat() {          System.out.println( "eat something" );      } }   public  class  Demo {      public  static  void  main(String[] args) {          Person p =  new  Child();          p.eat();      } }

运行结果：eat something

可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用

但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？

这个时候就引入了匿名内部类

 

实例2：匿名内部类的基本实现

1 2 3 4 5 6 7 8 9 10 11 12 13 14

abstract  class  Person {      public  abstract  void  eat(); }   public  class  Demo {      public  static  void  main(String[] args) {          Person p =  new  Person() {              public  void  eat() {                  System.out.println( "eat something" );              }          };          p.eat();      } }

运行结果：eat something

可以看到，我们直接将抽象类Person中的方法在大括号中实现了

这样便可以省略一个类的书写

并且，匿名内部类还能用于接口上

 

实例3：在接口上使用匿名内部类

interface  Person {      public  void  eat(); }   public  class  Demo {      public  static  void  main(String[] args) {          Person p = new  Person() {              public  void  eat() {                  System.out.println( "eat something" );              }          };          p.eat();      } }

运行结果：eat something

 

由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现

最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口

 

实例4：Thread类的匿名内部类实现

public  class  Demo {      public  static  void  main(String[] args) {          Thread t = new  Thread() {              public  void  run() {                  for  ( int  i = 1 ; i <= 5 ; i++) {                      System.out.print(i + " " );                  }              }          };          t.start();      } }

运行结果：1 2 3 4 5

 

实例5：Runnable接口的匿名内部类实现

1 2 3 4 5 6 7 8 9 10 11 12 13

public  class  Demo {      public  static  void  main(String[] args) {          Runnable r =  new  Runnable() {              public  void  run() {                  for  ( int  i =  1 ; i <=  5 ; i++) {                      System.out.print(i +  " " );                  }              }          };          Thread t =  new  Thread(r);          t.start();      } }

运行结果：1 2 3 4 5