AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

针对Android中类的重载方法很多时的几种优化解决方案

2018-03-20 962
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 在平时Android开发中，可能会出现某个类有很多个重载方法。这个问题很多人在维护项目的时候可能会经常遇到，比如需求变更，刚开始只有一个构造方法，传入一个参数的。

在平时Android开发中，可能会出现某个类有很多个重载方法。

这个问题很多人在维护项目的时候可能会经常遇到，比如需求变更，刚开始只有一个构造方法，传入一个参数的。如下所示：

public class Demo{

    private int a;

    public Demo(int a){
        this.a=a; 
        //do something...
    }
}

后来需求变更，传入两个参数比较符合业务逻辑，如下图所示：

public class Demo{
    
    private int a;
    private int b;

    public Demo(int a){
        //do something...
        this(a,0); 
    }

    public Demo(int a,int b){
        this.a=a; 
        this.b=b; 
        //do something...
    }
}

再到后来随着业务逻辑的扩展，可能会有3个构造方法。可能每个构造方法里面的逻辑也有所不一样。如下所示：

public class Demo{
    
    private int a;
    private int b;
    private int c;

    public Demo(int a){
        //do something...
        this(a,0); 
    }

    public Demo(int a,int b){
        //do something...
        this(a,b,0); 
    }

    public Demo(int a,int b,int c){
        this.a=a; 
        this.b=b; 
        this.c=c;   
           //do something...
    }

}

甚至有4个构造方法的：

public class Demo{
    
    private int a;
    private int b;
    private int c;
    private int d;

    public Demo(int a){
        //do something...
        this(a,0); 
    }

    public Demo(int a,int b){
        //do something...
        this(a,b,0); 
    }

    public Demo(int a,int b,int c){
        //do something...
        this(a,b,c,0);  
    }

    public Demo(int a,int b,int c,int d){ 
        this.a=a; 
        this.b=b; 
        this.c=c;  
        this.d=d; 
                   //do something...
    }

}

随着业务的发展，方法越来越多，越来越不好维护，重载方法之间的逻辑也不大相同。那么遇到这种问题应该怎么最好的优化呢？我这里给出了 以下几种方案 供大家选择：

一、可以模仿Android源码，使用 @Deprecated 注解标记一下方法过时，建议在哪个版本中使用哪个方法，这样也起一个标记的作用。

【优点】暂时解决了方法维护的问题，开发人员不再为过时方法维护了，而且旧版本也可以使用相应方法，对老版本兼容性比较好。
【缺点】所有的方法都在，还是有那么多冗余代码，还是没从根源上解决问题。

示例如下：

public class Demo{
    
    private int a;
    private int b;
    private int c;
    private int d;

    public Demo(int a){
        //do something...
        this(a,0); 
    }

    //比如在app的v1.0.0版本中在这个构造方法中标记为过时，后续版本中不使用该方法
    @Deprecated
    {@link Demo(int, int, int)}
    public Demo(int a,int b){
        //do something...
        this(a,b,0); 
    }

    public Demo(int a,int b,int c){
        //do something...
        this(a,b,c,0);  
   }

    public Demo(int a,int b,int c,int d){ 
        this.a=a; 
        this.b=b; 
        this.c=c;  
        this.d=d; 
        //do something...
    }

}
二、根据面向对象的思想，把参数实例化成一个实体类，然后构造里面引入这个实体类，想要哪些属性，通过getter和setter来访问成员变量。

【优点】解决了代码冗余问题。
【缺点】针对不同版本设置的代码不一样，代码量还是很大的。

示例代码如下：

//封装一个实体类
public class DataBean{

    private int dataA;
    private int dataB;
    private int dataC;
    private int dataD;

    public int getDataA() {
        return dataA;
    }

    public void setDataA(int dataA) {
        this.dataA = dataA;
    }

    public int getDataB() {
        return dataB;
    }

    public void setDataB(int dataB) {
        this.dataB = dataB;
    }

    public int getDataC() {
        return dataC;
    }

    public void setDataC(int dataC) {
        this.dataC = dataC;
    }

    public int getDataD() {
        return dataD;
    }

    public void setDataD(int dataD) {
        this.dataD = dataD;
    }

    //篇幅有限，toString，equals和hasCode方法省去不写了
}

然后我加了一个接口，处理版本号码的问题，所有的版本号码都可以写在这个接口里面，都是int类型的，实质相当于枚举，因为枚举比较耗性能，所以就用接口替代了。（为什么写接口，写接口方便扩展，性能好。）

/**
 * 处理版本号的接口
 */
