设计模式-00 6大设计原则

最新推荐文章于 2021-02-03 14:30:17 发布
最新推荐文章于 2021-02-03 14:30:17 发布
阅读量784 收藏
点赞数
分类专栏： 零散备忘 文章标签： 设计原则 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SImple_a/article/details/68951654
版权

1 单一职责原则
单一职责的定义是：就一个类而言，应阿盖仅有一个引起他变化的原因。简单来说，一个类中应该是一组相关性和高的函数，数据的封装。但是由于每个人的理解不一样。那么划分类的界限也不一样。
下面是一个示例：

/**
 * 图片加载类
 */

public class ImageLoader {
    //图片缓存
    LruCache<String,Bitmap> mImageCache;

    //线程池，线程数量
    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 bitmap) {
                return bitmap.getRowBytes()*bitmap.getHeight()/1024;
            }
        };
    }

    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);

            }
        });

    }

    public Bitmap downloadImage(String imageUrl){
        Bitmap bitmap = null;
        try{
            URL url = new URL(imageUrl);
            final HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(connection.getInputStream());
            connection.disconnect();

        }catch(Exception e){
            e.printStackTrace();
        }
        return  bitmap;
    }


}

上面是一个图片加载的类。使用该类直接调用31行方法displayImage(final String url, final ImageView imageView)就能给ImageView赋值。那么该类中把缓存相关的逻辑也加入其中。如第七行定义了LruCache类型的变量。并在16行的initImageCache()进行了初始化。那么可以把ImageCache单独提取到一个类中。这样就可以降低代码的耦合。下面是分开后的代码：

使用单一原则修改后

/**
 * 图片缓存类
 */

public class ImageCache {
    //图片缓存
    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 bitmap) {
                return bitmap.getRowBytes()*bitmap.getHeight()/1024;
            }
        };
    }

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

    public Bitmap get(String url){
        return  mImageCache.get(url);
    }

}
/**
 * 图片加载类
 */

public class ImageLoader {
    //图片缓存
    ImageCache mImageCache = new ImageCache() ;

    //线程池，线程数量
    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);

            }
        });

    }

    public Bitmap downloadImage(String imageUrl){
        Bitmap bitmap = null;
        try{
            URL url = new URL(imageUrl);
            final HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(connection.getInputStream());
            connection.disconnect();

        }catch(Exception e){
            e.printStackTrace();
        }
        return  bitmap;
    }


}

其实就是把ImageCache这个类提取出来。使代码更简洁。用设计原则来说这是单一职责原则

2 开闭原则
开闭原则的定义是：软件中的对象应该是对于扩展是开放的。但是对于修改是关闭的。因为在该原来版本的代码时，如果修改了原来的代码可能会破坏原来的代码。

还是原来的代码，现在又加入了新的缓存方式，SD卡缓存。

/**
 * SD卡缓存
 */

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

    //从缓存中获取图片
    public Bitmap get(String url){
        return BitmapFactory.decodeFile(cacheDir+url);
    }

    //将图片缓存到内存中
    public void put(String url,Bitmap bitmap){
        FileOutputStream fileOutputStream = null;
        try{
            fileOutputStream = new FileOutputStream(cacheDir+url);
            bitmap.compress(Bitmap.CompressFormat.PNG,100,fileOutputStream);
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            if(fileOutputStream!=null){
                try{
                    fileOutputStream.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

缓存方式改变后，又要重新更改ImageLoader中获取缓存的方式。

 //是否使用SD卡缓存
    boolean isUsedDisCache  = false;
 //SD卡缓存
    DiskCache mDiskCache = new DiskCache();

通过这种加标记的方式，来判断当前要缓存的方式。当调用ImageLoader类时，需要指定哪一种缓存。

 //判断是否是SD缓存
        Bitmap bitmap = isUsedDisCache?mDiskCache.get(url):mImageCache.get(url);

修改ImageLoader后

/**
 * 图片加载类
 */

public class ImageLoader {
    //内存缓存
    ImageCache mImageCache = new ImageCache() ;

    //SD卡缓存
    DiskCache mDiskCache = new DiskCache();

    //线程池，线程数量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    //是否使用SD卡缓存
    boolean isUsedDisCache  = false;


    public void displayImage(final String url, final ImageView imageView){
        //判断是否是SD缓存
        Bitmap bitmap = isUsedDisCache?mDiskCache.get(url):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);

            }
        });

    }

    public Bitmap downloadImage(String imageUrl){
        Bitmap bitmap = null;
        try{
            URL url = new URL(imageUrl);
            final HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(connection.getInputStream());
            connection.disconnect();

        }catch(Exception e){
            e.printStackTrace();
        }
        return  bitmap;
    }


}

