单例、多例设计模式、枚举 - Java基础知识 16

最新推荐文章于 2024-08-19 08:54:17 发布
最新推荐文章于 2024-08-19 08:54:17 发布
阅读量273 收藏
点赞数
分类专栏： # Java基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34949782/article/details/106003990
版权

目录

单例与多例

单例设计

多例设计

枚举

枚举的基本定义

Enum类

定义枚举结构

枚举应用案例

学习笔记

单例与多例

单例设计模式与多例设计模式主要是一种控制实例化对象产生个数的设计操作。

单例设计

如果现在有一个程序类该程序类的定义如下：

class Singleton{
	public void print(){
		System.out.println("测试") ;
	}
}

public class JavaDemo{
	public static void main(String[] args){
		Singleton instanceA = new Singleton() ;
		Singleton instanceB = new Singleton() ;
		Singleton instanceC = new Singleton() ;
		Singleton instanceD = new Singleton() ;

		instanceA.print() ;
		instanceB.print() ;
		instanceC.print() ;
		instanceD.print() ;



	}
}

但是由于某些要求，现在要求Singleton这个类只允许提供有一个实例化对象。那么此时应该控制构造方法。因为新的实例化对象产生一定调用构造方法，如果构造方法“没有了”，那么就无法产生实例化对象。

范例：构造方法私有化

class Singleton{
	private Singleton(){} ; // 构造方法私有化
	public void print(){
		System.out.println("测试") ;
	}
}

public class JavaDemo{
	public static void main(String[] args){
		Singleton instance = null ; // 声明对像
		instance = new Singleton() ; // 对象实例化  JavaDemo.java:11: 错误: Singleton() 在 Singleton 中是 private 访问控制
	}
}

但是要求是：必须产生一个实例化对象，现在必须产生一个是实例化对象交给客户端去调用。那么这个时候的分析如下：

1、private访问权限的主要特点在于：不能在类外部访问，但是可以在类的内部访问构造。

class Singleton{
	private Singleton instance = new Singleton() ;
	private Singleton(){} ; // 构造方法私有化
	public void print(){
		System.out.println("测试") ;
	}
}

public class JavaDemo{
	public static void main(String[] args){
		Singleton instance = null ; // 声明对像
		instance = new Singleton() ; // 对象实例化
	}
}

2、 此时Singleton类内部的instance属于一个普通属性，而普通属性是在有实例化对象产生之后才会被调用的，那么这个时候外部无法产生实例化对象，所以这个属性就不能访问到了，那么就必须考虑没有实例化对象的时候访问此属性，那么只有static属性可以做到。

class Singleton{
	static Singleton instance = new Singleton() ;
	private Singleton(){} ; // 构造方法私有化
	public void print(){
		System.out.println("测试") ;
	}
}

public class JavaDemo{
	public static void main(String[] args){
		Singleton instance = null ; // 声明对像
		instance = Singleton.instance ; // 对象实例化
		instance.print() ;
	}
}

3、类中的属性应该封装后使用，所以理论上此时的instance需要被封装起来，那么就需要通过一个static方法获得。 

class Singleton{
	private static Singleton instance = new Singleton() ;
	private Singleton(){} ; // 构造方法私有化
	public static Singleton getInstance(){
		return instance ;  // 不能加this
	}

	public void print(){
		System.out.println("测试") ;
	}
}

public class JavaDemo{
	public static void main(String[] args){
		Singleton instance = null ; // 声明对像
		instance = Singleton.getInstance() ;
		instance.print() ;
	}
}

4、整个代码强调的时只有一个实例化对象，这个时候虽然提供有static的实例化对象，但是这个对象依然可以重新实例化，所以需要保证此时singleton类内部的instance无法再次实例化，那么应该使用final定义。

class Singleton{
	private static final Singleton INSTANCE = new Singleton() ;
	private Singleton(){} ; // 构造方法私有化
	public static Singleton getInstance(){
		return INSTANCE ;  // 不能加this
	}

	public void print(){
		System.out.println("测试") ;
	}
}

public class JavaDemo{
	public static void main(String[] args){
		Singleton instance = null ; // 声明对像
		instance = Singleton.getInstance() ;
		instance.print() ;
	}
}