public interface IVersionCode {
    public int VERSION_ONE = 1;
    public int VERSION_TWO = 2;
    public int VERSION_THREE = 3;
    public int VERSION_FOUR = 4;
}

然后原代码里面只需要传入这个DataBean实体类就可以了，同时实现了IVersionCode接口，可以直接使用里面的常量。

再看看原来那个类的变化：

public class Demo implements IVersionCode{

    private DataBean dataBean;
    //通过一个LinkedList有序列表去保存版本号
    private List<Integer> mLinkedList = new LinkedList<>();

    public Demo(DataBean bean){
        this.dataBean = bean;
    }

    /**
     * 设置版本信息
     * 传入一个版本号，根据对应的版本号设置对应的方法
     *
     */
    public void setVersion(int versionName){
        switch(versionName){
            //假如是版本VERSION_ONE,调用的是一个参数
            case VERSION_ONE:
                //避免重复添加
                if(!mLinkedList.contains(VERSION_ONE)){
                    mLinkedList.add(VERSION_ONE);
                }
                dataBean.setDataA(1);
                //do something...
                break;
            case VERSION_TWO:
                if(!mLinkedList.contains(VERSION_TWO)){
                    mLinkedList.add(VERSION_TWO);
                }
                dataBean.setDataA(1);
                dataBean.setDataB(2);
                //do something...
                break;
            case VERSION_THREE:
                if(!mLinkedList.contains(VERSION_THREE)){
                    mLinkedList.add(VERSION_THREE);
                }
                dataBean.setDataA(1);
                dataBean.setDataB(2);
                dataBean.setDataC(3);
                //do something...
                break;
            case VERSION_FOUR:
                if(!mLinkedList.contains(VERSION_FOUR)){
                    mLinkedList.add(VERSION_FOUR);
                }
                dataBean.setDataA(1);
                dataBean.setDataB(2);
                dataBean.setDataC(3);
                dataBean.setDataD(4);
                //do something...
                break;
            default:
                break;
        }
    }

    /**
     * 根据获取的版本信息得到实体类对象
     * 调用get方法就可以拿到实体类里面的具体方法
     * @return
     */
    public DataBean getVersion(int versionName){
        for(int i =0; i<mLinkedList.size(); i++){
            if(mLinkedList.get(i) == VERSION_ONE){
                dataBean.getDataA();
            }else if(mLinkedList.get(i) == VERSION_TWO){
                dataBean.getDataA();
                dataBean.getDataB();
            }else if(mLinkedList.get(i) == VERSION_THREE){
                dataBean.getDataA();
                dataBean.getDataB();
                dataBean.getDataC();
            }else if(mLinkedList.get(i) == VERSION_FOUR){
                dataBean.getDataA();
                dataBean.getDataB();
                dataBean.getDataC();
                dataBean.getDataD();
            }
        }
       return dataBean;
    }
}

那么有没有一种更好的解决方案呢？我觉得目前能够想出来的解决方案就是下面这种了：

三、使用建筑者模式，把Demo这个类的构建对象的操作转移到内部类里面去执行，对外隐藏对象创建的细节。

【优点】这种对象的构建方式不但解决了代码可读性的问题，并大幅减少了构造参数，构建过程保证了一定的一致性。
【缺点】建造者模式的产品的组件基本相同，如果产品的差异性较大，建造者模式就不适用了。

示例代码如下：

public class Demo{
    
    private int dataA;
    private int dataB;
    private int dataC;
    private int dataD;

    private Demo(Builder builder) {
        this.dataA = builder.dataA; 
        this.dataB = builder.dataB; 
        this.dataC = builder.dataC;  
        this.dataD = builder.dataD; 
    }

    public void setA(int a){
        this.dataA = a;
    }

    public void setB(int b){
        this.dataB = b;
    }

    public void setC(int c){
        this.dataC = c;
    }

    public void setD(int d){
        this.dataD = d;
    }

    public void getA(int a){
        return dataA;
    }

    public void getB(int b){
        return dataB;
    }

    public void getC(int c){
        return dataC;
    }

    public void getD(int d){
        return dataD;
    }


    public static class Builder {  

        private int dataA;
        private int dataB;
        private int dataC;
        private int dataD;

        public Demo build() {  
            return new Demo(this);  
        } 

        public Builder getDataA(int a) {  
            this.dataA = a;  
            return this;  
        } 

        public Builder getDataB(int b) {  
            this.dataB = b;  
            return this;  
        } 

        public Builder getDataC(int c) {  
            this.dataC = c;  
            return this;  
        } 

