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);
}
}
修改后的关系图