Java开发的23种设计模式详解（创建型模式）

最新推荐文章于 2021-03-29 14:25:03 发布
最新推荐文章于 2021-03-29 14:25:03 发布
阅读量242 收藏 1
点赞数
分类专栏： Java 设计模式 文章标签： 创建型模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43611145/article/details/89646742
版权

Java开发的23种设计模式详解（创建型模式）

相关文章链接：

相关文章链接 第1节 设计模式

观前提示：

本文所使用Eclipse版本为Photon Release (4.8.0)，Idea版本为ultimate 2019.1，JDK版本为1.8.0_141。

1.单例模式

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。

1.1 要点

  1. 某个类只能有一个实例。
  2. 它必须自行创建这个实例。
  3. 它必须自行向整个系统提供这个实例。

1.2 构建方式

  1. 懒汉方式。指全局的单例实例在第一次被使用时构建。
  2. 饿汉方式。指全局的单例实例在类装载时构建。

1.2.1 懒汉方式

package singleton;

public class LazySingleton {

	private static LazySingleton instance = null;
	
	/**
	 * @Description 私有默认构造方法，防止被实例化
	 */
	private LazySingleton() {}
	
	/**
	 * @Description 静态工厂方法，创建实例
	 * @return
	 */
	public static LazySingleton getInstance() {
		if(instance == null) {
			instance = new LazySingleton(); 
		}
		return instance;
	}
}

1.2.2 饿汉方式

package singleton;

public class HungrySingleton {

	private static HungrySingleton instance = new HungrySingleton();
	
	/**
	 * @Description 私有默认构造方法，防止被实例化
	 */
	private HungrySingleton() {}
	
	/**
	 * @Description 静态工厂方法，创建实例
	 * @return
	 */
	public static HungrySingleton getInstance() {
		return instance;
	}
}

1.3 优缺点

优点

  1. 实例控制。单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

  2. 灵活性。因为类控制了实例化过程，所以类可以灵活更改实例化过程。

缺点

  1. 开销。虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。

  2. 可能的开发混淆。使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。

  3. 对象生存期。不能解决删除单个对象的问题。在提供内存管理的语言中(例如基于 .NET Framework的语言)，只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。

2.工厂方法模式

如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”，它不属于 GoF 的 23 种经典设计模式，它的缺点是增加新产品时会违背“开闭原则”。

作为抽象工厂模式的孪生兄弟，工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，也就是说工厂方法模式让实例化推迟到子类。

工厂方法模式非常符合“开闭原则”，当需要增加一个新的产品时，我们只需要增加一个具体的产品类和与之对应的具体工厂即可，无须修改原有系统。同时在工厂方法模式中用户只需要知道生产产品的具体工厂即可，无须关系产品的创建过程，甚至连具体的产品类名称都不需要知道。虽然他很好的符合了“开闭原则”，但是由于每新增一个新产品时就需要增加两个类，这样势必会导致系统的复杂度增加

举例如下（生产hat和shirt的工厂）

定义公共接口Clothes.java

package factory;

public interface Clothes {

	public void produce();
}

创建实现类Hat.java，Shirt.java

package factory;

public class Hat implements Factory {

	@Override
	public void produce() {
		System.out.println("Produce Hat");
	}
}

package factory;

public class Shirt implements Factory {

	@Override
	public void produce() {
		System.out.println("Produce Shirt");
	}
}

创建工厂Factory.java

package factory;

public class Factory {

	public Clothes doProduce(String type) {
		if("shirt".equals(type)) {
			return new ShirtFactory();
		} else if("hat".equals(type)) {
			return new HatFactory();
		} else {
			System.out.println("请输入正确的类型");
			return null;
		}
	}
}

编写测试方法FactoryTest.java

package factory;

public class FactoryTest {

	public static void main(String[] args) {
		Factory factory = new Factory();
		Clothes clothes = factory.doProduce("hat");
		clothes.produce();
	}
}

结果如图
在这里插入图片描述

3.抽象工厂模式

为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。

3.1 例子

定义公共接口Clothes.java，Pants.java

package abstractFactory;

public interface Clothes {

	public void produceClothes();
}

package abstractFactory;

public interface Pants {

	public void producePants();
}

具体实现类Sweater.java，Shirt.java，Jeans.java，Trousers.java

package abstractFactory;

public class Sweater implements Clothes {

