Java架構師之路九、設計模式：常見的設計模式，如單例模式、工廠模式、策略模式、橋接模式等

目錄

常見的設計模式：

單例模式：

工廠模式：

策略模式：

橋接模式：

責任鏈模式：

Java架構師之路八、安全技術：Web安全、網絡安全、系統安全、數據安全等-CSDN博客


Java架構師之路十、框架和工具：Spring Framework、Spring Boot、Spring Cloud、MyBatis、Hibernate、Dubbo、Zookeeper、Redis等-CSDN博客
?

常見的設計模式：

在 Java 中，設計模式是軟件開發中常用的解決方案模板，可以幫助開發者解決特定的設計問題并提高代碼的可重用性、可維護性和靈活性。Java 中常見的設計模式包括創建型模式、結構型模式、行為型模式以及其他模式，其中還包括責任鏈模式。

  1. 創建型模式：

    • 工廠模式（Factory Pattern）：定義一個創建對象的接口，但讓子類決定實例化哪個類。
    • 單例模式（Singleton Pattern）：確保一個類只有一個實例，并提供一個全局訪問點。
    • 建造者模式（Builder Pattern）：將一個復雜對象的構建過程與其表示分離，使相同的構建過程可以創建不同的表示。

  2. 結構型模式：

    • 適配器模式（Adapter Pattern）：將一個類的接口轉換成客戶希望的另一個接口，使原本由于接口不兼容而不能在一起工作的類可以一起工作。
    • 裝飾器模式（Decorator Pattern）：動態地給一個對象添加一些額外的職責，而不影響從這個類派生的其他對象。
    • 代理模式（Proxy Pattern）：為其他對象提供一種代理以控制對這個對象的訪問。

  3. 行為型模式：

    • 觀察者模式（Observer Pattern）：定義對象間的一對多依賴關系，使得當一個對象改變狀態時，所有依賴它的對象都會得到通知并自動更新。
    • 策略模式（Strategy Pattern）：定義一系列算法，將每個算法封裝起來，并使它們可以互相替換。
    • 模板方法模式（Template Method Pattern）：定義算法的框架，由子類實現具體步驟。
    • 責任鏈模式（Chain of Responsibility Pattern）：為請求創建一個接收者對象的鏈，并沿著這條鏈傳遞請求，直到有對象處理請求為止。

  4. 其他模式：

    • 享元模式（Flyweight Pattern）：通過共享技術來有效支持大量細粒度對象的復用。
    • 備忘錄模式（Memento Pattern）：在不破壞封裝性的前提下，捕獲一個對象的內部狀態，并在該對象之外保存這個狀態。

這些設計模式在 Java 開發中有著廣泛的應用，合理運用設計模式可以提高軟件的質量和可維護性，降低系統的耦合度，使代碼更加清晰易懂。責任鏈模式特別適用于處理請求的場景，可以靈活地組織處理者鏈條，實現請求與處理者的解耦，提高代碼的靈活性和可擴展性。

單例模式：

單例模式是一種創建型設計模式，保證一個類只有一個實例，并提供一個全局訪問點。在實際應用中，有些對象只需要一個實例，例如線程池、緩存、對話框、注冊表設置等。單例模式可以確保系統中某個類只有一個實例，避免了重復創建對象，節省了系統資源，并且方便對該實例的控制和管理。

在 Java 中，單例模式通常有幾種實現方式：

  1. 懶漢式：

    • 延遲加載，在第一次使用時創建實例。
    • 線程安全需要考慮，可以通過 synchronized 加鎖，或者使用雙重檢查鎖定（Double-Checked Locking）。
    • 可能會存在性能問題，因為每次獲取實例都需要進行同步操作。

  2. 餓漢式：

    • 類加載時即創建實例。
    • 線程安全，但可能會浪費內存。

  3. 靜態內部類：

    • 利用類加載機制保證線程安全且延遲加載。
    • 通過靜態內部類持有外部類的實例，當外部類被加載時靜態內部類并不會被加載和初始化。

  4. 枚舉：

    • 最簡潔、安全的實現方式，由 JVM 保證只會實例化一次。
    • 防止反射和序列化攻擊。

實現單例模式時需要考慮線程安全性、延遲加載、性能等因素。在選擇實現方式時，可以根據具體需求和場景來決定使用哪種方式。單例模式在很多框架和庫中都有廣泛應用，如 Spring 框架中的 Bean 默認就是單例模式，保證了在應用中只有一個 Bean 實例存在。

