JAVA内部类

转载 2004年08月19日 22:37:00

//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 
{} 

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) 


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 

------------ 
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; 


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) 


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) 


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

Java内部类(DOC)

  • 2009年10月21日 13:31
  • 57KB
  • 下载

java 内部类应用

  • 2008年10月17日 09:06
  • 31KB
  • 下载

Java 接口 内部类

  • 2011年08月05日 21:07
  • 205KB
  • 下载

java内部类解析.......

  • 2009年10月27日 23:46
  • 239KB
  • 下载

java 四种内部类 使用细节(含代码)

一: 内部类     定义在类体部,方法体部,甚至比方法体更小的代码块内部的类(if 语句里面等)     1.静态内部类(内部类中最简单的形式)         1.声明在类体部,方法体外,并...
  • qq_33599978
  • qq_33599978
  • 2017-04-27 23:28:19
  • 5223

java内部类的四大作用

放在一个类的内部的类我们就叫内部类。 二、 作用 1.内部类可以很好的实现隐藏  一般的非内部类,是不允许有 private 与protected权限的,但内部类可以 2.内部类拥有外围类的所...
  • mid120
  • mid120
  • 2016-12-14 19:25:51
  • 5654

Java日记——获取内部类的几种方式

内部类用于增强类与类的耦合关系,也是经常会用到的,下面是几种在静态方法中获取内部类的方式1.内部类设为静态类public class TestInnerClass { public stati...
  • qq_32198277
  • qq_32198277
  • 2017-05-21 08:31:11
  • 2089

内部类的.this和.new

1.在内部类中,外部类名+.this是生成外部类对象的引用。此会在编译器受检,没有任何运行时开销。 package Inner; public class DotThis { void f(){...
  • u011514810
  • u011514810
  • 2016-04-23 11:55:44
  • 1132

java 什么时候使用内部类

java中的内部类和接口加在一起,可以的解决常被C++程序员抱怨java中存在的一个问题 没有多继承。...
  • l732427480
  • l732427480
  • 2016-06-25 20:01:27
  • 1185

java内部类常见面试题汇总

1.根据注释填写(1),(2),(3)处的代码 public class Test{ public static void main(String[] args){ /...
  • tomcat_2014
  • tomcat_2014
  • 2016-04-18 17:13:41
  • 3351
收藏助手
不良信息举报
您举报文章:JAVA内部类
举报原因:
原因补充:

(最多只允许输入30个字)