面向對象的六大原則

時間  2019-12-08
標籤 面向對象 六大 原則 欄目 軟件設計 简体版
原文   原文鏈接

《Android源碼設計模式解析與實戰》讀書筆記(一)php

《Android源碼設計模式解析與實戰》PDF資料下載編程

1、單一職責原則

單一職責原則的英文名稱是Single Responsibility Principle，縮寫是SRP。SRP的定義是：就一個類而言，應該僅有一個引發它變化的緣由。設計模式

簡單來講，一個類中應該是一組相關性很高的函數、數據的封裝。單一職責的劃分界限並不老是那麼清晰，不少時候都是須要靠我的經驗來界定。緩存

1.一、示例代碼

下面是一個圖片加載器的項目代碼。bash

/**
 * 圖片加載類
 */
public class ImageLoader {
    //圖片緩存
    LruCache<String, Bitmap> mImageCache;
    //線程池，線程數量爲CPU的數量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    public ImageLoader() {
        initImageCache();
    }

    private void initImageCache() {
        //計算可以使用的最大內存
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        //取四分之一的可用內存做爲緩存
        final int cacheSize = maxMemory / 4;
        mImageCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };
    }

    public void displayImage(final String url, final ImageView imageView) {
        imageView.setTag(url);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(url);
                if (bitmap == null) {
                    return;
                }
                if (imageView.getTag().equals(url)) {
                    imageView.setImageBitmap(bitmap);
                }
                mImageCache.put(url, bitmap);
            }
        });
    }

    private Bitmap downloadImage(String imageUrl) {
        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            final HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(conn.getInputStream());
            conn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }

}
複製代碼

將各個功能獨立出來，知足單一職責原則的代碼以下。微信

/**
 * 圖片加載類
 */
public class ImageLoader {
    //圖片緩存
    ImageCache mImageCache = new ImageCache();
    //線程池，線程數量爲CPU的數量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    //加載圖片
    public void displayImage(final String url, final ImageView imageView) {
        Bitmap bitmap=mImageCache.get(url);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            return;
        }
        imageView.setTag(url);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(url);
                if (bitmap == null) {
                    return;
                }
                if (imageView.getTag().equals(url)) {
                    imageView.setImageBitmap(bitmap);
                }
                mImageCache.put(url, bitmap);
            }
        });
    }

    private Bitmap downloadImage(String imageUrl) {
        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            final HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(conn.getInputStream());
            conn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }

}
複製代碼
public class ImageCache {
    //圖片LRU緩存
    LruCache<String,Bitmap> mImageCache;
    public ImageCache() {
        initImageCache();
    }

    private void initImageCache() {
        //計算可以使用的最大內存
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        //取四分之一的可用內存做爲緩存
        final int cacheSize = maxMemory / 4;
        mImageCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };
    }

    public void put(String url,Bitmap bitmap){
        mImageCache.put(url, bitmap);
    }

    public Bitmap get(String url){
        return mImageCache.get(url);
    }
}
複製代碼

將原來的代碼一拆爲二，ImageLoader只負責圖片加載的邏輯，而ImageCache只負責處理圖片緩存的邏輯，使得職責更清晰。網絡

2、開閉原則

開閉原則的英文全稱是Open Close Principle，縮寫是OCP，它是Java世界裏最基礎的設計原則，它指導咱們如何創建一個穩定的、靈活的系統。ide

開閉原則的定義是：軟件中的對象（類、模塊、函數等）應該對於擴展是開放的，可是對於修改是封閉的。函數

2.一、示例代碼

上面重構以後的ImageLoader職責單1、結構清晰。經過內存緩存解決了每次從網絡加載圖片的問題，可是Android應用的內存有限，且具備易失性，就是當應用從新啓動以後，原來已經加載過的圖片將會丟失，這樣重啓以後就須要從新下載。優化

public class DiskCache {
    static String cacheDir="sdcard/cache/";

    //從緩存中獲取圖片
    public Bitmap get(String url){
        return BitmapFactory.decodeFile(cacheDir + url);
    }