總的來說，單例模式是一種常見且重要的設計模式，合理使用可以提高代碼的效率和可維護性，但也需要注意避免濫用單例模式導致的問題，如增加代碼耦合度、隱藏依賴關系等。

懶漢式單例模式：

在懶漢式單例模式中，實例在需要的時候才被創建。

實現步驟：
  1. 將構造函數設置為私有，防止外部直接實例化該類。
  2. 提供一個靜態方法獲取實例，在方法內部判斷實例是否為空，為空則創建實例，否則直接返回實例。
Java 代碼示例：
public class LazySingleton {private static LazySingleton instance;private LazySingleton() {// 私有構造函數}public static LazySingleton getInstance() {if (instance == null) {instance = new LazySingleton();}return instance;}
}
示例代碼說明：
  • LazySingleton?類中的構造函數是私有的，外部無法直接實例化。
  • getInstance()?方法是獲取實例的靜態方法，通過判斷instance?是否為空來決定是否創建實例。
測試代碼：
public class Main {public static void main(String[] args) {LazySingleton singleton1 = LazySingleton.getInstance();LazySingleton singleton2 = LazySingleton.getInstance();System.out.println(singleton1 == singleton2); // 輸出 true，說明是同一個實例}
}

示例說明：

  • 在上面的示例中，通過調用?LazySingleton.getInstance()?方法兩次獲取實例，得到的兩個實例是相同的，因為單例模式確保了只有一個實例存在。
  • 這種懶漢式單例模式雖然簡單，但在多線程環境下存在線程安全問題，可能會創建多個實例。可以通過加鎖或使用雙重檢查鎖定等方式來解決線程安全性問題。

工廠模式：

工廠模式是一種創建型設計模式，它提供一種封裝對象創建過程的方式。工廠模式通過定義一個共同的接口來創建對象，但具體的實現由子類決定。這樣可以將對象的創建與使用代碼解耦，提高代碼的靈活性和可維護性。

工廠模式常見的幾種變體包括簡單工廠模式、工廠方法模式和抽象工廠模式。

下面分別詳細介紹這三種工廠模式的實現方式，并給出相應的代碼示例：

1. 簡單工廠模式（Simple Factory Pattern）：

簡單工廠模式通過一個工廠類負責創建多個不同類型的對象。

實現步驟：
  1. 創建一個共同的接口或抽象類，用于描述所要創建的對象。
  2. 創建具體的實現類，實現共同的接口或抽象類。
  3. 創建一個簡單工廠類，負責根據參數的不同返回不同的具體對象。
Java 代碼示例：
// 共同的接口
public interface Product {void operation();
}// 具體的實現類
public class ConcreteProductA implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductA operation");}
}public class ConcreteProductB implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductB operation");}
}// 簡單工廠類
public class SimpleFactory {public static Product createProduct(String type) {if (type.equals("A")) {return new ConcreteProductA();} else if (type.equals("B")) {return new ConcreteProductB();}return null;}
}
示例代碼說明：
  • Product?是一個共同的接口，描述了所要創建的對象應具有的行為。
  • ConcreteProductA?和?ConcreteProductB?是具體的實現類，實現了?Product?接口。
  • SimpleFactory?是簡單工廠類，根據參數的不同返回不同的具體對象。
測試代碼：
public class Main {public static void main(String[] args) {Product productA = SimpleFactory.createProduct("A");productA.operation(); // 輸出 "ConcreteProductA operation"Product productB = SimpleFactory.createProduct("B");productB.operation(); // 輸出 "ConcreteProductB operation"}
}

2. 工廠方法模式（Factory Method Pattern）：

工廠方法模式將對象的創建延遲到子類，每個子類負責創建一個具體的對象。

實現步驟：
  1. 創建一個抽象工廠類，聲明一個抽象的工廠方法。
  2. 創建具體的工廠類，實現抽象工廠類中的工廠方法，每個具體工廠類負責創建一個具體的對象。
  3. 創建一個共同的接口或抽象類，用于描述所要創建的對象。
  4. 創建具體的實現類，實現共同的接口或抽象類。
Java 代碼示例：
// 共同的接口
public interface Product {void operation();
}// 具體的實現類
public class ConcreteProductA implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductA operation");}
}public class ConcreteProductB implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductB operation");}
}// 抽象工廠類
public abstract class Factory {public abstract Product createProduct();
}// 具體的工廠類
public class ConcreteFactoryA extends Factory {@Overridepublic Product createProduct() {return new ConcreteProductA();}
}public class ConcreteFactoryB extends Factory {@Overridepublic Product createProduct() {return new ConcreteProductB();}
}

