了解java设计模式：常用的7种设计模式简介，需要具体代码示例
java设计模式是一种解决软件设计问题的通用解决方案，它提供了一套被广泛接受的设计思想与行为准则。设计模式帮助我们更好地组织和规划代码结构，使得代码具有更好的可维护性、可读性和可扩展性。在本文中，我们将介绍java中常用的7种设计模式，并提供相应的代码示例。
单例模式（singleton pattern）：
单例模式保证一个类只有一个实例，并提供一个全局访问点。这在需要共享资源或限制对象个数的场景中非常有用。下面是一个单例模式的代码示例：public class singleton { private static singleton instance; private singleton() { // 私有构造函数，防止外部实例化 } public static singleton getinstance() { if (instance == null) { synchronized (singleton.class) { if (instance == null) { instance = new singleton(); } } } return instance; }}
工厂模式（factory pattern）：
工厂模式通过一个工厂类来创建对象，封装了对象的创建过程。这可以隐藏对象的具体实现细节，使得客户端的代码更加简洁和可扩展。下面是一个工厂模式的代码示例：public interface shape { void draw();}public class circle implements shape { @override public void draw() { system.out.println("circle::draw()"); }}public class rectangle implements shape { @override public void draw() { system.out.println("rectangle::draw()"); }}public class shapefactory { public shape getshape(string shapetype) { if (shapetype == null) { return null; } if (shapetype.equalsignorecase("circle")) { return new circle(); } else if (shapetype.equalsignorecase("rectangle")) { return new rectangle(); } return null; }}
观察者模式（observer pattern）：
观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生变化时，依赖于它的其他对象将自动更新。这在事件驱动、发布-订阅，以及gui开发中非常有用。下面是一个观察者模式的代码示例：import java.util.arraylist;import java.util.list;public class subject { private list<observer> observers = new arraylist<>(); private int state; public int getstate() { return state; } public void setstate(int state) { this.state = state; notifyallobservers(); } public void attach(observer observer) { observers.add(observer); } public void notifyallobservers() { for (observer observer : observers) { observer.update(); } }}public abstract class observer { protected subject subject; public abstract void update();}public class binaryobserver extends observer { public binaryobserver(subject subject) { this.subject = subject; this.subject.attach(this); } public void update() { system.out.println("binary string: " + integer.tobinarystring(subject.getstate())); }}public class octalobserver extends observer { public octalobserver(subject subject) { this.subject = subject; this.subject.attach(this); } public void update() { system.out.println("octal string: " + integer.tooctalstring(subject.getstate())); }}public class hexobserver extends observer { public hexobserver(subject subject) { this.subject = subject; this.subject.attach(this); } public void update() { system.out.println("hex string: " + integer.tohexstring(subject.getstate())); }}public class observerpatterndemo { public static void main(string[] args) { subject subject = new subject(); new binaryobserver(subject); new octalobserver(subject); new hexobserver(subject); system.out.println("first state change: 15"); subject.setstate(15); system.out.println("second state change: 10"); subject.setstate(10); }}
建造者模式（builder pattern）：
建造者模式通过将对象的构建过程分离，使得相同的构建过程可用于创建不同的表示。这可以提高代码的灵活性和可读性，并且可以避免构建参数过多的问题。下面是一个建造者模式的代码示例：public class computer { private string cpu; private string memory; private string disk; // 省略其他属性和方法}public interface computerbuilder { computerbuilder setcpu(string cpu); computerbuilder setmemory(string memory); computerbuilder setdisk(string disk); computer build();}public class basiccomputerbuilder implements computerbuilder { private computer computer; public basiccomputerbuilder() { computer = new computer(); } public computerbuilder setcpu(string cpu) { computer.setcpu(cpu); return this; } public computerbuilder setmemory(string memory) { computer.setmemory(memory); return this; } public computerbuilder setdisk(string disk) { computer.setdisk(disk); return this; } public computer build() { return computer; }}public class director { private computerbuilder computerbuilder; public director(computerbuilder computerbuilder) { this.computerbuilder = computerbuilder; } public computer construct() { return computerbuilder .setcpu("i5") .setmemory("8gb") .setdisk("1tb") .build(); }}public class builderpatterndemo { public static void main(string[] args) { computerbuilder computerbuilder = new basiccomputerbuilder(); director director = new director(computerbuilder); computer computer = director.construct(); system.out.println(computer.tostring()); }}
原型模式（prototype pattern）：
原型模式通过复制现有对象来创建新对象，而不是重新创建。这可以提高对象的创建效率，尤其是在对象的初始化过程比较复杂时。下面是一个原型模式的代码示例：public abstract class shape implements cloneable { private string id; protected string type; abstract void draw(); public string getid() { return id; } public void setid(string id) { this.id = id; } public object clone() { object clone = null; try { clone = super.clone(); } catch (clonenotsupportedexception e) { e.printstacktrace(); } return clone; }}public class circle extends shape { public circle() { type = "circle"; } public void draw() { system.out.println("inside circle::draw() method."); }}public class rectangle extends shape { public rectangle() { type = "rectangle"; } public void draw() { system.out.println("inside rectangle::draw() method."); }}public class shapecache { private static map<string, shape> shapemap = new hashmap<>(); public static shape getshape(string shapeid) { shape cachedshape = shapemap.get(shapeid); return (shape) cachedshape.clone(); } public static void loadcache() { circle circle = new circle(); circle.setid("1"); shapemap.put(circle.getid(), circle); rectangle rectangle = new rectangle(); rectangle.setid("2"); shapemap.put(rectangle.getid(), rectangle); }}public class prototypepatterndemo { public static void main(string[] args) { shapecache.loadcache(); shape clonedshape1 = shapecache.getshape("1"); system.out.println("shape: " + clonedshape1.gettype()); shape clonedshape2 = shapecache.getshape("2"); system.out.println("shape: " + clonedshape2.gettype()); }}
适配器模式（adapter pattern）：
适配器模式将一个类的接口转换成客户端所期望的另一个接口。这可以在不改变现有代码的情况下，为不兼容的接口之间提供协同工作的能力。下面是一个适配器模式的代码示例：public interface mediaplayer { void play(string audiotype, string filename);}public interface advancedmediaplayer { void playvlc(string filename); void playmp4(string filename);}public class vlcplayer implements advancedmediaplayer { public void playvlc(string filename) { system.out.println("playing vlc file. name: " + filename); } public void playmp4(string filename) { // 空实现 }}public class mp4player implements advancedmediaplayer { public void playvlc(string filename) { // 空实现 } public void playmp4(string filename) { system.out.println("playing mp4 file. name: " + filename); }}public class mediaadapter implements mediaplayer { advancedmediaplayer advancedmediaplayer; public mediaadapter(string audiotype) { if (audiotype.equalsignorecase("vlc")) { advancedmediaplayer = new vlcplayer(); } else if (audiotype.equalsignorecase("mp4")) { advancedmediaplayer = new mp4player(); } } public void play(string audiotype, string filename) { if (audiotype.equalsignorecase("vlc")) { advancedmediaplayer.playvlc(filename); } else if (audiotype.equalsignorecase("mp4")) { advancedmediaplayer.playmp4(filename); } }}public class audioplayer implements mediaplayer { mediaadapter mediaadapter; public void play(string audiotype, string filename) { if (audiotype.equalsignorecase("mp3")) { system.out.println("playing mp3 file. name: " + filename); } else if (audiotype.equalsignorecase("vlc") || audiotype.equalsignorecase("mp4")) { mediaadapter = new mediaadapter(audiotype); mediaadapter.play(audiotype, filename); } else { system.out.println("invalid media. " + audiotype + " format not supported"); } }}public class adapterpatterndemo { public static void main(string[] args) { audioplayer audioplayer = new audioplayer(); audioplayer.play("mp3", "beyond_the_horizon.mp3"); audioplayer.play("mp4", "alone.mp4"); audioplayer.play("vlc", "far_far_away.vlc"); audioplayer.play("avi", "mind_me.avi"); }}
策略模式（strategy pattern）：
策略模式定义了一系列的算法，并将每个算法封装起来，使得它们可以互相替换。这样可以方便地切换算法或扩展新的算法，而不影响其他部分的代码。下面是一个策略模式的代码示例：public interface strategy { int dooperation(int num1, int num2);}public class operationadd implements strategy { public int dooperation(int num1, int num2) { return num1 + num2; }}public class operationsubtract implements strategy { public int dooperation(int num1, int num2) { return num1 - num2; }}public class operationmultiply implements strategy { public int dooperation(int num1, int num2) { return num1 * num2; }}public class context { private strategy strategy; public context(strategy strategy) { this.strategy = strategy; } public int executestrategy(int num1, int num2) { return strategy.dooperation(num1, num2); }}public class strategypatterndemo { public static void main(string[] args) { context context = new context(new operationadd()); system.out.println("10 + 5 = " + context.executestrategy(10, 5)); context = new context(new operationsubtract()); system.out.println("10 - 5 = " + context.executestrategy(10, 5)); context = new context(new operationmultiply()); system.out.println("10 * 5 = " + context.executestrategy(10, 5)); }}
通过以上示例代码，我们对java中常用的7种设计模式进行了简单的介绍。每一种设计模式都有不同的场景和应用，它们可以在不同的项目中发挥作用。希望这篇文章可以帮助你了解并应用设计模式，并提升你的代码质量和开发效率。
以上就是深入了解常用的7种java设计模式的详细内容。