设计模式（JAVA）

最新推荐文章于 2023-06-10 18:46:24 发布
最新推荐文章于 2023-06-10 18:46:24 发布
阅读量295 收藏 1
点赞数
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43337444/article/details/118569865
版权

设计模式

一、简单工厂模式

简述：一个工厂，想要什么自己就生产什么
图例：
在这里插入图片描述

package 设计模式.简单工厂模式;
//抽象产品类
public interface TV {
   
    public void play();
}

package 设计模式.简单工厂模式;
//具体产品类
public class HaierTV implements TV{
   

    @Override
    public void play() {
   
        System.out.println("海尔电视机播放中...");
    }
}

package 设计模式.简单工厂模式;
//具体产品类
public class HisenseTV implements TV{
   
    @Override
    public void play() {
   
        System.out.println("海信电视机播放中...");
    }
}

package 设计模式.简单工厂模式;
//工厂类
public class TVFactory {
   
    public static TV productTV(String brand) throws Exception {
   
        if(brand.equalsIgnoreCase("Haier"))
        {
   
            System.out.println("电视机工厂生产海尔电视机！");
            return new HaierTV();
        }
        else if(brand.equalsIgnoreCase("Hisense"))
        {
   
            System.out.println("电视机工厂生产海信电视机！");
            return new HisenseTV();
        }
        else
        {
   
            throw new Exception("对不起，咱不能生产该品牌电视机！");
        }
    }
}

配置文件

<?xml version="1.0" encoding="utf-8" ?>
<config>
    <brandName>Haier</brandName>
</config>

package 设计模式.简单工厂模式;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.File;
//XML操作工具类
public class XMLUtilTV {
   
    public static String getBrandName()
    {
   
        try {
   
            //创建文档对象
            DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
            DocumentBuilder builder=dFactory.newDocumentBuilder();
            Document doc;
            doc=builder.parse(new File("src/设计模式/简单工厂模式/configTV.xml"));
            NodeList nl=doc.getElementsByTagName("brandName");
            Node classNode=nl.item(0).getFirstChild();
            String brandName=classNode.getNodeValue().trim();
            return brandName;
        } catch (Exception e) {
   
            e.printStackTrace();
            return null;
        }

    }
}

package 设计模式.简单工厂模式;

public class Cilent {
   
    public static void main(String[] args)
    {
   
        try {
   
            TV tv;
            String brandName=XMLUtilTV.getBrandName();
            tv=TVFactory.productTV(brandName);
            tv.play();
        } catch (Exception e) {
   
            e.printStackTrace();
        }
    }
}

二、工厂方法模式

简述：多个工厂，不同工厂生产各自的产品
图例：
在这里插入图片描述

package 设计模式.工厂方法模式;
//抽象产品类
public interface TV {
   
    public void play();
}

package 设计模式.工厂方法模式;
//具体产品类
public class HaierTV implements TV{
   
    @Override
    public void play() {
   
        System.out.println("海尔电视机播放中...");
    }
}

package 设计模式.工厂方法模式;
//具体产品类
public class HisenseTV implements TV{
   
    @Override
    public void play() {
   
        System.out.println("海信电视机播放中...");
    }
}

package 设计模式.工厂方法模式;
//抽象工厂类
public interface TVFactory {
   
    public TV productTV();
}

package 设计模式.工厂方法模式;

public class HaierTVFactory implements TVFactory{
   
    @Override
    public TV productTV() {
   
        System.out.println("海尔电视机工厂生产海尔电视机.");
        return new HaierTV();
    }
}

package 设计模式.工厂方法模式;

public class HisenseTVFactory implements TVFactory{
   
    @Override
    public TV productTV() {
   
        System.out.println("海信电视机工厂生产海信电视机。");
        return new HisenseTV();
    }
}

配置文件

<?xml version="1.0" encoding="utf-8" ?>
<config>
    <className>HaierTVFactory</className>
</config>

package 设计模式.工厂方法模式;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;

public class XMLUtil {
   
    public static Object getBean(){
   
        try {
   
            //创建文档对象
            DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
            DocumentBuilder builder=dFactory.newDocumentBuilder();
            Document doc;
            doc=builder.parse(new File("src/设计模式/工厂方法模式/configTV.xml"));
            NodeList nl=doc.getElementsByTagName("className");
            Node classNode=nl.item(0).getFirstChild();
            String cName=classNode.getNodeValue().trim();
            //通过类名生成实例对象并将其返回
            Class c=Class.forName("设计模式.工厂方法模式."+cName);
            Object obj=c.newInstance();
            return obj;
        } catch (Exception e) {
   
            e.printStackTrace();
            return null;
        }
    }
}

