一、优化代码第一步——单一职责原则
- 一个类中应该是一组相关性很高的函数、数据的封装
- 合理的划分一个类、一个函数的职责。例如：完全不一样的功能就不能放在同一类中、
- 需要不断审视自己的代码，根据具体业务功能进行拆分
具体案例：
结构清晰，两个类得功能逻辑互相独立不会影响彼此
ImageLoader负责图片加载的逻辑
public class ImageLoader {
//图片缓存
ImageCache mImageCache = new ImageCache();
//线程池，线程数量为CPU的数量
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
Handler mUiHandler = new android.os.Handler(Looper.getMainLooper());
private void updateImageView(final ImageView imageView, final Bitmap bitmap) {
mUiHandler.post(new Runnable() {
@Override
public void run() {
imageView.setImageBitmap(bitmap);
}
});
}
//加载图片
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 bitmapD = downloadImage(url);
if (bitmapD == null) return;
if (imageView.getTag().equals(url)) {
updateImageView(imageView, bitmap);
}
mImageCache.put(url, bitmap);
}
});
}
public Bitmap downloadImage(String imageUrl) {
Bitmap bitmap = null;
try {
URL url = new URL(imageUrl);
final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
bitmap = BitmapFactory.decodeStream(connection.getInputStream());
connection.disconnect();
} catch (Exception e) {
e.printStackTrace();
}
return bitmap;
}
}
ImageCache 负责处理图片缓存的逻辑
public class ImageCache {
//图片LRU缓存
LruCache<String, Bitmap> mImageCache;
public ImageCache() {
}
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);
}
}
二、让程序更稳定、更灵活——开闭原则
开闭原则：Open Close Principle，缩写OCP
**定义：**软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是，对于修改是封闭的。
当软件需要变化时，应该尽量通过扩展的方式来实现变化，而不是通过修改已有的代码来实现
具体案例：
实现ImageCache接口实现不同的缓存类，通过setImageCache方法注入不同的缓存，使ImageLoader更简单、健壮，也使得ImageLoader可扩展性、灵活性更高
ImageLoader
public class ImageLoader {
//图片缓存
ImageCache mImageCache = new MemoryCache();
//线程池，线程数量为CPU的数量
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
Handler mUiHandler = new android.os.Handler(Looper.getMainLooper());
private void updateImageView(final ImageView imageView, final Bitmap bitmap) {
mUiHandler.post(new Runnable() {
@Override
public void run() {
imageView.setImageBitmap(bitmap);
}
});
}
//注入缓存实现
public void setImageCache(ImageCache cache){
mImageCache=cache;
}
//加载图片
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 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)) {
updateImageView(imageView, bitmap);
}
mImageCache.put(imageUrl, bitmap);
}
});
}
public Bitmap downloadImage(String imageUrl) {
Bitmap bitmap = null;
try {
URL url = new URL(imageUrl);
final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
bitmap = BitmapFactory.decodeStream(connection.getInputStream());
connection.disconnect();
} catch (Exception e) {
e.printStackTrace();
}
return bitmap;
}
}
ImageCache接口，用来抽象图片缓存功能
public interface ImageCache {
public Bitmap get(String url);
public void put(String url,Bitmap bitmap);
}
MemoryCache：内存缓存类
public class MemoryCache implements ImageCache{
private LruCache<String, Bitmap> mMemoryCache;
public MemoryCache() {
//初始化LRU缓存
initMemoryCache();
}
private void initMemoryCache() {
//计算可使用的最大内存
final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
//取四分之一的可用内存作为缓存
final int cacheSize = maxMemory / 4;
mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getRowBytes() * value.getHeight() / 1024;
}
};
}
@Override
public Bitmap get(String url) {
return mMemoryCache.get(url);
}
@Override
public void put(String url, Bitmap bitmap) {
mMemoryCache.put(url, bitmap);
}
}
DiskCache：将图片缓存到SD卡
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 bitmap){
FileOutputStream fileOutputStream=null;
try {
fileOutputStream=new FileOutputStream(cacheDir+url);
bitmap.compress(Bitmap.CompressFormat.PNG,100,fileOutputStream);
}catch (FileNotFoundException e){
e.printStackTrace();
}finally{
if(fileOutputStream!=null){
try {
fileOutputStream.close();
}catch (IOException e){
e.printStackTrace();
}
}
}
}
}
DoubleCache：双缓存类
获取图片时先从内存缓存中获取，如果内存中没有缓存该图片，再从SD卡中获取。缓存图片也是在内存和SD卡中都缓存一份
public class DoubleCache implements ImageCache{
ImageCache mMemoryCache=new MemoryCache();
DiskCache mDiskCache=new DiskCache();
//先从内存缓存中获取图片，如果没有，再从SD卡中获取
@Override
public Bitmap get(String url){
Bitmap bitmap=mMemoryCache.get(url);
if(bitmap==null) bitmap=mDiskCache.get(url);
return bitmap;
}
//将图片缓存到内存和SD卡中
@Override
public void put(String url,Bitmap bitmap){
mMemoryCache.put(url,bitmap);
mDiskCache.put(url,bitmap);
}
}
用户通过ImageLoader类中的setImageCache函数设置缓存实现，也就是通常说的依赖注入
ImageLoader imageLoader=new ImageLoader();
//使用内存缓存
imageLoader.setImageCache(new MemoryCache());
//使用SD卡缓存
imageLoader.setImageCache(new DiskCache());
//使用双缓存
imageLoader.setImageCache(new DoubleCache());
//使用自定义的图片缓存
imageLoader.setImageCache(new ImageCache() {
@Override
public Bitmap get(String url) {
return null;//从缓存中获取图片
}
@Override
public void put(String url, Bitmap bitmap) {
//缓存图片
}
});
三、构建扩展性更好的系统——里氏替换原则
里氏替换原则：Liskov Substitution Principle，缩写LSP
第一种定义：如果对每一个类型为S的对象O1，都有类型为T的对象O2，使得以T定义的所有程序P在所有的对象O1都替换成O2时，程序P的行为没有发生变化，那么类型S时类型T的子类型。
第二种定义：所有引用基类的地方必须能透明地使用其子类的对象
核心原则：抽象，抽象又依赖于继承这个特性
-
在OOP中，继承的优缺点
优点
- 代码重写，减少创建类的成本，每个子类都拥有父类中的方法和属性
- 子类与父类基本相似，但又与父类有所区别
- 提高代码的可扩展性
缺点
- 继承是侵入性的，只要继承就必须拥有父类的所有属性和方法
- 可能造成子类代码冗余、灵活性降低
具体案例：
- Window依赖于View
- View定义一个视图抽象，measure是各个子类共享的方法
- 子类通过覆写View的draw方法实现具有各自特色的功能
- 任何继承自View的子类都可以传递给show函数，这就是里氏替换
- Window负责组织View，并且将View显示到屏幕上
//窗口类
public class Window{
public void show(View child){
child.draw();
}
}
//建立视图抽象，测量视图的宽高为公共代码，绘制时先交给具体的子类
public abstract class View{
public abstract void draw();
public void measure(int width,int height){
//测量视图大小
}
}
//文本控制类的具体实现
public class TextView extends View{
@Override
public void draw() {
//绘制本文
}
}
//ImageView的具体实现
public class ImageView extends View{
@Override
public void draw() {
//绘制图片
}
}
四、让项目拥有变化的能力——依赖倒置原则
依赖倒置原则：Dependence Inversion Principle，缩写是DIP
指一种特定的解耦形式，使得高层次的模块不依赖于低层次模块的实现细节的目的
关键：
- 高层模块不应该依赖低层模块，两者都应该依赖其抽象
- 抽象不应该依赖细节
- 细节应该依赖抽象
**面向抽象编程：**抽象指的是接口或者抽象类
**在Java语言中的表现：**模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的。
具体案例：
建立ImageCache抽象，让ImageLoader依赖于抽象而不是具体细节。当需求发生变化时，只需要实现ImageCache类或者继承其他已有的ImageCache子类完成相应的缓存功能，然后将具体的实现注入到ImageLoader即可实现缓存功能的替换
public interface ImageCache {
public Bitmap get(String url);
public void put(String url,Bitmap bitmap);
}
public class ImageLoader {
//图片缓存类，依赖于抽象，并且有一个默认的实现
ImageCache mImageCache = new MemoryCache();
//加载图片
public void displayImage(final String url, final ImageView imageView) {
Bitmap bitmap = mImageCache.get(url);
if (bitmap == null) {
//异步加载图片
downloadImageAsync(url,imageViewl);
}else{
imageView.setImageBitmap(bitmap);
}
}
//设置缓存策略，依赖于抽象
public void setImageCache(ImageCache cache){
mImageCache=cache;
}
/.../
}
五、系统有更高的灵活性——接口隔离原则
接口隔离原则：Interface Segregation Principles，缩写是ISP
定义：
- 客户端不应该依赖他不需要的接口
- 类间的依赖关系应该建立在最小的接口上
将非常庞大臃肿的接口拆分成更小的和更具体的接口
**目的：**系统揭开耦合，从而容易重构、更改和重新部署
具体案例：
closeQuietLly方法的基本原理是依赖于Closeable抽象而不是具体实现，并且建立在最小化依赖原则的基础上，它只需要知道这个对象时可关闭的，不用去关心别的，即接口隔离原则。
public class CloseUtils {
private CloseUtils() {}
/**
* 关闭Closeable对象
* @param closeable
*/
public static void closeQuietly(Closeable closeable){
if(null!=closeable){
try{
closeable.close();
}catch (IOException e){
e.printStackTrace();
}
}
}
}
public void put(String url, Bitmap bitmap){
FileOutputStream fileOutputStream=null;
try {
fileOutputStream=new FileOutputStream(cacheDir+url);
bitmap.compress(Bitmap.CompressFormat.PNG,100,fileOutputStream);
}catch (FileNotFoundException e){
e.printStackTrace();
}finally {
CloseUtils.closeQuietly(fileOutputStream);
}
}
六、更好的可拓展性——迪米特原则
迪米特原则：Law of Demeter，缩写是LOD，也称为最少知识原则（Least Knowledge Principle）
一个类有个对自己需要耦合或调用的类知道得最少，类的内部如何实现与调用者或者依赖者没关系，调用者或者依赖者只需要知道它需要的方法即可
Only talk to your immediate friend “只与直接的朋友通信”
wg：类与类之间的关联尽可能分开，避免多个类耦合在一起，每个类的职责要明确
举例：
租户提供所需的房间面积和价格给中介，中介将符合要求的房子提供给租户
错误示范：
Tenant不仅依赖了Mediator类，还需要借助Room类，这样使得中介类的功能弱化不够明确，也使得Tenant与Room的耦合较高。
/**
* 房间
*/
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<>();
public Mediator() {
for(int i=0;i<5;i++){
mRooms.add(new Room(14+i,(14+i)*150));
}
}
public List<Room> getAllRooms() {
return mRooms;
}
}
/**
* 租客
*/
public class Tenant{
public void rentRoom(float roomArea,float roomPrice,Mediator mediator){
List<Room> rooms=mediator.getAllRooms();
for(Room room:rooms){
if(isSuitable(roomArea,roomPrice,room)){
System.out.println("租到房子了！"+room);
break;
}
}
}
//租金要小于等于指定的值，面积要大于等于指定的值
private boolean isSuitable(float roomArea,float roomPrice,Room room){
return room.price<=roomPrice&&room.area>=roomArea;
}
}
正确示范：
将Room相关的操作从Tenant移入Mediator类
/**
* 中介
*/
public class Mediator{
List<Room> mRooms=new ArrayList<>();
public Mediator() {
for(int i=0;i<5;i++){
mRooms.add(new Room(14+i,(14+i)*150));
}
}
public Room rentOut(float area,float price){
for(Room room:mRooms){
if(isSuitable(area,price,room)){
return room;
}
}
return null;
}
private boolean isSuitable(float roomArea,float roomPrice,Room room){
return room.price<=roomPrice&&room.area>=roomArea;
}
}
/**
* 租客
*/
public class Tenant{
public void rentRoom(float roomArea,float roomPrice,Mediator mediator){
System.out.println("租到房子了！"+mediator.rentOut(roomArea,roomPrice));
}
}
