JAVA技能专题综述之内部类篇

副标题#e#

有些类的界说中包括另一个类的界说。这种处于内部的类称为内部类(inner class)。

譬喻：

public class OuterClass
{
public class InnerClass
{
//---This is a inner class.
}
}

InnerClass类嵌套在OuterClass中，而且被声明为public，因此被OuterClass类之外的工具会见。

InnerClass类没有被声明为OuterClass类的一个静态成员，因此除非生成了一个OuterClass工具，不然无法生成任何InnerClass工具。可是，当你声明一个包括嵌套类的类工具时，并不必然会生成嵌套类的工具，这主要由包括嵌套类的类的结构要领抉择。

示例1：

class OuterClass
{
class InnerClass
{}
}
public class Test
{
public static void main(String[] args)
{
OuterClass out = new OuterClass();
OuterClass.InnerClass in = out.new InnerClass();
}
}

我们利用OuterClass out = new OuterClass();语句生成了一个OuterClass类工具。然后又利用OuterClass.InnerClass in = out.new InnerClass();语句借助外部类的实例生成了一个内部类的工具。main()要领中的两条语句也可以用下面的这一条语句替换：

OuterClass.InnerClass in = new OuterClass().new InnerClass();

总之：在一个类(Test)中，建设另一个类(OuterClass)中的非静态内部类(InnerClass)必需要借助这个外部类(OuterClass)的一个实例。并且这个内部类工具的声明也必需用OuterClass.InnerClass的形式。

示例2：

public class Test
{
class InnerClass
{}
1
public static void main(String[] args)
{
InnerClass in = new Test().new InnerClass();
}
}

在main()要领中实例化本类的内部类可以用上例的形式。

示例3：

public class Test
{
class InnerClass
{}
InnerClass in = new InnerClass();
public static void main(String[] args)
{}
}

#p#副标题#e#

在main()要领外，实例化本类的内部类就和我们泛泛的操纵一样了。

示例4：

public class Test
{
class InnerClass
{}
public void method()
{
InnerClass in = new InnerClass();
}
public static void main(String[] args)
{}
}

在本类的非静态要领中，实例化本类的内部类也和我们泛泛的操纵一样。

为了让内部类的工具不依赖于外部类的工具，你可以把内部类声明为static。

示例5：

class OuterClass
{
static class InnerClass
{}
}
public class Test
{
public static void main(String[] args)
{
2
OuterClass.InnerClass in = new OuterClass.InnerClass();
}
}

从这个例子我们可以看出：建设InnerClass类的工具不再需要OuterClass类的工具。但依然要用OuterClass.InnerClass这个形式声明in工具。

示例6：

class Outer
{
static int outer_stat = 0;
int outer_non_stat = 1;
static class StaticInner
{
static int stat = 2;
static int stat_test = outer_stat;
public void tester()
{
System.out.println("outer_stat = " + outer_stat);
}
}
class NonStaticInner
{
public void tester()
{
System.out.println("outer_stat = " + outer_stat);
System.out.println("outer_non_stat = " + outer_non_stat);
System.out.println("StaticInner.stat = " + StaticInner.stat);
}
}
}
public class Test
{
public static void main(String[] args)
{
new Outer().new NonStaticInner().tester();
System.out.println("------------");
new Outer.StaticInner().tester();
}
}
输出功效：
outer_stat = 0
outer_non_stat = 1
StaticInner.stat = 2
3
------------
outer_stat = 0

NonStaticInner类中的System.out.println("outer_stat = " + outer_stat);语句说明：非静态内部类的非静态成员可以会见外部类的静态变量。

System.out.println("outer_non_stat = " + outer_non_stat);语句说明：非静态内部类的非静态成员可以会见外部类的非静态变量。

System.out.println("StaticInner.stat = " + StaticInner.stat);语句说明：非静态内部类的非静态成员可以会见沟通外部类下的静态内部类的静态变量。

StaticInner类中的System.out.println("outer_stat = " + outer_stat);语句说明：静态内部类的非静态成员可以会见外部类的静态变量。

static int stat_test = outer_stat;语句说明：静态内部类的静态成员可以会见外部类的静态变量。

#p#副标题#e#

留意：静态内部类可以有静态成员，而非静态内部类则不能有静态成员。

示例7：

#p#分页标题#e#

class Outer
{
public void tester()
{
class Inner
{}
}
}
public class Test
{
public static void main(String[] args)
{}
}

可以在一个要领中界说一个类，这个类称为当地内部类。只能在当地，也就是说在该类界说呈现的要领中生成一个当地内部类的工具。这种处理惩罚合用于一个要领中的计较要求利用一种非凡的类，而这个类在其他处所基础不需要的时候。

当地内部类可以引用其界说呈现地址的要领中声明的变量，当且仅当这种变量是final型的。请看示例8。

示例8：

class Outer
{
public void tester()
{
final int i = 5;
class Inner
{
int j = i;
4
}
Inner in = new Inner();
}
}
public class Test
{
public static void main(String[] args)
{}
}

最厥后讲授匿名内部类。简朴地说：匿名内部类就是没有名字的内部类。什么环境下需要利用匿名内部类？假如满意下面的一些条件，利用匿名内部类是较量符合的：

·只用到类的一个实例。

·类在界说后顿时用到。

·类很是小（SUN推荐是在4行代码以下）

·给类定名并不会导致你的代码更容易被领略。

在利用匿名内部类时，要记着以下4个原则：

·匿名内部类不能有结构要领。

·匿名内部类不能界说任何静态成员、要领和类。

·匿名内部类不能是public,protected,private,static。

·只能建设匿名内部类的一个实例。

#p#副标题#e#

下面是匿名内部类的用法举例。请读者通过例子来体会匿名内部类的用法。

示例9：（留意：匿名内部类以";"竣事）

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Test extends JFrame
{
Test()
{
super("test_title");
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
JButton btn = new JButton("close");
cp.add(btn);
btn.addActionListener(act);
setSize(300,200);
}
ActionListener act = new ActionListener()
{
public void actionPerformed(ActionEvent e)
5
{
System.exit(0);
}
};
public static void main(String[] args)
{
Test test = new Test();
test.setVisible(true);
}
}

示例10：（按照示例8改编）

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Test extends JFrame
{
Test()
{
super("test_title");
Container cp = getContentPane();
cp.setLayout(new FlowLayout());
JButton btn = new JButton("close");
cp.add(btn);
btn.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
System.exit(0);
}
});
}
public static void main(String[] args)
{
Test test = new Test();
test.setSize(300,200);
test.setVisible(true);
}
}

示例11：

 

public class Test
{
public static void main(String[] args)
6
{
Thread r = new Thread()
{
public void run()
{
for(int k=0;k<10;k++)
{
System.out.print(k);
}
}
};
r.start();
}
}

示例12：（按照示例11改编）

public class Test
{
public static void main(String[] args)
{
new Thread(new Runnable()
{
public void run()
{
System.out.println("run");
}
}).start();
}
}

示例11和12的措施并没有什么实际用处，在实际编程时险些没有人这样写措施。但这两个措施有助于我们领略匿名内部类的用法。