示例代碼說明：
  • Product?是一個共同的接口，描述了所要創建的對象應具有的行為。
  • ConcreteProductA?和?ConcreteProductB?是具體的實現類，實現了?Product?接口。
  • Factory?是抽象工廠類，聲明了一個抽象的工廠方法?createProduct()。
  • ConcreteFactoryA?和?ConcreteFactoryB?是具體的工廠類，分別負責創建?ConcreteProductA?和?ConcreteProductB?對象。
測試代碼：
public class Main {public static void main(String[] args) {Factory factoryA = new ConcreteFactoryA();Product productA = factoryA.createProduct();productA.operation(); // 輸出 "ConcreteProductA operation"Factory factoryB = new ConcreteFactoryB();Product productB = factoryB.createProduct();productB.operation(); // 輸出 "ConcreteProductB operation"}
}

3. 抽象工廠模式（Abstract Factory Pattern）：

抽象工廠模式提供一個接口，用于創建一系列相關或相互依賴的對象。

實現步驟：
  1. 創建一組共同的接口，用于描述所要創建的對象。
  2. 創建多個具體的實現類，實現共同的接口。
  3. 創建一個抽象工廠類，聲明創建一組對象的抽象方法。
  4. 創建具體的工廠類，實現抽象工廠類中的抽象方法，負責創建一組相關的對象。
Java 代碼示例：
// 共同的接口
public interface ProductA {void operationA();
}public interface ProductB {void operationB();
}// 具體的實現類
public class ConcreteProductA1 implements ProductA {@Overridepublic void operationA() {System.out.println("ConcreteProductA1 operationA");}
}public class ConcreteProductA2 implements ProductA {@Overridepublic void operationA() {System.out.println("ConcreteProductA2 operationA");}
}public class ConcreteProductB1 implements ProductB {@Overridepublic void operationB() {System.out.println("ConcreteProductB1 operationB");}
}public class ConcreteProductB2 implements ProductB {@Overridepublic void operationB() {System.out.println("ConcreteProductB2 operationB");}
}// 抽象工廠類
public interface AbstractFactory {ProductA createProductA();ProductB createProductB();
}// 具體的工廠類
public class ConcreteFactory1 implements AbstractFactory {@Overridepublic ProductA createProductA() {return new ConcreteProductA1();}@Overridepublic ProductB createProductB() {return new ConcreteProductB1();}
}public class ConcreteFactory2 implements AbstractFactory {@Overridepublic ProductA createProductA() {return new ConcreteProductA2();}@Overridepublic ProductB createProductB() {return new ConcreteProductB2();}
}

示例代碼說明：
  • ProductA?和?ProductB?是一組共同的接口，描述了所要創建的對象應具有的行為。
  • ConcreteProductA1、ConcreteProductA2、ConcreteProductB1?和?ConcreteProductB2?是具體的實現類，分別實現?ProductA?和?ProductB?接口。
  • AbstractFactory?是抽象工廠類，聲明了創建一組對象的抽象方法?createProductA()?和?createProductB()。
  • ConcreteFactory1?和?ConcreteFactory2?是具體的工廠類，分別負責創建一組相關的對象。
測試代碼：
public class Main {public static void main(String[] args) {AbstractFactory factory1 = new ConcreteFactory1();ProductA productA1 = factory1.createProductA();productA1.operationA(); // 輸出 "ConcreteProductA1 operationA"ProductB productB1 = factory1.createProductB();productB1.operationB(); // 輸出 "ConcreteProductB1 operationB"AbstractFactory factory2 = new ConcreteFactory2();ProductA productA2 = factory2.createProductA();productA2.operationA(); // 輸出 "ConcreteProductA2 operationA"ProductB productB2 = factory2.createProductB();productB2.operationB(); // 輸出 "ConcreteProductB2 operationB"}
}

工廠模式通過封裝對象的創建過程，將對象的具體類型與使用代碼解耦，提供了一種靈活的方式來創建對象。它能夠隱藏對象的創建細節，簡化了客戶端的代碼，并且方便擴展和維護。工廠模式在實際應用中經常被使用，例如在 Java 中，Spring 框架的 BeanFactory 就是一個工廠模式的實現。

策略模式：

策略模式（Strategy Pattern）是一種行為型設計模式，它定義了一系列算法，并將每個算法封裝在獨立的類中，使得它們可以互相替換。策略模式使得算法可以獨立于使用它的客戶端而變化。

在策略模式中，有三個核心角色：

