尝试以MarkdownPad2方式写博客，感觉十分有条理，第一次使用花的时间较长，但是熟能生巧，后面会越用越熟练，更快吧~

1. 模板设计模式

(1).模板方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类来实现

(2)优点：使用模板方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求

(3)缺点：如果算法骨架有修改的话，则需要修改抽象类

实现代码~

package pra_25;
public class J_48 {
	public static void main(String[] args) {
		songetTime st=new songetTime();
		System.out.println(st.getTime());
	}

}
abstract class getTime{
	public final long getTime(){
		long s=System.currentTimeMillis();
		code();
		long e=System.currentTimeMillis();
		return e-s;
	}

	public abstract void code();
}
class songetTime extends getTime{

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

2.枚举类

枚举：是指将变量的值都列出来，变量的值只限于列举出来的值的范围内。如：一周只有七天。

枚举类的注意事项：

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

自定义实现枚举类：

package pra_25;
public class J_49 {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//枚举方式1.空参构造
		Week mon=Week.Mon;
		Week tue=Week.Tue;
		System.out.println(mon);
		
		//枚举方式2.有参构造
		Week2 mon2=Week2.Mon;
		System.out.println(mon2.getName());
		
		//枚举方式3.加了抽象类，抽象方法，只能定义一个匿名内部类，然后重写其方法
		Week3 mon3=Week3.Mon;
		mon3.show();
	}
}
class Week{		//私有构造，不让其他类创建本类对象
	public static final Week Mon=new Week();
	public static final Week Tue=new Week();
	private Week(){
		
	}
}
class Week2{		//私有构造，不让其他类创建本类对象
	public static final Week2 Mon=new Week2("周一");
	public static final Week2 Tue=new Week2("周二");
	private String name;
	private Week2(String name){
		this.name=name;
	}
	public String getName() {
		return name;
	}
}
abstract class Week3{		//私有构造，不让其他类创建本类对象
	public static final Week3 Mon=new Week3("周一"){
		public void show(){
			System.out.println("周一");
		}
	};
	public static final Week3 Tue=new Week3("周二"){
		public void show(){
			System.out.println("周二");
		}
	};
	private String name;
	private Week3(String name){
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public abstract void show();
}

通过enum实现枚举类

package pra_25;
public class J_50 {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//无参
		Month j=Month.Jan;
		System.out.println(j); 	//Jan
		
		//有参
		Month2 f=Month2.Feb;
		System.out.println(f.getName());
		
		//方法
		Month3 m=Month3.Mar;
		m.show();
	}

}
//枚举方式1
enum Month{
	Jan,Feb,Mar;	//空参构造
}
//枚举方式2
enum Month2{
	Jan("一月"),Feb("二月"),Mar("三月");	
	private String name;
	private Month2(String name){
		this.name=name;
	}
	public String getName() {
		return name;
	}
}
//枚举方式3
enum Month3{
	Jan("一月"){
		public void show(){
			System.out.println("一月");
		}
	},Feb("二月"){
		public void show(){
			System.out.println("二月");
		}
	},Mar("三月"){
		public void show(){
			System.out.println("三月");
		}
	};	
	private String name;
	private Month3(String name){
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public abstract void show();
}

枚举类的常见方法

int ordinal()
int compareTo(E o)
String name()
String toString()
<T> T valueOf(Class<T> type,String name)
values()

这里注意一下：因为尖括号或出现问题，所以这里建议用&lt对<>进行处理

package pra_25;
import pra_25.J_50;
public class J_51 {
	public static void main(String[] args) {
		Month2 J=Month2.Jan;
		Month2 F=Month2.Feb;
		//枚举项都是由编号的
		System.out.println(J.ordinal());//0
		System.out.println(F.ordinal());//1
		//比较的是编号
		System.out.println(J.compareTo(F));	//-1
		//获取实例的名称
		System.out.println(J.name()); //Jan
		//通过字节码对象，获取枚举项
		Month2 j2=Month2.valueOf(Month2.class,"Jan");
		System.out.println(j2);	
		//获取每一个枚举项
		Month2[] arr=Month2.values();
		for (Month2 month2 : arr) {
			System.out.println(month2);
		}
	}
}

Java——模板设计模式和枚举类的实现

1. 模板设计模式

2.枚举类

猜你喜欢