【java】内部类

在一个类的内部定义的类，称为内部类

内部类主要分类： 

➢实例内部类

➢局部内部类

➢静态内部类 

1、实例内部类 

➢创建实例内部类，外部类的实例必须已经创建；

➢实例内部类会持有外部类的引用；

➢实例内部不能定义 static 成员，只能定义实例成员。

public class InnerClassTest01 {    
    private int a;    
    private int b;

    InnerClassTest01(int a, int b) {   
        this.a = a;   
        this.b = b;  
    }    
    //内部类可以使用 private 和 protected 修饰  
    private class Inner1 {   
        int i1 = 0;   
        int i2 = 1;      
        int i3 = a;   
        int i4 = b;      
        //实例内部类不能采用 static 声明   
        //static int i5 = 20;  
    }     
    public static void main(String[] args) {   
        InnerClassTest01.Inner1 inner1 = new InnerClassTest01(100, 200).new Inner1();               
        System.out.println(inner1.i1);   
        System.out.println(inner1.i2);   
        System.out.println(inner1.i3);   
        System.out.println(inner1.i4);    
    }  
} 

2、静态内部类 

静态内部类不会持有外部的类的引用，创建时可以不用创建外部类；

静态内部类可以访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问。

public class InnerClassTest02 {    
    static int a = 200;    
    int b = 300;    
    static class Inner2 {   
        //在静态内部类中可以定义实例变量 
        int i1 = 10;   
        int i2 = 20;        
        //可以定义静态变量   
        static int i3 = 100;      
        //可以直接使用外部类的静态变量   
        static int i4 = a;      
        //不能直接引用外部类的实例变量   
        //int i5 = b;      
        //采用外部类的引用可以取得成员变量的值   
        int i5 = new InnerClassTest02().b;     
    }      
    public static void main(String[] args) {   
        InnerClassTest02.Inner2 inner = new InnerClassTest02.Inner2();           
             System.out.println(inner.i1);  
    }  
}

 3、局部内部类 

局部内部类是在方法中定义的，它只能在当前方法中使用。

和局部变量的作用一样，局部内部类和实例内部类一致，不能包含静态成员。

public class InnerClassTest03 {    
    private int a = 100;    
    //局部变量，在内部类中使用必须采用 final 修饰  
    public void method1(final int temp) {   
        class Inner3 {        
            int i1 = 10;        
            //可以访问外部类的成员变量    
            int i2 = a;        
            int i3 = temp;  
    }       
    //使用内部类   
    Inner3 inner3 = new Inner3();      
    System.out.println(inner3.i1); 
    System.out.println(inner3.i3); 
  }          
    public static void main(String[] args) {   
        InnerClassTest03 innerClassTest03 = new InnerClassTest03();               
        innerClassTest03.method1(300);  
    }
} 

4、匿名内部类 

是一种特殊的内部类，该类没有名字 

没有使用匿名类 

public class InnerClassTest04 {    
    public static void main(String[] args) {   
        MyInterface myInterface = new MyInterfaceImpl();   
        myInterface.add();  
    }  
} 
 
interface MyInterface { 
 
    public void add();  
} 
 
class MyInterfaceImpl implements MyInterface { 
 
    public void add() {   
        System.out.println("-------add------");   
    }  
}

使用匿名类 

public class InnerClassTest05 { 
    public static void main(String[] args) {   
        /*   MyInterface myInterface = new MyInterface() {    
                    public void add() {     
                    System.out.println("-------add------");      
            }   
    };   
        myInterface.add();   
        */      
    /*   
        MyInterface myInterface = new MyInterfaceImpl();    
        InnerClassTest05 innerClassTest05 = new InnerClassTest05();           
        innerClassTest05.method1(myInterface);   
    */   
        InnerClassTest05 innerClassTest05 = new InnerClassTest05();       
        innerClassTest05.method1(new MyInterface() {    
            public void add() {     
                System.out.println("-------add------");      
          }    
        });     
    }       
    private void method1(MyInterface myInterface) {   
        myInterface.add();  
    } 
} 
 
interface MyInterface { 
 
    public void add();  
} 
 
/* 
class MyInterfaceImpl implements MyInterface { 
 
    public void add() {   
        System.out.println("-------add------");   
        }  
} 
*/