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("匿名内部类做返回值");
             }

         };
     }
 }