package 设计模式.工厂方法模式;

public class Client {
   
    public static void main(String[] args)
    {
   
        TV tv;
        TVFactory factory;
        factory= (TVFactory) XMLUtil.getBean();
        tv=factory.productTV();
        tv.play();
    }
}

三、抽象工厂模式

简述：多个工厂，多种产品，不同工厂生产属于自己牌子的产品
图例：
在这里插入图片描述

package 设计模式.抽象工厂模式;
//抽象产品类
public interface Television {
   
    public void play();
}

package 设计模式.抽象工厂模式;
//具体产品类
public class HaierTelevision implements Television{
   
    @Override
    public void play() {
   
        System.out.println("海尔电视机播放中...");
    }
}

package 设计模式.抽象工厂模式;
//具体产品类
public class TCLTelevision implements Television{
   
    @Override
    public void play() {
   
        System.out.println("TCL电视机播放中...");
    }
}

package 设计模式.抽象工厂模式;
//抽象产品类
public interface AirConditioner {
   
    public void changeTemperature();
}

package 设计模式.抽象工厂模式;
//具体产品类
public class HairAirConditioner implements AirConditioner{
   
    @Override
    public void changeTemperature() {
   
        System.out.println("海尔空调温度改变中...");
    }
}

package 设计模式.抽象工厂模式;
//抽象工厂类
public interface EFactory {
   
    public Television produceTelevision();
    public AirConditioner produceAirConditioner();
}

package 设计模式.抽象工厂模式;
//具体工厂类
public class HaierFactory implements EFactory{
   
    @Override
    public Television produceTelevision() {
   
        return new HaierTelevision();
    }

    @Override
    public AirConditioner produceAirConditioner() {
   
        return new HairAirConditioner();
    }
}

package 设计模式.抽象工厂模式;
//具体工厂类
public class TCLFactory implements EFactory{
   
    @Override
    public Television produceTelevision() {
   
        return new TCLTelevision();
    }

