關於設計模式(單例模式、工廠模式、代理模式、介面卡模式、觀察者設計模式)的理解
1):單例模式
package designMode.singleton; /** * 單例模式形成的原因: * * 構造器私有---> 外界無法例項化,就在類內部建立一個例項物件,用static修飾,可以用類名直接呼叫---> 但是,類的一般用法都講究封裝,例項化物件封裝 * ---> 建立getInstance()方法 ---> 由於instance是靜態屬性,所以方法需要static修飾 * */ public class Singleton { private static Singleton instance = new Singleton(); private Singleton(){ } public static Singleton getInstance(){ return instance; } public void print(){ System.out.println("單例模式!"); } public static void main(String[] args) { Singleton s1 = Singleton.getInstance();//訪問類中的靜態方法,取得類中的靜態例項 Singleton s2 = Singleton.getInstance(); Singleton s3 = Singleton.getInstance(); s1.print(); //輸出資訊 s2.print(); s3.print(); } }
結果:
單例模式!
單例模式!
單例模式!
2):工廠模式:
程式在介面和子類之間加入了一個過度端,通過此過度端取得介面的例項化物件,一般都會稱這個過渡端為工廠類;
因為介面物件的例項是從工廠取得的,以後如果再有子類擴充,直接修改工廠類客戶端既可以根據標記得到相應的例項,靈活性較高。
package designMode.factory;
/**
* 父介面
*
*/
public interface Fruit {
void eat();
}
package designMode.factory; public class Apple implements Fruit { @Override public void eat() { System.out.println("**吃蘋果"); } }
package designMode.factory;
public class Orange implements Fruit{
@Override
public void eat() {
System.out.println("**吃橘子");
}
}
package designMode.factory; public class Factory { public static Fruit getInstance(String fruitString){ Fruit fruit = null; if(fruitString.equals("apple")){ fruit = new Apple(); } if(fruitString.equals("orange")){ fruit = new Orange(); } return fruit; } }
package designMode.factory;
/**
* 工廠模式
*
*/
public class FactoryDemo {
public static void main(String[] args) {
Fruit fruit = null;
fruit = Factory.getInstance("designMode.factory.Orange ");
fruit.eat();
}
}
結果:
**吃橘子
將反射應用在工廠模式上
package designMode.factory;
/**
* 工廠模式
*
*/
public class FactoryDemo {
public static void main(String[] args) {
Fruit fruit = null;
fruit = Factory.getInstance("orange");
fruit.eat();
}
}
結果;
**吃橘子
對比:運用反射的好處,
無論增加多少個子類,子類增加多個個屬性,工廠類不用做任何的修改。
3):代理模式:
使用者只關心上網,代理處理如何上網,
定義一個上網介面,使用者和代理都實現該介面,分別做自己要做的事情,
package designMode.proxy;
public interface Network {
void browse();
}
package designMode.proxy;
public class Real implements Network{ //真實的上網操作。
@Override
public void browse() {
System.out.println("真實的上網操作");
}
}
package designMode.proxy;
public class Proxy implements Network {
private Network network;
public Proxy(Network network){
this.network = network;
}
public void check(){
System.out.println("代理檢查使用者是否合法");
}
@Override
public void browse() {
check();
network.browse();
}
}
package designMode.proxy;
/**
* 代理模式
*
*/
public class ProxyDemo {
public static void main(String[] args) {
new Proxy(new Real()).browse(); //有參構造,例項化代理,執行代理的方法。
}
}
結果:
代理檢查使用者是否合法
真實的上網操作
4):介面卡模式:
主介面有太多的方法,如果直接實現,就必須覆寫全部的方法,如果我只想操作其中的幾個,就需要是用介面卡進行適配。
package designMode.adapter;
public interface Window {//定義介面,,定義了很多的方法,但是隻需要使用其中個別的方法,就需要使用代理模式了
void open();
void close();
void activated();
void iconified();
void deiconified();
}
package designMode.adapter;
public abstract class WindowAdapter implements Window {//用抽象類實現介面,方法體為空
@Override
public void activated() {
// TODO Auto-generated method stub
}
@Override
public void close() {
// TODO Auto-generated method stub
}
@Override
public void deiconified() {
// TODO Auto-generated method stub
}
@Override
public void iconified() {
// TODO Auto-generated method stub
}
@Override
public void open() {
// TODO Auto-generated method stub
}
}
package designMode.adapter;
import java.awt.event.WindowAdapter;
public class WindowImpl extends WindowAdapter { //例項體繼承 抽象類。重寫需要的方法
public void open(){
System.out.println("視窗開啟");
}
public void close(){
System.out.println("視窗關閉");
}
}
package designMode.adapter;
public class AdapterDemo {
public static void main(String[] args) { //呼叫介面父類,執行需要的方法,其他的方法沒有結果,在公司的eclipse上執行成功了,可是我自己的卻不行,不知道是什麼原因
Window window = (Window) new WindowImpl();
window.open();
window.close();
window.activated();
System.out.println();
window.iconified();
System.out.println();
window.deiconified();
}
}
結果:
視窗開啟
視窗關閉
5):觀察者設計模式
什麼叫做觀察者
舉個例子,現在很多人買房,都在關注房價,如果價格變動,所有的購房者都可以觀察到,(購房者就是觀察者,這就叫觀察者設計模式)java中使用Observable類和Observer介面,輕鬆實現上述功能。
package library.watch;
import java.util.Observable;
public class House extends Observable{
private float price;
public House(float price){
this.price = price;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
super.setChanged(); //設定變化點
super.notifyObservers(price); //通知所有觀察者價格改變
this.price = price;
}
@Override
public String toString() {
return "房子價格為: price=" + price;
}
}
package library.watch;
import java.util.Observable;
import java.util.Observer;
public class HousePriceObserver implements Observer {
private String name;
public HousePriceObserver(String name) {
super();
this.name = name;
}
@Override
public void update(Observable o, Object arg) {
if (arg instanceof Float) { //判斷引數型別
System.out.print(this.name +"觀察到價格更改為:");
System.out.println(((Float)arg).floatValue());
}
}
public static void main(String[] args) {
House h = new House(1000000);
HousePriceObserver hpo1 = new HousePriceObserver("購房者A");
HousePriceObserver hpo2 = new HousePriceObserver("購房者B");
HousePriceObserver hpo3 = new HousePriceObserver("購房者C");
h.addObserver(hpo1); //加入觀察者
h.addObserver(hpo2);
h.addObserver(hpo3);
System.out.println(h); //輸出房子價格
h.setPrice(600000); //修改房子價格
System.out.println(h);
}
}
結果:
房子價格為: price=1000000.0
購房者C觀察到價格更改為:600000.0
購房者B觀察到價格更改為:600000.0
購房者A觀察到價格更改為:600000.0
房子價格為: price=600000.0
抽象類--->摸具(繼承的子類都具有父類的全部特徵)
介面 --->指定標準(子類需要全部執行這些標準)
JDK1.8開始,可以在介面中定義普通方法:
產生背景:如果一個介面已經產生了至少30萬個子類,突然有一天需要增加介面功能,並且這些方法對於所有的子類實現都是相同的,難道要子類覆寫30萬次?
如此,1.8之後,放寬介面的定義要求,可以定義抽象方法和靜態方法,並且這些方法可以根據子類繼承的原則被所有的介面子類繼承。
相關推薦
javaSE (三十八)設計模式 ( 單例設計模式(餓漢式/懶漢式)、簡單工廠模式、工廠模式、介面卡模式、模板方法設計模式)
1、單例設計模式(餓漢式/懶漢式): 概念:保證類在記憶體中只有一個物件 思路: 私有構造方法,其他類不能再訪問該構造方法了 建立本類物件(就在本類裡建立),將物件的應用作為成員變數,並私有靜態化(在這裡又分為餓漢式和懶漢式,餓漢式直接引用連線物件,而懶漢式在第二步先建
ThinkPHP筆記5——PHP常用設計模式(單例、工廠、註冊樹)
<?php //單例模式 class Site{ //屬性 public $siteName; //本類的靜態例項 private static $instance = null; //禁用構造方法 private function __construct($siteN
關於設計模式(單例模式、工廠模式、代理模式、介面卡模式、觀察者設計模式)的理解
1):單例模式 package designMode.singleton; /** * 單例模式形成的原因: * * 構造器私有---> 外界無法例項化,就在類內部建立一個例項物件,用static修飾,可以用類名直接呼叫---> 但是,類的一般用法都講究
設計模式(單例、代理、工廠)
一、單例模式 <span style="font-family:Microsoft YaHei;font-size:12px;">主要包括懶漢式,餓漢式,登記式,以及懶漢式的改進型,還有一個關於讀取propertoes配置檔案的例項。</span&g
【JAVA】基礎:設計模式(單例設計模式,工廠設計模式)
設計模式:解決某一類問題最行之有效的方法。 java中有23種設計模式。 建立型模式(5種):工廠方法模式,抽象工廠模式,單例模式,建造者模式,原型模式。 結構型模式(7種):介面卡模式,裝飾器模式,代理模式,外觀模式,橋接模式,組合模式,享元模式。 行為型模式(11種):策略模式、模板方法
設計模式(單例模式,工廠模式,介面卡模式)
1:設計模式是什麼? 前人總結的一些經驗和思想,給我們提供了從抽象到具體的方法 總共有23種 分類: 建立型模式: 建立物件。(其實建立物件比較耗記憶體的動作) 結構型模式: 物件的組成。 行為模式: 物件能夠做什
java中幾種設計模式(單例模式,介面卡模式,簡單工廠模式)
1、單例模式:也分餓漢式單例模式(建立物件)與懶漢式單例模式(未建立物件)程式碼實現:餓漢式單例模式:懶漢式單例模式:2、介面卡模式:介面:實現介面的類:實現介面某個方法的類:3、簡單工廠模式:介面:類1:類2:工廠類:測試類:
創建型設計模式(單例模式)
創建型設計模式 true 自己 singleton span 創建 final 調用 ati 單例模式有以下特點: 1、單例類只能有一個實例。 2、單例類必須自己創建自己的唯一實例。 3、單例類必須給所有其他對象提供這一實例。 一、懶漢式單例 //懶漢式單例類.在第
添磚加瓦:設計模式(單例模式)
argv pri 方法 職責 ger 資源管理 存在 優缺點 names 1、單例定義及要素 定義: 保證一個類只有一個實例存在,同時提供能對該實例加以訪問的全局訪問方法(GoF中單例模式的定義)。 要素: (1)某個類只能有一個實例 (2)必須自行
設計模式——(單例模式)
單例模式簡介: 單例模式(Singleton Pattern)是 Java 中最簡單的設計模式之一。這種型別的設計模式屬於建立型模式,它提供了一種建立物件的最佳方式。 這種模式涉及到一個單一的類,該類負責建立自己的物件,同時確保只有單個物件被建立。這個類提供了一種訪問其唯一的物件的
java 設計模式(單例,享元,策略)
讀書不覺已春深,一寸光陰一寸金。 java的設計模式大體上分為三大類: 建立型模式(5種):工廠方法模式,抽象工廠模式,單例模式,建造者模式,原型模式。 結構型模式(7種):介面卡模式,裝飾器模式,代理模式,外觀模式,橋接模式,組合模式,享元模式。
Python設計模式(單例模式)筆記
版本:Python3.6.1# coding = utf - 8 """ time:2018年4月3日 10:15:02 function:設計模式---單例模式 """ """ 單例模式: 保證物件的唯一性 思路: 在建立物件時,只分配一個記憶體
Java---設計模式(單例變形)多例
★ 快取在單例中的使用(“單例+快取”技術) 快取在程式設計中使用很頻繁,有著非常重要的作用,它能夠幫助程式實現以空間換取時間,通常被設計成整個應用程式所共享的一個空間,現要求實現一個用快取存放單例物
原始碼學習之設計模式(單例模式)
眾所周知,單例模式分為餓漢式和懶漢式,昨天在看了《spring5核心原理與30個類手寫實戰》之後才知道餓漢式有很多種寫法,分別適用於不同場景,避免反射,執行緒不安全問題。下面就各種場景、採用的方式及其優缺點介紹。 餓漢式 (絕對的執行緒安全) 程式碼示例 1.第一種寫法 ( 定義即初始化) public cl
設計模式:對象生成(單例、工廠、抽象工廠)
添加 對象實例 log return ray 靜態 學習 線程 tco 對象的創建有時會成為面向對象設計的一個薄弱環節。我們可以使用多種面向對象設計方案來增加對象的創建的靈活性。 單例模式:生成一個且只生成一個對象實例的特殊類 工廠方法模式:構建創建者類的繼承層級
java中的設計模式之單例模式、工廠模式
Java中的設計模式 轉載地址:https://www.toutiao.com/i6573486403282272775/ 為什麼要學習設計模式 1)設計模式都是一些相對優秀的解決方案,很多問題都是典型的
設計模式(三)(單例模式、命令模式)
六:單例模式 單例模式確保一個類只有一個例項,並提供一個全域性訪問點。 意圖:保證一個類僅有一個例項,並提供一個訪問它的全域性訪問點。 主要解決:一個全域性使用的類頻繁地建立與銷燬。 何時使用:
【設計模式】單例模式、三個工廠模式
interface IFactory { Operation CreateOperation(); } class AddFactory : IFactory { public Operation CreateOperation()
Java中常見的設計模式---簡單工廠模式、工廠方法模式和單例模式
在講設計模式之前,我們首先來說一下面向物件思想的設計原則,在實際的開發中,我們要想更深入的瞭解面向物件思想,就必須熟悉前人總結過的面向物件的思想的設計原則:1.單一職責原則:“高內聚,低耦合”,也就是說,每個類應該只有一個職責,對外只能提供一種功能,而引起類變化的原因應該只有
java設計模式淺談(單例模式,模板模式,工廠模式,代理模式)
這篇文章講述的是java設計模式,包括單例模式、工廠模式、代理模式,如有錯誤或不當之處,希望各位大神批評指正。 什麼是設計模式? 設計模式:是指在大量的理論和實踐中總結和理論化之後,優選的程式碼結構、程式設計風格、以及解決問題的思考模式。正如數學中的公