java 枚举（网上找的留着温习）

最新推荐文章于 2024-09-16 21:37:07 发布
最新推荐文章于 2024-09-16 21:37:07 发布
阅读量527 收藏
点赞数
文章标签： java integer 游戏 语言 javadoc class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l853967144/article/details/6496157
版权

对枚举类型印象大多来自于C 语言，在 C 语言中，枚举类型是一个 HardCode （硬编码）类型，其使用价值并不大。因此，在 Java 5 之前，枚举是被抛弃的。然而 Java 5 以后的发现版本开始对枚举进行支持，枚举的引入给 Java 世界带来了争议。

笔者比较赞同引入枚举，作为一门通用的静态编程语言，应该是海纳百川的（因此笔者赞成闭包进入Java 7 ），多途径实现功能。

如果您不了解枚举的用法，建议参考笔者以前网络资源，了解基本的用法。 地址为： http://mercyblitz.blog.ccidnet.com/blog-htm-do-showone-uid-45914-type-blog-itemid-189396.html

枚举是一种特殊的（受限制的）类，它具有以下特点：

  1. 可 列性
  2. 常 量性
  3. 强 类型
  4. 类 的特性

留下一个问题-怎么利用这些枚举特点，更好为设计服务呢？根据这些特 点，下面向大家分别得介绍设计技巧。

一、 可 列性

在设计中，必须搞清楚枚举 使 用场景 。 枚 举内部成员都是可列的，或者说固定的。这种硬编码的形式，看上去令人觉得不自在，不过这就是枚举。如果需要动态（不可列）的成员话，请不好使用枚举。

JDK提供不少良好的可列性设计枚举。比如时间单位 java.util.concurrent.TimeUnit 和 线程状态枚举 java.lang.Thread.State 。

 

假设有一个游戏难度枚举，有三种难度NORMAL , MEDIUM, HARD

Java代码
  1. /** 
  2.  
  3.  * 游戏中的难度枚举：NORMAL , MEDIUM, HARD 
  4.  
  5.  *  
  6.  
  7.  * @author mercyblitz 
  8.  
  9.  */  
  10.   
  11. public enum Difficulty {  
  12.   
  13. NORMAL, MEDIUM, HARD //注意：枚举成员命名，请使用英文大写形式  
  14.   
  15. }  

/**

 * 游戏中的难度枚举：NORMAL , MEDIUM, HARD

 * 

 * @author mercyblitz

 */

public enum Difficulty {

NORMAL, MEDIUM, HARD //注意：枚举成员命名，请使用英文大写形式

}

 

 

如果要添加其他成员，只能通过硬编码的方法添加到枚举类。回到枚举Difficulty，低版 本的必定会影响二进制兼容性。对于静态语言来说，是无法避免的，不能认为是枚举的短处。

 

二、 常 量性

之所以定性为常量性，是因为枚举是不能改变，怎么证明 成员其不变呢？利用上面的Difficulty枚举为例，一段简单的代码得到其原型，如下：

