Java的内部类

Java的内部类

　　

首先我们来了解一下什么是内部类?

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

 

为什么要使用内部类?

　　比如我们在new一个接口的时候,我们是不是需要new一个实现接口的类,然后要实现接口中的方法,显得很麻烦,如果是使用内部类的话,可以直接在类中直接new一个接口的实现,显得是很方便的,又例如我们要使用某一个对象的中的方法,我们是不是new这个类出来,然后调用这个类的方法,这样做的话,类文件会大量的存在,为了避免这种情况,我们也可以借助内部类来实现.

 

一. java内部类的分类

　　　　1. 成员内部类

　　　　2. 方法内部类

　　　　3. 匿名内部类

 

成员内部类

public class Test {
     class A{
        public void show(){
            System.out.println("这是一个成员内部类");
        }
    }
    
    /**
     * 在下面方法,构建成员内部类的对象,并调用成员内部类中的方法
     */
    public void test(){
        A a = new A();
        a.show();
    }
    
    public static void main(String[] args) {
        new Test().test();
    }
}

成员内部类方式二

public class Test1 {
    class A {
        public void test(){
            System.out.println("A");
        }
    }
    
    public static void main(String[] args) {
　　　　　　

　　　　　　/**
　　　　　　 * 语法：　外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称() ;
　　　　　　 */

        Test1.A ta = new Test1().new A();
        ta.test();
    }
}

方法内部类

public class B {
    public void show(){
        System.out.println("这是一个方法的外部类");
    }
}

/**
 *     测试方法内部类
 *
 */
public class Test {
    public void test(){
        class A extends B {
            
            public void method(){
                System.out.println("方法内部类的方法只在该方法中调用");
            }    

        }
        
        /**
         * 定义在方法里的类,称为方法的内部类
         * 且方法内部类中的方法要在该方法中调用
         */
        new A().method();
        
        System.out.println("该方法执行完毕");
    }
    
    public static void main(String[] args) {
        Test t = new Test();
        t.test();
    }
}

方法内部类要注意的局部变量问题

public class Test1 {
    private int a = 10 ;
    
    public void show(){
        System.out.println("这是成员的内部类");
    }
    
    /**
     * 方法内部类可以直接调用外部类的成员
     */
    public void test(){
        
        class A {
            public void showA(){
                System.out.println("a= :"+a);
                show() ;
            }
        }
        
        /**
         * 方法内部类,只有在方法内部调用才有效
         */
        new A().showA();
    }
    
    public void test1(){
        /**
         * int c = 10 ;
         * 局部变量是在栈内存的,方法中的变量是随着方法的调用而创建的,随着方法的调用完毕而销毁
         */
        
        /**
         * 为什么final什么的变量就可以呢?因为final是发生在编译期间的,这个时候它已经编译好了,
         * 所以是可以引用的
         */
        final int c = 10 ;
        class B {
            public void showB(){
                System.out.println("c="+c);
            }
        }
        
        /**
         * 而new出来的的对象是在堆内存的,但是等方法调用完毕会,有可能这个对象还没有销毁
         * 但是这个方法已经销毁了,让一个存在的对象要调用一个不存在的变量,显然会报错
         */
        B b = new B();
        b.showB();
    }
}

匿名内部类

　　

　匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。

　　　　什么情况下需要使用匿名内部类？如果满足下面的一些条件，使用匿名内部类是比较合适的：

　　　　　　a·只用到类的一个实例。
　　　　　　b·类在定义后马上用到。
　　　　　　c·类非常小（SUN推荐是在4行代码以下）
　　　　　　d·给类命名并不会导致你的代码更容易被理解。

　　　　在使用匿名内部类时，要记住以下几个原则：

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

/**
 * 定义个接口
 */
public interface TestInterface {
    public void show();
}

/**
 * 
 * 一个类实现一个接口时,要么实现接口中的方法,要么继续抽象
 */
public abstract class Test implements TestInterface{
    public void test(){
        System.out.println("这是抽象类中的方法");
    }
}

public class AnonymousTest extends Test{
    
    public void show() {
        System.out.println("实现了接口中的方法");
    }
}

测试没有带名字的匿名内部类和带名字的匿名内部类

public class Demo {
    public static void main(String[] args) {
        AnonymousTest at = new AnonymousTest();
        at.show();
        at.test();
        
        
        /**
         * 创建了一个没有名字内部类,它实现了TestInterface接口
         * 同时还创建了一个没有名字的内部类对象
         */
        new TestInterface(){

            public void show() {
                System.out.println("实现了接口中的方法");
            }
            
        }.show();
        
        /**
         * 创建了一个没有名字内部类,它是一个抽象类
         * 同时还创建了一个没有名字的内部类对象
         */
        new Test(){

            public void show() {
                System.out.println("实现了接口中的方法");
            }
        };
        
        /**
         * 这是一个带名字的内部类,它是一个接口
         * 同时创建了一个内部类对象
         */
        TestInterface tf = new TestInterface(){

            public void show() {
                System.out.println("这是接口中的方法");
            }
            
        };
        
        /**
         * 这是一个带名字的匿名内部类,它是抽象的类
         * 同时还创建了一个带名字的内部类对象
         */
        Test t = new Test(){

            public void show() {
                System.out.println("带名字的匿名内部类");
            }
        };
        
        /**
         * 调用方法
         * 
         * t.show()是匿名内部类中的方法
         * t.test()是Test抽象类中的方法
         */
        t.show();
        t.test();
    }
}

匿名内部类做参数传递

/**
 *    匿名内部类做参数
 *
 */
public class Demo1 {
    public static void main(String[] args) {
        new Demo1().show(new TestInterface(){

            public void show() {
                System.out.println("匿名内部类做参数");
            }
            
        });
    }
    
    public void show(TestInterface tf){
        tf.show();
    }
}

匿名内部类做返回值

public class Demo2 {
    public static void main(String[] args) {
        TestInterface tf = new Demo2().test();
        System.out.println(tf);
        
        Test t = new Demo2().test1();
        System.out.println(t);
    }
    
    /**
     * TestInterface是一个接口
     * @return TestInterface
     */
    public TestInterface test(){
        return new TestInterface(){

            public void show() {
                System.out.println("匿名内部类做返回值");
            }
            
        };
    }
    
    /**
     * Test是一个抽象类
     * @return Test
     */
    public Test test1(){
        return new Test(){

            public void show() {
                System.out.println("匿名内部类做返回值");
            }
            
        };
    }
}