	@Override
	public void produceClothes() {
		System.out.println("Produce Sweater");
	}
}

package abstractFactory;

public class Shirt implements Clothes {

	@Override
	public void produceClothes() {
		System.out.println("Produce Shirt");
	}
}

package abstractFactory;

public class Jeans implements Pants {

	@Override
	public void producePants() {
		System.out.println("Produce Jeans");
	}
}

package abstractFactory;

public class Trousers implements Pants {

	@Override
	public void producePants() {
		System.out.println("Produce Trousers");
	}
}

定义抽象的工厂接口，一系列的获取实例的接口方法AbstractFactory.java

package abstractFactory;

public interface AbstractFactory {

	Clothes getClothes();
	
	Pants getPants();
}

定义具体的工厂实现类ClothingAbstractFactory1.java，ClothingAbstractFactory.java

package abstractFactory;

public class ClothingAbstractFactory1 implements AbstractFactory {

	@Override
	public Clothes getClothes() {
		return new Sweater();
	}

	@Override
	public Pants getPants() {
		return new Jeans();
	}
}

package abstractFactory;

public class ClothingAbstractFactory2 implements AbstractFactory {

	@Override
	public Clothes getClothes() {
		return new Shirt();
	}

	@Override
	public Pants getPants() {
		return new Trousers();
	}
}

编写测试方法AbstractFactoryTest.java

package abstractFactory;

public class AbstractFactoryTest {

	public static void main(String[] args) {
		AbstractFactory factory1 = new ClothingAbstractFactory1();
		Clothes clothes1 = factory1.getClothes();
		clothes1.produceClothes();
		Pants pants1 = factory1.getPants();
		pants1.producePants();
		
		AbstractFactory factory2 = new ClothingAbstractFactory2();
		Clothes clothes2 = factory2.getClothes();
		clothes2.produceClothes();
		Pants pants2 = factory2.getPants();
		pants2.producePants();
	}
}

结果如图
在这里插入图片描述

3.2 优缺点

优点：

  1. 它分离了具体的类

  2. 它使得易于交换产品系列

  3. 它有利于产品的一致性

缺点：

  1. 难以支持新种类的产品

4.建造者模式

建造者模式是设计模式的一种，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式是一种对象创建型模式。

建造者模式一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

4.1 适用场景

  1. 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。

  2. 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。

  3. 对象的创建过程独立于创建该对象的类。在建造者模式中通过引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类和客户类中。

  4. 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

4.2 角色

  1. Builder（抽象建造者）：为创建一个产品对象的各个部件指定抽象接口。

  2. ConcreteBuilder（具体建造者）：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。

  3. Director（指挥者）：构造一个使用Builder接口的对象。

  4. Product（产品角色）：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

4.3 例子

产品角色Animal.java

package builder;

public class Animal {

	private String eat;
	private String run;
	private String sleep;
	private String drink;
	public String getEat() {
		return eat;
	}
	public void setEat(String eat) {
		this.eat = eat;
	}
	public String getRun() {
		return run;
	}
	public void setRun(String run) {
		this.run = run;
	}
	public String getSleep() {
		return sleep;
	}
	public void setSleep(String sleep) {
		this.sleep = sleep;
	}
	public String getDrink() {
		return drink;
	}
	public void setDrink(String drink) {
		this.drink = drink;
	}
	@Override
	public String toString() {
		return "Animal [eat=" + eat + ", run=" + run + ", sleep=" + sleep + ", drink=" + drink + "]";
	}
}

抽象建造者AnimalBuilder.java

package builder;

public abstract class AnimalBuilder {

	protected Animal animal = new Animal();
	
	public abstract void eat();
	public abstract void run();
	public abstract void sleep();
	public abstract void drink();
	
	public Animal createAnimal() {
		return animal;
	}
}

具体建造者DogBuilder.java，CatBuilder.java

package builder;

public class DogBuilder extends AnimalBuilder{

	@Override
	public void eat() {
		animal.setEat("Dog Eat!");
	}

	@Override
	public void run() {
		animal.setRun("Dog Run!");
	}

	@Override
	public void sleep() {
		animal.setSleep("Dog Sleep!");
	}

	@Override
	public void drink() {
		animal.setDrink("Dog Drink!");
	}

}

package builder;

public class CatBuilder extends AnimalBuilder{

	@Override
	public void eat() {
		animal.setEat("Cat Eat!");
	}

