内部类（inner class）的简单介绍

本文主要介绍内部类（inner class）的一些基本应用，将从内部类的分类角度，首先对每一个具体内部类进行介绍。主要包括普通的内部类【common inner class】、局部内部类[local inner class]、嵌套内部类【nested innner class】、匿名内部类【anonymous inner class】、然后比较一下局部内部类[local inner class]和匿名内部类【anonymous inner class ]的区别，进而知道在具体情况下该选择内部类，即到底用local inner class还是anonymous inner class。最后介绍内部类的应用。

一：首先对每一个具体内部类进行介绍

1.普通的内部类【common inner class】

定义：在一个类里面直接定义一个类：

一些详细情况看代码：

package com.qls.comonInnerClass;

public class A {
    /**
     * 从B C D E 这四个普通内部类中可以看出类前面的修饰符可以是
     * private  protected default(也就是什么修饰符没有的D) public.  而在局部内部类中修饰类的只能是：
     * abstract 或final 或者什么修饰符都没有。
     * 注意的问题如下：
     * 1.通常情况下:外部类会有一个返回内部类引用的一个方法如getB()这个方法。
     * 2.如何在内部类中用this指代外部类引用？【答：外部类名.this 参考第19行代码。】
     * 以及如何创建内部类的一个实例？【答：x.new B() 其中x是外部类的一个实例，B为一个内部类。
     * 若是直接写new B()会报错。参考第38、39两行代码。】
     * 上述两个注意点对其他的内部类也适用。
     * @author 秦林森
     *
     */
    private  class B {
        public A outer(){
            return A.this;//A.this是指代A的一个引用。
        }
    }
    protected class C{
        
    }
    class D{
        
    }
    public class E{
        
    }
    /**
     * 返回内部类的引用：
     */
    B getB(){
        return new B();
    }
    public static void main(String[] args) {
        A a = new A();
        B b = a.new B();
    }
}

局部内部类【local innner class】

定义：把类定义在方法里面，或者是方法中的某一个区域中。

代码如下：

package com.qls.localInnerClass2;
/**
 * 定义：the creation of an entire class within the scope of a method,or Nesting a class within 
 * a scope of a method.
 * This is called a local inner class.
 * 注意情况如下：
 * 1.局部内部类【local inner class】如果想要修饰的话，只有abstract 和final可以，
 * 其余的如(public protected)等都不可以。
 * 2.在局部内部类中只能访问包含该内部类的范围(enclosing scope)的final变量。若不是则会报错。
 * 
 * @author 秦林森
 *
 */
public class A {
    public void ouyangfeng(){
        //把类D定义在方法ouyangfeng()的某个区域中。
        if(3>2){
            class D{
                
            }
        }
        final class B{
            
        }
    }
    
    public void  sixi(final String s){
        int e=1;
        final int c=8;
        class C{
            /**
             * 在局部内部类或者匿名内部类中只能访问包含该内部类的范围(enclosing scope)的final变量。
             * 若不是则会报错。
             * 如int f=e；编译器报错。
             */
            String str=s;
            int d=c;
//            int f=e;//编译器报错。
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}

匿名内部类：没有名字的内部类。

下面的代码介绍了以下的内容：

1.匿名内部类实现一个接口，

2.匿名内部类实现一个没有默认构造方法的抽象类

3.匿名内部类和局部内部类一样把参数定义成final，完成字段初始化

4.匿名内部类用普通代码块{}完成初始化，弥补了匿名内部类没有构造方法的缺陷。

代码如下：

package com.qls.anonymouseInnerClass;
/**
 * 匿名内部类(anonymous inner class)一般用在return 语句中。
 * 注意情况如下：
 * 匿名内部类由于没有名字，自然而然也就没有构造方法，其他三种内部类都有构造方法。
 * 没有构造方法怎么给对象赋值进行初始化呢？【答：用普通的代码块{},在这个代码块里面实行初始化。】
 * @author 秦林森
 *
 */
interface B{
    void ouyangfeng();
}
abstract class C{
    private int i;
    public C(int i) {
        this.i=i;
    }
    public abstract int value();
    
}
public class A {
    public B getB(){
        //new B(){};就是匿名内部类：用默认的构造方法
        return new B() {
            
            @Override
            public void ouyangfeng() {
                // TODO Auto-generated method stub
                System.out.println("ouyangfeng is chief village of sixi ");
            }
        };
    }
    public C getC(final int i){
        //匿名内部类用一个带参数的构造方法
        return new C(i) {
            //用普通代码块实现初始化：
            {
                //这里写两个输出语句作为演示。
                System.out.println("泗溪");
                System.out.println("ouyangfeng");
                System.out.println(value());//输出value的值
            }
            @Override
            public int value() {
                // TODO Auto-generated method stub
                return i;//从这里可以看出要想引用i,必须把i定义成final。这和局部内部类一样。
            }
        };
        
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new A().getC(4);//输出泗溪、ouyangfeng、4
        
    }

}

 嵌套内部类：

package com.qls.nestedClass;
/**
 * 如果你不想让内部类的对象和外部类的对象有如何联系的话，你就可以把内部类定义成static
 * 嵌套内部类(Nested inner class)的定义：类中关键词static修饰的内部类。
 * 注意情况如下：
 * 1.在嵌套内部类中不能访问外部类的非静态变量。
 * 2.创建内部类变量时，你不想通过创建外部类变量才能创建内部类变量时，你可以把这个内部类定义成static
 * 即嵌套内部类。
 * 3.在接口interface中定义的内部类默认都是public static 的，所以在接口中的内部类必是嵌套内部类。
 * @author 秦林森
 *
 */
interface D{
    void hello();
    class Test implements D{

        @Override
        public void hello() {
            // TODO Auto-generated method stub
            System.out.println("hello");
        }
        public static void main(String[] args) {
            /**
             * 由于Test类默认是public static 的，所以创建Test对象时，不需要通过外部类D，
             * 所以直接new Test()即可创建Test类中的一个对象。
             * 话又说回来了，如果在接口中的类不是public static 的那么这个内部类也就是普通的内部类
             * 在创建Test的对象时，也就需要外部类的对象。关键D是接口，你怎么new 呢？
             * 所以在的类只能是static 的。
             */
            new Test().hello();//输出hello
        }
    }
}
public class A {
    int a=9;
    public static  class B{
//        int b=a;编译报错
         void f(){
            System.out.println("f()");
        }
    }
    public static void main(String[] args) {
        /**
         * 从这里你看到了，可以对B直接new ，访问B中的函数f().
         * 但是如果B没有static这个关键字，即B是普通内部类时，必须这样才能访问到f()
         * new A().new B().f();
         */
        new B().f();
    }
}

 二：比较一下局部内部类[local inner class]和匿名内部类【anonymous inner class ]的区别

1.匿名内部类没有构造犯法，二局部内部类有构造方法。

2.如果在一个外部类有两个或两个以上的方法，返回的都是某个接口或者抽象类的引用，建议把写一个局部内部类。若写成匿名内部类时，代码会显得特别冗长。反之如果一个时，建议用匿名内部类。

代码如下：

package com.qls.anonymouseInnerClass;
interface Six{
    void six();
}
public class Ouyangfeng {
    private class SixTest implements Six{

