Java的单例模式和枚举类

内容目录：

1、单例模式

2、枚举类（自定义枚举类和enum关键字定义枚举类）

———————————分割线——————————————

单例模式

单例设计模式就是采用一定的方法保证在整个软件系统中，对于某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

1、必须将类的构造方法的访问权限设置为private，这样就保证了不能够用new操作在类的外部产生对象。

2、在类的内部创建一个对象，同时提供一个静态方法返回内部创建的这个对象。

3、由于静态方法只能访问类中的静态成员变量，所以，类对象的变量也要定位为静态的。

package com.lj95801.singleton;

/*
 * 单例模式
 * 该类只能够创建一个实例
 */
public class testSingleton {
	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		//如何来判断S1和S2就是同一个实例呢，可以判断两者的引用是否一致
		System.out.println(s1 == s2);//打印ture说明引用相同
	}
}


class Singleton{
	//1、私有化构造器,使得在类的外部不能够用new创建对象。能够用new就能够创建多个实例。
	private Singleton(){
	}
	//2、在类的内部创建一个实例.私有化对象，提供公共的调用方法
	private static final Singleton instance = new Singleton();
	//3、此公共方法只能够通过类来调用，从而设置为static。静态方法只能够调用静态变量
	public static Singleton getInstance() {
		return instance;
	}
}

执行结果：

枚举类

枚举类是类的对象只能是固定的几个。比如说，一年只有四个季节，一个星期只有七天等。

1、自定义枚举类。

就是在上面单例模式的基础上多添加几个类的内部对象就成了自定义枚举类。

代码：

package com.lj95801.singleton;
/*
 * 自定义枚举类
 * 在单例模式的基础上多添加几个内部类
 */
public class testUser_defined {
	public static void main(String[] args) {
		//利用“类名.对象”来引用
		Season spring = Season.SPRING;
		System.out.println(spring.toString());
	}
}

class Season{
	private final String seasonName;
	private final String seasonDesc;
	
	//1、私有化构造器
	private Season(String seasonName, String seasonDesc) {
		super();
		this.seasonName = seasonName;
		this.seasonDesc = seasonDesc;
	}
	//2、创建有限个的对象,需要通过类名来调用的，所以声明为static
	public static final Season SPRING = new Season("spring","大地复苏");
	public static final Season SUMMER = new Season("summer","阳光明媚");
	public static final Season AUTUMN = new Season("autumn","秋高气爽");
	public static final Season WINTER = new Season("winter","苍茫大地");
	//3、通过公共方法来调用对象
	public String getSeasonName() {
		return seasonName;
	}
	public String getSeasonDesc() {
		return seasonDesc;
	}
	@Override
	public String toString() {
		return "Season [seasonName=" + seasonName + ", seasonDesc="
				+ seasonDesc + "]";
	}
}

2、利用enum关键字来定义枚举类型

      （1）常用的方法

package com.lj95801.singleton;

public class testEnum {
	public static void main(String[] args) {
		Season1 spring = Season1.SPRING;
		System.out.println(spring);
		System.out.println(spring.getSeasonName());
		//枚举类的方法
		System.out.println("--------->");
		//values()方法能将枚举类型转换成相应的数组类型
		Season1[] seasons = Season1.values();
		for(int i=0;i<seasons.length;i++){
			System.out.println(seasons[i]);
		}
		System.out.println("--------->");
		//valueOf(String name)返回对应的对象
		String str = "SPRING";	//只能写枚举类对象的名字，否则会报错
		Season1 sea = Season1.valueOf(str);
		System.out.println(sea);
	}
}

enum Season1{
	//1、将类的对象放在最上面
	SPRING("spring","大地复苏"),
	SUMMER("summer","阳光明媚"),
	AUTUMN("autumn","秋高气爽"),
	WINTER("winter","苍茫大地");
	//2、私有的常量成员变量
	private final String seasonName;
	private final String seasonDesc;
	//3、私有化的构造器
	private Season1(String seasonName, String seasonDesc) {
		this.seasonName = seasonName;
		this.seasonDesc = seasonDesc;
	}
	
	public String getSeasonName() {
		return seasonName;
	}
	public String getSeasonDesc() {
		return seasonDesc;
	}
}

执行结果：

     （2）枚举类型实现接口有两种方式：统一重写方法，各个枚举对象分别重写方法。

package com.lj95801.singleton;

public class testEnum {
	public static void main(String[] args) {
		Season1 spring = Season1.SPRING;
		System.out.println(spring);
		System.out.println(spring.getSeasonName());
		//枚举类的方法
		System.out.println("--------->");
		//values()方法能将枚举类型转换成相应的数组类型
		Season1[] seasons = Season1.values();
		for(int i=0;i<seasons.length;i++){
			System.out.println(seasons[i]);
		}
		System.out.println("--------->");
		//valueOf(String name)返回对应的对象
		String str = "SPRING";	//只能写枚举类对象的名字，否则会报错
		Season1 sea = Season1.valueOf(str);
		System.out.println(sea);
		
		System.out.println("--------->");
		Season1.SPRING.show();
		Season1.WINTER.show();
	}
}


interface Info{
	void show();
}

/*
 * 实现接口，需要重写show方法，这个有两种方式:
 * 1、在Season1类中重写，和普通的类一样，只有一个。
 * 2、在各个类的对象中分别重写，这样就能够实现不同的类有不同的实现形式。
 * 但是要保证每个类对象中都要重写才行。
 */

enum Season1 implements Info{
	//1、将类的对象放在最上面
	SPRING("spring","大地复苏"){
		public void show(){
			System.out.println("春困");
		}
	},
	SUMMER("summer","阳光明媚"){
		public void show(){
			System.out.println("夏乏");
		}
	},
	AUTUMN("autumn","秋高气爽"){
		public void show(){
			System.out.println("秋打盹");
		}
	},
	WINTER("winter","苍茫大地"){
		public void show(){
			System.out.println("冬天太冷了");
		}
	};
	//2、私有的常量成员变量
	private final String seasonName;
	private final String seasonDesc;
	//3、私有化的构造器
	private Season1(String seasonName, String seasonDesc) {
		this.seasonName = seasonName;
		this.seasonDesc = seasonDesc;
	}
	//实现接口，重写show()方法，这个就是第一种重写方式。
//	@Override
//	public void show() {
//		System.out.println("我们都是一个季节");
//	}
//	
	public String getSeasonName() {
		return seasonName;
	}
	public String getSeasonDesc() {
		return seasonDesc;
	}
}
	

执行结果：