JAVA内部类

来源：互联网发布：剑三苍云正太捏脸数据编辑：程序博客网时间：2024/05/01 15:30

//StaticCls.java

public class StaticCls{
public static void main(String[] args){
//  OuterCls ci = new StaticCls().new OuterCls();//method 3 replace 2.1
//  OuterCls.InnerCls oi=new OuterCls.InnerCls();//method 1
  OuterCls ci = new OuterCls();//method 2.1
  OuterCls.InnerCls oi = ci.new InnerCls();//method 2.2
}
}//if we use method 3 ,we must put OuterCls into the StaticCls

class OuterCls{
OuterCls(){
  System.out.println("OuterCls");
}
// public static class InnerCls{//1 public or default? Please have a try
public class InnerCls{
  InnerCls(){
   System.out.println("InnerCls");
  }
}
}

//xTest.java

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 xTest{
public static void main(String[] args){
  new Outer().new NonStaticInner().tester();
  System.out.println("------------");
  new Outer.StaticInner().tester();
}
}

JAVA技术专题综述之内部类篇
来源：IT网络学院 2003年5月8日11:6

　　有些类的定义中包含另一个类的定义。这种处于内部的类称为内部类(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)
{}
}

　　在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;语句说明：静态内部类的静态成员可以访问外部类的静态变量。
注意：静态内部类可以有静态成员，而非静态内部类则不能有静态成员。

　　示例7：

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。
　　·只能创建匿名内部类的一个实例。

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

　　示例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的程序并没有什么实际用处，在实际编程时几乎没有人这样写程序。但这两个程序有助于我们理解匿名内部类的用法。