第二十三：Java内部类

一.

关于匿名内部类：匿名内部类一定是继承了某个父类或是实现了某个接口

补充:面试题：

匿名内部类可以继承其他类和实现接口，因为匿名类就是在抽象类和接口的基础之上发展起来的！

public abstract class Anonymous {
	private String name;
	private int age;
	
	public Anonymous(){
		
	}
	public Anonymous(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String getInfo(){
		return "Name:"+name+"\tAge:"+age;
	}
	public abstract void work();
}

//匿名内部类的举例，体会一下！---通过抽象类的演示
//可以参考ActionListener接口来理解该问题
public class AnonymousTest {
	public static void main(String[] args) {
		/*Anonymous a = new Anonymous() {
			public void work() {
				System.out.println("个人信息：" + this.getInfo());
				System.out.println(" I am sailing,I am sailing!");
			}
		};
		a.work();*/
		// 这两种方式是等价的
		// 以继承抽象类的方法写匿名内部类
		class Singer extends Anonymous {
			public Singer() {
			}

			public Singer(String name, int age) {
				super(name, age);
			}

			public void work() {
				System.out.println("个人信息：" + this.getInfo());
				System.out.println("I am sailing, I am sailing!");
			}
		}
		Anonymous a = new Singer();
		a.work();

	}

}

public interface Anonymous2 {
	public abstract void swim();
}

//匿名内部类使用举例2------通过接口的演示
public class Anonymous2Test {
	 public static void main(String[] args) {
		 Anonymous2Test at = new Anonymous2Test();
		 at.test(new Anonymous2() {
		 	public void swim() {
		 		System.out.println(" I's swimming!");
		 	}
		 });
	 }
	//这两种方法是等价的
	//以显示接口的方式来写匿名内部类 
	/*public static void main(String args[]) {
		Anonymous2Test ta = new Anonymous2Test();
		class Anony implements Anonymous2 {
			public void swim() {
				System.out.println("I'swimming!");
			}
		}
		ta.test(new Anony());
	}*/

	public void test(Anonymous2 swimmer) {
		swimmer.swim();
	}
}

二.

在new 类型名(接口名){重写其的方法}........匿名内部类

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JButton;
import javax.swing.JFrame;

/**
 * 匿名[内部]类在swing中的应用
 * */
public class SwingTest {
	public static void main(String[] args) {
		// 创建一个窗体
		JFrame frame = new JFrame("JFrame");
		// 设置其大小
		frame.setSize(500, 500);
		// 设置关闭按钮
		// frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		// 设置窗体大小不可变
		frame.setResizable(false);
		// 另一种 设置关闭按钮
		frame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				// 系统正常退出
				System.exit(0);
			}
		});

		// 创建一个按钮
		JButton button = new JButton("JButton");
		// 添加监听器
		button.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent event) {
				System.out.println("按钮被点击");
			}
		});
		// 把按钮加入面板中
		frame.getContentPane().add(button);
		// 设置窗体可见
		frame.setVisible(true);

	}
}

三.

类中static的内部类.......相当于静态方法

四.

类中非static的内部类......相当于非静态方法

五.

方法中的内部类(不能有public,无修饰符，或者有abstract、final修饰符)......

1.只能访问其所在方法中final类型的变量，传递给方法的参数也必须是final的！？？？还是要在实际中操作！！
2.可以肯定的一点是：如果局部类要访问其所在方法中的变量，那么此变量必须是final的

六：

静态内部类(static inner class)

/**
 * 静态内部类......相当于静态方法
 * */
class StaticInner{
	private static int a=3;
	public static class Inner{
		public void test(){
			System.out.println(a);
		}
	}
}

public class Test2 {
	public static void main(String[] args) {
		StaticInner.Inner inner=new StaticInner.Inner();//静态内部类直接调用
		inner.test();
	}
}

成员内部类(member inner class)

/**
 * 成员内部类......相当于非静态方法
 * */
class MemberInner {
	private int a = 3;

	public class Inner2 {
		private int a = 2;

		public void doSomething() {
			// 调用外部类的属性
			System.out.println(MemberInner.this.a);// 这块要注意......很重要！！！
			System.out.println(a);
		}
	}
}

public class Test3 {
	public static void main(String[] args) {
		MemberInner.Inner2 inner2 = new MemberInner().new Inner2();// 非静态内部类要new实例
		inner2.doSomething();
	}
}

局部内部类(local inner class)

/**
 * 局部内部类......相当于局部变量
 * */
class LocalInner {
	public void doSomething(int b) {
		final int a = 3;// 只能访问final的变量
		class Inner3 {
			public void test(int b) {
				System.out.println(b);
				System.out.println(a);
			}
		}
		new Inner3().test(b);
	}
}

public class Test4 {
	public static void main(String[] args) {
		LocalInner inner = new LocalInner();
		inner.doSomething(4);
	}
}

匿名内部类(anonymous inner class)------一种特殊的局部内部类

/**
 * 匿名内部类也相当于局部变量......记住无构造函数！！！
 * 所谓匿名类是没有名字的类，
 * 而构造函数是与类名相同无返回值的方法，
 * 所以一个匿名类不能由程序员给定构造函数。
 * */
public class Test {
	@SuppressWarnings("deprecation")
	public String get(Date date) {
		return date.toLocaleString();
	}

	public static void main(String[] args) {
		Test test = new Test();

		String result = test.get(new Date() {// 生成Date类的一个子类
					private static final long serialVersionUID = 1L;

					public String toLocaleString() {// 意义上是重写了这个方法
						return "hello world";
					}
				});
		System.out.println(result);
	}
}

补充问题：
1.内部类的一个好处是内部类一般可以访问它的嵌套类(外部类)的域。
2.不像外部类，内部类可以是private或static。