这种每次加入新的缓存时都要修改原来的代码，这样很可能会引入bug.而且会使原来的代码逻辑变得原来越复杂。
使用接口开闭原则修改后

/**
 * 抽象缓存
 */

public interface ImageCache {
    Bitmap get(String url);

    void put(String url, Bitmap bmp);
}
/**
 *文件缓存
 */
public class DiskCache implements ImageCache {
    static String cacheDir = "sdcard/cache/";

    //从缓存中获取图片
    public Bitmap get(String url){
        return BitmapFactory.decodeFile(cacheDir+url);
    }

    //将图片缓存到内存中
    public void put(String url,Bitmap bitmap){
        FileOutputStream fileOutputStream = null;
        try{
            fileOutputStream = new FileOutputStream(cacheDir+url);
            bitmap.compress(Bitmap.CompressFormat.PNG,100,fileOutputStream);
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            if(fileOutputStream!=null){
                try{
                    fileOutputStream.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}
/**
 * 内存缓存
 */

public class MemoryCache implements ImageCache {
    //图片缓存
    LruCache<String,Bitmap> mImageCache;

    public MemoryCache(){
        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 bitmap) {
                return bitmap.getRowBytes()*bitmap.getHeight()/1024;
            }
        };
    }


    @Override
    public Bitmap get(String url) {
        return mImageCache.get(url);
    }

    @Override
    public void put(String url, Bitmap bmp) {
        mImageCache.put(url,bmp);
    }
}
/**
 * 图片加载类
 */

public class ImageLoader {
    //默认是内存缓存
    ImageCache mImageCache = new MemoryCache() ;

    //线程池，线程数量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    //是否使用SD卡缓存
    boolean isUsedDisCache  = false;

    public void setImageCache(ImageCache cache){
        mImageCache = cache;
    }


    public void displayImage(final String url, final ImageView imageView){
        //判断是否是SD缓存
        Bitmap bitmap = mImageCache.get(url);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            return;
        }

        //图片没缓存 提交到线程池中现在图片
        submitLoadRequest(url,imageView);

    }

    private void submitLoadRequest(final String imageUrl,final ImageView imageView){
        imageView.setTag(imageUrl);

        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(imageUrl);
                if(bitmap==null){
                    return;
                }
                if(imageView.getTag().equals(imageUrl)){
                    imageView.setImageBitmap(bitmap);
                }

                mImageCache.put(imageUrl,bitmap);

            }
        });
    }

    public Bitmap downloadImage(String imageUrl){
        Bitmap bitmap = null;
        try{
            URL url = new URL(imageUrl);
            final HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(connection.getInputStream());
            connection.disconnect();

        }catch(Exception e){
            e.printStackTrace();
        }
        return  bitmap;
    }


}

概括来说就是用一个抽象的ImageCache对象在setImageCache中赋予具体缓存方式。然后直接用这种缓存

3 里氏替换原则
定义
所有引用基类的地方必须能透明的使用其子类对象

示例

public abstract class View {
    public abstract  void draw();
    public void measure(int width,int height){

    }
}
public class Button extends View{
    @Override
    public void draw() {

    }
}
public class TextView extends View {
    @Override
    public void draw() {

    }
}

所有View的子类都可以调用draw()方法。

public class Window {
    public void show(View child){
        child.draw();
    }
}

优缺点
优点：

  • 代码重用，减少创建类的成本，每个子类都拥有父类的方法和属性
  • 子类和父类基本相似，但又与父类有所区别。
  • 提高代码的可扩展性。

缺点：

  • 继承是侵入性的，只要继承就必须拥有父类的所有属性和方法。
  • 可能造成子类代码冗余，灵活性降低，因为子类必须拥有父类的属性和方法。

4 依赖倒置原则
依赖倒置原则指代了一种特定的解耦形式。使得高层次的模块不依赖于低层次的模块的实现细节的目的。
主要思想：

  • 高层模块不应该依赖于底层模块，两者都应该依赖于抽象。
  • 抽象不应该依赖细节。
  • 细节应该依赖抽象。

模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或者抽象类产生的

概括来说就是面向接口编程
就像开闭原则中用到的修改之前 ImageLoader中的ImageCache 直接用这种方式赋值.

//默认是内存缓存
    ImageCache mImageCache = new MemoryCache() ;
public void setImageCache(ImageCache cache){
        mImageCache = cache;
    }