        public Builder getDataD(int d) {  
            this.dataD = d;  
            return this;  
        } 

    }

}
四、使用接口回调来处理

实体类稍微改了一下：

public class DataBean{

    public static final String TAG = DataBean.class.getSimpleName();

    private int dataA;
    private int dataB;
    private int dataC;
    private int dataD;

    /**
     *  是否已经设置了A属性，解决不同版本何止不同的参数问题
     */
    private boolean isDataASetted;
    /**
     *  是否已经设置了B属性，解决不同版本何止不同的参数问题
     */
    private boolean isDataBSetted;
    /**
     *  是否已经设置了C属性，解决不同版本何止不同的参数问题
     */
    private boolean isDataCSetted;
    /**
     *  是否已经设置了D属性，解决不同版本何止不同的参数问题
     */
    private boolean isDataDSetted;


    public int getDataA() {
        Log.d(TAG, "getDataA: " + dataA);
        return dataA;
    }

    public void setDataA(int dataA) {
        this.dataA = dataA;
    }

    public int getDataB() {
        Log.d(TAG, "getDataB: " + dataB);
        return dataB;
    }

    public void setDataB(int dataB) {
        this.dataB = dataB;
    }

    public int getDataC() {
        Log.d(TAG, "getDataC: " + dataC);
        return dataC;
    }

    public void setDataC(int dataC) {
        this.dataC = dataC;
    }

    public int getDataD() {
        Log.d(TAG, "getDataD: " + dataD);
        return dataD;
    }

    public void setDataD(int dataD) {
        this.dataD = dataD;
    }

    public boolean isDataASetted() {
        return isDataASetted;
    }

    public void setDataASetted(boolean dataASetted) {
        isDataASetted = dataASetted;
    }

    public boolean isDataBSetted() {
        return isDataBSetted;
    }

    public void setDataBSetted(boolean dataBSetted) {
        isDataBSetted = dataBSetted;
    }

    public boolean isDataCSetted() {
        return isDataCSetted;
    }

    public void setDataCSetted(boolean dataCSetted) {
        isDataCSetted = dataCSetted;
    }

    public boolean isDataDSetted() {
        return isDataDSetted;
    }

    public void setDataDSetted(boolean dataDSetted) {
        isDataDSetted = dataDSetted;
    }

    @Override
    public String toString() {
        return "DataBean{" +
                "dataA=" + dataA +
                ", dataB=" + dataB +
                ", dataC=" + dataC +
                ", dataD=" + dataD +
                ", isDataASetted=" + isDataASetted +
                ", isDataBSetted=" + isDataBSetted +
                ", isDataCSetted=" + isDataCSetted +
                ", isDataDSetted=" + isDataDSetted +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;

        DataBean dataBean = (DataBean) o;

        if (dataA != dataBean.dataA)
            return false;
        if (dataB != dataBean.dataB)
            return false;
        if (dataC != dataBean.dataC)
            return false;
        if (dataD != dataBean.dataD)
            return false;
        if (isDataASetted != dataBean.isDataASetted)
            return false;
        if (isDataBSetted != dataBean.isDataBSetted)
            return false;
        if (isDataCSetted != dataBean.isDataCSetted)
            return false;
        return isDataDSetted == dataBean.isDataDSetted;
    }

    @Override
    public int hashCode() {
        int result = dataA;
        result = 31 * result + dataB;
        result = 31 * result + dataC;
        result = 31 * result + dataD;
        result = 31 * result + (isDataASetted ? 1 : 0);
        result = 31 * result + (isDataBSetted ? 1 : 0);
        result = 31 * result + (isDataCSetted ? 1 : 0);
        result = 31 * result + (isDataDSetted ? 1 : 0);
        return result;
    }

}

原来的那个类改造如下：

public class Demo implements IVersionCode{

    private DataBean dataBean;
    private OnVersionChoosedListener mOnVersionChoosedListener;

    public Demo(DataBean bean){
        this.dataBean = bean;
    }


