Java 设计模式：结构型模式

最新推荐文章于 2024-07-06 13:51:47 发布
最新推荐文章于 2024-07-06 13:51:47 发布
阅读量522 收藏 13
点赞数 22
文章标签： java 设计模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011464172/article/details/139888261
版权

Java 设计模式：结构型模式

结构型模式关注的是 类和对象的组合方式，它们提供了一种 灵活且可扩展的方式 来构建复杂系统。 这些模式主要通过 定义类和对象的结构 来解决系统设计中的 复杂性问题。

一、 结构型模式分类

结构型模式主要分为以下几类：

  • 适配器模式 (Adapter)：将一个类的接口转换成客户期望的另一个接口。适配器模式让你可以将现有的类和不兼容的类一起工作。
  • 桥接模式 (Bridge)：将抽象部分与实现部分分离，使它们可以独立变化。桥接模式可以用来 减少类之间的耦合，并 提高代码的可复用性。
  • 组合模式 (Composite)：将对象组合成树形结构，以表示"部分 - 整体" 的层次关系。组合模式可以让你 统一地处理单个对象和组合对象。
  • 装饰器模式 (Decorator)：动态地给一个对象添加额外的职责。装饰器模式可以让你 在不修改原有类的情况下，扩展对象的功能。
  • 外观模式 (Facade)：为子系统提供一个统一的接口，隐藏子系统的复杂性。外观模式可以让你 简化对子系统的调用，并 降低耦合度。
  • 享元模式 (Flyweight)：运用共享技术有效地支持大量细粒度的对象。享元模式可以让你 减少内存占用，并 提高性能。
  • 代理模式 (Proxy)：为其他对象提供一种代理以控制对这个对象的访问。代理模式可以让你 控制对对象的访问，并 实现延迟加载、安全控制等功能。

二、 结构型模式详解

1. 适配器模式 (Adapter)

定义： 将一个类的接口转换成客户期望的另一个接口。适配器模式让你可以将现有的类和不兼容的类一起工作。

分类：

  • 类适配器： 使用继承来实现适配器，将目标接口继承下来，并实现源接口。
  • 对象适配器： 使用组合来实现适配器，将目标对象作为成员变量，并实现源接口。

应用场景：

  • 需要使用一个已有类的功能，但是它的接口不符合需求。
  • 需要将多个接口统一成一个接口。

实例：

假设你需要使用一个第三方库的 LegacyClass 类，它使用的是老式的 LegacyInterface 接口，而你的程序需要使用的是 ModernInterface 接口。 你可以使用适配器模式来解决这个问题：

// LegacyInterface 接口
public interface LegacyInterface {
    void legacyMethod();
}

// LegacyClass 类
public class LegacyClass implements LegacyInterface {
    @Override
    public void legacyMethod() {
        System.out.println("调用 LegacyClass 的方法");
    }
}

// ModernInterface 接口
public interface ModernInterface {
    void modernMethod();
}

// 类适配器实现
public class ClassAdapter extends LegacyClass implements ModernInterface {
    @Override
    public void modernMethod() {
        // 将现代方法调用转化为旧的方法调用
        this.legacyMethod();
    }
}

// 对象适配器实现
public class ObjectAdapter implements ModernInterface {
    private LegacyClass legacyClass;

    public ObjectAdapter(LegacyClass legacyClass) {
        this.legacyClass = legacyClass;
    }

    @Override
    public void modernMethod() {
        // 将现代方法调用转化为旧的方法调用
        legacyClass.legacyMethod();
    }
}

// 使用适配器
public class Main {
    public static void main(String[] args) {
        // 使用类适配器
        ClassAdapter adapter1 = new ClassAdapter();
        adapter1.modernMethod();

        // 使用对象适配器
        ObjectAdapter adapter2 = new ObjectAdapter(new LegacyClass());
        adapter2.modernMethod();
    }
}

2. 桥接模式 (Bridge)

定义： 将抽象部分与实现部分分离，使它们可以独立变化。桥接模式可以用来 减少类之间的耦合，并 提高代码的可复用性。

应用场景：

  • 当你希望 独立地修改抽象部分和实现部分 时。
  • 当你希望 提供多个实现部分，以满足不同的需求时。

实例：

假设你需要设计一个图形绘制工具，它可以绘制不同的形状，并且可以支持不同的颜色。 你可以使用桥接模式来实现这个功能：

// 形状抽象类
public abstract class Shape {
    protected Color color;

    public Shape(Color color) {
        this.color = color;
    }

    public abstract void draw();
}

