Wu Yudong's Blog

原创文章，转载请注明： 转载自工学1号馆

java内部类分为： 非静态内部类、静态内部类、局部内部类、匿名内部类

内部类的共性：

(1)内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。

(2)内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的 。

(3)内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量 。

java 中的内部类和接口加在一起，可以的解决常被 C++ 程序员抱怨 java 中存在的一个问题：没有多继承。实际上，C++ 的多继承设计起来很复杂，而 java 通过内部类加上接口，可以很好的实现多继承的效果。

非静态内部类

当一个类作为另一个类的非静态成员，则这个类就是一个非静态内部类。

创建非静态内部类是很容易的，只需要定义一个类让该类作为其他类的非静态成员。该非静态内部类和成员变量或者成员方法没有区别，同样可以在非静态内部类前面加可以修饰成员的修饰符。创建非静态内部类的基本语法如下所示：

class OutClass {
    class InClass {
        //内部类成员
    }
    //外部类成员
}

在内部类的程序中，是经常会进行外部类和内部类之间访问的。在外部类中访问内部类是很容易的，只要把内部类看成一个类，然后创建该类的对象，使用对象来调用内部类中的成员就可以了。

在外部类中访问内部类的程序–举个例子：

class OutClass {
    class InClass {    //创建非静态内部类
        int i = 5;    //内部类成员
    }
    public void fun() {    //外部类成员
        InClass in = new InClass();    //创建一个内部类对象
        int i = in.i;        //访问内部类成员
        System.out.println("InClass's var is: " + i);
    }
}
public class javatest {  
    public static void main(String args[ ]) { 
         OutClass out = new OutClass();
         out.fun();
   }
}

运行结果：

InClass’s var is: 5

分析：在main方法中，首先创建一个外部类对象，然后访问外部类的成员方法。在外部类的成员方法中，创建了一个内部类对象，然后使用内部类对象调用内部类的成员变量，从而得到结果。编译该程序将产生三个class文件，分别是主类、外部类和内部类。内部类产生的class文件的名称为OutClass$InClass.class，在该名称中可以区分该内部类到底是哪一个类的内部类。

不但可以在外部类中访问内部类，还可以在外部类外访问内部类。在外部类外访问内部类的基本语法如下所示。

OutClass.InClass oi=new OutClass().new InClass();

使用该方法就能够创建一个内部类对象，使用该内部类对象就可以访问内部类的成员。该方法是不容易理解的，可以分为下面的两条语句：

Wai w=new Wai();

Wai.Nei wn=w.new Nei();

这样就很容易理解了。首先是创建一个外部类的对象，然后让该外部类对象调用创建一个内部类对象。

在外部类外访问内部类的程序—举个例子：

class OutClass {
    class InClass {    //创建非静态内部类
        int i = 5;    //内部类成员
        int j = 6;
    }
}
public class javatest {  
    public static void main(String args[ ]) { 
        OutClass.InClass oi1 = new OutClass().new InClass();
        OutClass ocClass = new OutClass();
        OutClass.InClass oi2 = ocClass.new InClass();
        System.out.println("InClass's var i is: " + oi1.i);
        System.out.println("InClass's var j is: " + oi1.j);  
   }
}

在示例代码中使用了两种方法来从外部类外访问内部类。在外部类外访问内部类时，是不能够直接创建内部类对象的，因为内部类只是外部类的一个成员。所以要想创建内部类对象，首先要创建外部类对象，然后以外部类对象为标识来创建内部类对象。

在内部类中访问外部类

在内部类中访问外部类，就像所有的同一个类中成员互相访问一样，这样是没有限制的，包括将成员声明为private私有的。

举个例子：

class OutClass {
    int i = 8;    //外部类成员变量
    class InClass {    //创建非静态内部类
        public void fun() {
            System.out.println("OutClass's var is: " + i);
        }
    }
}
public class javatest {  
    public static void main(String args[ ]) { 
        OutClass oc = new OutClass();    //创建外部类对象
        OutClass.InClass oi = oc.new InClass();    //创建内部类对象
        oi.fun();    //调用内部类中的成员
   }
}

在示例代码中，在内部类中定义了一个fun来访问外部类中的成员变量i。可以看到从内部类中访问外部类是非常容易的，不需要添加任何内容，就像成员方法间调用一样。如果外部类中也有一个成员变量i，得到的是内部类成员变量的值。下面通过示例代码解决这个问题：

class OutClass {
    int i = 8;    //外部类成员变量
    class InClass {    //创建非静态内部类
        int i = 9;
        OutClass oc = new OutClass();
        public void fun() {    //内部类成员
            System.out.println("InClass's var is: " + i);
            System.out.println("OutClass's var is: " + oc.i);
        }
    }
}
public class javatest {  
    public static void main(String args[ ]) { 
        OutClass oc = new OutClass();    //创建外部类对象
        OutClass.InClass ic = oc.new InClass();    //创建内部类对象
        ic.fun();    //调用内部类中的成员
   }
}

在本程序中先定义了一个外部类的成员变量，接着定义了一个内部类的成员变量，这两个成员变量的名称是相同的。而在内部直接访问时，将访问的是内部类的成员变量。要想访问外部类成员变量，就需要首先创建一个外部类对象，然后使用该对象调用外部类成员变量。

局部内部类

局部内部类的作用范围是和局部变量的作用范围相同的，只在局部中起作用，所以对局部内部类进行访问时，只能在该局部内部类的作用范围内。

举个例子：

class OutClass {
    public void fun() {    
        class InClass {    //定义一个局部内部类
            int i = 5;    //局部内部类的成员变量
        }
        InClass ic = new InClass();
        System.out.println("InClass's var is: " + ic.i);
    }
}
public class javatest {  
    public static void main(String args[ ]) { 
        OutClass oc = new OutClass();
        oc.fun();
   }
}