	@Override
	public void run() {
		animal.setRun("Cat Run!");
	}

	@Override
	public void sleep() {
		animal.setSleep("Cat Sleep!");
	}

	@Override
	public void drink() {
		animal.setDrink("Cat Drink!");
	}

}

指挥者AnimalDirector.java

package builder;

public class AnimalDirector {

	public Animal contruct(AnimalBuilder builder) {
		//逐步创建复杂对象
		Animal animal;
		builder.eat();
		builder.run();
		builder.sleep();
		builder.drink();
		animal = builder.createAnimal();
		return animal;
	}
}

测试类Test.java

package builder;

public class Test {

	public static void main(String[] args) {
		AnimalDirector animalDirector = new AnimalDirector();
		
		AnimalBuilder dogBuilder = new DogBuilder();
		Animal dog = animalDirector.contruct(dogBuilder);
		System.out.println(dog);
		
		AnimalBuilder catBuilder = new CatBuilder();
		Animal cat = animalDirector.contruct(catBuilder);
		System.out.println(cat);
	}
}

测试结果
在这里插入图片描述

4.4 优缺点

优点

  1. 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
    每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。由于指挥者类针对抽象建造者编程，增加新的具体建造者无须修改原有类库的代码，系统扩展方便，符合 “开闭原则”。

  2. 可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

缺点

  1. 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，例如很多组成部分都不相同，不适合使用建造者模式，因此其使用范围受到一定的限制。

  2. 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，增加系统的理解难度和运行成本。

5.原型模式

原型模式是一种创建型设计模式，Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

5.1 适用场景

  1. 对象种类繁多，无法将他们整合到一个类的时候；

  2. 难以根据类生成实例时；

  3. 想解耦框架与生成的实例时。

5.2 角色

  1. Prototype（抽象原型类）：声明克隆自身的接口。

  2. ConcretePrototype（具体原型类）：实现克隆的具体操作。

  3. Client（客户类）：让一个原型克隆自身，从而获得一个新的对象。

5.3 例子

具体原型类AnimalPrototype.java

package prototype;

public class AnimalPrototype implements Cloneable{

	private String name;
	
	private String head;
	private String hand;
	private String foot;
	
	private String eat;
	private String run;
	private String sleep;
	private String drink;
	
	public AnimalPrototype(String name) {
		this.name = name;
	}
	
	public void setAnimalBody(String head, String hand, String foot) {
		this.head = head;
		this.hand = hand;
		this.foot = foot;
	}
	
	public void setAnimalBehavior(String eat, String run, String sleep, String drink) {
		this.eat = eat;
		this.run = run;
		this.sleep = sleep;
		this.drink = drink;
	}
	
	/**
	 * 克隆该实例
	 */
	public Object clone() {
		AnimalPrototype animalPrototype = null;
		try {
			animalPrototype = (AnimalPrototype) super.clone();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return animalPrototype;
	}

	@Override
	public String toString() {
		return "AnimalPrototype [name=" + name + ", head=" + head + ", hand=" + hand + ", foot=" + foot + ", eat=" + eat
				+ ", run=" + run + ", sleep=" + sleep + ", drink=" + drink + "]";
	}
}

客户端测试类ClientTest.java

package prototype;

public class ClientTest {

	public static void main(String[] args) {
		//原型对象dog
		AnimalPrototype dog = new AnimalPrototype("Dog");
		dog.setAnimalBody("Dog Head", "Dog Hand", "Dog Foot");
		dog.setAnimalBehavior("Dog Eat", "Dog Run", "Dog Sleep", "Dog Drink");
		
		//克隆对象wolfDog
		AnimalPrototype wolfDog = (AnimalPrototype) dog.clone();
		
		//输出dog与wolfDog
		System.out.println(dog.toString());
		System.out.println(wolfDog.toString());
		
		//测试dog==wolfDog，对任何的对象x，都有x.clone() !=x，即克隆对象与原对象不是同一个对象
		System.out.println("dog == wolfDog :" + (dog == wolfDog));
		
		//对任何的对象x，都有x.clone().getClass()==x.getClass()，即克隆对象与原对象的类型一样。
		System.out.println("dog.getClass() == wolfDog.getClass() :" + (dog.getClass() == wolfDog.getClass()));
	}
}

测试结果
在这里插入图片描述

5.4 优缺点

优点