// 圆形类
public class Circle extends Shape {
    public Circle(Color color) {
        super(color);
    }

    @Override
    public void draw() {
        System.out.println("绘制一个" + color.getColorName() + "色的圆形");
    }
}

// 正方形类
public class Square extends Shape {
    public Square(Color color) {
        super(color);
    }

    @Override
    public void draw() {
        System.out.println("绘制一个" + color.getColorName() + "色的正方形");
    }
}

// 颜色抽象类
public abstract class Color {
    public abstract String getColorName();
}

// 红色类
public class Red extends Color {
    @Override
    public String getColorName() {
        return "红色";
    }
}

// 蓝色类
public class Blue extends Color {
    @Override
    public String getColorName() {
        return "蓝色";
    }
}

// 使用桥接模式
public class Main {
    public static void main(String[] args) {
        // 创建红色圆形
        Shape redCircle = new Circle(new Red());
        redCircle.draw();

        // 创建蓝色正方形
        Shape blueSquare = new Square(new Blue());
        blueSquare.draw();
    }
}

3. 组合模式 (Composite)

定义： 将对象组合成树形结构，以表示"部分 - 整体" 的层次关系。组合模式可以让你 统一地处理单个对象和组合对象。

应用场景：

  • 需要表示 部分 - 整体 的层次关系。
  • 需要 统一地处理单个对象和组合对象。

实例：

假设你需要设计一个文件系统，它可以包含目录和文件，并且可以递归地遍历文件系统。 你可以使用组合模式来实现这个功能：

// 文件系统抽象类
public abstract class FileSystemItem {
    public abstract String getName();

    public abstract void printDetails();

    public abstract FileSystemItem findItem(String name);
}

// 文件类
public class File extends FileSystemItem {
    private String name;

    public File(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void printDetails() {
        System.out.println("文件: " + name);
    }

    @Override
    public FileSystemItem findItem(String name) {
        return name.equals(this.name) ? this : null;
    }
}

// 目录类
public class Directory extends FileSystemItem {
    private String name;
    private List<FileSystemItem> items = new ArrayList<>();

    public Directory(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void printDetails() {
        System.out.println("目录: " + name);
        for (FileSystemItem item : items) {
            item.printDetails();
        }
    }

    @Override
    public FileSystemItem findItem(String name) {
        for (FileSystemItem item : items) {
            if (item.getName().equals(name)) {
                return item;
            }
            if (item instanceof Directory) {
                FileSystemItem foundItem = ((Directory) item).findItem(name);
                if (foundItem != null) {
                    return foundItem;
                }
            }
        }
        return null;
    }

    public void addItem(FileSystemItem item) {
        items.add(item);
    }
}

// 使用组合模式
public class Main {
    public static void main(String[] args) {
        // 创建文件系统
        Directory root = new Directory("root");
        Directory dir1 = new Directory("dir1");
        Directory dir2 = new Directory("dir2");
        File file1 = new File("file1.txt");
        File file2 = new File("file2.txt");

        // 构建树形结构
        root.addItem(dir1);
        root.addItem(dir2);
        dir1.addItem(file1);
        dir2.addItem(file2);

        // 打印文件系统细节
        root.printDetails();

        // 查找文件
        FileSystemItem foundFile = root.findItem("file2.txt");
        if (foundFile != null) {
            System.out.println("找到文件: " + foundFile.getName());
        }
    }
}

4. 装饰器模式 (Decorator)

定义： 动态地给一个对象添加额外的职责。装饰器模式可以让你 在不修改原有类的情况下，扩展对象的功能。

应用场景：

  • 需要 动态地扩展对象的功能，而不改变原有类的代码。
  • 需要 提供多种装饰功能，并可以自由组合。

实例：

假设你需要设计一个咖啡机，它可以制作各种咖啡，并且可以添加不同的配料，比如糖、牛奶、香草等。 你可以使用装饰器模式来实现这个功能：

// 咖啡抽象类
public abstract class Coffee {
    public abstract String getDescription();

    public abstract double cost();
}

// 黑咖啡类
public class Espresso extends Coffee {
    @Override
    public String getDescription() {
        return "Espresso";
    }

    @Override
    public double cost() {
        return 1.99;
    }
}

// 装饰器抽象类
public abstract class CoffeeDecorator extends Coffee {
    protected Coffee coffee;

    public CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription();
    }

    @Override
    public double cost() {
        return coffee.cost();
    }
}

// 糖装饰器类
public class Sugar extends CoffeeDecorator {
    public Sugar(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + " + 糖";
    }