        @Override
        public void six() {
            // TODO Auto-generated method stub
            
        }
        
    }
    public Six f(){
        return new SixTest();
    }
    public Six g(){
        return new SixTest();
    }
}

三：内部类的应用：

用内部类实现java的多重继承。

package com.qls.anonymouseInnerClass;
class D{
    
}
abstract class E{
    
}
class F extends D{
    //这是实现多重继承的核心代码。这里是用一个匿名内部类实现
    E makeE(){
        return new E() {
        };
    }
}
public class MultipleInherit {
    public static void takesD(D d){
        
    }
    public static void takesE(E d){
        
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        F d = new F();
        takesD(d);
        takesE(d.makeE());
    }

}

最后简要介绍一下让一个类继承另一个类中的内部类？以及怎么让一个类中的内部类继承另一个类的内部类呢？

首先是：让一个类继承另一个类中的内部类

 代码如下：

package com.qls.anonymouseInnerClass;

import com.qls.anonymouseInnerClass.WithInner.Inner;

class WithInner{
    class Inner{
        private int a;
        public Inner(int a) {
            this.a=a;
        }
        public Inner() {
            // TODO Auto-generated constructor stub
        }
    }
}
public class InheritInner extends Inner{
    public InheritInner(WithInner withInner) {
        // TODO Auto-generated constructor stub
        /**
         * 这句话必须要写。否则编译器会报错。即：外部类的一个对象.super().
         * 这里的super()，比奥斯Inner的一个默认构造方法。
         * 如果Inner中比如有这样一个构造方法：public Inner(int a) 
         * 你现在也可以写成：把withInner.super();改为withInner.super(1);编译器是不会报错的。
         * 如果没有默认构造方法public Inner() 则这题必须写成：withInner.super(1);的形式。
         */
        
        withInner.super();
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        WithInner withInner = new WithInner();
        InheritInner inheritInner = new InheritInner(withInner);
    }

}

 让一个类中的内部类继承另一个类的内部类

代码如下：

package com.qls.anonymouseInnerClass;
/**
 * 朱元璋家住凤阳，刘伯温家住青田
 * @author 秦林森
 *
 */
class ZhuYuanZhang{
    class FengYang{
        private String location;

        public FengYang(String location) {
            this.location = location;
        }
        
    }
}
class LiuBoWei{
    class QingTian extends ZhuYuanZhang.FengYang{
        private String location;
        public QingTian(ZhuYuanZhang zhuYuanZhang, String location) {
            zhuYuanZhang.super(location);//这句话必须要写。或者会报错，
            this.location=location;
        }
        public void accurate(){
            System.out.println("一统江山刘伯温 ，家在"+location);
        }
    }
}
public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new LiuBoWei().new QingTian(new ZhuYuanZhang(), "青田").accurate();
    }

}/*Output:
一统江山刘伯温 ，家在青田*///:~