  1. 当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程，通过一个已有实例可以提高新实例的创建效率。

  2. 可以动态增加或减少产品类。

  3. 原型模式提供了简化的创建结构。

  4. 可以使用深克隆的方式保存对象的状态。

缺点

  1. 需要为每一个类配备一个克隆方法，而且这个克隆方法需要对类的功能进行通盘考虑，这对全新的类来说不是很难，但对已有的类进行改造时，不一定是件容易的事，必须修改其源代码，违背了“开闭原则”。

  2. 在实现深克隆时需要编写较为复杂的代码。

V5放纵丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java的23种设计模式，详细讲解（二）
不喝枸杞的程序员
10-16 225
1. 责任链（Chain Of Responsibility） Intent 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链发送该请求，直到有一个对象处理它为止。 Class Diagram Handler：定义处理请求的接口，并且实现后继链（successor） Implementation publi...
JAVA开发的23种设计模式之 --- 解释器模式
叶孤心的专栏
09-07 376
解释器模式 概述 : 给定一个语言,定义它的文法表示,并定义一个解释器,这个解释器使用该标识来解释语言中的句子.使用场景 : 如果一种特定类型的问题发生的频率足够高,那么可能就值得将该问题的各个实例表述为一个简单语言中的句子.这样就可以构建一个解释器,该解释器通过解释这些句子来解决该问题.解释器模式的结构 : 抽象解释器 : 声明一个所有具体表达式都要实现的抽象接口(或者抽象类),接口
学习、探究Java设计模式——装饰者模式
热门推荐
蓝天白云梦的csdn博客
08-03 1万+
定义装饰者模式：在不改变原类文件以及不使用继承的情况下，动态地将责任附加到对象上，从而实现动态拓展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。设计原则要使用装饰者模式，需要满足以下设计原则： 1、多用组合，少用继承 2、开放-关闭原则：类应该对拓展开放，对修改关闭UML类图我们先来看看装饰者模式的类图，再来详细讲述： 由上自下： 1、Component是基类。通常是
设计模式__概述
茨时代べ 的博客
03-15 336
1. 设计模式有两种分类方法，即根据模式的目的来分和根据模式的作用的范围来分。 根据目的来分 根据模式是用来完成什么工作来划分，这种方式可分为创建型模式、结构型模式和行为型模式 3 种。 创建型模式：“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。 结构型模式：如何将类或对象按某种布局组成更大的结构 行为型模式：类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样...
Java-设计模式分类(创建型,结构型,行为型)
qq_36138652的博客
03-29 449
创建型(Creational):主要用于创建对象 工厂方法模式(Factory Method) 将类的实例化操作延迟到子类中完成,即由子类来决定究竟应该实例化(创建)哪个类 抽象工厂方法模式(Abstract Factory) 提供了一个创建一系列相关或者相互依赖对象的接口,而无需指定他们具体的类 建造者模式(Builder) 将一个复杂对象构建与他表示分离,使得同样的构建过程可以创建不同表示 原型模式(Prototype)...
Java的23种设计模式(0)23种设计模式分类与简介
NothingToSay
06-02 110
文章目录什么是设计模式设计模式的三个分类创建型模式结构型模式行为型模式 什么是设计模式 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们
Java的23 种设计模式的分类和功能以及简单介绍
zhaoquanwei2018的博客
12-27 258
设计模式有两种分类方法，即根据模式的目的来分和根据模式的作用的范围来分。 1. 根据目的来分 根据模式是用来完成什么工作来划分，这种方式可分为创建型模式、结构型模式和行为型模式3 种。 创建型模式：用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。GoF 中提供了单例、原型、工厂方法、抽象工厂、建造者等 5 种创建型模式。这样可以降低系统的耦合度，使用者不需要关注对象的创...
Java设计模式-23种设计模式详解
11-24
Java设计模式详解 Java设计模式是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。 设计模式的六大原则...
Java设计模式之23种设计模式详解
08-18
"Java设计模式之23种设计模式详解" Java设计模式是软件工程的基石，项目中合理的运用设计模式可以完美的解决很多问题。设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计...
Java开发中的23种设计模式详解.docx
最新发布
08-25
Java开发中的23种设计模式是软件设计的重要组成部分，它们为编写可维护、可扩展和高效代码提供了蓝图。设计模式是经过时间和实践验证的解决方案，用于解决常见的软件设计问题。这些模式通常分为三类：创建型、结构型...
java23种设计模式详解+源码(绝对详解)
08-10
在Java编程中，有23种经典的GoF（Gang of Four）设计模式，它们被分为三大类：创建型、结构型和行为型。本资源集合了这些模式的详细解释与源码分析，旨在帮助开发者深入理解和应用设计模式。 1. 创建型模式...
详解基于JWT的token认证（Java实现）
weixin_43611145的博客
03-04 2678
详解基于JWT的token认证（Java实现）1.简介2.JWT2.1 header2.2 payload2.3 signature3.使用4.例子 观前提示： 本文所使用的IDEA版本为ultimate 2019.1，JDK版本为1.8.0_141。 1.简介 在计算机身份认证中是令牌（临时）的意思，token其实说的更通俗点可以叫暗号，在一些数据传输之前，要先进行暗号的核对，不同的暗号被授权不...
Windows配置JDK、Tomcat环境变量
weixin_43611145的博客
05-26 2483
Windows配置JDK、Tomcat环境变量 1.配置JDK环境变量 1.1 将jdk和jre安装在同一Java目录下 1.2 此电脑右键->属性->高级系统设置->环境变量 1.3 系统变量->新建 JAVA_HOME 变量 变量值为安装的jdk目录（例：我的jdk目录：D:\Program Files\Java\jdk1.8.0_141） 1.4 系统变量-&g...
IDEA安装阿里代码规范检查插件
weixin_43611145的博客
06-29 2434
IDEA安装阿里代码规范检查插件1.安装插件2.下载本地zip包插件并安装3.代码检查 观前提示： 本文所使用的IDEA版本为ultimate 2019.1。 近来，公司要求代码规范检查，自己想提前自检一遍，这时，阿里代码规范检查插件便是不二之选。 接下来，便是如何安装阿里代码规范检查插件的步骤讲解。 1.安装插件 File->Settings… 选择Plugins->Maketplace->搜索框输入Alibaba->找到Alibaba Java Coding Guideline
java值传递和引用传递（附实例）
weixin_43611145的博客
12-16 1946
java值传递和引用传递1.数据类型1.1 基本数据类型1.2 引用数据类型2.形参与实参 观前提示： 本文所使用的IDEA版本为ultimate 2019.1，JDK版本为1.8.0_141。 1.数据类型 1.1 基本数据类型 基本数据类型包括数值型（整数型和浮点型），字符型和布尔型 整数型：byte，short，int，long 浮点型：float，double 字符型：char 布尔型：...
dom4j解析及生成XML
weixin_43611145的博客
05-19 1514
dom4j解析XML 1.概述 dom4j是一个Java的XML API，是jdom的升级品，用来读写XML文件的。dom4j是一个十分优秀的JavaXML API，具有性能优异、功能强大和极其易使用的特点，它的性能超过sun公司官方的dom技术，同时它也是一个开放源代码的软件，可以在SourceForge上找到它。在IBM developerWorks上面还可以找到一篇文章，对主流的Java X...
IDEA 使用外部Tomcat运行JavaWeb项目Js乱码解决
weixin_43611145的博客
11-18 1431
IDEA 使用外部Tomcat运行JavaWeb项目Js乱码解决1.IDEA 使用外部Tomcat运行JavaWeb项目Js乱码1.1 修改IDEA配置文件1.2 设置全局和项目编码1.3 配置外部Tomcat1.4 Maven项目配置2.Tomcat运行Maven打war包Js乱码2.1 配置server.xml2.2 配置catalina.bat启动文件2.3 配置注册表（此步解决cmd控制台输出乱码）3.可能出现的问题3.1.配置完第2点后，IDEA启动不了项目 观前提示： 本文所使用的IDEA版本为
JAVA异常与错误
weixin_43611145的博客
10-08 1393
JAVA异常与错误1.错误与异常 1.错误与异常 还有一点注意的是，catch与finally语句块并不会因为return的操作而受到影响： package Exception; public class Test { public static void main(String[] args) { try { int a = 1/0; return; } catch (...
Java开发23种设计模式详解：提升工程化与代码复用
Java开发中的23种设计模式是软件工程中的核心概念，它们提供了在面向对象编程中解决常见问题的标准解决方案。本文旨在详细介绍这23种模式，帮助开发者提升代码质量、可读性和可维护性。设计模式主要分为三类： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值