    @Override
    public AirConditioner produceAirConditioner() {
   
        return new TCLAirConditioner();
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<config>
    <className>HaierFactory</className>
</config>

package 设计模式.抽象工厂模式;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;

public class XMLUtil {
   
    public static Object getBean(){
   
        try {
   
            //创建文档对象
            DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
            DocumentBuilder builder=dFactory.newDocumentBuilder();
            Document doc;
            doc=builder.parse(new File("src/设计模式/抽象工厂模式/config.xml"));
            NodeList nl=doc.getElementsByTagName("className");
            Node classNode=nl.item(0).getFirstChild();
            String cName=classNode.getNodeValue().trim();
            //通过类名生成实例对象并将其返回
            Class c=Class.forName("设计模式.抽象工厂模式."+cName);
            Object obj=c.newInstance();
            return obj;
        } catch (Exception e) {
   
            e.printStackTrace();
            return null;
        }
    }
}

package 设计模式.抽象工厂模式;

public class Client {
   
    public static void main(String[] args)
    {
   
        try {
   
            EFactory factory;
            Television tv;
            AirConditioner ac;
            factory= (EFactory) XMLUtil.getBean();
            tv=factory.produceTelevision();
            tv.play();
            ac=factory.produceAirConditioner();
            ac.changeTemperature();
        }catch (Exception e)
        {
   
            System.out.println(e.getMessage());
        }
    }
}

四、建造者模式

简述：一个服务员去帮助用户准备不同的套餐
图例：
在这里插入图片描述

package 设计模式.建造者模式;
//产品类
public class Meal {
   
    private String food;
    private String drink;

    public String getFood() {
   
        return food;
    }

    public void setFood(String food) {
   
        this.food = food;
    }

    public String getDrink() {
   
        return drink;
    }

    public void setDrink(String drink) {
   
        this.drink = drink;
    }
}

package 设计模式.建造者模式;
//抽象建造者类
public abstract class MealBuilder {
   
    protected Meal meal=new Meal();

    public abstract void buildFood();
    public abstract void buildDrink();

    public Meal getMeal()
    {
   
        return meal;
    }
}

package 设计模式.建造者模式;
//具体建造者类A
public class SubMealBuilderA extends MealBuilder{
   

    @Override
    public void buildFood() {
   
        meal.setFood("一个鸡腿堡");
    }

    @Override
    public void buildDrink() {
   
        meal.setDrink("一杯可乐");
    }
}

package 设计模式.建造者模式;
//具体建造者类B
public class SubMealBuilderB extends MealBuilder{
   
    @Override
    public void buildFood() {
   
        meal.setFood("一个鸡肉卷");
    }

    @Override
    public void buildDrink() {
   
        meal.setDrink("一杯果汁");
    }
}

package 设计模式.建造者模式;
//指挥者类
public class KFCWaiter {
   
    private MealBuilder mb;

    public void setMealBuilder(MealBuilder mb) {
   
        this.mb = mb;
    }
    public Meal construct()
    {
   
        mb.buildDrink();
        mb.buildFood();
        return mb.getMeal();
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<config>
    <className>SubMealBuilderA</className>
</config>

package 设计模式.建造者模式;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;

public class XMLUtil {
   
    public static Object getBean(){
   
        try {
   
            //创建文档对象
            DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
            DocumentBuilder builder=dFactory.newDocumentBuilder();
            Document doc;
            doc=builder.parse(new File("src/设计模式/建造者模式/config.xml"));
            NodeList nl=doc.getElementsByTagName("className");
            Node classNode=nl.item(0).getFirstChild();
            String cName=classNode.getNodeValue().trim();
            //通过类名生成实例对象并将其返回
            Class c=Class.forName("设计模式.建造者模式."+cName);
            Object obj=c.newInstance();
            return obj;
        } catch (Exception e) {
   
            e.printStackTrace();
            return null;
        }
    }
}

package 设计模式.建造者模式;

public class Client {
   
    public static void main(String[] args)
    {
   
        //动态确定套餐种类
        MealBuilder mb= (MealBuilder) XMLUtil.getBean();
        //服务员是指挥者
        KFCWaiter waiter=new KFCWaiter();
        //服务员准备套餐
        waiter.setMealBuilder(mb);
        //客户获得套餐
        Meal meal=waiter.construct();

        System.out.println("套餐组成：");
        System.out.println(meal.getFood());
        System.out.println(meal.getDrink());
    }
}

五、原型模式

简述：深拷贝、浅拷贝
图例：
在这里插入图片描述
浅拷贝

package 设计模式.原型模式.浅克隆;
//具体原型类
public class Email implements Cloneable{
   
    private Attachment attachment=null;
    public Email()
    {
   
        this.attachment=new Attachment();
    }
    public Object clone()
    {
   
        Email clone=null;
        try{
   
            clone= (Email) super.clone();
        }catch(CloneNotSupportedException e)
        {
   
            System.out.println("Clone failure!");
        }
        return clone;
    }
    public Attachment getAttachment()
    {
   
        return this.attachment;
    }
    public void display()
    {
   
        System.out.println("查看邮件");
    }
}

package 设计模式.原型模式.浅克隆;
//附件类
public class Attachment {
   
    public void download()
    {
   
        System.out.println("下载附件");
    }
}

package 设计模式.原型模式.浅克隆;

public class Client {
   
    public static void main(String[] agrs)
    {
   
        Email email,copyEmail;
        email=new Email();
        copyEmail= (Email) email.clone();
        System.out.println("email==copyEmail?");
        System.out.println(email==copyEmail);
        System.out.println("email.getAttachment==copyEmail.getAttachment?");
        System.out.println(email.getAttachment()==copyEmail.getAttachment());
    }
}

深拷贝
在这里插入图片描述

package 设计模式.原型模式.深克隆;
//具体原型类
import java.io.*;

public class Email implements Serializable {
   
    private Attachment attachment=null;
    public Email()
    {
   
        this.attachment=new Attachment();
    }
    public Object deepClone() throws IOException, ClassNotFoundException {
   
        ByteArrayOutputStream bao=new ByteArrayOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(bao);
        oos.writeObject(this);

        //将对象从流中取出
        ByteArrayInputStream bis=new ByteArrayInputStream(bao.toByteArray());
        ObjectInputStream ois=new ObjectInputStream(bis);
        return (ois.readObject());
    }
    public Attachment getAttachment()
    {
   
        return this.attachment;
    }
    public void display()
    {
   
        System.out.println("查看邮件");
    }
}

package 设计模式.原型模式.深克隆;
import java.io.Serializable;
//附件类
public class Attachment implements Serializable {
   
    public void download()
    {
   
        System.out.println("下载附件");
    }
}

package 设计模式.原型模式.深克隆;

public class Client {
   
    public static void main(String[] args)
    {
   
        Email email,copyEmail=null;
        email=new Email();
        try
        {
   
            copyEmail= (Email) email.deepClone();
        }catch (Exception e)
        {
   
            e.printStackTrace();
        }
        System.out.println("email==copyEmail?");
        System.out.println(email==copyEmail);
        System.out.println("email.getAttrachment==copyEmail.getAttachment?");
        System.out.println(email.getAttachment()==copyEmail.getAttachment());
    }
}

六、单例模式

简述：一个类只有一个对象，并且同一时间只有一个线程可以使用这个对象

包含所有类型的单例

package 设计模式.单例模式;

public class singletondemo {
   
    public static void main(String[] args)
    {
   
        sington1 object=sington1.getInstance();
        object.show();
    }
}
//饿汉式，线程安全
class sington1{
   
    private static sington1 instance=new sington1();
    private sington1() {
   }
    public static sington1 getInstance(){
   
        return instance;
    }
    public void show(){
   
        System.out.println("Hello,world!");
    }
}
//懒汉式，线程不安全
class sington2{
   
    private static sington2 instance;
    private sington2(){
   }
    public static sington2 getInstance(){
   
        if(instance==null)
        {
   
            instance=new sington2();
        }
        return instance;
    }
    public void show(){
   
        System.out.println("Hello,world!");
    }
}
//懒汉式，线程安全，加synchronized
class sington3{
   
    private static sington3 instance;
    private sington3(){
   }
    public static synchronized sington3 getInstance()
最低0.47元/天 解锁文章
冰河的鱼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的23种设计模式
微笑听雨
05-06 1万+
项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构设计模式：立面模式
danpu0978的博客
05-01 220
作为开发人员，大多数时候我们必须处理复杂的系统，包括许多依赖项，甚至根本不存在任何文档。 在这些情况下，找到应对这些挑战的方法至关重要。 处理它的最常见方法是隐藏所有这些依赖项并指定一个前置接口。 为了实现使用的模式是立面模式。 最终您会以非常复杂的系统结束它，该系统会以各种方式生成报告。 系统将报告生成为xml文件，csv文件，甚至从数据库生成报告。 xml文件中生成的报告基...
浅谈设计模式-解释器模式
langfeiyes的博客
08-17 239
定义：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
Java常见设计模式总结
张维鹏的博客
09-18 18万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
JAVA设计模式之单例模式
热门推荐
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
23种Java设计模式
qq_41847894的博客
03-06 2759
Java 设计模式可以分为三大类：创建型模式 (Creational Patterns)、结构型模式 (Structural Patterns) 、行为型模式 (Behavioral Patterns)。另一类设计模式：J2EE 设计模式。
一文讲完Java常用设计模式（全23种）
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-10 2万+
设计模式是软件开发中非常有用的工具，可以提高代码的可重用性和可维护性，同时也可以提高开发人员的工作效率。 设计模式有几种类型，包括创建型、结构型和行为型模式。 创建型模式用于以灵活和高效的方式创建对象。包括Singleton模式、工厂模式和抽象工厂模式等。 结构型模式用于组合类和对象以形成更大的结构。包括适配器模式、桥接模式和装饰器模式等。 行为型模式用于处理类或对象之间的通信和控制流。包括观察者模式、策略模式和模板方法模式。
Github项目分享——设计模式Java体现
su_zui的博客
01-30 1568
设计模式Java体现 项目地址 https://github.com/iluwatar/java-design-patterns 项目介绍 设计模式是程序员在设计应用程序或系统时可以用来解决常见问题的最佳形式化实践。 设计模式可以通过提供经过测试的，经过验证的开发范例来加快开发过程。 重用设计模式有助于防止引起重大问题的细微问题，并且还可以为熟悉模式的程序员和架构师们提高代码可读性。 这个站点展示了Java设计模式。该解决方案是由开源社区中经验丰富的程序员和架构师开发的。可以通过他们高级描述或查看源代码来浏
Java设计模式——策略模式
涛涛的个人博客
10-29 9万+
策略模式 1.策略模式简介 策略模式：策略模式是一种行为型模式，它将对象和行为分开，将行为定义为 一个行为接口 和 具体行为的实现。策略模式最大的特点是行为的变化，行为之间可以相互替换。每个if判断都可以理解为就是一个策略。本模式使得算法可独立于使用它的用户而变化 2.模式结构 策略模式包含如下角色： Strategy: 抽象策略类：策略是一个接口，该接口定义若干个算法标识，即定义了若干个抽象方法（如下图的algorithm()） Context: 环境类 /上下文类： 上下文是依赖于接口的类（
Java设计模式-工厂模式
Java厂长
08-06 1万+
Java设计模式-工厂模式 什么是工厂模式？ 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 简单编写一个类： 1、简单工厂模式 interface IFruit{ public void eat(); //吃水果 } class Apple implements IFruit{ public voi
设计模式Java
08-08
Java版本设计模式，深入浅出系列 Java版本设计模式，深入浅出系列 Java版本设计模式，深入浅出系列
设计模式java
12-20
主要内容:单例模式, 工厂模式, 策略模式, spring IOC ,反射机制
设计模式java案例.zip
03-11
本资源"设计模式java案例.zip"包含了23种经典设计模式的Java源码实现，下面将逐一解析这些设计模式及其在Java中的应用。 1. **单例模式（Singleton）**：确保一个类只有一个实例，并提供全局访问点。在Java中，通常...
23种设计模式之Java实现
12-02
本资源包含23种经典设计模式的Java实现，下面将详细阐述这些设计模式的基本概念和应用场景。 1. **单例模式**：确保一个类只有一个实例，并提供全局访问点。常用于日志记录、线程池等场景。 2. **工厂方法模式**：...
新版本idea下static web问题
weixin_43337444的博客
02-20 3656
新版本idea下static web问题 新版本下没有static web模块，旧版本才有下面的static web 旧版本要创建static web模块下的static的话，即 就要去以下界面去创建了 而如果要找到旧版本static web模块下的内容，新版本是把他们放在了javascript模块下的 如果vue.js没有的话，就得去新建立得项目的setting下的plugins下创建这个插件，然后再创建项目就看到了。 ...
薪酬管理系统（java）
weixin_43337444的博客
12-13 2732
薪酬管理系统（java）前言一、总体架构二、不同模块功能流程介绍1.用户计算工资2.修改用户信息/创建用户3.录入工作量4.参数设置总结 前言 该系统是基于Java语言，模拟学院老师的薪资建立的系统 例如：该系统分成了不同的模块，登录界面，注册界面，登录后分为了用户信息、工资查询、工资发放、用户管理、工作量录入、参数设置模块。 提示：下面以图的形式对系统进行介绍，底部有源码、图、数据库、视频的地址。 一、总体架构 示例：左边栏目的分支主要使用树的形式实现，整个框架是用了swing这种轻量级的方式实现的
Java学习笔记
weixin_43337444的博客
02-05 686
Java学习笔记（一些在学校可能接触不到的知识） 备注：是一位优秀的师兄分享给我的，我认为总结得还不错，所以这里也和大家分享下，喜欢的同学可以共同学习下，有哪里不对的也可以在下方评论下哦。 学习内容： 1、 java基础知识 2、 JVM体系知识 3、 SSM框架体系知识 4、 Java锁体系知识 5、Java线程体系知识 6、Java运维知识 7、数据结构 Java基础知识： 【Java基础知识】 补充： Java中判断两个变量是否相等有两种方式：一种是利用双=运算符，另一种是利用equals方法。
计算机网络重要面试知识点
weixin_43337444的博客
03-06 573
计算机网络重要面试知识点 补充：常用端口号了解： （1）http 80 https 443 ftp 21 telnet 23 tomcat 8080 mysql 3306 （2）http get/post基本区别： （一）传输层 UDP特点： 1.基于IP协议：复用、分用。可以实现简单的错误校验。 2.尽最大努力交付：可能丢失，非按需达到。 3.无连接：发送方与接收方不需要握手，每个UDP段的处理独立于其他段。 UDP为什么存在（意义）： 1.不需要连接，减少延迟。 2.实现简单，无需维护连接状态..
大话设计模式java
最新发布
09-17
在《大话设计模式Java》这本书中，作者通过具体的案例和实例详细介绍了23种常用的设计模式，包括工厂模式、代理模式和策略模式等。工厂模式是一种创建型模式，它提供了一种创建对象的最佳方式，通过工厂类来创建具体...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值