在很多情况下有些类的是不需要重复产生对象的，如果：如果一个程序启动，那么现在肯定有一个类负责保存一些有一些程序加载的数据信息。

 

对于单例设计模式也分为两种：懒汉式、饿汉式。在之前所定义的属于饿汉式。在系统加载类的时候就提供Singleton类的实例化对象，而还有一种懒汉式是第一次使用的时候进行实例化对象处理。

范例：将单例修改为懒汉式

class Singleton{
	private static Singleton instance ;
	private Singleton(){} ; // 构造方法私有化
	public static Singleton getInstance(){
		if (instance == null){ // 第一次使用
			instance = new Singleton() ; //实例化
		}
		return instance ;  // 不能加this
	}

	public void print(){
		System.out.println("测试") ;
	}
}

public class JavaDemo{
	public static void main(String[] args){
		Singleton instance = null ; // 声明对像
		instance = Singleton.getInstance() ;
		instance.print() ;
	}
}

面试题：请编写一个Singleton程序，并说明组要特点？

  • 代码如上，可以把懒汉式（后面还要考虑线程的同步问题）和饿汉式都写上。

  • 特点：构造方法私有化，类内部提供static方法获取实例化对象，不挂外部如何操作永远都只有一个是实例化对象提供。

多例设计

与单例设计对应的还有多例设计，单例是指只保留一个实例化对象，多例则是保留多个实例化对象。例如：如果要定义一个描述性别的类，那么该对象只能产生来两个：男、女。或者描述颜色基色的类：红、绿、蓝。这种情况下，使用多例设计。

class Color{ // 定义描述颜色的类
	private static final Color RED = new Color("红色") ;
	private static final Color GREEN = new Color("绿色") ;
	private static final Color BLUE = new Color("蓝色") ;

	private String title ;
	private Color(String title){ // 构造方法私有化
		this.title = title ;
	}
	
	public static Color getInstance(String color){
		switch(color){
			case "红色": {
				return RED ;
			}
			case "绿色": {
				return GREEN ;
			}
			case "蓝色":{
				return BLUE ;
			}
			default: return null ;
		}
	}
	public String toString(){
		return this.title ;
	}


}

public class JavaDemo{
	public static void main(String[] args){
		Color instance = null ;
		Color  red = instance.getInstance("红色") ;
		System.out.println(red.toString()) ;
		
		Color  green = instance.getInstance("绿色") ;
		System.out.println(green) ; // 自动调用toString
		
		Color  blue = Color.getInstance("蓝色") ;
		System.out.println(blue) ;
	}
}

多例设计与单例设计的本质是相同的，一定都会在内部提供static方法以返回实例化对象。构造方法私有化，不仅仅是private，只要不是public都是私有化。

枚举

很多的编程语言都会提供枚举的概念，但是Java到JDK1.5之后才提出了枚举的概念。在实际的开发之中，用于定义有限个数对象的一种结构（多例设计），枚举属于多例设计，但其结构比多例设计简单。

枚举的基本定义

从JDK1.5之后提供有enum的关键字，利用此关键字可以实现枚举的定义。

范例：定义一个枚举

enum Color{  // 定义枚举类
	RED, GREEN, BLUE ; // 实例化对象

}
public class JavaDemo{
	public static void main(String[] args){
		Color c = Color.RED ; // 实例化对象
		System.out.println(c) ;
	}
}

这个代码实现多例设计中的问题。还可以使用中文

enum Color{  // 定义枚举类
	红色, 绿色, 蓝色 ; // 实例化对象

}
public class JavaDemo{
	public static void main(String[] args){
		Color c = Color.红色 ; // 实例化对象
		System.out.println(c) ;
	}
}

如果此时采用多例模式来设计，会多出很多代码，这样对于开发的复杂度是比较高的，因为里面毕竟涉及到构造方法的私有化和静态方法。多例设计与枚举设计虽然可以实现相同的功能，但是使用枚举可以在程序编译的时候判断所使用的实例化对象是否存在。

在进行枚举处理的时候，可以使用values()方法获取所有的枚举对象进行输出。