    //將圖片緩存到內存中
    public void put(String url, Bitmap bmp) {
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(cacheDir + url);
            bmp.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
複製代碼

僅僅新增了一個DiskCache類和往ImageLoader類中加入少許代碼就添加了SD卡緩存的功能，用戶能夠經過useDiskCache方法來對使用哪一種緩存進行設置。

緩存優先使用內存緩存，若是內存緩存沒有圖片再使用SD卡緩存，若是SD卡中也沒有圖片最後才從網絡上獲取，這纔是最好的緩存策略。

public interface ImageCache {

    public void put(String url,Bitmap bitmap);

    public Bitmap get(String url);
}
複製代碼
public class MemoryCache implements ImageCache {
    //圖片LRU緩存
    LruCache<String, Bitmap> mMemeryCache;

    public MemoryCache() {
        //初始化LRU緩存
    }

    @Override
    public void put(String url, Bitmap bitmap) {
        mMemeryCache.put(url, bitmap);
    }

    @Override
    public Bitmap get(String url) {
        return mMemeryCache.get(url);
    }
}
複製代碼
//SD卡緩存DiskCache類
public class DiskCache  implements ImageCache{
    static String cacheDir="sdcard/cache/";

    //從緩存中獲取圖片
    @Override
    public Bitmap get(String url){
        return BitmapFactory.decodeFile(cacheDir + url);
    }

    //將圖片緩存到內存中
    @Override
    public void put(String url, Bitmap bmp) {
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(cacheDir + url);
            bmp.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
複製代碼
public class DoubleCache {
    ImageCache mMemoryCache=new MemoryCache();
    DiskCache mDiskCache=new DiskCache();

    //先從內存緩存中獲取圖片，若是沒有，再從SD卡中獲取
    public Bitmap get(String url){
        Bitmap bitmap = mMemoryCache.get(url);
        if (bitmap == null) {
            bitmap = mDiskCache.get(url);
        }
        return bitmap;
    }

    //將圖片緩存到內存和SD卡中
    public void put(String url, Bitmap bmp) {
        mMemoryCache.put(url, bmp);
        mDiskCache.put(url, bmp);
    }
}
複製代碼
/**
 * 圖片加載類
 */
public class ImageLoader {
    //內存緩存
    private ImageCache mImageCache = new MemoryCache();
    //線程池，線程數量爲CPU的數量
    private ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    //注入緩存實現
    public void setImageCache(ImageCache imageCache) {
        mImageCache = imageCache;
    }

    //加載圖片
    public void displayImage(final String url, final ImageView imageView) {
        Bitmap bitmap =  mImageCache.get(url);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            return;
        }
        //圖片沒緩存，提交到線程池中下載圖片
        submitLoadRequest(url, imageView);
    }

    private void submitLoadRequest(final String url, final ImageView imageView) {
        imageView.setTag(url);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(url);
                if (bitmap == null) {
                    return;
                }
                if (imageView.getTag().equals(url)) {
                    imageView.setImageBitmap(bitmap);
                }
                mImageCache.put(url, bitmap);
            }
        });
    }

    private Bitmap downloadImage(String imageUrl) {
        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            final HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(conn.getInputStream());
            conn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }

}
複製代碼

3、里氏替換原則

里氏替換原則英文全稱是Liskov Substitution Principle，縮寫是LSP。LSP的第一種定義是：若是對每個類型爲S的對象O1，都有類型爲T的對象O2，使得以T定義的全部程序P在全部對象O1都代換成O2時，程序P的行爲沒有發生變化，那麼類型S是類型T的子類型。

里氏替換原則第二種定義：全部引用基類的地方必須能透明地使用其子類的對象。

3.一、核心原理

里氏替換原則的核心原理是抽象，抽象又依賴於繼承這個特性，在OOP中，繼承的優缺點都至關明顯。

  1. 優勢：
  • 代碼重用，減小建立類的成本，每一個子類都擁有父類的方法和屬性；
  • 子類與父類基本類似，但又與父類有所區別；
  • 提升代碼的可擴展性。
  1. 缺點：
  • 繼承是侵入性的，只要繼承就必須擁有父類的全部屬性和方法；
  • 可能形成子類代碼冗餘、靈活性下降，由於子類必須擁有父類的屬性和方法。

開閉原則和里氏替換原則一般是生死相依、不離不棄的，經過里氏替換原則來達到對擴展開放，對修改關閉的效果。這兩個原則都強調了一個OOP的重要特性——抽象。