    @Override
    public double cost() {
        return coffee.cost() + 0.25;
    }
}

// 牛奶装饰器类
public class Milk extends CoffeeDecorator {
    public Milk(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + " + 牛奶";
    }

    @Override
    public double cost() {
        return coffee.cost() + 0.50;
    }
}

// 使用装饰器模式
public class Main {
    public static void main(String[] args) {
        // 创建黑咖啡
        Coffee espresso = new Espresso();
        System.out.println(espresso.getDescription() + " $" + espresso.cost());

        // 添加糖和牛奶
        Coffee coffeeWithSugarAndMilk = new Milk(new Sugar(espresso));
        System.out.println(coffeeWithSugarAndMilk.getDescription() + " $" + coffeeWithSugarAndMilk.cost());
    }
}

5. 外观模式 (Facade)

定义： 为子系统提供一个统一的接口，隐藏子系统的复杂性。外观模式可以让你 简化对子系统的调用，并 降低耦合度。

应用场景：

  • 需要 简化对复杂子系统的调用。
  • 需要 降低子系统与其他模块的耦合度。

实例：

假设你需要设计一个数据库系统，它包含多个组件，比如连接池、数据库操作、事务管理等。 你可以使用外观模式来简化对数据库系统的调用：

// 数据库子系统接口
public interface DatabaseSubsystem {
    void connect();

    void executeQuery(String query);

    void commitTransaction();

    void rollbackTransaction();

    void disconnect();
}

// 数据库子系统实现类
public class DatabaseSubsystemImpl implements DatabaseSubsystem {
    // 连接池
    private ConnectionPool connectionPool;

    // 数据库操作
    private DatabaseOperations databaseOperations;

    // 事务管理
    private TransactionManager transactionManager;

    public DatabaseSubsystemImpl(ConnectionPool connectionPool, DatabaseOperations databaseOperations, TransactionManager transactionManager) {
        this.connectionPool = connectionPool;
        this.databaseOperations = databaseOperations;
        this.transactionManager = transactionManager;
    }

    @Override
    public void connect() {
        connectionPool.getConnection();
    }

    @Override
    public void executeQuery(String query) {
        databaseOperations.executeQuery(query);
    }

    @Override
    public void commitTransaction() {
        transactionManager.commitTransaction();
    }

    @Override
    public void rollbackTransaction() {
        transactionManager.rollbackTransaction();
    }

    @Override
    public void disconnect() {
        connectionPool.releaseConnection();
    }
}

// 数据库外观类
public class DatabaseFacade {
    private DatabaseSubsystem databaseSubsystem;

    public DatabaseFacade(DatabaseSubsystem databaseSubsystem) {
        this.databaseSubsystem = databaseSubsystem;
    }

    public void executeAndCommit(String query) {
        databaseSubsystem.connect();
        databaseSubsystem.executeQuery(query);
        databaseSubsystem.commitTransaction();
        databaseSubsystem.disconnect();
    }

    public void executeAndRollback(String query) {
        databaseSubsystem.connect();
        databaseSubsystem.executeQuery(query);
        databaseSubsystem.rollbackTransaction();
        databaseSubsystem.disconnect();
    }
}

// 使用数据库外观
public class Main {
    public static void main(String[] args) {
        // 创建数据库子系统
        DatabaseSubsystem databaseSubsystem = new DatabaseSubsystemImpl(new ConnectionPool(), new DatabaseOperations(), new TransactionManager());

        // 创建数据库外观
        DatabaseFacade databaseFacade = new DatabaseFacade(databaseSubsystem);

        // 使用外观执行查询并提交事务
        databaseFacade.executeAndCommit("SELECT * FROM users");

        // 使用外观执行查询并回滚事务
        databaseFacade.executeAndRollback("UPDATE users SET name = 'John'");
    }
}

6. 享元模式 (Flyweight)

定义： 运用共享技术有效地支持大量细粒度的对象。享元模式可以让你 减少内存占用，并 提高性能。

应用场景：

  • 需要 创建大量相同或相似的对象。
  • 需要 减少内存占用，并 提高性能。

实例：

假设你需要设计一个游戏，它需要创建大量的树木，而这些树木可能只是颜色和大小不同，其他属性都相同。 你可以使用享元模式来实现这个功能：

// 树抽象类
public abstract class Tree {
    public abstract void draw(int x, int y);
}

// 具体树类
public class ConcreteTree implements Tree {
    private String color;
    private int size;

    public ConcreteTree(String color, int size) {
        this.color = color;
        this.size = size;
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("绘制一棵 " + color + " 色的树，大小为 " + size + "，位置为 (" + x + ", " + y + ")");
    }
}

// 树工厂类
public class TreeFactory {
    private Map<String, Tree> trees = new HashMap<>();