Java代码
  1. package org.mercy.design.enumeration;  
  2.   
  3. import java.lang.reflect.Field;  
  4.   
  5. /** 
  6.  * Difficulty 元 信息 
  7.  * @author mercy 
  8.  */  
  9. public class MetaDifficulty {  
  10.   
  11.     public static void main(String[] args) {  
  12.         MetaDifficulty instance = new MetaDifficulty();  
  13.         // 利用反射连接其成员的特性  
  14.         Class<Difficulty> classDifficulty = Difficulty.class;  
  15.         for (Field field : classDifficulty.getFields()) {  
  16.             instance.printFieldSignature(field);  
  17.             System.out.println();  
  18.         }  
  19.     }  
  20.   
  21.     /** 
  22.      * 打 印字段 签名(signature) 
  23.      *  
  24.      * @param field 
  25.      */  
  26.     private void printFieldSignature(Field field) {  
  27.         StringBuilder message = new StringBuilder("字段  ")  
  28.                                 .append(field.getName())  
  29.                                 .append(" 的签名：")  
  30.                                 .append(field.toString())  
  31.                                 .append("/t");  
  32.         System.out.print(message);  
  33.     }  

	package org.mercy.design.enumeration;
	
	import java.lang.reflect.Field;
	
	/**
	 * Difficulty 元信息
	 * @author mercy
	 */
	public class MetaDifficulty {
	
		public static void main(String[] args) {
			MetaDifficulty instance = new MetaDifficulty();
			// 利用反射连接其成员的特性
			Class<Difficulty> classDifficulty = Difficulty.class;
			for (Field field : classDifficulty.getFields()) {
				instance.printFieldSignature(field);
				System.out.println();
			}
		}
	
		/**
		 * 打印字段 签名(signature)
		 * 
		 * @param field
		 */
		private void printFieldSignature(Field field) {
			StringBuilder message = new StringBuilder("字段  ")
									.append(field.getName())
									.append(" 的签名：")
									.append(field.toString())
									.append("/t");
			System.out.print(message);
		}

}

 

 

printFieldSignature 方 法输出枚举 Difficulty的 字段，其结果为：

字段  NORMAL 的签 名：public static final org.mercy.design.enumeration.Difficulty org.mercy.design.enumeration.Difficulty.NORMAL

字段  MEDIUM 的签 名：public static final org.mercy.design.enumeration.Difficulty org.mercy.design.enumeration.Difficulty.MEDIUM

字段  HARD 的签 名：public static final org.mercy.design.enumeration.Difficulty org.mercy.design.enumeration.Difficulty.HARD

 

这个结果得出了两个结论，其一，每个枚举成员是枚举的字段。其二，每个成员都被 public static final。 凡是 static final  变量都是 Java 中的“常量”，其保存在常量池中。根据其常量性和命名规则，建议全大写命名每个枚举的成员（前面提到）。

常量性提供了数据一致性，不必担心被被其他地方修改，同时保证了线程安全。因此在设计过程中，不必担心线程安全问题。

枚举类型是常量，那么在判断是可以使用== 符号来做比较。可是如果枚举成员能够克隆 (Clone) 的话 , 那么 == 比较会失效，从而一致性不能得到保证。如果按照类的定义方法，考虑枚举的话，那么枚举类是集成了 java.lang.Object 类，因此，它继承了 protected java.lang.Object clone() 方法，也就是说支持 clone ，虽然需要通过反射的手段去调用。 Java 语言规范提到，每个枚举继承了 java.lang.Enum<E> 抽象基类。

提供一段测试代码来验明真伪：

Java代码
  1. /** 
  2.  * 指 定的类是枚举java.lang.Enum<E>的子类吗？ 
  3.  *  
  4.  * @param klass 
  5.  * @return 
  6.  */  
  7. private boolean isEnum(Class<?> klass) {  
  8.     Class<?> superClass = klass.getSuperclass();  
  9.     while (true) { // 递归查找  
  10.         if (superClass != null) {  
  11.             if (Enum.class.equals(superClass))  
  12.                 return true;  
  13.         } else {  
  14.             break;  
  15.         }  
  16.         superClass = superClass.getSuperclass();  
  17.     }  
  18.     return false;  
  19. }  

	/**
	 * 指定的类是枚举java.lang.Enum<E>的子类吗？
	 * 
	 * @param klass
	 * @return
	 */
	private boolean isEnum(Class<?> klass) {
		Class<?> superClass = klass.getSuperclass();
		while (true) { // 递归查找
			if (superClass != null) {
				if (Enum.class.equals(superClass))
					return true;
			} else {
				break;
			}
			superClass = superClass.getSuperclass();
		}
		return false;
	}

 

    客户端代码调用： instance.isEnum(Difficulty. class ) ;  结 果返回true ，那么证明了 Difficulty 枚 举继承了java.lang.Enum<E> 抽象基类。

那么java.lang.Enum<E> 有没有覆盖 clone 方法呢？查看一下源代码：

Java代码
  1. /** 
  2.  
  3.      * Throws CloneNotSupportedException.  This guarantees that enums 
  4.  
  5.      * are never cloned, which is necessary to preserve their "singleton" 
  6.  
  7.      * status. 
  8.  
  9.      * 
  10.  
  11.      * @return (never returns) 
  12.  
  13.      */  
  14.   
  15.     protected final Object clone() throws CloneNotSupportedException{  
  16.   
  17. throw new CloneNotSupportedException();  
  18.   
  19. }  

/**

     * Throws CloneNotSupportedException.  This guarantees that enums

     * are never cloned, which is necessary to preserve their "singleton"

     * status.

     *

     * @return (never returns)

     */

    protected final Object clone() throws CloneNotSupportedException{

throw new CloneNotSupportedException();

}

 

 

 

 

很明显，java.lang.Enum<E> 基类 final 定义了 clone 方法，即枚举不支持克隆，并且 Java doc 提到要保持单体性。那么这也是面向对象设计的原则之一 - 对于保持单态性的对象而言，尽可能不支持或者不暴露clone 方法。

 

三、 强 类型

前面的两个特性，在前Java 5 时代，利用了常量字段也可以完成需 要。比如可以这么设计Difficulty类的字段，

 

Java代码
  1. public static final int NORMAL = 1;  
  2.   
  3. public static final int MEDIUM = 2;  
  4.   
  5. public static final int HARD = 3;  

public static final int NORMAL = 1;

public static final int MEDIUM = 2;

public static final int HARD = 3;

 

 

这么设计有一个缺点-弱类型，因为三个字段都是int原生型。

比如有一个方法用于设置游戏难度，定义如下：

Java代码
  1. public void setDifficulty(int difficulty)  

public void setDifficulty(int difficulty)

   

  利用int类型作为参数，可能会有问题-如果参数在NORMAL，MEDIUM，HARD之外int数是可以接受的。利用规约的方法可以避免这个问题，比 如设计范围检查：

Java代码
  1. /** 
  2.  
  3.  * 设置游戏难度 
  4.  
  5.  * @param difficulty 难 度数 
  6.  
  7.  * @throws IllegalArgumentException 
  8.  
  9.  *             如 果参数不是 NORMAL、MEDIUM和Hard其中一个，那么报出IllegalArgumentException 
  10.  
  11.  */  
  12.   
  13. public void setDifficulty(int difficulty)  
  14.   
  15.  throws IllegalArgumentException   

/**

 * 设置游戏难度

 * @param difficulty 难度数

 * @throws IllegalArgumentException

 *             如果参数不是 NORMAL、MEDIUM和Hard其中一个，那么报出IllegalArgumentException

 */

public void setDifficulty(int difficulty)

 throws IllegalArgumentException

 

 

在可能实现方法中，通过三次成员比较，这样比较笨拙和憋足。

如果您在使用Java 5以前版本的话，作者提供一个较好的实现方法:

Java代码
  1. package org.mercy.design.enumeration;  
  2.   
  3. import java.util.Collections;  
  4. import java.util.HashSet;  
  5. import java.util.Set;  
  6. /** 
  7.  * Difficulty JDK1.4 实现　Difficulty枚举 
  8.  * @author mercy 
  9.  */  
  10. public class Difficulty14 {  
  11.     //枚举字段  
  12.     public static final int NORMAL = 1;  
  13.     public static final int MEDIUM = 2;  
  14.     public static final int HARD = 3;  
  15.       
  16.     private final static Set difficulties;  
  17.   
  18.     static {  
  19.         // Hash 提供快速查找  
  20.         HashSet difficultySet = new HashSet();  
  21.         difficultySet.add(Integer.valueOf(NORMAL));  
  22.         difficultySet.add(Integer.valueOf(MEDIUM));  
  23.         difficultySet.add(Integer.valueOf(HARD));  
  24.         //利用不变的对象是一个好的设计实践  
  25.         difficulties= Collections.unmodifiableSet(difficultySet);  
  26.     }  
  27.       
  28.     /** 
  29.      * 设 置游戏难度 
  30.      * @param difficulty 难 度数 
  31.      * @throws IllegalArgumentException 
  32.      *             如果参数不是NORMAL、MEDIUM和Hard其中一个，那么报出 IllegalArgumentException 
  33.      */  
  34.     public void setDifficulty(int difficulty)   
  35.     throws IllegalArgumentException {  
  36.         if(!difficulties.contains(Integer.valueOf(difficulty)))  
  37.             throw new IllegalArgumentException("参数错误");  
  38.         //设置难度...  
  39.     }  
  40. }  

package org.mercy.design.enumeration;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
/**
 * Difficulty JDK1.4实现　Difficulty枚举
 * @author mercy
 */
public class Difficulty14 {
	//枚举字段
	public static final int NORMAL = 1;
	public static final int MEDIUM = 2;
	public static final int HARD = 3;
	
	private final static Set difficulties;

	static {
		// Hash 提供快速查找
		HashSet difficultySet = new HashSet();
		difficultySet.add(Integer.valueOf(NORMAL));
		difficultySet.add(Integer.valueOf(MEDIUM));
		difficultySet.add(Integer.valueOf(HARD));
		//利用不变的对象是一个好的设计实践
		difficulties= Collections.unmodifiableSet(difficultySet);
	}
	
	/**
	 * 设置游戏难度
	 * @param difficulty 难度数
	 * @throws IllegalArgumentException
	 *             如果参数不是NORMAL、MEDIUM和Hard其中一个，那么报出IllegalArgumentException
	 */
	public void setDifficulty(int difficulty) 
	throws IllegalArgumentException {
		if(!difficulties.contains(Integer.valueOf(difficulty)))
			throw new IllegalArgumentException("参数错误");
		//设置难度...
	}
}

 

 

在上面的代码中，尽管提供了范围检查，不过参数范围还是巨大（可以 说是无数），并且是运行时检查。因为 setDifficulty 的 参数是 int的， 客户端调用时候，编译器可以接受 int 以及范围更小的 short 、 byte 等类型。那么违反了 一个良好的实践 -在面向对象设计中，类型范围最好在编译时确定而非运行时。

另一个良好的面向对象实践 -利用对象类型，而不是原生型（如果编程语言支持的话）。 那 么，如果使用java.lang.Integer 取代 int 类型，并且 Integer 是 final 类，没有必要担心多态的情况下，不就可以提供强类型吗？的确，提供了强类型约束，并且更好的锁定类型范围（因为是 final 的）。可是， Integer 的范围在一定程度上，认为是无限的，同时不支持 swtich 语句（ 仅支持 int  、 short 、 byte 和 Java 5  枚举类型）。因此 Integer 还是不合适的。

枚举的常量性和可列性，在Difficulty 场景中尤其适合。

 

四、 类 的特性

已知每个枚举都继承了java.lang.Enun<E> 基类，其既有常量性，同时也有类的特点。尽管它是一种被限制的类，比如name和ordinal字段状态都是有JVM处理的。不过开发人员可以充分的利用 类的特点，作出优美的设计。

枚举既然也是类，那么也遵循类的设计。通过扩张 Difficulty 类， 面向对象的方式来设计枚举。

1.  封 装设计

如果有一个 需求 - Difficulty 持 久化，把其存入 d ifficult ies数 据库表中，并且提供一个唯一的 id 整型值。面向对象的封装，枚举也适用。示例如下：

Java代码
  1. public enum Difficulty {  
  2.     // 注意：枚举成员命名，请使用英文大写形式  
  3.     NORMAL(1), MEDIUM(2), HARD(3);   
  4.     /** 
  5.      * final 修饰字段是一个良好的实践。 
  6.      */  
  7.     final private int id;  
  8.       
  9.     Difficulty(final int id){  
  10.         this.id=id;  
  11.     }  
  12.     /** 
  13.      * 获 得ID 
  14.      * @return 
  15.      */  
  16.     public int getId() {  
  17.         return id;  
  18.     }  
  19. }  

public enum Difficulty {
	// 注意：枚举成员命名，请使用英文大写形式
	NORMAL(1), MEDIUM(2), HARD(3); 
	/**
	 * final修饰字段是一个良好的实践。
	 */
	final private int id;
	
	Difficulty(final int id){
		this.id=id;
	}
	/**
	 * 获得ID
	 * @return
	 */
	public int getId() {
		return id;
	}
}

 

 

通过调用getId 方法可以获取枚举成员的 ID 值。

2.  抽 象设计

在不同的游 戏难度级别中，不同任务的难度值不同（大多数情况是通过值来表示，而非枚举对象本身）。以Difficulty为例，定义一个抽象的方法，计算难度值。

Java代码
  1. /** 
  2.  * 获 取不同任务的难度值 
  3.  *  
  4.  * @param mission 
  5.  * @return 
  6.  * @throws IllegalArgumentException 
  7.  *             如果<code>mission</code> 为负数时。 
  8.  */  
  9. public abstract int getValue(int mission) throws IllegalArgumentException;  

	/**
	 * 获取不同任务的难度值
	 * 
	 * @param mission
	 * @return
	 * @throws IllegalArgumentException
	 *             如果<code>mission</code> 为负数时。
	 */
	public abstract int getValue(int mission) throws IllegalArgumentException;

 

3.  多 态设计

Difficulty 枚举中定义抽象方法getValue，那么其子类必须实现这个方法。不过枚举不能被继承，也不能继承其他类，除了默认额 java.lang.Enum<E>类以外。因此枚举是一个final的版本，不能实现抽象方法？

枚举的特殊 在此，枚举虽然不能显示地利用extends关键字继承，不过它的每个成员都是自己的子类。那么以Difficulty为例，其类层次关系 为：java.lang.Enum<E> -> Difficulty -> HARD。这么看来，每个枚举成员相当于定了一个 final的类内置类。

回到 Difficulty枚举，实现抽象方法如下：

 

 

Java代码
  1. NORMAL(1) {  
  2.         @Override  
  3.         public int getValue(int mission)   
  4.     throws IllegalArgumentException {  
  5.             return mission + this.getId();  
  6.         }  
  7.     },  
  8.     MEDIUM(2) {  
  9.         @Override  
  10.         public int getValue(int mission)   
  11.     throws IllegalArgumentException {  
  12.             return mission * this.getId();  
  13.         }  
  14.     },  
  15.     HARD(3) {  
  16.         @Override  
  17.         public int getValue(int mission)   
  18.     throws IllegalArgumentException {  
  19.             return mission << this.getId();  
  20.         }  
  21.     };  

NORMAL(1) {
		@Override
		public int getValue(int mission) 
	throws IllegalArgumentException {
			return mission + this.getId();
		}
	},
	MEDIUM(2) {
		@Override
		public int getValue(int mission) 
	throws IllegalArgumentException {
			return mission * this.getId();
		}
	},
	HARD(3) {
		@Override
		public int getValue(int mission) 
	throws IllegalArgumentException {
			return mission << this.getId();
		}
	};

 

4.  继 承设计

在上述实现 中，可以观察到一点，每个实现getValue 的方法都利用的 getId() 方法。那么再次说明了枚举类本身也是一个特殊基类，可以定义模板方法。

5.  串 行化设计

在某些设计中，需要把枚举通过串行化。回到 Difficulty14 的 示例中，三个成员变量都是常量，那么 static的 变量是不可能被串行化的。如果去掉 static 修饰，那么语义将会被改变。而枚举不同，所有自定义枚举都是 java.lang.Enum<E> 的 子类，因此所有的枚举都是可序列化的（ java.lang.Enum<E>  实 现了java.io.Serializable ） 。 这也是枚举相对于常量的优势之一。

实现中可以提供类似这样的方法：

Java代码
  1. private void readObject(ObjectInputStream in) throws IOException  
  2.   
  3. private void readObjectNoData() throws ObjectStreamException   

private void readObject(ObjectInputStream in) throws IOException

private void readObjectNoData() throws ObjectStreamException

 

 

总之，枚举也可以像类那样，实现面向对象的特点，不过值得一提的 是， 枚举中应该保持尽量可能少的状态，职责单一的设计。

 

l853967144
关注
Java枚举
走不动的木木
10-23 171
JDK1.5之前的枚举 在JDK1.5之前是没有enum这个关键字的，那么那个时代是怎么实现枚举的呢？主要是通过私有化构造器，然后在类里面创建静态final的对象，在类的外面通过 ** 类名.对象名 ** 来使用枚举的， 如下： class Season{ String name; String description; private Season(String na...
Java 枚举
CHIKA2333的博客
07-31 194
本例和上例的执行结果完全相同。
Java--枚举类型（枚举类型介绍 & 定义枚举类型 & 枚举类型的使用 & 枚举类型的注意事项 & 遍历枚举项）
天行健 君子以自强不息，地势坤 君子以厚德载物。
08-05 1718
1. 枚举类型 1.1 大量使用常量来表示数据存在以下问题: 示例: public static final String WEI_XIN = "weixin"; public static final String WEI_XIN_URL = "https://weixin.qq.com/"; public static final String ZHI_FU_BAO = "zhifubao"; public static final String ZHI_FU_BA
JAVA温习小记-C-01
球状闪电000的博客
07-29 592
重新拾起的原因是因为企业对编程类语言的要求，信息管理岗位的刚需，主要提升对项目的完成能力和编程能力，中后期以大厂的编程算法类题目为主，思维>语法。使用编译器版本：IDEA 2023.03.07参考书籍：Java基础入门第二版北大教授用256个小时讲完的Java课程！Java入门基础视频教程，java零基础自学就选黑马程序员Java入门教程（含Java项目和Java真题）全程二倍速食用除chapter one之外，基础语法不再赘述，关注问题与算法思维。
Java-Java温习之Java中的重点和难点
m0_67322837的博客
03-01 350
Java中有很多内容在开发项目的过程中并不常用，但是却是很重要的部分，为了避免忘记，今天重新温习了一遍Java中的重点和难点，借此机会记录一下方便以后查找。 本文主要分为以下几个部分： 1.进制的相互转换 2.Java中位运算符的解释和运用 3.Java数组中常用的排序算法分析 4.Java中折半查找方法的分析和运用 5.Java中对象的初始化过程 6.Java抽象类在模板方法模式中的运用 7.Java多线程的难点和设计多线程程序时需要注意的问题 8.Java中集合框架运用时需要注意的问题
太肝了 5年来最火183个Java面试问题含答案（
q66562636的博客
05-18 2973
文末有彩蛋 Java 面试随着时间的改变而改变。在过去的日子里，当你知道 String 和 StringBuilder 的区别（String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象。因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后，JVM 的 GC
133个Java面试问题列表
weixin_70730532的博客
09-02 270
Java 面试随着时间的改变而改变。在过去的日子里，当你知道 String 和 StringBuilder 的区别就能让你直接进入第二轮面试，但是现在问题变得越来越高级，面试官问的问题也更深入。在我初入职场的时候，类似于 Vector 与 Array 的区别、HashMap 与 Hashtable 的区别是最流行的问题，只需要记住它们，就能在面试中获得更好的机会，但这种情形已经不复存在。如今，你将会被问到许多 Java 程序员都没有看过的领域，如 NIO，
Java面试常见问题总结
m0_67265464的博客
06-24 638
Java 面试随着时间的改变而改变。在过去的日子里，当你知道 String 和 StringBuilder 的区别就能让你直接进入第二轮面试，但是现在问题变得越来越高级，面试官问的问题也更深入。 在我初入职场的时候，类似于 Vector 与 Array 的区别、HashMap 与 Hashtable 的区别是最流行的问题，只需要记住它们，就能在面试中获得更好的机会，但这种情形已经不复存在。如今，你将会被问到许多 Java 程序员都没有看过的领域，如 NIO，设计模式，成熟的单元测试，或者那些很难掌握的知识，
各个平台3年来最火的183个Java面试问题，太透了！（建议收藏）
m0_73256420的博客
08-20 930
文末有彩蛋Java 面试随着时间的改变而改变。在过去的日子里，当你知道 String 和 StringBuilder 的区别（String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象。因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后，JVM 的 GC 就会
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1113
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 155
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 919
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 346
spirng security中的几大组件的差异和执行顺序
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-16 840
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1196
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1069
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
07_Python数据类型_集合
最新发布
fx_yzjy101的专栏
09-16 410
可以使用大括号 {} 或者 set() 函数来创建集合。如果使用大括号，则至少需要包含一个元素；如果使用 set()，则可以创建一个空集合。# 创建一个空集合# 创建一个包含一个元素的集合# 创建一个包含几个元素的集合。
JAVA开源项目 在线视频教育平台 计算机毕业设计
as230627的博客
09-14 1047
基于Vue.js和SpringBoot的在线视频教育平台是一个功能丰富的系统，它包括管理后台和用户网页端，为管理员、普通用户和教师角色提供了不同的功能。在管理后台，管理员可以进行用户管理，包括用户信息的增删改查。
Java 枚举用法详解
枚举的构造函数默认是私有的，这意味着外部代码不能直接创建新的枚举实例，只能通过枚举类自身来创建。这保证了枚举的封闭性，避免了意外创建额外的实例。 4. **枚举的遍历** Java枚举可以方便地进行迭代，例如：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值