mImageCache在初始化的时候赋予了默认值。而mImageCache实际被赋值是在setImageCache中完成。可以看出mImageCache是依赖ImageCache这个抽象。而非具体的Memorycache.

5 接口隔离原则
定义
客户端不应该依赖它不需要的接口。
也就是类间的依赖关系应该建立在最小的接口上。

示例
社会上的职业有很多种，比如农民，老师，司机等。

/**
 *工作
 */

public interface Job {
    /**
     * 饲养动物
     */
    void feedAnimal();

    /**
     * 开车
     */
    void driveCar();

    /**
     * 教知识
     */
    void teach();

    /**
     * 保卫国家
     */
    void defendCountry();

}

将庞大，臃肿的接口拆分成更小的和更具体的接口。

/**
 *司机
 */

public interface Drivier {
    void driveCar();
}
/**
 * 老师
 */

public interface Teacher {
    void teach();
}

那么一个常人不可能会做这么多的工作。所以实现了Job接口。大部分的方法都是不能空方法。


/**
 * 普通人
 */

public class NomalPerson implements Job{

    @Override
    public void feedAnimal() {

    }

    @Override
    public void driveCar() {

    }

    @Override
    public void teach() {

    }

    @Override
    public void defendCountry() {

    }
}

只实现这个一个接口更简洁。

/**
 * 普通人
 */

public class NomalPerson implements Teacher{

    @Override
    public void teach() {

    }

}

6 迪米特原则
迪米特原则也称为最少知识原则，通俗的说就是一个对象应该对其他对象有最少的了解。雷与雷之间的关系越密切，耦合度越大，当一个类发生改变时，对另外一个类的影响也就越大。

示例
租房子的时候，会把你需要找的房源类型告知中介，中介把所有的房型给你。然后你把这些房型经过筛选。知道自己满意的房子。

/**
 *房间
 */
public class Room {
    public float area;//面积
    public float price; //价格

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

    @Override
    public String toString() {
        return "Room{" +
                "area=" + area +
                ", price=" + price +
                '}';
    }
}
/**
 *中介
 */

public class Mediator {
    List<Room> rooms = new ArrayList<>();
    public Mediator(){
        for(int i=0;i<5;i++){
            //模拟多套可租的房子
            rooms.add(new Room(i+14,(14+i)*150));
        }
    }

    public List<Room> getAllRooms() {
        return rooms;
    }
};
/**
 *租户
 */

public class Tenant {

    public static final float maxPrice = 2300;
    public static final float minArea = 14;

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

    private boolean isSuitable(Room room) {
        //满意的房子必须要大于最小面积并低于最低价格
        return room.area>minArea&&room.price<maxPrice;
    }
}

关系类图
这里写图片描述

从代码中可以看出，租户不仅依赖中介，还要与Room打交道。这样导致Tenant 和Room的耦合较高。
进行修改后:

/**
 *中介
 */

public class Mediator {
    List<Room> rooms = new ArrayList<>();

    public static final float maxPrice = 2300;
    public static final float minArea = 14;

    public Mediator(){
        for(int i=0;i<5;i++){
            //模拟多套可租的房子
            rooms.add(new Room(i+14,(14+i)*150));
        }
    }

    //把房源进行删选
    public void  filter(){
        for(Room room:rooms){
            if(isSuitable(room)){
               notifyTenant(room);
            }
        }
    }

    //通知租户 
    public void notifyTenant(Room room){
        Tenant tenant = new Tenant();
        tenant.getMessage(room);
    }

    private boolean isSuitable(Room room) {
        //满意的房子必须要大于最小面积并低于最低价格
        return room.area>minArea&&room.price<maxPrice;
    }
};

当中介找到合适的房源中介通知租户。Tenant不在和Room相关联。

/**
 *租户
 */

public class Tenant {

    public void getMessage(Room room){
        System.out.println("找到房间了"+room);
    }

}

修改后的关系图
这里写图片描述