4、依賴倒置原則

依賴倒置原則英文全稱是Dependence Inversion Principle，縮寫是DIP。依賴倒置原則指代了一種特定的解耦形式，使得高層次的模塊不依賴於低層次的模塊的實現細節的目的，依賴模塊被顛倒了。

依賴倒置原則有如下幾個關鍵點：

  • 高層模塊不該該依賴低層模塊，二者都應該依賴其抽象；
  • 抽象不該該依賴細節；
  • 細節應該依賴抽象。

在Java中，抽象是指接口或抽象類，二者都不能直接被實例化；細節就是實現類，實現接口或繼承抽象類而產生的類就是細節，能夠直接被實例化。

高層模塊就是調用端，低層模塊就是具體實現類。

依賴倒置原則在Java語言中的表現：模塊間的依賴經過抽象發生，實現類之間不發生直接的依賴關係，其依賴關係是經過接口或抽象類產生的。

5、接口隔離原則

接口隔離原則英文全稱是Interface Segregation Principles，縮寫是ISP。ISP的定義是：客戶端不該該依賴它不須要的接口。另外一種定義是：類間的依賴關係應該創建在最小的接口上。

接口隔離原則的目的是系統解開耦合，從而容易重構、更改和從新部署。

Robert C Martin在21世紀早期將單一職責、開閉原則、里氏替換、接口隔離以及依賴倒置5個原則定義爲SOLID原則，做爲面向對象編程的5個基本原則。

6、迪米特原則

迪米特原則英文全稱爲Law of Demeter，縮寫是LOD，也稱爲最少知識原則（Least Knowledge Principle）。其定義是：一個對象應該對其餘對象有最少的瞭解。

6.一、示例代碼

以租房爲例來講一下迪米特原則的應用。

/**
 * 房間
 */
public class Room {
    public float area;
    public float price;

    public Room(float area, float price) {
        this.area = area;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Room{" +
                "area=" + area +
                ", price=" + price +
                '}';
    }
}
複製代碼
/**
 * 中介
 */
public class Mediator {
    List<Room> mRooms = new ArrayList<Room>();

    public Mediator() {
        for (int i = 0; i < 5; i++) {
            mRooms.add(new Room(14 + i, (14 + i) * 150));
        }
    }

    public List<Room> getRooms() {
        return mRooms;
    }
}
複製代碼
/**
 * 租戶
 */
public class Tenant {
    public float roomArea;
    public float roomPrice;
    public static final float diffPrice = 100.0001f;
    public static final float diffArea = 0.00001f;

    public void rentRoom(Mediator mediator) {
        List<Room> rooms = mediator.getRooms();
        for (Room room :
                rooms) {
            if (isSuitable(room)) {
                System.out.println("租到房間了" + room);
                break;
            }
        }
    }

    private boolean isSuitable(Room room) {
        return Math.abs(room.price - roomPrice) < diffPrice
                && Math.abs(room.area - roomArea) < diffArea;
    }
}
複製代碼

從上面的代碼中能夠看到，Tenant不只依賴了Mediator類，還須要頻繁地與Room類打交道。優化代碼以下：

/**
 * 中介
 */
public class Mediator {
    List<Room> mRooms = new ArrayList<Room>();

    public Mediator() {
        for (int i = 0; i < 5; i++) {
            mRooms.add(new Room(14 + i, (14 + i) * 150));
        }
    }

    public List<Room> getRooms() {
        return mRooms;
    }

    public Room rentOut(float area,float price){
        for (Room room : mRooms) {
            if (isSuitable(area,price,room)) {
                return room;
            }
        }
        return null;
    }

    private boolean isSuitable(float area,float price,Room room) {
        return Math.abs(room.price - price) < Tenant.diffPrice
                && Math.abs(room.area - area) < Tenant.diffArea;
    }
}
複製代碼
/**
 * 租戶
 */
public class Tenant {
    public float roomArea;
    public float roomPrice;
    public static final float diffPrice = 100.0001f;
    public static final float diffArea = 0.00001f;

    public void rentRoom(Mediator mediator) {
        System.out.println("租到房了" + mediator.rentOut(roomArea, roomPrice));
    }
}
複製代碼

學海無涯苦做舟

個人微信公衆號
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程