    public Tree getTree(String color, int size) {
        String key = color + "_" + size;
        Tree tree = trees.get(key);
        if (tree == null) {
            tree = new ConcreteTree(color, size);
            trees.put(key, tree);
        }
        return tree;
    }
}

// 使用享元模式
public class Main {
    public static void main(String[] args) {
        // 创建树工厂
        TreeFactory treeFactory = new TreeFactory();

        // 创建多棵树
        Tree tree1 = treeFactory.getTree("绿色", 10);
        Tree tree2 = treeFactory.getTree("绿色", 10);
        Tree tree3 = treeFactory.getTree("蓝色", 5);

        // 绘制树
        tree1.draw(10, 20);
        tree2.draw(30, 40);
        tree3.draw(50, 60);
    }
}

7. 代理模式 (Proxy)

定义： 为其他对象提供一种代理以控制对这个对象的访问。代理模式可以让你 控制对对象的访问，并 实现延迟加载、安全控制等功能。

分类：

  • 远程代理： 为位于不同地址空间的对象提供本地代理。
  • 虚拟代理： 为需要较长时间创建的对象提供代理，延迟创建真实对象。
  • 保护代理： 为真实对象提供安全控制，限制对对象的访问。

应用场景：

  • 需要 控制对对象的访问。
  • 需要 实现延迟加载、安全控制等功能。

实例：

假设你需要设计一个图片加载器，它可以加载网络图片。 你可以使用代理模式来实现这个功能，并实现延迟加载：

// 图片接口
public interface Image {
    void display();
}

// 真实图片类
public class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk(fileName);
    }

    private void loadFromDisk(String fileName) {
        System.out.println("从磁盘加载 " + fileName + " 图片...");
        // 这里模拟图片加载过程
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("图片加载完成");
    }

    @Override
    public void display() {
        System.out.println("显示 " + fileName + " 图片");
    }
}

// 图片代理类
public class ProxyImage implements Image {
    private String fileName;
    private RealImage realImage;

    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}

// 使用代理模式
public class Main {
    public static void main(String[] args) {
        // 创建图片代理
        Image image = new ProxyImage("photo.jpg");

        // 首次调用 display()，会加载图片
        image.display();

        // 再次调用 display()，图片已经加载，直接显示
        image.display();
    }
}

三、 总结

结构型模式是设计模式中非常重要的组成部分，它们提供了一种灵活且可扩展的方式来构建复杂系统。 在实际开发中，我们可以根据具体需求选择合适的结构型模式来 提高代码的可读性、可维护性和可扩展性。

需要注意的是，设计模式不是万能的，应该根据实际情况选择合适的模式，不要为了使用模式而使用模式。