小 黄 鸡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
软件设计原则
一揽芳华
05-17 688
昨天我们单位的答辩过去了，同事们针对各组提问的问题，归根到底，都围绕着设计原则，所以小笨鸟下来就查了，什么是设计原则撒，要怎么运用到我们的实际项目开发中呢？下面是我总结的前辈的经验，结合自己的理解，同样与君共勉~ 一、开闭原则 昨天答辩的时候这个原则是我们小组提出来的，导师给我简单的说了一句：对扩展开放，对修改关闭！小笨鸟觉得不懂啊，后来仔细查查才知道，开闭原则说的也就是：在不修改原（
六个设计原则
江湖怎么没有水的博客
05-29 2430
六个设计原则 一、单一职责原则 ​ （Single Responsibility Principle) There should never be more than one reason for a class to change. ​ 意思说：一个类，应当只有一个引起它变化的原因；即一个类应该只有一个职责。类的职责越少，则对象之间的依赖关系就越少，耦合度...
00设计七大原则
六石
06-06 982
面向对象原则综述 七大原则总脉络图：                             注：1，2，3，4，5显示的重要等级           常用的面向对象设计原则包括7个，这些原则并不是孤立存在的，它们相互依赖，相互补充。            下面就是面向对象七个原则的一一解析 一、          开闭原则 1.          开闭原则
6个设计原则【重要】
jimotudou的博客
04-23 439
转载于 https://blog.csdn.net/geekun/article/details/51325520 摘要： 这6（7）个设计原则非常重要，在我们以后写project的时候注意思考应该用到哪儿些原则，是否违背了原则。设计思想是我们在设计程序的时候应该考虑到的。 单一职责原则 定义 单一职责原则（SRP：Single responsibility principl...
六大设计原则
stepMore的博客
02-22 9773
六大设计原则 1.单一职责原则（Single Responsibility Principle） 定义：应该有且仅有一个原因引起类的变更。 单一职责原则的好处： 类的复杂性降低，实现什么职责都有清晰明确的定义 可读性提高，复杂性降低 可维护性提高，可读性提高 变更引起的风险降低 2.里氏替换原则（Liskov Substitution Principle） 定义： 1）如果对每一个类型为S的对...
6大设计原则
xutatu
05-07 733
单一职责原则 简称: SRP 定义: 应该有且仅有一个原因引起类的变更. 好处: 1. 类的复杂性降低 2. 可读性提高 3. 可维护性提高 4. 变更引起的风险降低 里氏替换原则 简称: LSP 定义: 1. 如果对每一个类型为S的对象o1,都有类型为T的对象o2,使得以T定义的所有程序P在所有 的对象o1都代换成o2时,程序P的行...
Java23种设计模式6大原则总结.doc
11-24
设计模式可以分为三大类：创建型模式、结构型模式、行为型模式。 创建型模式的主要功能是封装创建逻辑，使得客户代码尽量不修改或少修改。常见的创建型模式有单例模式、工厂方法模式、抽象工厂模式、建造者模式、...
24种设计模式介绍与6大设计原则
03-22
在软件工程领域，设计模式是一套被反复...以上就是24种设计模式和6大设计原则的详细知识点梳理。在实际软件开发过程中，合理地应用这些设计模式和遵循设计原则，能够有效地提高代码的可维护性、可扩展性和可复用性。
24种设计模式与6大设计原则
最新发布
04-19
### 设计模式与六大设计原则概述 #### 一、策略模式（Strategy Pattern） **定义**： 策略模式定义了一系列算法，并将每一个算法封装起来，使它们可以互相替换。该模式让算法独立于使用它的客户而变化。 **应用...
00设计原则
weixin_30344995的博客
01-09 118
1、找出应用中可能需要变化之处，把他们独立出来，不要可那些不需要改变的代码混在一起。 2、针对接口编程，而不是针对实现编程。 3、多用组合，少用继承。 4、为了交互对象之间的松耦合设计而努力。 5、开放-关闭原则：类应该对扩展开放，对修改关闭。 6、依赖倒置原则：要依赖抽象，不要依赖具体类。 7、最少知识原则：只和你的密友谈话。交互尽量少。 8、好莱坞原则：别调用我们，我们...
软件架构设计的五大原则简析
liuyong0507的博客
02-03 1242
软件架构设计的六大原则简析 在软件以及系统的设计中，有人简单的认为，我编程很厉害，所以架构设计我没问题，但实际操作的过程中，常常会一团乱麻，而实际的架构设计工作中还是遵循 六大原则，有时候也会有原则会相互冲突。下面简单的说说六大设计原则，以及延升的原则，如果面试问道，先说六大原则，如果还想扩展，那就自己实际开发过程理解。 1. 单一职责原则（Single Responsibility Principle - SRP） 原文：There should never be more than one re
Java设计模式详解：24种模式与6大设计原则
Java设计模式介绍与6大设计原则 Java设计模式是软件开发中的一种解决方案，它提供了一些通用的设计解决方案，以便更好地编写代码、提高代码的可读性、可维护性和可扩展性。下面是对24种设计模式和6大设计原则的总结...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值