Java的四种内部类(含代码实例)

 写在前面：本博客为本人原创，严禁任何形式的转载！本博客只允许放在博客园（.cnblogs.com），如果您在其他网站看到这篇博文，请通过下面这个唯一的合法链接转到原文！

本博客全网唯一合法URL：https://www.cnblogs.com/acm-icpcer/p/8575721.html

 

 

Java的四种内部类包括如下：

　　1、成员内部类

　　2、静态内部类

　　3、局部内部类

　　4、匿名内部类

 

现一一说明：

 

1、成员内部类

简单的讲就是：

（1）没有使用static修饰的内部类；
（2）在成员内部类中不允许出现静态变量和静态方法的声明。static只能用在静态常量的声明上。
（3）成员内部类中可以访问外部类中所有的成员(变量，方法)，包含私有成员，如果在内部类中定义有和外部类同名的实例变量，访问方法如下：

OuterClass.this.outerMember;

（4）构建内部类的实例，要求必须外部类的实例先存在。

sample code：

class MemberOuter{     
    private String s1 = "Outer InstanceMar";  
    private String s2 = "OuterStatic s2";  
    public void setS1(String s1) {  
        this.s1 = s1;  
        new MemberOuter().new MemberInner();  
        this.new MemberInner();  //此时MemberOuter已经实例化完成,所以可以使用this  
        new MemberInner().test2();  
    }  
    public static void  test2 (){  
        new MemberOuter().new MemberInner();  
        /*
        this.new MemberInner();   
        此时MemberOuter没有实例化完成,所以不可以使用this 
        static 是在MemberOuter构造器前使用,所以此时this不能使用 
        */  
    }  
  
    class MemberInner{  
        String s1= "Inner  instanceMae  ";  
        static final String s4 = "static final  MemberInner";  
        void test2(){  
            System.out.println(" s1 =" + s1);  
            System.out.println(" Outter MemberOuter.this.s1 =" + MemberOuter.this.s1);  
            System.out.println("s2 = "+s2);  
        }  
    }  
      
}  
  
public class MemberInnerTest {  
    public static void main (String args []){  
    /*  MemberOuter.MemberInner mm =  new MemberOuter().new MemberInner(); 
        mm.test2();*/   
        MemberOuter mo = new MemberOuter();  
        mo.setS1("");   
    }  
}  

 

2、静态内部类

　　静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。

sample code：

public class StaticInnerTest {  
    public static void main(String[] args) {  
  
        StaticOuter.StaticInner si = new StaticOuter.StaticInner();  
        si.test2();  
        //StaticOuter.StaticInner.test();  
        System.out.println("si.b = "+si.b);  
        System.out.println("si.a = "+si.a);  
    //  System.out.println("StaticOuter.b  = "+StaticOuter.b);  这里报错  
    }  
  
}  
  
class StaticOuter {  
private int a = 100;  
private static int b = 150;  
public static void test(){  
    System.out.println("Outer static test ...");  
}  
public  void test2(){  
    System.out.println("Outer instabce test ...");  
}     
  
    static class StaticInner {  
        public  int a = 200;  
        static int b =300;  
        public static void test(){  
            System.out.println("Inner static test ...");  
        }  
        public  void test2(){  
            System.out.println("Inner instance test ...");  
            StaticOuter.test();  
            new StaticOuter().test2();  
            System.out.println("StaticOuter.b  = "+StaticOuter.b);  
        }     
    }  
}  

 

3、局部内部类

简单的说就是：

（1）定义在方法体，甚至比方法体更小的代码块中
（2）类比局部变量。
（3）局部内部类是所有内部类中最少使用的一种形式。
（4）局部内部类可以访问的外部类的成员根据所在方法体不同。
（5）在静态方法中：可以访问外部类中所有静态成员，包含私有；
     在实例方法中：可以访问外部类中所有的成员，包含私有；
     局部内部类可以访问所在方法中定义的局部变量，但是要求局部变量必须使用final修饰。

sample code：

public class LocalInnerTest {  
  
    private int a = 1;  
    private static int b = 2;  
  
    public void test() {  
        final int c = 3;  
        class LocalInner {  
            public void add1() {  
                System.out.println("a= " + a);  
                System.out.println("b= " + b);  
                System.out.println("c= " + c);  
            }  
        }  
        new LocalInner().add1();  
    }  
  
    static public void test2() {  
        final int d = 5;  
        class LocalInner2 {  
            public void add1() {  
                // System.out.println("a= " + a);  
                System.out.println("b= " + b);  
                System.out.println("c= " + d);  
            }  
        }  
        new LocalInner2().add1();  
    }  
  
    public static void main(String args[]) {  
        // LocalInnerTest() lc = new LocalInnerTest();  
        new LocalInnerTest().test2();  
        new LocalInnerTest().test();  
    }  
} 

 

4、匿名内部类

（1）没有名字的局部内部类。
（2）没有class,interface,implements,extends关键字
（3）没有构造器。
（4）一般隐式的继承某一个父类或者实现某一个接口
（5）为了方便和速成而写的类，一般只使用一次，复用性不高。

sample code：

interface innerclass{  
    public void print();  
}  
  
public class Main{  

    public static void main(String[] args)  
    {  
        innerclass A = new innerclass() {  
            public void print() {  
                System.out.println("匿名内部类1");  
            }  
        };  
        A.print();  
        
        innerclass B = new innerclass() {  
            public void print() {  
                System.out.println("匿名内部类2");  
            }  
        };  
        B.print();  
        A.print();  
    }  
    
}

 

 

 

tz@COI HZAU

2018/3/15