  1. 上下文（Context）：上下文是客戶端與策略模式之間的接口，它負責調用具體的策略對象來完成任務。
  2. 策略（Strategy）：策略是定義了一組相同行為的接口或抽象類，它代表了一種算法或行為。
  3. 具體策略（Concrete Strategy）：具體策略是策略接口的實現類，它實現了具體的算法或行為。

策略模式的優點包括：

  1. 提高代碼的可擴展性：由于策略模式將算法封裝在獨立的類中，因此可以很容易地添加新的策略類來擴展系統的功能。
  2. 提供了一定程度的靈活性：客戶端可以根據需要選擇不同的策略來完成特定的任務，而不需要修改客戶端的代碼。
  3. 使代碼易于理解和維護：策略模式將不同的算法分離開來，使得每個算法都具有清晰的目的和職責，使代碼更加可讀和易于維護。

下面是一個簡單的策略模式的示例，以計算商品折扣價格為例：

 

// 策略接口
public interface DiscountStrategy {double applyDiscount(double price);
}// 具體策略類
public class NoDiscountStrategy implements DiscountStrategy {@Overridepublic double applyDiscount(double price) {return price;}
}public class FixedDiscountStrategy implements DiscountStrategy {private double discountAmount;public FixedDiscountStrategy(double discountAmount) {this.discountAmount = discountAmount;}@Overridepublic double applyDiscount(double price) {return price - discountAmount;}
}public class PercentageDiscountStrategy implements DiscountStrategy {private double discountPercentage;public PercentageDiscountStrategy(double discountPercentage) {this.discountPercentage = discountPercentage;}@Overridepublic double applyDiscount(double price) {return price * (1 - discountPercentage);}
}// 上下文類
public class Product {private String name;private double price;private DiscountStrategy discountStrategy;public Product(String name, double price, DiscountStrategy discountStrategy) {this.name = name;this.price = price;this.discountStrategy = discountStrategy;}public double getPriceAfterDiscount() {return discountStrategy.applyDiscount(price);}
}// 客戶端代碼
public class Main {public static void main(String[] args) {Product product1 = new Product("Product 1", 100.0, new NoDiscountStrategy());System.out.println("Price: " + product1.getPriceAfterDiscount());  // 輸出 "Price: 100.0"Product product2 = new Product("Product 2", 100.0, new FixedDiscountStrategy(20.0));System.out.println("Price: " + product2.getPriceAfterDiscount());  // 輸出 "Price: 80.0"Product product3 = new Product("Product 3", 100.0, new PercentageDiscountStrategy(0.25));System.out.println("Price: " + product3.getPriceAfterDiscount());  // 輸出 "Price: 75.0"}
}
 

 

在上述示例中，策略模式通過定義 DiscountStrategy 接口和具體的策略類 NoDiscountStrategy、FixedDiscountStrategy 和 PercentageDiscountStrategy 來實現不同的折扣算法。Product 類作為上下文類，它包含一個折扣策略對象，并通過調用 applyDiscount() 方法來計算最終的折扣價格。
 

通過使用策略模式，客戶端可以根據具體的需求選擇不同的折扣策略，而無需修改上下文類的代碼。這樣一來，當需要添加新的折扣策略時，只需要創建新的具體策略類并實現 DiscountStrategy 接口即可，而不會對原有的代碼造成影響。這提高了代碼的可擴展性和靈活性。
 

橋接模式：
 

橋接模式（Bridge Pattern）是一種結構型設計模式，它將抽象部分與實現部分分離，使它們可以獨立變化而互不影響。橋接模式通過組合的方式，將抽象和實現解耦，從而可以在兩者之間建立一座橋梁，使它們可以獨立地進行變化和擴展。
 

在橋接模式中，有四個核心角色：
 