    /**
     * 设置版本名
     */
    public void setVersion(int versionName){
        switch(versionName){
            case VERSION_ONE:
                dataBean.setDataA(1);
                dataBean.setDataASetted(true);
                dataBean.setDataBSetted(false);
                dataBean.setDataCSetted(false);
                dataBean.setDataDSetted(false);
                mOnVersionChoosedListener.setVersion(versionName,dataBean);
                //do something...
                break;
            case VERSION_TWO:
                dataBean.setDataA(1);
                dataBean.setDataB(2);
                //表示在这个版本只有A B这两个方法是有效的
                dataBean.setDataASetted(true);
                dataBean.setDataBSetted(true);
                dataBean.setDataCSetted(false);
                dataBean.setDataDSetted(false);
                mOnVersionChoosedListener.setVersion(versionName,dataBean);
                //do something...
                break;
            case VERSION_THREE:
                dataBean.setDataA(1);
                dataBean.setDataB(2);
                dataBean.setDataC(3);
                dataBean.setDataASetted(true);
                dataBean.setDataBSetted(true);
                dataBean.setDataCSetted(true);
                dataBean.setDataDSetted(false);
                mOnVersionChoosedListener.setVersion(versionName,dataBean);
                //do something...
                break;
            case VERSION_FOUR:
                dataBean.setDataA(1);
                dataBean.setDataB(2);
                dataBean.setDataC(3);
                dataBean.setDataD(4);
                dataBean.setDataASetted(true);
                dataBean.setDataBSetted(true);
                dataBean.setDataCSetted(true);
                dataBean.setDataDSetted(true);
                mOnVersionChoosedListener.setVersion(versionName,dataBean);
                //do something...
                break;
            default:
                break;
        }

    }

    public DataBean getVersion(){
        if(dataBean.isDataASetted()){
            dataBean.getDataA();
        }
        if(dataBean.isDataBSetted()){
            dataBean.getDataB();
        }
        if(dataBean.isDataCSetted()){
            dataBean.getDataC();
        }
        if(dataBean.isDataDSetted()){
            dataBean.getDataD();
        }
        return dataBean;
    }

    public int getVersionName(){
        return mOnVersionChoosedListener.getVersionName();
    }




    interface OnVersionChoosedListener{
        /**
         * 设置版本
         * @param version
         * @param dataBean
         */
        void setVersion(int version, DataBean dataBean);

        /**
         * 获取版本号
         * @return
         */
        int getVersionName();

        /**
         * 获取对应的实体类对象 方便下一步的操作
         * @return
         */
        DataBean getVersion();

    }

    public void setOnVersionChoosedListener(@NonNull OnVersionChoosedListener onVersionChoosedListener) {
        mOnVersionChoosedListener = onVersionChoosedListener;
    }
}
五、使用观察者模式处理

。。。待完善。。。

基本就这些了，如果你还有更好的解决方式，欢迎提出疑问，留言或者私信我都可以。

喜欢的话就打赏，点个赞 吧！