斯陀含
关注
  • 22
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java设计模式之结构型模式
qq_53799708的博客
08-14 173
在安全组合模式中，在抽象构件角色中没有声明任何用于管理成员对象的方法，而是在树枝节点Menu类中声明并实现这些方法，安全组合模式的缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别的对待叶子构件和容器构件。在使用组合模式时，根据抽象构件类的定义形式，我们可将组合模式分为透明组合模式和安全组合模式两种形式。对象适配器模式可采用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口。
Java实现七种结构型模式
Admin_Lian的博客
08-12 545
目录(一) 桥接模式概述 (一) 桥接模式概述 桥接模式(Bridge Pattern): 又称之为接口模式, 将 抽象部分 与 实现部分 分离, 使它们都可以独立地变化. 属于对象结构模型的一种 桥接模式基于类的最小设计原则, 通过使用封装、聚合及继承等行为让不同的类承担不同的职责. 它最主要特点是把 抽象 与 行为实现 分离开来, 从而可以保持各部分的独立性以及应对他们的功能扩展 举例: 抽象类Shape中存在draw绘画的抽象方法, 可以画 圆形、正方形、长方形等, 又还需要给这些形状进行上色, 如白
Java设计模式之七大结构型模式
CharlesYan的博客
03-08 533
代桥组装享外适 装饰模式(Decorator Pattern) 代理模式(Proxy Pattern) 适配器模式(Adapter Pattern) 桥接模式(Bridge Pattern) 组合模式(Composite Pattern) 外观模式(Facade Pattern) 享元模式(Flyweight Pattern)
Java设计模式之结构型模式
duncan891101的专栏
08-08 249
什么是代理？什么是静态代理？什么是动态代理？ 举个例子： 车站（被代理）需要卖票，为了方便更多的客户，车站在很多地方找了第三方的合作机构进行卖票（这个角色就是代理），票卖出去之后，第三方机构会抽取一定的提成，同时也需要提供除了票以外的一些其他售后服务，在这里第三方机构就是代理。所谓的静态代理就是，全国各地除了车站外还要多设置100个售票的地方，而这100个地方就需要找100个第三方机构来管理和卖，这种形式就静态代理，成本较高。假设找一个第三方机构，让它一个去管理这100个地方的售票和售后服务，在不同的地方切
详解23种设计模式（基于Java）—— 结构型模式（三 / 五）
代码星辰的博客
11-12 430
结构型模式（三 / 五）
Java设计模式代码案例 (二)：结构型设计模式.pdf
11-18
Java设计模式代码案例（二）：结构型设计模式 Java设计模式代码案例（二）：结构型设计模式主要介绍了结构型设计模式，包括适配器模式、桥接模式、组合模式、装饰模式、外观模式等。这些模式都是为了解决接口不匹配...
Java学习资料-结构型设计模式 
06-16
Java结构型设计模式 ：Java结构型设计模式 ；Java结构型设计模式 ；Java结构型设计模式 ；
Java结构型设计模式资料day03
10-01
本课程从设计模式的一些相关的概念开始，再到软件设计原则，重点讲解23种设计模式，针对每一种模式都配备了相关的代码。最后通过一个综合案例将常用的设计模式使用起来。 市面上已经有很多的设计模式的教程，而我们...
JAVA-设计模式-结构型模式-组合模式
08-10
JAVA-设计模式-结构型模式-组合模式
JAVA-设计模式-结构型模式-装饰模式
08-10
JAVA-设计模式-结构型模式-装饰模式
Java的结构型模式
qq_35543434的博客
05-26 305
结构型模式是描述如何将类对象结合在一起，形成一个更大的结构，结构模式描述两种不同的东西：类与类的实例。故可以分为类结构模式和对象结构模式。 1.适配器模式 Adapter 　适配器模式是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 　两个成熟的类需要通信，但是接口不同，由于开闭原则，我们不能去修改这两个类的接口，...
Java经典设计模式之七大结构型模式（附实例和详解）
weixin_30535043的博客
03-07 1335
博主在大三的时候有上过设计模式这一门课，但是当时很多都基本没有听懂，重点是也没有细听，因为觉得没什么卵用，硬是要搞那么复杂干嘛。因此设计模式建议工作半年以上的猿友阅读起来才会理解的比较深刻。当然，你没事做看看也是没有坏处的。 总体来说设计模式分为三大类：创建型模式、结构型模式和行为型模式。 博主的上一篇文章已经提到过创建型模式，此外该文章还有设计模式概况和设计模式的六大原则...
java设计模式三（结构型）
主攻中间件方向，喜欢研究相关源码，欢迎一起讨论，共同进步
04-07 234
设计模式之结构型
Java设计模式之结构型七大模式
swimming_in_IT_的博客
07-28 581
这一篇我们接着讨论设计模式，上篇文章我讲完了5种创建型模式，这章开始，我将讲下7种结构型模式：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源，我们看下面的图： 下面我对这七个模式，进行的是自己我总结和对比，具体见图： 下面开始讲这七个模式 1 适配器模式 1， 适配器模式  适配器模式将某个类的接口转换
Java设计模式 七种结构型模式
qf2019的博客
07-01 607
在Java 中一般认为有23 种设计模式，这听上去很多，然而Java设计模式不需要所有的都会，我们只需要掌握常用的几种设计模式。 Java设计模式分为三大类： 创建型模式、结构型模式、行为型模式。小面详细来讲解Java设计模式中的七种结构型模式。 Java设计模式中的七种结构型模式即：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源。 一、适配器模式： 类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
m0_61086522的博客
07-02 1206
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 493
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
解决分布式环境下session共享问题
最新发布
shenxiaomo1688的博客
07-06 483
在分布式环境下，session会存在两个问题第一个问题:不同域名下，浏览器存储的jsessionid是没有存储的。比如登录时认证服务auth.gulimall.com存储了session，但是搜索服务search.gulimall.com是没有这个session的；
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 299
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
Java设计模式代码案例 (一)：创建型设计模式.pdf
11-18
“Java设计模式代码案例 (一)：创建型设计模式.pdf，涵盖了工厂模式的讲解及其实现。” 本文将详细解析创建型设计模式之一的工厂模式，它在Java编程中有着广泛的应用，能帮助我们更好地组织代码结构，提高代码的可...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

斯陀含

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值