范例：获取所有枚举对象

enum Color{  // 定义枚举类
	红色, 绿色, 蓝色 ; // 实例化对象

}
public class JavaDemo{
	public static void main(String[] args){
		for(Color c : Color.values()){
			System.out.println(c) ;
		}
	}
}

在多例中如何获取所有对象方式，使用对象数组。

从JDK1.5追加了枚举结构之后，就可以使用switch之中的枚举像进行判断。

范例：观察枚举与switch处理

 

enum Color{  // 定义枚举类
	RED, GREEN, BLUE ; // 实例化对象

}
public class JavaDemo{
	public static void main(String[] args){
		Color c = Color.RED ;
		switch (c){
			case RED :{
				System.out.println("红色") ;
				break ;
			}
			case GREEN:{
				System.out.println("绿色") ;
				break ;
			}
			case BLUE:{
				System.out.println("蓝色") ;
				break ;
			}		
		}
	}
}

多例上是无法实现与switch的直接连接的，多例要想实现它需要编写大量的if 判断。

Enum类

严格意义上讲枚举不属于一种新的结构，它的本质相当于一个类，但是这个类默认会继承Enum类。

观察Enum类的定义：

public abstract class Enum<E extends Enum<E>>
extends Object
implements Comparable<E>, Serializable

现在定义的枚举类型就是Enum中使用的E类型。下面观察Enum中定义的方法。

方法名称类型描述
protected Enum​(String name, int ordinal)
构造传入名字和序号
public final String name​()
普通获得对象的名字
public final int ordinal​()
普通获得对象的序号

范例：观察Enum类的存在

enum Color{  // 定义枚举类
	RED, GREEN, BLUE ; // 实例化对象

}
public class JavaDemo{
	public static void main(String[] args){
		for(Color c : Color.values()){
			System.out.println(c.name()) ;
			System.out.println(c.ordinal()) ;
		}
	}
}

在枚举之中，每一个序号的对象都是根据枚举对象的定义顺序来决定的。

面试题：请解释Enum与enum的区别？

  • enum：是从JDK1.5过后提供的关键字，用于定义枚举类的结构；

  • Enum：是一个抽象类，所有使用所有使用enum定义的类就直接默认继承Enum类。

定义枚举结构

枚举本身就属于多例的设计模式，那么既然是多例的设计模式，那么在一个类之中可以定义的结构是非常多的，例如：构造方法、普通方法、属性等。那么这些内容在枚举中依然可以直接定义，但是需要注意的是：枚举类中的构造方法必须私有化（public无法使用）。

范例：在枚举中定义其它结构

enum Color{  
	RED("红色"), GREEN("绿色"), BLUE("蓝色") ; // 枚举对象必须放在首行
	private String title ; // 定义属性
	private Color(String title){
		this.title = title ;
	} 
	public String toString(){
		return this.title ;
	}
}
public class JavaDemo{
	public static void main(String[] args){
		for(Color c : Color.values()){
			System.out.println(c.ordinal() + "-" + c.name() + "-" + c) ;
		}
	}
}

本程序在简化程度上远远高于多设计模式。除了这种基本的结构之外，在枚举类中也可以实现接口的继承。

范例：让枚举实现接口

interface IMessage{
	public abstract String getMessage() ;
}


enum Color implements IMessage{  
	RED("红色"), GREEN("绿色"), BLUE("蓝色") ; // 枚举对象必须放在首行
	private String title ; // 定义属性
	private Color(String title){
		this.title = title ;
	} 
	public String toString(){
		return this.title ;
	}
	public String getMessage(){
		return this.title ;
	}
}
public class JavaDemo{
	public static void main(String[] args){
		IMessage msg = Color.RED ;
		System.out.println(msg.getMessage()) ;
	}
}

在枚举里面最有意思的是可以直接定义抽象方法，并且要求每一个枚举对象都要独立覆写此抽象方法。

范例：观察过枚举中定义抽象方法