文章标签：
Android开发
关键词：
Android解决方案
Android优化
Android类
Android方法
Android优化解决方案
aweiloveandroid
目录
相关文章
mzlogin
|
21天前
|
缓存 Java Shell
Android 系统缓存扫描与清理方法分析
Android 系统缓存从原理探索到实现。
mzlogin
45 15
Android 系统缓存扫描与清理方法分析
Ant.Dream
|
2月前
|
存储 缓存 编解码
Android经典面试题之图片Bitmap怎么做优化
本文介绍了图片相关的内存优化方法，包括分辨率适配、图片压缩与缓存。文中详细讲解了如何根据不同分辨率放置图片资源，避免图片拉伸变形；并通过示例代码展示了使用`BitmapFactory.Options`进行图片压缩的具体步骤。此外，还介绍了Glide等第三方库如何利用LRU算法实现高效图片缓存。
Ant.Dream
64 20
Android经典面试题之图片Bitmap怎么做优化
东方睿赢
|
1月前
|
调度 Android开发 开发者
构建高效Android应用：探究Kotlin多线程优化策略
【10月更文挑战第11天】本文探讨了如何在Kotlin中实现高效的多线程方案，特别是在Android应用开发中。通过介绍Kotlin协程的基础知识、异步数据加载的实际案例，以及合理使用不同调度器的方法，帮助开发者提升应用性能和用户体验。
东方睿赢
46 4
Ant.Dream
|
1月前
|
JSON 调度 数据库
Android面试之5个Kotlin深度面试题：协程、密封类和高阶函数
本文首发于公众号“AntDream”，欢迎微信搜索“AntDream”或扫描文章底部二维码关注，和我一起每天进步一点点。文章详细解析了Kotlin中的协程、扩展函数、高阶函数、密封类及`inline`和`reified`关键字在Android开发中的应用，帮助读者更好地理解和使用这些特性。
Ant.Dream
20 1
游客sjjs6jgz4gp7m1
|
13天前
|
安全 搜索推荐 程序员
深入探索Android系统的碎片化问题及其解决方案
在移动操作系统的世界中，Android以其开放性和灵活性赢得了广泛的市场份额。然而，这种开放性也带来了一个众所周知的问题——系统碎片化。本文旨在探讨Android系统碎片化的现状、成因以及可能的解决方案，为开发者和用户提供一种全新的视角来理解这一现象。通过分析不同版本的Android系统分布、硬件多样性以及更新机制的影响，我们提出了一系列针对性的策略，旨在减少碎片化带来的影响，提升用户体验。
游客sjjs6jgz4gp7m1
35 0
游客762btuqu5wybw666
|
13天前
|
安全 Android开发 iOS开发
深入探索iOS与Android系统的差异性及优化策略
在当今数字化时代，移动操作系统的竞争尤为激烈，其中iOS和Android作为市场上的两大巨头，各自拥有庞大的用户基础和独特的技术特点。本文旨在通过对比分析iOS与Android的核心差异，探讨各自的优势与局限，并提出针对性的优化策略，以期为用户提供更优质的使用体验和为开发者提供有价值的参考。
游客762btuqu5wybw666
32 0
悟道了凡
|
14天前
|
前端开发 Java 测试技术
android MVP契约类架构模式与MVVM架构模式，哪种架构模式更好？
android MVP契约类架构模式与MVVM架构模式，哪种架构模式更好？
悟道了凡
22 0
聚优云惠
|
1月前
|
前端开发 Java 测试技术
android MVP契约类架构模式与MVVM架构模式，哪种架构模式更好？
android MVP契约类架构模式与MVVM架构模式，哪种架构模式更好？
聚优云惠
20 2
shuj
|
1月前
|
开发框架 移动开发 Android开发
安卓与iOS开发中的跨平台解决方案：Flutter入门
【9月更文挑战第30天】在移动应用开发的广阔舞台上，安卓和iOS两大操作系统各自占据半壁江山。开发者们常常面临着选择：是专注于单一平台深耕细作，还是寻找一种能够横跨两大系统的开发方案？Flutter，作为一种新兴的跨平台UI工具包，正以其现代、响应式的特点赢得开发者的青睐。本文将带你一探究竟，从Flutter的基础概念到实战应用，深入浅出地介绍这一技术的魅力所在。
shuj
76 7
天下无贼001
|
2月前
|
开发框架 前端开发 Android开发
安卓与iOS开发中的跨平台解决方案
【9月更文挑战第27天】在移动应用开发的广阔天地中，安卓和iOS两大操作系统如同双子星座般耀眼。开发者们在这两大平台上追逐着创新的梦想，却也面临着选择的难题。如何在保持高效的同时，实现跨平台的开发？本文将带你探索跨平台开发的魅力所在，揭示其背后的技术原理，并通过实际案例展示其应用场景。无论你是安卓的忠实拥趸，还是iOS的狂热粉丝，这篇文章都将为你打开一扇通往跨平台开发新世界的大门。
天下无贼001
60 8

热门文章

最新文章

  • 1
    Android 11 中的存储机制更新
  • 2
    《Android游戏开发详解》——第1章，第1.1节什么是编程
  • 3
    android处理拍照旋转问题及带来的对内存占用
  • 4
    Android 中ViewPager嵌套RecyclerView出现滑动冲突的解决方案
  • 5
    Android——Fragment介绍
  • 6
    Android Ap 开发 设计模式第五篇：单件模式
  • 7
    android使用Activity
  • 8
    Android Sqlite数据库版本升级管理初探
  • 9
    Android开发1——查找所需要出示权限的内容
  • 10
    实现一个用于显示当前时间的Google Android 窗口小部件（AppWidget）
  • 1
    kotlin开发安卓app，如何让布局自适应系统传统导航和全面屏导航
    127
  • 2
    kotlin开发安卓app，使用webivew 触发 onShowFileChooser， 但只能触发一次，第二次无法触发，是怎么回事。 如何解决
    349
  • 3
    Android面试题之View的invalidate方法和postInvalidate方法有什么区别
    57
  • 4
    Android深入Binder拦截问题分析
    59
  • 5
    安卓与iOS开发环境对比：选择适合你的平台
    45
  • 6
    安卓与iOS开发环境对比：选择合适的平台
    45
  • 7
    使用kotlin Jetpack Compose框架开发安卓app， webview中h5如何访问手机存储上传文件
    157
  • 8
    探索安卓应用开发的未来趋势
    45
  • 9
    安卓与iOS开发环境对比分析
    50
  • 10
    Android studio 安装以及第一个程序
    126

    • 相关课程

    更多
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • 58同城Android客户端Walle框架演进与实践之路
  • Android组件化实现
  • 蚂蚁聚宝Android秒级编译——Freeline
    • 下一篇
    阿里云OSS设置跨域访问