在本程序中定义了一个局部内部类，并进行了对该局部内部类的访问。对该内部类进行访问必须在该内部类所在的方法中通过创建内部类对象来进行访问。这是因为这里的内部类是作为局部成员的形式出现的，只能在它所在的方法中进行调用。

局部内部类中访问外部类成员变量

举个例子：

class OutClass {
    int i = 9;    //定义一个外部类的成员变量
    public void fun() {    
        class InClass {    //定义一个局部内部类
            public void Infun() {
                System.out.println("OutClass's var is: " + i);    //访问外部类中的成员变量
            }
        }
        InClass ic = new InClass();    //创建内部类对象
        ic.Infun();    //调用内部类中的成员方法
    }
}
public class javatest {  
    public static void main(String args[ ]) { 
        OutClass oc = new OutClass();    //创建外部类对象
        oc.fun();    //调用内部类中的成员
   }
}

在示例代码中定义了一个局部内部类，在该局部内部类中定义了一个方法来访问外部类的成员变量。

在局部内部类中访问外部类的局部变量

和访问外部类的成员变量不同，在局部内部类中访问外部类中和局部内部类在同一局部的局部变量是不能够直接访问的。

举个例子（下面是一段错误的代码）：

class OutClass {
    public void OutFun() {
        int i = 9;
        class InClass {
            public void InFun() {
                System.out.println("OutClass's var is: " + i);//访问外部类的成员变量
            }
        }
        InClass ic = new InClass();    //创建内部类对象
        ic.InFun();    //调用内部类中的成员方法
    }
}
public class javatest {  
    public static void main(String args[ ]) { 
        OutClass oc = new OutClass();    //创建外部类对象
        oc.OutFun();    //调用内部类中的成员
   }
}

运行产生异常:

Exception in thread “main” java.lang.Error: Unresolved compilation problem:
Cannot refer to a non-final variable i inside an inner class defined in a different method

运行该程序是会发生错误的，错误信息为“从内部类中访问局部变量i；需要被声明为最终类型”。在局部内部类中访问外部类的局部变量是不能够访问普通的局部变量的，必须将该局部变量声明为final。

静态方法中的局部内部类

局部内部类定义在非静态方法和静态方法中是不同的，在前面例子都是将局部内部类定义在非静态方法中，下面就来学习静态方法中定义局部内部类的情况。在静态方法中定义的局部内部类要想访问外部类中的成员，该成员必须是静态成员。

class OutClass {
    static int i = 4;
    public static void OutFun() {    //外部类成员
        class InClass {
            public void InFun() {
                System.out.println("OutClass's local var is: " + i);
            }
        }
        InClass ic = new InClass();
        ic.InFun();
    }
}
public class javatest {  
    public static void main(String args[ ]) { 
        OutClass.OutFun();
   }
}

静态内部类

class OutClass {
    static class InClass {
        //内部类成员
    }
    //外部类成员
}

在外部类中访问静态内部类

在外部类中访问静态内部类和在外部类中访问非静态内部类一样的，只需要从成员间访问的角度就可以考虑到这一点。举个例子：

class OutClass {
    static class InClass {    //创建静态内部类
        int i = 5;    //内部类成员
    }
    public void OutFun() {    //外部类成员
        InClass ic = new InClass();    //创建一个内部类对象
        int ii = ic.i;    //访问内部类成员
        System.out.println("static InClass's var is: " + ii);
    }
}
public class javatest {  
    public static void main(String args[ ]) { 
        OutClass oc = new OutClass();    //创建外部类对象
        oc.OutFun();    //调用内部类中的成员
   }
}

在外部类中访问静态内部类和访问非静态内部类是相同的，但是在外部类中访问静态内部类和非静态内部类就不再相同。因为静态内部类是外部类的静态成员，静态成员是不需要外部类对象而存在的，所以在外部类外，对静态内部类进行访问时是不需要创建外部类对象的。

注意：因为静态内部类是外部类的静态成员，静态成员是不需要外部类对象而存在的，所以在外部类外，对静态内部类进行访问时是不需要创建外部类对象的。

匿名内部类

在所有的内部类中最难的就应该是匿名内部类。匿名内部类从名字上看就知道是没有类名的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写，

但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

创建匿名内部类

在创建匿名内部类中将使用到继承父类或者实现接口的知识，匿名内部类是没有名字的，所以在创建匿名内部类时同时创建匿名内部类的对象。创建匿名内部类的语法格式如下：

new InFather() {
    //匿名内部类
};

在创建匿名内部类的语法中，InFather是匿名内部类继承的父类的类名，使用new同时创建了匿名内部类的对象。在匿名内部类中可以重写父类中的方法，也可以定义自己的方法。

实例1:不使用匿名内部类来实现抽象方法

abstract class Person {
    public abstract void eat();
}
 
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
public class test {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

运行结果：

eat something

可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用。但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类会很麻烦。这个时候就引入了匿名内部类

实例2：匿名内部类的基本实现

abstract class Person {
    public abstract void eat();
}
public class test {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

运行结果：

eat something

可以看到，我们直接将抽象类Person中的方法在大括号中实现了，这样便可以省略一个类的书写，并且匿名内部类还能用于接口上

实例3：在接口上使用匿名内部类

interface Person {
    public void eat();
}
public class test {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

运行结果：

eat something

由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现。最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口

实例4：Thread类的匿名内部类实现

public class test {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        t.start();
    }
}

运行结果：

1 2 3 4 5

实例5：Runnable接口的匿名内部类实现

public class test {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        Thread t = new Thread(r);
        t.start();
    }
}

运行结果：

1 2 3 4 5