enum Color{  
	RED("红色"){
		public String getMessage(){
			return this.toString() ;
		}
	}, GREEN("绿色"){
		public String getMessage(){
			return this.toString() ;
		}
	}, BLUE("蓝色"){
		public String getMessage(){
			return this.toString() ;
		}
	} ; // 枚举对象必须放在首行
	private String title ; // 定义属性
	private Color(String title){
		this.title = title ;
	} 
	public String toString(){
		return this.title ;
	}
	public abstract String getMessage() ;
}
public class JavaDemo{
	public static void main(String[] args){
		System.out.println(Color.RED.getMessage()) ;
	}
}

枚举的定义是非常灵活的，但是在实际应用之中，枚举更多情况下，建议使用它的正确用法，就是定义实例对象即可。

枚举应用案例

编写一个程序，观察过枚举的应用，例如：现在定义一个Person类，里面有性别，性别不希望用户随意输入，所以使用枚举最合适。

范例：使用枚举

enum Sex{
	MALE("男"), FEMALE("女") ;
	private String title ;
	private Sex(String title){
		this.title = title ;
	}
	public String toString(){
		return this.title ;
	}
}

class Person{
	private String name ;
	private int age ;
	private Sex sex;
	
	public Person(String name, int age, Sex sex){
		this.name = name ;
		this.age = age ;
		this.sex = sex ;
	}

	public String toString(){
		return "姓名：" + this.name +
				"、年龄：" + this.age + 
				"、性别：" + this.sex ;
	}

}

public class JavaDemo{
	public static void main(String[] args){
		Person per = new Person("张三", 18, Sex.MALE) ;
		System.out.println(per) ;
	}
}

这个程序不使用枚举也可以实现，追加几个判断即可，所以对于枚举，愿意用就用。

 

 