  1. 抽象類（Abstraction）：定義了抽象部分的接口，維護一個指向實現類的引用。
  2. 具體實現類（Concrete Implementation）：實現了實現部分的接口，并具體實現了其方法。
  3. 實現類接口（Implementation）：定義了實現部分的接口，供具體實現類實現。
  4. 具體抽象類（Concrete Abstraction）：繼承自抽象類，實現了抽象部分的具體功能。
 

橋接模式的優點包括：
 

  1. 解耦抽象和實現：橋接模式通過將抽象部分和實現部分分離，使得它們可以獨立變化，互不影響。
  2. 擴展性強：由于抽象部分和實現部分可以獨立變化，因此很容易添加新的抽象類或實現類，擴展系統的功能。
  3. 隱藏實現細節：橋接模式可以隱藏實現部分的細節，使客戶端只需要關注抽象部分即可。
 

下面是一個簡單的橋接模式的示例，以形狀和顏色為例：
 

// 顏色接口
public interface Color {void applyColor();
}// 紅色類
public class RedColor implements Color {@Overridepublic void applyColor() {System.out.println("Applying red color");}
}// 藍色類
public class BlueColor implements Color {@Overridepublic void applyColor() {System.out.println("Applying blue color");}
}// 形狀抽象類
public abstract class Shape {protected Color color;public Shape(Color color) {this.color = color;}public abstract void applyColor();
}// 圓形類
public class Circle extends Shape {public Circle(Color color) {super(color);}@Overridepublic void applyColor() {System.out.print("Circle filled with ");color.applyColor();}
}// 正方形類
public class Square extends Shape {public Square(Color color) {super(color);}@Overridepublic void applyColor() {System.out.print("Square filled with ");color.applyColor();}
}// 客戶端代碼
public class Main {public static void main(String[] args) {Shape redCircle = new Circle(new RedColor());redCircle.applyColor();  // 輸出 "Circle filled with Applying red color"Shape blueSquare = new Square(new BlueColor());blueSquare.applyColor();  // 輸出 "Square filled with Applying blue color"}
}
 

 

在上述示例中，橋接模式通過將形狀類和顏色類分離，使它們可以獨立變化。Shape 是抽象類，它包含一個顏色對象，并定義了一個抽象方法 applyColor()。Circle 和 Square 是具體抽象類，它們繼承自 Shape，并實現了 applyColor() 方法來應用顏色。
 

通過使用橋接模式，客戶端可以選擇不同的顏色來填充不同的形狀，而不需要修改形狀類的代碼。這樣一來，當需要添加新的形狀或顏色時，只需要創建新的具體抽象類并傳入相應的顏色對象即可，而不會對原有的代碼造成影響。橋接模式提高了代碼的靈活性和可擴展性。
 

責任鏈模式：
 

責任鏈模式（Chain of Responsibility Pattern）是一種行為設計模式，用于解耦發送者和接收者之間的關系。在責任鏈模式中，多個對象（處理者）依次處理請求，直到其中一個對象能夠處理該請求為止。這些對象被串成一條鏈，請求沿著鏈傳遞，直到有一個處理者處理它為止。
 

責任鏈模式通常包括以下幾個角色：
 

  1. 抽象處理者（Handler）：定義一個處理請求的接口，通常包括一個處理請求的方法和一個設置下一個處理者的方法。
  2. 具體處理者（ConcreteHandler）：實現抽象處理者接口，在處理請求時可以決定是否自己處理，或者將請求傳遞給下一個處理者。
  3. 客戶端（Client）：創建責任鏈，并向鏈頭的處理者發送請求。
 

責任鏈模式的優點包括：
 

  • 解耦發送者和接收者：發送者不需要知道具體的接收者，只需將請求發送給第一個處理者即可。
  • 靈活性增強：可以動態地修改責任鏈中的處理者順序或增加新的處理者，而不需要修改客戶端代碼。
  • 可以動態地指定處理者：每個處理者都有機會處理請求，客戶端可以根據需要靈活地指定處理者的順序。
 

然而，責任鏈模式也存在一些缺點，包括：
 

