JavaSE--- 设计模式、JDK5.0新特性、JDK7.0新特性

12 扩展知识

12.1 设计模式

12.1.1 装饰设计模式

1. 概述

    装饰模式就是使用被装饰类的一个子类的实例，在客户端将这个子类的实例交给装饰类。是继承的替代方案。

2. 代码实现

例:计算出一段代码运行的时间。

GetTime.java

package cn.itcast_01;

public abstract class GetTime {

	public long getTime() {
		long start = System.currentTimeMillis();

		code();

		long end = System.currentTimeMillis();

		return end - start;
	}
	public abstract void code();
}

ForDemo.java

package cn.itcast_01;

public class ForDemo extends GetTime {

	@Override
	public void code() {
		for(int x = 0;x<10000;x++){
			System.out.println(x);
		}
	}

}

IODemo.java

package cn.itcast_01;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class IODemo extends GetTime{

	@Override
	public void code() {
		try {
			BufferedInputStream bis = new BufferedInputStream(
					new FileInputStream("a.avi"));
			BufferedOutputStream bos = new BufferedOutputStream(
					new FileOutputStream("b.avi"));
			byte[] bys = new byte[1024];
			int len = 0;
			while ((len = bis.read(bys)) != -1) {
				bos.write(bys, 0, len);
			}
			bos.close();
			bis.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
}

GetTimeDemo.java

package cn.itcast_01;

public class GetTimeDemo {
	public static void main(String[] args) {
		// GetTime gt = new GetTime();
		// System.out.println(gt.getTime() + "毫秒");

		GetTime gt = new ForDemo();
		System.out.println(gt.getTime() + "毫秒");

		gt = new IODemo();
		System.out.println(gt.getTime() + "毫秒");
	}
}

    运行结果:

3. 优缺点

    优点：使用装饰模式，可以提供比继承更灵活的扩展对象的功能，它可以动态的添加对象的功能，并且可以随意的组合这些功能。

    缺点：正因为可以随意组合，所以就可能出现一些不合理的逻辑。

12.1.2 装饰设计模式

1. 概述

2. 代码实现

3. 优缺点

12.2 JDK5.0新特性

12.2.1 枚举

1. 概述

    枚举是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。举例：一周只有7天，一年只有12个月等。

    回想单例设计模式：单例类是一个类只有一个实例，那么多例类就是一个类有多个实例，但不是无限个数的实例，而是有限个数的实例。这才能是枚举类。

2. 格式

public enum 枚举类名 {
枚举项1，枚举项2，枚举项3…;
}

示例1：

最常见的枚举类：

package cn.itcast_02;

public enum Direction {
	FRONT,BEHIND,LEFT,RIGHT;
}

带有带参构造方法的枚举类：

package cn.itcast_02;

public enum Direction2{
	FRONT("前"),BEHIND("后"),LEFT("左"),RIGHT("右");
	
	private String name;
	
	private Direction2(String name){
		this.name = name;
	}
	
	public String getName(){
		return name;
	}
}

带有抽象方法的枚举类：

package cn.itcast_02;

public enum Direction3 {
	FRONT("前") {

		@Override
		public void show() {
			System.out.println("前");
		}

	},
	BEHIND("后") {

		@Override
		public void show() {
			System.out.println("后");
		}

	},
	LEFT("左") {

		@Override
		public void show() {
			System.out.println("左");
		}

	},
	RIGHT("右") {

		@Override
		public void show() {
			System.out.println("右");
		}

	};

	private String name;

	private Direction3(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public abstract void show();
}

测试类：

 package cn.itcast_02;

public class DirectionDemo {
	public static void main(String[] args) {
		Direction d = Direction.FRONT;
		System.out.println(d);
		System.out.println("--------");
		 
		Direction2 d2 = Direction2.FRONT;
		System.out.println(d2);
		System.out.println(d2.getName());
		System.out.println("--------");
		
		Direction3 d3 = Direction3.FRONT;
		System.out.println(d3);
		System.out.println(d3.getName());
		d3.show();
	}
}

    运行结果：

注意事项：

1）定义枚举类要用关键字enum
2）所有枚举类都是Enum的子类
3）枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
4）枚举类可以有构造器，但必须是private的，它默认的也是private的。枚举项的用法比较特殊：枚举(“”);
5）枚举类也可以有抽象方法，但是枚举项必须重写该方法
6）枚举在switch语句中的使用

public class DirectionDemo {
	public static void main(String[] args) {

		Direction3 dd = Direction3.FRONT;
		dd = Direction3.LEFT;
		switch (dd) {
		case FRONT:
			System.out.println("你选择了前");
			break;
		case BEHIND:
			System.out.println("你选择了后");
			break;
		case LEFT:
			System.out.println("你选择了左");
			break;
		case RIGHT:
			System.out.println("你选择了右");
			break;
		}
	}
}

    运行结果：

12.3 JDK7.0新特性

1）二进制字面量
2）数字字面量可以出现下划线
3）switch 语句可以用字符串
4）泛型简化
5）异常的多个catch合并
6）ry-with-resources 语句

package cn.itcast_03;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class Demo {
	public static void main(String[] args) {
		// 二进制字面量
		int x = 0b100101;
		System.out.println(x);

		// 数字字面量可以出现下划线
		int y = 1_1234_1000;

		// 不能出现在进制标识和数值之间
		// 不能出现在数值开头和结尾
		// 不能出现在小数点旁边

		// switch语句可以使用字符串

		// 泛型简化
		ArrayList<String> array = new ArrayList<>();

		// 异常的多个cath合并

		method();

	}

	private static void method() {
		// try-with-resources 语句
		// try(必须是java.lang.AutoCloseable的子类对象){…}

		try {
			FileReader fr = new FileReader("a.txt");
			FileWriter fw = new FileWriter("b.txt");
			int ch = 0;
			while ((ch = fr.read()) != -1) {
				fw.write(ch);
			}
			fw.close();
			fr.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

		// 改进版的代码
		try (FileReader fr = new FileReader("a.txt");
				FileWriter fw = new FileWriter("b.txt");) {
			int ch = 0;
			while ((ch = fr.read()) != -1) {
				fw.write(ch);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}