java内部类和匿名类从入门到深入

1 内部类
⏹内部类定义：
⏹在A类的内部但是所有方法的外部定义了一个B类，则B类就是A类
的内部类，A是B的外部类
⏹内部类访问原则
⏹内部类的方法可以访问外部类所有的成员
⏹外部类的方法不可以直接访问内部类的成员
⏹内部类的优点：
⏹可以让一个类方便的访问另一个类中的所有成员
⏹增加程序的安全性，有效避免其他不相关类对该类的访问
⏹何时使用内部类
⏹如果一个A类要使用B类的所有成员，并且A类不需要被除B类以外
的其他类访问，则我们应当把A类定义为B类的内部类
⏹class A{
⏹private int i = 1;
⏹private void f(){
⏹}
⏹
⏹//B是A的内部类
⏹class B{
⏹public int bi = 10;
⏹
⏹//非静态的内部类可以访问外部类所有的成员
⏹public void g(){
⏹System.out.printf("i = %d\n", i);
⏹f();
⏹}
⏹}
⏹
⏹public void k(){
⏹//g(); //error 外部类的方法不可以直接访问内部类的成员
⏹//System.out.println(bi); //error 外部类的方法不可以直
接访问内部类的成员
⏹
⏹ B bb = new B();
⏹bb.g();
⏹}
⏹}
⏹public class Test{
⏹public static void main(String[] args){
⏹ A aa = new A();
⏹aa.k();
⏹}
⏹}
本程序证明了：
•外部类的方法不可以直接访问内部类的成员
•内部类的方法却可以访问外部类的所有成员
匿名类
⏹匿名类是一种特殊的内部类
⏹如果在一个方法内部定义了一个匿名类，则该匿名类可以访问
⏹外部类的所有成员
⏹包裹本匿名类的方法中的所有final类型的局部变量，非fianl类型的
局部变量无法被匿名类访问
⏹import java.awt.*;
⏹import java.awt.event.*;
⏹public class TestWindow
⏹{
⏹public static void main(String[] args)
⏹{
⏹//如果把10行的final去掉，本程序在18行就会报错,
⏹ //因为匿名类只能访问包裹它的方法中的final类型的局部变量
⏹final Frame f = new Frame(); //10
⏹ f.setSize(200, 200);
⏹ f.addWindowListener(
⏹new WindowAdapter()
⏹{
⏹public void
windowClosing(WindowEvent e)
⏹{
⏹ f.setVisible(false);//18行
⏹System.exit(-1);
⏹}
⏹}
⏹);
⏹ f.setVisible(true);
⏹}
⏹}
创建匿名类的三种方式
⏹继承父类
⏹实现接口
⏹实现抽象类
创建匿名类之实现接口
⏹假设Ａ是接口名
new A()
{
实现接口中方法的代码
};
⏹功能：
⏹生成一个实现了A接口的匿名类
创建匿名类之实现抽象类
⏹假设A是抽象类
⏹格式：
⏹new A()
⏹{
⏹实现了A类的所有抽象类的方法代码
⏹添加自己的方法或属性代码【不建议，因为没有实际意义】
⏹}
⏹功能：
⏹生成一个匿名类，该匿名类必须得实现了A类的所有抽象方法，当然该
匿名类也可以定义自己的属性和方法
创建匿名类之继承父类
⏹假设A是个类名
⏹格式：
⏹new A()
⏹{
⏹重写了A类的方法代码
⏹添加自己的属性和方法【不建议，因为没有实际意义】
⏹}
⏹生成一个A类的子类对象，该匿名类对象继承了A的所有非private
成员
class A{
private int i = 1;
private void f(){
System.out.println("哈哈");
}
//B是A的内部类
class B{
public int bi = 10;
//非静态的内部类可以访问外部类所有的成员
public void g(){
System.out.printf("i = %d\n", i);
f();
}
}
public void k(){
//g(); //error 外部类的方法不可以直接访问内部类的成员
//System.out.println(bi); //error 外部类的方法不可以直接访问内部类的成员
B bb = new B();
bb.g();
}
}
public class Test{
public static void main(String[] args){
A aa = new A();
aa.k();
}
}
/*
假设Ａ是接口名
new A()
{
实现接口中方法的代码
};
功能：生成一个实现了A接口的匿名类
*/
interface It
{
void f();
//void g(); // 如果该语句生效的话，21行到27行的代码中就必须的实现g 方法
}
public class TestAnonyClass_1
{
public static void main(String[] args)
{
It it = new It()
{ //21行
public void f()
{
System.out.println("哈哈");
}
}; //27行
//error
// It it = new It1()
// ( //是{ 不是(
// public void f()
// {
// System.out.println("哈哈");
// }
// ); // 是} 不是)
//error
// It it = new It()
// (
// {
// public void f()
// {
// System.out.println("哈哈"); // }
// }
// ;
it.f();
}
}
/*
假设A是抽象类
new A()
{
实现了A类的所有抽象类的方法代码
添加自己的方法或属性代码【不建议，因为没有实际意义】}
功能：生成一个匿名类，该匿名类必须得实现了A类的所有抽象方法，当然该匿名类也可以定义自己的属性和方法
*/
abstract class A
{
abstract public void f();
public void g()
{
}
}
public class TestAnonyClass_2
{
public static void main(String[] args)
{
A aa = new A()
{
//f方法不可以被注释掉, 因为f是抽象方法，匿名类必须的实现
public void f()
{
System.out.println("FFFF");
}
//g方法可以被注释掉
public void g()
{
System.out.println("GGGG");
}
public void k()
{
}
};
aa.f();
aa.g();
//aa.k();
}
}
/*
在JDK 1.6中的运行结果是：
-----------------------------
FFFF
GGGG
-----------------------------
*/
/*
假设A是个类名
new A()
{
重写了A类的方法代码
自己添加的属性和方法【【不建议，因为没有实际意义】】}
功能：生成一个A类的子类对象，该匿名类对象继承了A的所有非private成员
*/
class A
{
public void f()
{
System.out.println("哈哈");
}
}
public class TestAnonyClass_3
{
public static void main(String[] args)
{
A aa = new A()
{
//重写了父类A的方法
public void f()
{
System.out.println("嘿嘿");
}
//可以定义自己的方法，但没有任何实际意义
public void g()
{
System.out.println("GGGG");
}
};
aa.f();
//aa.g(); //error
}
}
/*
在JDK 1.6中的运行结果是：
-----------------------------
FFFF
GGGG
-----------------------------
*/
/*
2009年6月25日16:14:23
文本框内容相加方法一：
主函数代码过多
程序逻辑混乱
不推荐
*/
import java.awt.*;
import java.awt.event.*;
public class TestTF_1
{
public static TextField tf1, tf2, tf3;
public static void main(String[] args)
{
Frame f = new Frame();
tf1 = new TextField(30);
tf2 = new TextField(30);
tf3 = new TextField(30);
Button bn = new Button("=");
Label lb = new Label("+");
f.setLayout(new FlowLayout());
f.add(tf1);
f.add(lb);
f.add(tf2);
f.add(bn);
f.add(tf3);
bn.addActionListener(new MyMonitor());
f.pack();
f.setVisible(true);
}
}
class MyMonitor implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
int num1 = Integer.parseInt(TestTF_1.tf1.getText());
int num2 = Integer.parseInt(TestTF_1.tf2.getText());
int num3 = num1 + num2;
TestTF_1.tf3.setText(num3+"");
}
}
/*
2009年6月25日16:33:20
文本框内容相加方法二：
通过在B类中定义A类的属性，就可以达到在B类访问A类成员的目的
但是通过这种方式无法访问A类私有成员
本方式既繁琐又有局限性，不推荐
*/
import java.awt.*;
import java.awt.event.*;
public class TestTF_2
{
public static void main(String[] args)
{
new TF().launch();
}
}
class TF
{
public TextField tf1, tf2, tf3;
public void launch()
{
Frame f = new Frame();
tf1 = new TextField(30);
tf2 = new TextField(30);
tf3 = new TextField(30);
Button bn = new Button("=");
Label lb = new Label("+");
f.setLayout(new FlowLayout());
f.add(tf1);
f.add(lb);
f.add(tf2);
f.add(bn);
f.add(tf3);
bn.addActionListener(new MyMonitor(this));
f.pack();
f.setVisible(true);
}
}
class MyMonitor implements ActionListener
{
public TF tf = null;
public MyMonitor()
{
}
public MyMonitor(TF tf)
{
this.tf = tf;
}
public void actionPerformed(ActionEvent e)
{
int num1 = Integer.parseInt(tf.tf1.getText());
int num2 = Integer.parseInt(tf.tf2.getText());
int num3 = num1 + num2;
tf.tf3.setText(num3 + "");
}
}
/*
2009年6月25日16:37:28
文本框内容相加方法三:
把B当做A的内部类，则我们就可以在B类中轻松访问A类的所有成员，当然包括私有成员
推荐
*/
import java.awt.*;
import java.awt.event.*;
public class TestTF_3
{
public static void main(String[] args)
{
new TF().launch();
}
}
class TF
{
public TextField tf1, tf2, tf3;
public void launch()
{
Frame f = new Frame();
tf1 = new TextField(30);
tf2 = new TextField(30);
tf3 = new TextField(30);
Button bn = new Button("=");
Label lb = new Label("+");
f.setLayout(new FlowLayout());
f.add(tf1);
f.add(lb);
f.add(tf2);
f.add(bn);
f.add(tf3);
bn.addActionListener(new MyMonitor());
f.pack();
f.setVisible(true);
}
class MyMonitor implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
int num1 = Integer.parseInt(tf1.getText());
int num2 = Integer.parseInt(tf2.getText());
int num3 = num1 + num2;
tf3.setText(num3 + "");
}
}
}
/*
2009年6月25日16:37:28
文本框内容相加方法三:
把B当做A的内部类，则我们就可以在B类中轻松访问A类的所有成员，当然包括私有成员
推荐
*/
import java.awt.*;
import java.awt.event.*;
public class TestTF_3
{
public static void main(String[] args)
{
new TF().launch();
}
}
class TF
{
public TextField tf1, tf2, tf3;
public void launch()
{
Frame f = new Frame();
tf1 = new TextField(30);
tf2 = new TextField(30);
tf3 = new TextField(30);
Button bn = new Button("=");
Label lb = new Label("+");
f.setLayout(new FlowLayout());
f.add(tf1);
f.add(lb);
f.add(tf2);
f.add(bn);
f.add(tf3);
bn.addActionListener(new MyMonitor());
f.pack();
f.setVisible(true);
}
class MyMonitor implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
int num1 = Integer.parseInt(tf1.getText());
int num2 = Integer.parseInt(tf2.getText());
int num3 = num1 + num2;
tf3.setText(num3 + "");
}
}
}。