⑴ java枚举类型enum用法
用法如下：
用法一：常量 在JDK1.5之前，我们定义常量都是：public static fianl....。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法
用法六：使用接口组织枚举
用法七：关于枚举集合的使用
⑵ 设计模式之单例模式
单例设计模式理解起来非常简单。一个类只允许创建一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫单例模式。
下面的示例中如果每个类都创建一个 Logger 实例，就可能造成日志内容被覆盖的情况。
如果有些数据在系统中只应保存一份，那就比较适合设计为单例类。比如，配置信息类，全局 ID 生成器等。
要实现一个单例，我们要考虑以下几点：
懒汉式相对于饿汉式的优势是 “支持延迟加载” 。但缺点也很明显，因为使用了 synchronized 关键字导致这个方法的 “并发度很低” 。如果这个单例类偶尔会被用到，那这种实现方式还可以接受。但是，如果频繁地用到，就会导致性能瓶颈，这种实现方式就不可取了。
这是一种既支持延迟加载、又支持高并发的单例实现方式。
在 java1.5 以下 instance = new Singleton(); 有指令重排问题，需要给 instance 成员变量加上 volatile 关键字，java1.5 之后不会再这个问题。
这种方式利用了 Java 的静态内部类，有点类似饿汉式，但又能做到了延迟加载。
当外部类 Singleton 被加载的时候，并不会创建 SingletonHolder 实例对象。只有当调用 getInstance() 方法时，SingletonHolder 才会被加载，这个时候才会创建 instance。insance 的唯一性、创建过程的线程安全性，都由 JVM 来保证。所以，这种实现方法既保证了线程安全，又能做到延迟加载。
这是一种最简单的实现方式，基于枚举类型的单例实现。这种实现方式是通过 Java 枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性。
上面的单例类对象是进程唯一的，一个进程只能有一个单例对象。那如何实现一个线程唯一的单例呢？
假设 IdGenerator 是一个线程唯一的单例类。在线程 A 内，我们可以创建一个单例对象 a。因为线程内唯一，在线程 A 内就不能再创建新的 IdGenerator 对象了，而线程间可以不唯一，所以，在另外一个线程 B 内，我们还可以重新创建一个新的单例对象 b。
我们通过一个 ConcurrentHashMap 来存储对象，其中 key 是线程 ID，value 是对象。这样我们就可以做到，不同的线程对应不同的对象，同一个线程只能对应一个对象。实际上，Java 语言本身提供了 ThreadLocal 工具类，可以更加轻松地实现线程唯一单例。
⑶ 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语言中的枚举类型的使用方法如下：
用法一：常量；
publicenumColor{
RED,GREEN,BLANK,YELLOW
}用法二：switch；
enumSignal{
GREEN,YELLOW,RED
}
publicclassTrafficLight{
Signalcolor=Signal.RED;
publicvoidchange(){
switch(color){
caseRED:
color=Signal.GREEN;
break;
caseYELLOW:
color=Signal.RED;
break;
caseGREEN:
color=Signal.YELLOW;
break;
}
}
}用法三：向枚举中添加新方法；
publicenumColor{
RED("红色",1),GREEN("绿色",2),BLANK("白色",3),YELLO("黄色",4);
//成员变量
privateStringname;
privateintindex;
//构造方法
privateColor(Stringname,intindex){
this.name=name;
this.index=index;
}
//普通方法
publicstaticStringgetName(intindex){
for(Colorc:Color.values()){
if(c.getIndex()==index){
returnc.name;
}
}
returnnull;
}
//getset方法
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicintgetIndex(){
returnindex;
}
publicvoidsetIndex(intindex){
this.index=index;
}
}用法四：覆盖枚举的方法；
publicclassTest{
publicenumColor{
RED("红色",1),GREEN("绿色",2),BLANK("白色",3),YELLO("黄色",4);
//成员变量
privateStringname;
privateintindex;
//构造方法
privateColor(Stringname,intindex){
this.name=name;
this.index=index;
}
//覆盖方法
@Override
publicStringtoString(){
returnthis.index+"_"+this.name;
}
}
publicstaticvoidmain(String[]args){
System.out.println(Color.RED.toString());
}
}用法五：实现接口；
publicinterfaceBehaviour{
voidprint();
StringgetInfo();
}
{
RED("红色",1),GREEN("绿色",2),BLANK("白色",3),YELLO("黄色",4);
//成员变量
privateStringname;
privateintindex;
//构造方法
privateColor(Stringname,intindex){
this.name=name;
this.index=index;
}
//接口方法
@Override
publicStringgetInfo(){
returnthis.name;
}
//接口方法
@Override
publicvoidprint(){
System.out.println(this.index+":"+this.name);
}
}用法六：使用接口组织枚举。
publicinterfaceFood{
enumCoffeeimplementsFood{
BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO
}
enumDessertimplementsFood{
FRUIT,CAKE,GELATO
}
}以上就是Java语言中枚举类型的基本使用方法。
⑸ Java中枚举类型存储的元素可以重复吗
Set是Java集合类的重要组成部分,它用来存储不能重复的对象。枚举类型也要求其枚举元素各不相同。
⑹ JAVA 枚举类型的编程
可以通过Scanner循环录入数据，然后将数据封装成bean对象，再遍历打印每个bean对象
⑺ java中的enum有什么用呢
enum也就是枚举,像一个集合,只不过集合里面的内容都固定了.
public enum Season3 {
SPRING("春天"),
SUMMER("夏天"),
AUTUMN("秋天"),
WINTER("冬天");
private String name;
private Season3(String name){
this.name = name;
}
public double getAvgTemp(){
switch(this){
case SPRING:return 10.2;
case SUMMER:return 25.8;
case AUTUMN:return 19.6;
case WINTER:return -3.6;
}
return 0.0;
}
public String getName(){
return name;
}
}
public class Test {
public static void main(String[] args) {
m3(Season3.SPRING);
}
public static void m3(Season3 season){
System.out.println(season.getName()+":"+season.getAvgTemp());
Season3[] allSeason = Season3.values();//返回枚举类中所有枚举值的一个数组
System.out.println(allSeason[0]);
}
}
⑻ 为什么java中用枚举实现单例模式会更好
单例模式实现方式有很多：在第一次使用的时候创建（构造函数中判断是否已经有实例存在），在类加载的时候用静态块儿创建(静态块初始化)，在应用启动的时候创建。
在单线程中，基本大同小异，保证类的实例在整个应用中只有一个，都是没问题的。
但是在多线程环境下，什么时候创建这个实例是要考虑线程安全的。
枚举类型最大的特点就是：构造函数是private修饰的，也就是不能对其进行new，对象的实例都是预定义的，也就是在类加载的时候都是定义好了的，不会给其它调用去创建实例的机会。
结论是，可以模拟这个思路去创建单例，不一定非得用枚举，但是推荐用使用定义枚举的方式去实现单例模式
⑼ java中枚举用来干什么的
枚举是该类型的一个实例，相当于static final 类型的变量，可用于switch中，
//枚举类：
packagecom.golden.test;publicenumOperation{
/**增*/
INSERT,
/**删*/
DELETE,
/**改*/
UPDATE,
/**查*/
QUERY
}
//测试类
packagecom.golden.test;
publicclassTestEnum{
publicstaticvoidmain(String[]args){
System.out.println(Operation.DELETE);
System.out.println(Operation.valueOf("DELETE"));
System.out.println(Operation.valueOf("DELETE")==Operation.DELETE);
System.out.println("DELETE".equals(Operation.DELETE.toString()));
switch(Operation.DELETE){
caseINSERT:/**TODO*/break;
caseDELETE:/**TODO*/System.out.println("DELETE...");break;
caseUPDATE:/**TODO*/break;
caseQUERY:/**TODO*/break;
default:
break;
}
}
}
⑽ java中如何将枚举值用循环输出
java中可以私用enummap来保存枚举值，示例如下：
privatestaticvoidtestEnumMap(){
//1.演示定义EnumMap对象，EnumMap对象的构造函数需要参数传入,默认是key的类的类型
EnumMap<Light,String>currEnumMap=newEnumMap<Light,String>(
Light.class);
currEnumMap.put(Light.RED,"红灯");
currEnumMap.put(Light.GREEN,"绿灯");
currEnumMap.put(Light.YELLOW,"黄灯");
//2.遍历对象
for(LightaLight:Light.values()){
System.out.println("[key="+aLight.name()+",value="
+currEnumMap.get(aLight)+"]");
}
}