Java内部类的介绍

在Java的面向对象编程中，由于Java并没有类似C++的多重继承，所以采用了内部类这样的方式，现在介绍几种内部类的常见情况。

公开内部类

即由public关键词修饰的内部类，内部类作为外部类的一个成员，可以自由调用外部类的成员。

 1 public class Outter {
 2 Outter(){
 3 
 4 }
 5 public class inner{
 6 inner(){
 7 
 8 }
 9 public void play(){
10 System.out.println("inner play");
11 }
12 }
13 }

创建内部类的对象需要外部类的实例化作为支持，所以，在此之前必须先有外部类对象的创建。

在方法中的内部类

事实上，内部类作为类的一部分，是可以放置于外部类的方法中的

 1 public class m {
 2     m(){
 3         
 4     }
 5 
 6     public void oter(){
 7         class inner{
 8             private int data;
 9             inner(){
10                 
11             }
12             public void display(){
13                 System.out.println("inner display");
14             }
15         }
16     }
17         
18 
19 }

匿名内部类

匿名内部类作为一个成员，通常用于实现某个接口或者抽象类，所以，具有以下几个特点

（1）匿名类不能拥有构造器，即便是无参构造器；

（2）匿名类只能放置于静态方法中

接口内容

1 public interface Intof {
2     public void eat();
3 
4 }

在内部类中实现该接口

 1 public class Outter {
 2     Outter(){
 3         
 4     }
 5 
 6     public static Intof inner = new Intof(){
 7         public void eat(){
 8             System.out.println("Intof eat");
 9         }
10     };
11         
12 
13 }

静态内部类

静态内部类由于是静态的，所以其对象的创建可以不依赖于任何外部类的实例化。而缺陷在于，镜头aii内部类则只能调用外部类的静态成员和方法

 1 public class m {
 2     m(){
 3         
 4     }
 5 
 6     private static int data = 10;
 7     public static class inner{
 8         inner(){}
 9         public void display(){
10             System.out.println("data"+data);
11         }
12     }
13         
14 
15 }