「java单例模式枚举」java enum单例
本篇文章给大家谈谈java单例模式枚举，以及java enum单例对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、Java 中 Enum 如何继承？
- 2、如何在java中实现singleton模式
- 3、如何写一个简单的单例模式？
- 4、Java 枚举型为什么是静态的，以及是怎么实现的
- 5、java的单例模式怎么能保证始终是单例
Java 中 Enum 如何继承？
Java Enum是不能继承的，以下是解释：
枚举类使用enum定义后在编译后默认继承了java.lang.Enum类，而不是普通的继承Object类。enum声明类继承了Serializable和Comparable两个接口。且采用enum声明后，该类会被编译器加上final声明（同String），故该类是无法继承的。枚举类的内部定义的枚举值就是该类的实例（且必须在第一行定义，当类初始化时，这些枚举值会被实例化）。
Java 5新增的enum关键词，可以定义枚举类。该类是一个特殊的类，可以定义自己的field、方法、可以实现接口，也可以定义自己的构造器。
如何在java中实现singleton模式
单例模式大致有五种写法，分别为懒汉，恶汉，静态内部类，枚举和双重校验锁。
1、懒汉写法，常用写法
class LazySingleton{
private static LazySingleton singleton;
private LazySingleton(){
}
public static LazySingleton getInstance(){
if(singleton==null){
singleton=new LazySingleton();
}
return singleton;
}
}
2、恶汉写法，缺点是没有达到lazy loading的效果
class HungrySingleton{
private static HungrySingleton singleton=new HungrySingleton();
private HungrySingleton(){}
public static HungrySingleton getInstance(){
return singleton;
}
}
3、静态内部类，优点：加载时不会初始化静态变量INSTANCE，因为没有主动使用，达到Lazy loading
class InternalSingleton{
private static class SingletonHolder{
private final static InternalSingleton INSTANCE=new InternalSingleton();
}
private InternalSingleton(){}
public static InternalSingleton getInstance(){
return SingletonHolder.INSTANCE;
}
}
4、枚举，优点：不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
enum EnumSingleton{
INSTANCE;
public void doSomeThing(){
}
}
5、双重校验锁，在当前的内存模型中无效
class LockSingleton{
private volatile static LockSingleton singleton;
private LockSingleton(){}
public static LockSingleton getInstance(){
if(singleton==null){
synchronized(LockSingleton.class){
if(singleton==null){
singleton=new LockSingleton();
}
}
}
return singleton;
}
}
如何写一个简单的单例模式？
一、基本的实现思路:
单例的实现主要是通过以下两个步骤：
1、将该类的构造方法定义为私有方法，这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例；
2、在该类内提供一个静态方法，当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用。
二、示范如下：
1、枚举实现单例：
2、懒汉式线程不安全：
3、懒汉式线程安全：
4、饿汉式：
5、双重校验锁：
6、静态内部类：
扩展资料:
一、单列模式简介：
单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。
二、懒汉与饿汉：
1、懒汉方式：指全局的单例实例在第一次被使用时构建。
2、饿汉方式：指全局的单例实例在类装载时构建。
三、单例模式的三要点：
1、某个类只能有一个实例。
2、它必须自行创建这个实例。
3、它必须自行向整个系统提供这个实例。
四、优缺点：
1、优点：
①实例控制：单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
②灵活性：因为类控制了实例化过程，所以类可以灵活更改实例化过程。
2、缺点：
①开销：虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。
②可能的开发混淆：使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
③对象生存期：不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。
参考资料：百度百科单列模式
Java 枚举型为什么是静态的，以及是怎么实现的
是的，Java枚举型是静态常量，隐式地用static final修饰过。
确切地说，Java枚举型是“静态常量”，这里面包含了两层意思：
枚举型中的实例隐式地用static final修饰过。
枚举型作为某个类中的成员字段也隐式地用static final修饰过。
public class Traffic{
public enum Light{GREEN,YELLOW,RED}
}
还是你上面这个代码，反编译一下，你就能看到--编译器背着你偷偷做了哪些手脚：
/*
* Decompiled with CFR 0_118.
*/
package com.ciaoshen.thinkinjava.chapter19;
public class Traffic {
public static final class Light
extends EnumLight {
public static final /* enum */ Light GREEN = new Light();
public static final /* enum */ Light YELLOW = new Light();
public static final /* enum */ Light RED = new Light();
private static final /* synthetic */ Light[] $VALUES;
public static Light[] values() {
return (Light[])$VALUES.clone();
}
public static Light valueOf(String string) {
return Enum.valueOf(Light.class, string);
}
private Light() {
super(string, n);
}
static {
$VALUES = new Light[]{GREEN, YELLOW, RED};
}
}
}
首先，枚举型Light是个实实在在的类。继承自基类EnumLight。然后在你不知情的情况下，偷偷加了static final修饰词。
然后三个枚举实例GREEN, YELLOW, RED也确确实实是Light的实例。然而前面也加上了static final。
然后构造器也被偷偷地阉割成private。这种实例控制手段，是不是在单例器模式里也见过？所以枚举也是实现单例器的一种方法。
然后编译器还偷偷合成了Light[]数组，一个values( )方法，一个valueOf( )方法。这个values( )在Enum的文档里都找不到。
如果在Enum里定义一个相关方法，你还会看到一个匿名内部类：
public enum Light{
GREEN{public void show(){System.out.println("Green");}},
YELLOW{public void show(){System.out.println("Yellow");}},
RED{public void show(){System.out.println("Red");}};
}
反编译的结果如下：
/*
* Decompiled with CFR 0_118.
*/
package com.ciaoshen.thinkinjava.chapter18;
import java.io.PrintStream;
public class Light
extends EnumLight {
public static final /* enum */ Light GREEN = new Light("GREEN", 0){
public void show() {
System.out.println("Green");
}
};
public static final /* enum */ Light YELLOW = new Light("YELLOW", 1){
public void show() {
System.out.println("Yellow");
}
};
public static final /* enum */ Light RED = new Light("RED", 2){
public void show() {
System.out.println("Red");
}
};
private static final /* synthetic */ Light[] $VALUES;
public static Light[] values() {
return (Light[])$VALUES.clone();
}
public static Light valueOf(String string) {
return Enum.valueOf(Light.class, string);
}
private Light() {
super(string, n);
}
static {
$VALUES = new Light[]{GREEN, YELLOW, RED};
}
}
总之，Java的Enum枚举型整个就是一个大大的“语法糖”。明明是一个完整的类，但只向用户暴露几个静态常量，隐藏掉大部分实现的细节。
java的单例模式怎么能保证始终是单例
第一种：饱汉模式
public class SingleTon {
private SingleTon(){
}
//实例化放在静态代码块里可提高程序的执行效率，但也可能更占用空间
private final static SingleTon instance = new SingleTon();
public static SingleTon getInstance(){
return instance;
}
}
第二种：饥汉模式
public class SingleTon {
private SingleTon(){}
private static instance = null; //newSingleTon();
public static synchronized SingleTon getInstance(){
if(instance == null)
instance = new SingleTon();
return instance;
}
}
第三种：用枚举
public enum SingleTon{
ONE;
}
第三：更实际的应用（在什么情况用单例）
public classSequenceGenerator{
//下面是该类自身的业务功能代码
private int count = 0;
public synchronized int getSequence(){
++count;
}
//下面是把该类变成单例的代码
private SequenceGenerator(){}
private final static instance = new SequenceGenerator();
public static SingleTon getInstance(){
return instance;
}
}
第四：
public class MemoryDao {
privateHashMap map = new HashMap();
publicvoid add(Student stu1){
map.put(SequenceGenerator.getInstance().getSequence(),stu1);
}
//把MemoryDao变成单例
}
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例，是不是很奇怪？
//注意这是private 只供内部调用
private staticSingleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public staticSingleton getInstance() {
return instance;
}
}
第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次
//使用时生成实例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance;
}
}
其他形式:
定义一个类，它的构造函数为private的，所有方法为static的。
一般认为第一种形式要更加安全些
关于java单例模式枚举和java enum单例的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。