  • 請求可能未被處理：如果責任鏈沒有正確配置或者最終沒有處理請求的處理者，請求可能會被漏掉。
  • 性能問題：請求需要沿著責任鏈傳遞，可能導致一定的性能損失，特別是在責任鏈較長時。
 

總的來說，責任鏈模式適合于多個對象可以處理同一請求，且客戶端不需要明確指定處理者的情況下使用。通過合理設計責任鏈，可以更好地管理和處理請求，提高系統的靈活性和可擴展性。
 

假設我們有一個在線商城系統，當用戶下單購買商品時，訂單需要經過一系列的處理流程來驗證和處理。這時候可以使用責任鏈模式來處理訂單。
 

首先，我們定義一個抽象處理者（Handler）接口，其中包含處理請求的方法和設置下一個處理者的方法。
 

public interface OrderHandler {void handleOrder(Order order);void setNextHandler(OrderHandler handler);
}
 

然后，我們創建具體的處理者類，實現抽象處理者接口，并在處理請求時決定是否自己處理或者將請求傳遞給下一個處理者。 
 

public class StockHandler implements OrderHandler {private OrderHandler nextHandler;public void handleOrder(Order order) {if (order.getStock() >= order.getQuantity()) {System.out.println("庫存充足，可以繼續處理訂單。");// 處理訂單邏輯...} else {System.out.println("庫存不足，無法處理訂單，將請求傳遞給下一個處理者。");passToNextHandler(order);}}public void setNextHandler(OrderHandler handler) {this.nextHandler = handler;}private void passToNextHandler(Order order) {if (nextHandler != null) {nextHandler.handleOrder(order);} else {System.out.println("沒有合適的處理者，請求無法處理。");}}
}public class PaymentHandler implements OrderHandler {private OrderHandler nextHandler;public void handleOrder(Order order) {if (order.isPaymentValid()) {System.out.println("支付有效，可以繼續處理訂單。");// 處理訂單邏輯...} else {System.out.println("支付無效，無法處理訂單，將請求傳遞給下一個處理者。");passToNextHandler(order);}}public void setNextHandler(OrderHandler handler) {this.nextHandler = handler;}private void passToNextHandler(Order order) {if (nextHandler != null) {nextHandler.handleOrder(order);} else {System.out.println("沒有合適的處理者，請求無法處理。");}}
}
 

最后，我們創建客戶端代碼，創建責任鏈，并向鏈頭的處理者發送訂單請求。 
 

public class Client {public static void main(String[] args) {OrderHandler stockHandler = new StockHandler();OrderHandler paymentHandler = new PaymentHandler();stockHandler.setNextHandler(paymentHandler);Order order = new Order("ABC123", 10, 100.0);stockHandler.handleOrder(order);}
}
 

在上述例子中，訂單首先會經過庫存處理者（StockHandler），如果庫存充足，則訂單被處理；否則，請求會被傳遞給支付處理者（PaymentHandler），再次進行處理。如果沒有合適的處理者，請求將無法被處理。
 

通過使用責任鏈模式，訂單處理過程被解耦，每個處理者只需要關注自己的處理邏輯，增加新的處理者或者調整處理者的順序也變得靈活和簡單。











本文來自互聯網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。

如若轉載，請注明出處：http://www.pswp.cn/news/697167.shtml


繁體地址，請注明出處：http://hk.pswp.cn/news/697167.shtml

英文地址，請注明出處：http://en.pswp.cn/news/697167.shtml


如若內容造成侵權/違法違規/事實不符，請聯系多彩編程網進行投訴反饋email:809451989@qq.com，一經查實，立即刪除！











相關文章










Android 仿信號格子強度動畫效果實現








Android 仿信號格子強度動畫效果實現




效果圖  在 Android 中，如果你想要繪制一個圓角矩形并使其居中顯示，你可以使用 Canvas 類 drawRoundRect 方法。要使圓角矩形居中，你需要計算矩形的位置，這通常涉及到確定矩形左上角的位置（x, y）&#xff0…




閱讀更多...

















Leetcode 第 384 場周賽題解








Leetcode 第 384 場周賽題解




Leetcode 第 384 場周賽題解 Leetcode 第 384 場周賽題解題目1：3033. 修改矩陣思路代碼復雜度分析 題目2：3034. 匹配模式數組的子數組數目 I思路代碼復雜度分析 題目3：3035. 回文字符串的最大數量思路代碼復雜度分析 題目4：3036. …




閱讀更多...

















C語言標準庫介紹：＜string.h＞








C語言標準庫介紹：＜string.h＞




在C語言中&#xff0c;<string.h>頭文件是標準庫中的一個重要部分&#xff0c;它定義了一系列操作字符串和字符數組的函數。本文將詳細介紹<string.h>頭文件中包含的22個函數&#xff0c;并提供每個函數的完整示例代碼。 
簡介 
<string.h>頭文件定義了一個變…




閱讀更多...

















設計模式-工廠模式（Factory Pattern）








設計模式-工廠模式（Factory Pattern）




一、工廠模式說明 工廠模式是一種創建型設計模式&#xff0c;它提供了一種將對象的創建與使用分離的方式。工廠模式通過引入一個公共的接口來創建對象&#xff0c;而不是通過直接調用構造函數來創建對象。這樣做的好處是使得代碼更加靈活&#xff0c;更容易維護和擴展。 工廠模…




閱讀更多...

















第3部分 原理篇2去中心化數字身份標識符（DID）（2）








第3部分 原理篇2去中心化數字身份標識符（DID）（2）




3.2.2. DID相關概念 
3.2.2.1. 去中心化標識符 (Decentralized identifier&#xff0c;DID) 本聰老師&#xff1a;DID有兩個含義&#xff0c;一是Decentralized identity&#xff0c;就是去中心化身份&#xff0c;是廣泛意義的DID。另外一個是Decentralized identifier&#xf…




閱讀更多...

















Web性能優化-瀏覽器工作原理-MDN文檔學習筆記








Web性能優化-瀏覽器工作原理-MDN文檔學習筆記




瀏覽器工作原理 
查看更多學習筆記&#xff1a;GitHub&#xff1a;LoveEmiliaForever MDN中文官網 
導航 
導航是加載 web 頁面的第一步&#xff1a;輸入 URL、點擊一個鏈接、提交表單等等 
DNS查詢 
導航的第一步是要去尋找頁面資源的位置 例如訪問https://example.com&#x…




閱讀更多...

















如何解決DNS解析錯誤故障








如何解決DNS解析錯誤故障




DNS解析錯誤會導致將一個域名解析為錯誤的IP地址&#xff0c;或者根本無法確定某個域名對應的IP地址&#xff0c;從而無法通過域名訪問相應的站點&#xff0c;形成DNS解析故障。最常見的癥狀是訪問站點對應的IP地址沒有問題&#xff0c;但訪問其域名時卻出現錯誤。 
DNS解析異常…




閱讀更多...

















qt-動畫圓圈等待-LED數字








qt-動畫圓圈等待-LED數字




qt-動畫圓圈等待-LED數字 一、演示效果二、關鍵程序三、下載鏈接 一、演示效果 二、關鍵程序 
#include "LedNumber.h"
#include <QLabel>LEDNumber::LEDNumber(QWidget *parent) : QWidget(parent)
{//設置默認寬高比setScale((float)0.6);//設置默認背景色se…




閱讀更多...

















【深入了解TensorFlow】TensorFlow的安裝與配置








【深入了解TensorFlow】TensorFlow的安裝與配置




【深入了解TensorFlow】TensorFlow的安裝與配置 TensorFlow的安裝與配置準備就緒：開始前的準備工作1. 確定您的硬件和操作系統2. 選擇安裝方式3. 創建虛擬環境（可選）安裝TensorFlow使用pip安裝使用conda安裝從源代碼編譯安裝配置TensorFlow導入TensorFlow模塊檢查安裝是否成…




閱讀更多...

















Oracle 表被刪除或重命名后賬戶間的授權與同義詞關系








Oracle 表被刪除或重命名后賬戶間的授權與同義詞關系




Oracle 表被刪除或重命名后賬戶間的授權與同義詞關系 
情景一、 當數據表刪除后 
數據表被刪除后&#xff0c;同義詞還是存在的&#xff0c;可以查看當前用戶下查看同義詞&#xff1a; 
-- 查看當前用戶下的同義詞
select * from user_synonyms但授權關系不在了&#xff0c;若重…




閱讀更多...

















10 個 Linux 中超方便的 Bash 別名








10 個 Linux 中超方便的 Bash 別名




1、 你有幾次遇到需要解壓 .tar 文件但無法記住所需的確切參數&#xff1f;別名可以幫助你&#xff01;只需將以下內容添加到 .bash_profile 中&#xff0c;然后使用 untar FileName 解壓縮任何 .tar 文件。 alias untartar -zxvf  2、 下載文件時&#xff0c;如果出現問題想要…




閱讀更多...

















websocket與Socket的區別








websocket與Socket的區別




概念講解 網絡&#xff1a;通俗意義上&#xff0c;也就是連接兩臺計算器 五層網絡模型&#xff1a;應用層、傳輸層、網絡層、數據鏈路層、物理層  應用層 (application layer)&#xff1a;直接為應用進程提供服務。應用層協議定義的是應用進程間通訊和交互的規則&#xff0c;不…




閱讀更多...

















明明正常，卻不停return








明明正常，卻不停return




明明正常&#xff0c;卻不停return if(!is); 
{ return ; 
} 
熬人




閱讀更多...

















應急響應速查








應急響應速查




最重要的&#xff1a;我是誰&#xff1f;我在哪&#xff1f;別人怎么進來的&#xff1f;我就是這個被挖礦被勒索的電腦。 
分析項 &#xff1a; 
一、了解大概的被入侵系統情況&#xff1a; 
發現時間&#xff1f;怎么發現的&#xff1f;這臺機器有沒有人運維&#xff1f;平時還…




閱讀更多...

















排序第三篇 直接插入排序








排序第三篇 直接插入排序




插入排序的基本思想是&#xff1a; 每次將一個待排序的記錄按其關鍵字的大小插入到前面已排好序的文件中的適當位置&#xff0c; 直到全部記錄插入完為止。 一 簡介 
插入排序可分為2類  本文介紹 直接插入排序 它的基本操作是&#xff1a; 假設待排充序的記錄存儲在數組 R[1……




閱讀更多...

















電路設計（27）——交通信號燈的multisim仿真








電路設計（27）——交通信號燈的multisim仿真




1.功能要求 使用數字芯片設計一款交通信號燈&#xff0c;使得&#xff1a; 主干道的綠燈時間為60S&#xff0c;紅燈時間為45S 次干道的紅燈時間為60S&#xff0c;綠燈時間為45S 主、次干道&#xff0c;綠燈的最后5S內&#xff0c;黃燈閃爍 使用數碼管顯示各自的倒計時時間。 按…




閱讀更多...

















JavaScript 數組、遍歷








JavaScript 數組、遍歷




數組 多維數組&#xff1a;數組里面嵌套 一層數組為二維數組。一維數組的使用頻率是最高的。 如果數組訪問越界會返回undefined。 數組遍歷 數組方法Array.isArray() 這個方法可以去判定一個內容是否是數組。




閱讀更多...

















AndroidStudio 2024-2-21 Win10/11最新安裝配置(Kotlin快速構建配置,gradle鏡像源)








AndroidStudio 2024-2-21 Win10/11最新安裝配置(Kotlin快速構建配置,gradle鏡像源)




AndroidStudio 2024 Win10/11最新安裝配置 
教程目的&#xff1a; 
(從安裝到卸載) &#xff0c;針對Kotlin開發配置&#xff0c;gradle-8.2-src/bin下載慢&#xff0c;以及Kotlin構建慢的解決 好久沒玩AS了,下載發現裝個AS很麻煩,就覺得有必要出個教程了(就是記錄一下:嘻嘻) 因…




閱讀更多...

















把一個對象變成可迭代對象的兩種方法，使用Symbol.iterator 和生成器Generator








把一個對象變成可迭代對象的兩種方法，使用Symbol.iterator 和生成器Generator




方法一&#xff1a;自定義Symbol.iterator屬性 
如果對象擁有[Symbol.iterator] 方法&#xff0c;改方法返回一個迭代器對象&#xff0c;就可以稱之為可迭代對象&#xff0c;注意迭代器是一個有 next 方法的對象 步驟如下 
實現一個Symbol.iterator 鍵值是一個函數&#xff0c;…




閱讀更多...

















java 時間格式 YYYY 于yyyy的區別








java 時間格式 YYYY 于yyyy的區別




java formatDate 時間時&#xff0c;經常需要輸入格式比如 YYYYMMDD,yyyyMMdd 
這兩個是有區別的 具體每個參數可以看下面




閱讀更多...


















最新文章


















Copyright @ 2022~2023