梦世
关注
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
单例/多例设计模式和枚举
Darren的博客
06-23 204
文章目录1 单例设计模式2 多例设计模式3 枚举 1 单例设计模式 特点：构造方法私有化，类内部提供static方法获取实例化对象。 饿汉式：在定义时直接生成一个实例化对象。通过private static final修饰。 package cn.mldn.demo; class Singleton { // 单例程序类 // 在类内部进行Single类对象实例化，为了防止可能出现重复实例化所以使用final标记 private static final Singleton INSTANCE = ne
单例设计模式(饿汉式，懒汉式)
weixin_30346033的博客
07-14 93
单例设计模式 正常情况下一个类可以创建多个对象 1 public static void main(String[] args) { 2 // 正常情况下一个类可以创建多个对象 3 Person p1 = new Person(); 4 Person p2 = new Person(); 5 Person p3 = new Person(); 6...
C++新特性——枚举类（enum class），以及与传统枚举的区别
最新发布
Mitos的博客
08-19 598
enum class 是 C++11 引入的一种枚举类型，称为“强类型枚举”或“枚举类”。与传统的 enum 相比，enum class 具有更严格的类型检查，并且避免了命名冲突。
C++ enum class 如何使用
CHNIM的博客
12-29 1288
enum class提供了更好的类型安全性和作用域限定，使得枚举更加灵活和可维护。它是 C++11 引入的一个重要特性，推荐在新的代码中使用。
重新开始学Java——单例、多例、枚举
chicu8732的博客
08-09 168
单例 在某种特殊的情况下，这个类所对应的对象有且仅有一个，不能重复性的多次使用，那么就可以使用单例。 注意，这里的单例仅仅是单线程的情况下的单例，不涉及到多线程的单例。 DEMO /** * 单例（singleton 、 SINGLETON） */ public final class Sun...
Enum Class （枚举类）- 入门
abp47289的博客
07-17 1149
枚举类 如果一个类的对象是有限和固定的，则可以使用枚举类。本笔记，主要介绍基本的枚举类使用：基本语法和实例。 目录 1. 枚举类-语法 1.1 枚举类与普通类相同之处 1.2 枚举类与普通类不同之处 1.3 实例 1.4 成员变量、构造器和方法 正文 1. 枚举类-语法 1.1 枚举类与普通类相同之处 enum 与 class、interface 具有相同地位； 可...
【Java枚举与单例模式】：探索枚举在设计模式中的完美融合
![Java Enum（枚举类型）](https://crunchify.com/wp-content/uploads/2016/04/Java-eNum-Comparison-using-equals-operator-and-Switch-statement-Example.png)...单例模式则是一种常用的软件设计模式，它保证一个类只
java基础知识学习-个人笔记
10-27
Java是一种广泛使用的面向对象的编程语言，其基础知识是学习Java编程的基石。下面将详细解释标题和描述中涉及的关键...以上就是Java基础知识的一些核心概念和特性，理解并掌握这些知识点对于深入学习Java编程至关重要。
求职宝典-Java 基础面试题
04-02
Java 基础面试题是求职者在面试Java...以上就是Java面试中涉及的一些基础知识点，理解并熟练掌握这些内容对于成为一名合格的Java开发者至关重要。在面试中，能够清晰地阐述这些概念和应用，将大大增加成功入职的机会。
50-way-JAVA-basic.rar_Java基础练习题
09-24
10. **设计模式**: 虽非基础语法，但良好的编程习惯包括理解并应用设计模式，如单例模式、工厂模式、观察者模式等。 这份50个问题的Java基础编程练习集全面涵盖了Java初学者需要掌握的关键知识点，通过实践，初学者...
C#练手题
MrLiuの甜蜜小屋
04-15 5987
选择： 1、装箱是把值类型转换到（ b ）类型。 a)数组 b)引用 c)char d)string 2、静态构造函数只能对（ a ）数据成员进行初始化。 a) 静态 b) 动态 c)实例 d) 静态和实例 3、关于如下程序结构的描述中，哪一项是正确的？（ b ） for ( ; ; ) { 循环体; } a) 不执行循环体 b) 一直执行循环体,即死循环 c) 执行循环体一次 ...
C++11枚举类——enum class
热门推荐
千祠的博客
10-12 5万+
文章目录枚举类优势——降低命名空间污染枚举类优势——避免发生隐式转换枚举类优势——可以前置声明C++98中enum的使用情况 enum现在被称为不限范围的枚举型别 enum class是限定作用域枚举型别，他们仅在枚举型别内可见，且只能通过强制转换转换为其他型别。 两种枚举都支持底层型别指定，enum class默认是int，enum没有默认底层型别 enum可以前置声明，enum仅在指定默认底层型别的情况下才能前置声明   众所周知在C++中，变量名字仅仅在一个作用域内生效，出了大括号作用域，
Java基础---枚举
来了点个赞再走...
05-06 4406
枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则编译器就会报错，枚举可以让编译器在编译时就可以控制源程序赋给的非法值，使用普通变量的方式在开发阶段无法实现这一目标。 在JDK1.5之后，使用关键字enum定义一种新的类型，称为枚举类型 枚举（enum）和类（class）、接口（interface）是同一级别
JAVA —— 枚举（Enum）
黄坤的博客
06-30 197
1.枚举是一个特殊的类，一般用来表示一组特殊的常量 //枚举是一个特殊的类，一般用来表示一组特殊的常量 enum Color { //定义颜色常量：红色、绿色、蓝色 RED, GREEN, BLUE; } 2.使用枚举类 //使用枚举类 class useEnum { public static void main(String[] args) { Color color = Color.RED; System.out.println(color)
【解惑】理解java枚举类型
ccnunlp的专栏
09-26 292
枚举类型是JDK5.0的新特征。Sun引进了一个全新的关键字enum来定义一个枚举类。下面就是一个典型枚举类型的定义： public enum Color{ RED,BLUE,BLACK,YELLOW,GREEN } 显然，enum很像特殊的class，实际上enum声明定义的类型就是一个类。 而这些类都是类库中Enum类的子类(java.lang.Enum&lt;E&gt;)。...
C++之enum class简单使用
我不是萧海哇的博客
11-28 600
【代码】C++之enum class简单使用。
枚举类型的使用方法，参考其他博客，自我总结
qq_40727911的博客
07-28 489
枚举类型的用法： 枚举类型的用法一般有三种： 一、作为常量使用 public enum Color { RED,BLANK,YELLOW; //对个数值后面必须加上分号 } public class Test { public static void main(String[] args) { System.out.println(Color.RED); } } //输出返回值是RED 二、可在switch中使用 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值