使用Android Studio对代码进行重构

最新推荐文章于 2023-02-08 13:57:35 发布
最新推荐文章于 2023-02-08 13:57:35 发布
阅读量179 收藏
点赞数
原文链接：https://my.oschina.net/u/1780920/blog/657802
版权

简介

2013年Google I/O大会上，谷歌推出新的Android开发环境——Android Studio，从此Android程序员有了新的选择，使用Android Studio进行App开发。AndroidStudio是一项全新的基于IntelliJ IDEA的Android开发环境。类似于Eclipse ADT插件，现在已经成为了官方推荐的ide，同时Eclipse不再进行更新。

软件开发中，经过几个版本迭代，不少程序员会觉的以前的代码架构可能不满足日益增长的需求，这时候都会想到了重构，关于重构网上也有不少用于的资料。

重构资料

资料里面列举了如下几种方法，对代码进行重构。 

31天重构学习笔记01. 封装集合
31天重构学习笔记02. 移动方法
31天重构学习笔记03. 提升方法
31天重构学习笔记04. 降低方法
31天重构学习笔记05. 提升字段
31天重构学习笔记06. 降低字段
31天重构学习笔记07. 重命名（方法，类，参数）
31天重构学习笔记08. 使用委派代替继承
31天重构学习笔记09. 提取接口
31天重构学习笔记10. 提取方法
31天重构学习笔记11. 使用策略类
31天重构学习笔记12. 分解依赖
31天重构学习笔记13. 提取方法对象
31天重构学习笔记14. 分离职责
31天重构学习笔记15. 移除重复内容
31天重构学习笔记16. 封装条件
31天重构学习笔记17. 提取父类
31天重构学习笔记18. 使用条件判断代替异常
31天重构学习笔记19. 提取工厂类
31天重构学习笔记20. 提取子类
31天重构学习笔记21. 合并继承
31天重构学习笔记22. 分解方法
31天重构学习笔记23. 引入参数对象
31天重构学习笔记24. 分解复杂判断
31天重构学习笔记25. 引入契约式设计
31天重构学习笔记26. 避免双重否定
31天重构学习笔记27. 去除上帝类
31天重构学习笔记28. 为布尔方法命名
31天重构学习笔记29. 去除中间人对象
31天重构学习笔记30. 尽快返回
31天重构学习笔记31. 使用多态代替条件判断

Android Studio是基于优秀的ide的，ide提供了丰富的功能，很方便的对代码进行重构，下图是我的Android Studio Refactor菜单，部分快捷键与默认快捷键不同是因为方便而修改的。

Android Studio Refactor

古人云『工欲善其事必先利其器』，所以在对代码进行重构前，需要详细了解Android Studio提供的功能，下面对AS(Android Studio，后面简称AS)菜单进行简单示例。

如何使用

鼠标光标选中或者放在代码上，按下快捷键就可以弹出当前代码可以使用的功能。 
如下所示：

如何使用

代码与操作示例

  • ChangeSignature，改变函数签名，可以修改函数的名字，参数的顺序，参数的名字。

Before: 

// 改变签名
    void testChangeSignature(int second, int first) {
        System.out.println(first + "->" + second);
    }

Gif:

改变签名

After: 

// 改变签名
    void testChangeSignature(int one, int two) {
        System.out.println(one + "->" + two);
    }

修改前参数依次是second、first，修改是one、two。

  • ChangeClassSignatuere，改变类的签名，可以修改类的泛型签名

Before： 

// 改变类的签名
    void testChangeClassSignatuere() {
        String second = "second";
        int first = 100;
        new ChangeClassSignatuere(second, first);
    }

// **********************分割线******************************* 

public class ChangeClassSignatuere {

    private int first;
    private String second;

    public ChangeClassSignatuere(String second, int first) {
        this.first = first;
        this.second = second;
    }

    @Override
    public String toString() {
        return "ChangeClassSignatuere{" +
                "second='" + second + '\'' +
                ",first=" + first +
                '}';
    }
}

Gif:

改变类签名

After： 

// 改变类的签名
    void testChangeClassSignatuere() {
        String second = "second";
        int first = 100;
        new ChangeClassSignatuere<Activity>(second, first);
    }
// **********************分割线******************************* 

public class ChangeClassSignatuere<A> {

    private int first;
    private String second;

    public ChangeClassSignatuere(String second, int first) {
        this.first = first;
        this.second = second;
    }

    @Override
    public String toString() {
        return "ChangeClassSignatuere{" +
                "second='" + second + '\'' +
                ",first=" + first +
                '}';
    }
}
  • 修改匿名类为内部类

Before： 

// 匿名类改成内部类
    void testConvertAnonymousToInner() {
        View.OnClickListener clickListener = new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                System.out.println("onClick");
            }
        };
    }

Gif:

改变类签名

After: 

// 匿名类改成内部类
    void testConvertAnonymousToInner() {

        View.OnClickListener clickListener = new Abc123();
    }

    private static class Abc123 implements View.OnClickListener {

        @Override
        public void onClick(View v) {
            System.out.println("onClick");
        }
    }

这个是我最喜欢的一个功能，有时候匿名类刚刚开始逻辑很简单，过不了多久逻辑太多，就可以使用快捷键变成一个内部类。

  • ConvertToInstanceMethod，修改一个方法变成成员方法

Befor: 

// 变成成员方法
    void testConvertToInstanceMethod() {
        TestClass.convertToInstanceMethod(this, "test");
    }

public class TestClass {

    static void convertToInstanceMethod(RefactorDemo demo, String string) {
        System.out.println("convertToInstanceMethod = " + demo);
        System.out.println("convertToInstanceMethod = " + string);
    }
}

After: 

// 变成成员方法
    void testConvertToInstanceMethod() {
        this.convertToInstanceMethod("test");
    }

    void convertToInstanceMethod(String string) {
        System.out.println("convertToInstanceMethod = " + this);
        System.out.println("convertToInstanceMethod = " + string);
    }

在修改前，调用convertToInstanceMethod方法，第一个参数相是RefactorDemo，传递是this， 修改后就那个方法直接移动到本类中。

  • Copy，复制一个类

Before: 

// 复制一个类
    void testCopy() {
        new FirstClass();
    }

public class FirstClass implements Serializable {

    public String first;

    @Override
    public String toString() {
        return "FirstClass{" +
                "first='" + first + '\'' +
                '}';
    }
}

Gif:

复制一个类

After: 

public class SecondClass implements Serializable {

    public String first;

    @Override
    public String toString() {
        return "SecondClass{" +
                "first='" + first + '\'' +
                '}';
    }
}
  • EncapsulateFields，压缩一个字段，间接访问

Before: 

String filed = "filed";

    // 压缩一个字段，间接访问
    void testEncapsulateFields() {
        System.out.println(filed);
    }

After: 

private String filed = "filed";

    // 压缩一个字段，间接访问
    void testEncapsulateFields() {
        System.out.println(getFiled());
    }

    public String getFiled() {
        return filed;
    }

    public void setFiled(String filed) {
        this.filed = filed;
    }

相当于简介访问一个field，自动生成setter和getter。

  • GenerifyRefactoring，泛型重构

Before: 

// 泛型重构
    void testGenerifyRefactoring() {
        List list = new ArrayList();
        list.add("one");
        list.add("two");
        list.add("three");
    }

After: 

// 泛型重构
    void testGenerifyRefactoring() {
        List<String> list = new ArrayList<String>();
        list.add("one");
        list.add("two");
        list.add("three");
    }

自动添加泛型的参数。

  • Inline，内联函数

Before: 

// 内联
    void testInline() {
        int a = 100;
        int b = 200;
        System.out.println(add(a, b));
    }

    int add(int a, int b) {
        return a + b;
    }

Gif:

After: 

// 内联
    void testInline() {
        int a = 100;
        int b = 200;
        System.out.println(a + b);
    }

原先需要调用一个函数的地方，直接把那个函数里面的代码复制过来。

  • InvertBoolean，重构Boolean

Before: 

// 重构Boolean
    void testInvertBoolean() {
        System.out.println(checkPaswd(null));
        System.out.println(checkPaswd(""));
        System.out.println(checkPaswd("admin"));
    }

    boolean checkPaswd(String passwd) {
        if (passwd != null && passwd.length() != 0) {
            return true;
        }
        return false;
    }

Gif:

After: 

// 重构Boolean
    void testInvertBoolean() {
        System.out.println(checkPaswd(null));
        System.out.println(checkPaswd(""));
        System.out.println(checkPaswd("admin"));
    }

    boolean checkPaswd(String passwd) {
        return passwd != null && passwd.length() != 0;
    }
  • MakeClassStatic，使类变成静态的

Before: 

// 使类变成静态的
    void testMakeClassStatic() {
        new MyClass().fun();
    }

    String myClassField = "abc";

    class MyClass {
        void fun() {
            System.out.println("myClassField = " + myClassField);
        }
    }

Gif:

After: 

// 使类变成静态的
    void testMakeClassStatic() {
        new MyClass(myClassField).fun();
    }

    String myClassField = "abc";

    static class MyClass {
        private String myClassField;

        public MyClass(String myClassField) {
            this.myClassField = myClassField;
        }

        void fun() {
            System.out.println("myClassField = " + myClassField);
        }
    }

修改前需要调用外部内的成员变量myClassField，实际编译过后MyClass的class是持有外部类的对象，这样才能访问myClassField，通过重构，使得myClassField通过构造方法传入进去，然后再在fun方法中使用，这样重构会减少类的依赖。

  • MakeMethodStatic，使方法变成静态的

Before: 

// 使方法变成静态的
    void testMakeMethodStatic() {
        myFun();
    }

    void myFun() {
        System.out.println("myFun");
    }

After: 

// 使方法变成静态的
    void testMakeMethodStatic() {
        myFun();
    }

    static void myFun() {
        System.out.println("myFun");
    }
  • Move，移动一个类

Before: 

// 移动一个类
    void testMove() {
        new MoveClass().fun();
    }

    static class MoveClass {

        String movde;

        @Override
        public String toString() {
            return "MoveClass{" +
                    "movde='" + movde + '\'' +
                    '}';
        }

        void fun() {
            System.out.println(this);
        }
    }

Gif:

After: 

// 移动一个类
    void testMove() {
        new MoveClassxxxxxx().fun();
    }

class MoveClassxxxxxx {

    String movde;

    @Override
    public String toString() {
        return "MoveClass{" +
                "movde='" + movde + '\'' +
                '}';
    }

    void fun() {
        System.out.println(this);
    }
}
  • PullMenmberUp，上移

Before: 

public class Base {

    public String baseString;

    public Base(String baseString) {
        this.baseString = baseString;
    }

    public void funBase() {
        System.out.println(baseString);
    }
}
public class Sub extends Base {


    public Sub(String baseString) {
        super(baseString);
    }

    public void funSub() {
        System.out.println(baseString);
    }
}

    // 上移
    void testPullMenmberUp() {
        new Sub("base").funSub();
    }

Gif:

After: 

public class Base {

    public String baseString;

    public Base(String baseString) {
        this.baseString = baseString;
    }

    public void funBase() {
        System.out.println(baseString);
    }

    public void funSub() {
        System.out.println(baseString);
    }
}

public class Sub extends Base {


    public Sub(String baseString) {
        super(baseString);
    }

}

实际上就是把子类中的方法移动到父类中。

  • PullMenmberDown，下移

Before: 

public class Base {

    public String baseString;

    public Base(String baseString) {
        this.baseString = baseString;
    }

    public void funBase() {
        System.out.println(baseString);
    }
}
public class Sub extends Base {


    public Sub(String baseString) {
        super(baseString);
    }

    public void funSub() {
        System.out.println(baseString);
    }
}
    // 下移
    void testPullMenmberDown() {
        new Sub("base").funBase();
    }

After: 

public class Base {

    public String baseString;

    public Base(String baseString) {
        this.baseString = baseString;
    }

}

public class Sub extends Base {

    public Sub(String baseString) {
        super(baseString);
    }

    public void funSub() {
        System.out.println(baseString);
    }

    public void funBase() {
        System.out.println(baseString);
    }
}

实际上就是把父类中的方法移动到子类中。

  • Rename，重命名

这个功能也是我最喜欢的，只要选择重命名一个对象或者资源，所有使用到这个对象或者资源的地方，都会进行重新命名。

Before: 

// 重命名
    void testRename() {
        String first = "second";
        System.out.println(first);
    }

Gif:

After: 

// 重命名
    void testRename() {
        String second = "second";
        System.out.println(second);
    }
  • ReplaceConstructorWithBuilder，构造方法变成builder

还在羡慕Picasso，Fresco人性化调用方式吗？很简单，通过这个功能就可以快速生成代码

Before: 

public class MyAlertDialog {

    private String title;
    private String message;
    private String okButton;
    private String cancelButton;

    public MyAlertDialog(String title, String message, String okButton, String cancelButton) {
        this.title = title;
        this.message = message;
        this.okButton = okButton;
        this.cancelButton = cancelButton;
    }
}    
    // 构造方法变成builder
    void testReplaceConstructorWithBuilder() {
        new MyAlertDialog("title", "message", "ok", "cancel").show();
    }

Gif:

After: 

// 构造方法变成builder
    void testReplaceConstructorWithBuilder() {
        new MyAlertDialog.Builder()
                .setTitle("title")
                .setMessage("message")
                .setOkButton("ok")
                .setCancelButton("cancel")
                .createMyAlertDialog()
                .show();
    }

public static class Builder {
    private String title;
    private String message;
    private String okButton;
    private String cancelButton;

    public Builder setTitle(String title) {
        this.title = title;
        return this;
    }

    public Builder setMessage(String message) {
        this.message = message;
        return this;
    }

    public Builder setOkButton(String okButton) {
        this.okButton = okButton;
        return this;
    }

    public Builder setCancelButton(String cancelButton) {
        this.cancelButton = cancelButton;
        return this;
    }

    public MyAlertDialog createMyAlertDialog() {
        return new MyAlertDialog(title, message, okButton, cancelButton);
    }
}
  • ReplaceConstructorWithFactory，构造方法变成工程方法

Before: 

// 构造方法变成工程方法
    void testReplaceConstructorWithFactory() {
        new MyAlertDialog("title", "message", "ok", "cancel").show();
    }

Gif:

After: 

// 构造方法变成工程方法
    void testReplaceConstructorWithFactory() {
        MyAlertDialog.newInstance("title", "message", "ok", "cancel")
                .show();
    }
public class MyAlertDialog {    
    private MyAlertDialog(String title, String message, String okButton, String cancelButton) {
        this.title = title;
        this.message = message;
        this.okButton = okButton;
        this.cancelButton = cancelButton;
    }

    public static MyAlertDialog newInstance(String title, String message, String okButton, String cancelButton) {
        return new MyAlertDialog(title, message, okButton, cancelButton);
    }
}

通过上面代码发现，如果构造方法变成了工厂方式，那么它的构造参数是private的，这样调用者只能通过工厂方式来生成对象。

  • ReplaceInheritanceWithDelegation，代理代替继承

Before: 

public abstract class AbsClass {

    public abstract void sayHello();
}

public class ExtClass extends AbsClass {

    @Override
    public void sayHello() {
        System.out.println("hello");
    }
}
    // 代理代替继承
    void testReplaceInheritanceWithDelegation() {
        new ExtClass().sayHello();
    }

Gif:

After: 

public class ExtClass {

    private final AbsClassImpl abs = new AbsClassImpl();

    public void sayHello() {
        abs.sayHello();
    }

    private class AbsClassImpl extends AbsClass {
        @Override
        public void sayHello() {
            System.out.println("hello");
        }
    }
}

    // 代理代替继承
    void testReplaceInheritanceWithDelegation() {
        new ExtClass().sayHello();
    }

书上说过，组合由于继承大概说的就是这个意思。

  • SafeDelete，安全删除

Before: 

// 安全删除
    void testSafeDelete() {
        String unUsedString = "abc";

        unUsedString = getUnUsedString();
        System.out.println(new Date());
    }

    public String getUnUsedString() {
        return unUsedString;
    }

After: 

// 安全删除
    void testSafeDelete() {
        System.out.println(new Date());
    }

这个比较简单，如果某个变量没有使用，那么直接直接删除所有引用这个变量的地方。

  • WrapReturnValue，封装返回值

Before: 

// 封装返回值
    void testWrapReturnValue() {
        System.out.println(getUserName());
    }

    private String getUserName() {
        return "userName";
    }

Gif:

After: 

// 包装下返回值
    void testWrapReturnValue() {
        System.out.println(getUserName().getValue());
    }

    private UserInfo getUserName() {
        return new UserInfo("userName");
    }

    public class UserInfo {
        private final String value;

        public UserInfo(String value) {
            this.value = value;
        }

        public String getValue() {
            return value;
        }
    }
  • RemoveMiddleMan，去除中间人

Before: 

// 去除中间人
    void testRemoveMiddleMan() {
        OrderManager manager = new OrderManager();
        manager.newOrder("new");
        manager.confirm("confir");
        manager.invalidOrder("invalid");
    }

    public static class OrderManager {
        private List<String> unProcessOrderList;
        private List<String> processedOrderList;

        public OrderManager() {
            unProcessOrderList = new ArrayList<>();
            processedOrderList = new ArrayList<>();
        }

        public void newOrder(String order) {
            unProcessOrderList.add(order);
        }

        public void confirm(String order) {
            unProcessOrderList.remove(order);
            processedOrderList.add(order);
        }

        public void invalidOrder(String order) {
            processedOrderList.remove(order);
        }

        public void display() {
            System.out.println(unProcessOrderList);
            System.out.println(processedOrderList);
        }
    }

Gif:

After: 

// 去除中间人
    void testRemoveMiddleMan() {
        OrderManager manager = new OrderManager();
        manager.getUnProcessOrderList().add("new");
        manager.confirm("confir");
        manager.getProcessedOrderList().remove("invalid");
    }

    public static class OrderManager {
        private List<String> unProcessOrderList;
        private List<String> processedOrderList;

        public OrderManager() {
            unProcessOrderList = new ArrayList<>();
            processedOrderList = new ArrayList<>();
        }

        public void confirm(String order) {
            unProcessOrderList.remove(order);
            processedOrderList.add(order);
        }

        public void display() {
            System.out.println(unProcessOrderList);
            System.out.println(processedOrderList);
        }

        public List<String> getUnProcessOrderList() {
            return unProcessOrderList;
        }

        public List<String> getProcessedOrderList() {
            return processedOrderList;
        }
    }

用途就是，原先OrderManager持有一个List来保存Order，调用方直接使用OrderManager来处理订单，去除中间人的意思就是说，调用法直接获取保存Order的容器，调用方直接自己控制容器。

代码抽取

代码抽取在实际使用当中非常有用。

  • ExtraMethod，抽取一个方法

Before: 

// 抽取一个方法
    void testExtraMethod() {
        Map<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        map.put("three", 2);

        System.out.println(map);
    }

Gif:

After: 

// 抽取一个方法
    void testExtraMethod() {
        Map<String, Integer> map = initMap();

        System.out.println(map);
    }

    @NonNull
    private Map<String, Integer> initMap() {
        Map<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        map.put("three", 2);
        return map;
    }
  • ExtraMethodObject，抽取一个方法到一个对象中

和上面那个差不多，只不过把方法移动到另外一个类中。

Before: 

// 抽取一个方法到一个对象中
    void testExtraMethodObject() {
        Map<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 22);
        map.put("three", 33);

        System.out.println(map);
    }

After: 

// 抽取一个方法到一个对象中
    void testExtraMethodObject() {
        Map<String, Integer> map = MapUtil.invoke();
        System.out.println(map);
    }

    private static class MapUtil {
        private static Map<String, Integer> invoke() {
            Map<String, Integer> map = new HashMap<>();
            map.put("one", 1);
            map.put("two", 22);
            map.put("three", 33);
            return map;
        }
    }
  • ExtractParameterObject，抽取若干参数成一个类

这个比较使用，有时候一个方法参数太多，可以把这些参数合并成一个类。

Before: 

// 抽取若干参数成一个类
    void testExtractParameterObject() {
        print(100, 200);
    }

    // widht,height --> Size Class
    void print(int width, int height) {
        System.out.println("width = " + width + ", height = " + height);
    }

Gif:

After: 

// 抽取若干参数成一个类
    void testExtractParameterObject() {
        print(new Size(100, 200));
    }

    // widht,height --> Size Class
    void print(Size size) {
        System.out.println("width = " + size.getWidth() + ", height = " + size.getHeight());
    }


public class Size {
    private final int width;
    private final int height;

    public Size(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public int getWidth() {
        return width;
    }

    public int getHeight() {
        return height;
    }
}
  • ExtractSuperclass，抽取到父类

Before: 

// 抽取到父类
    void testExtractSuperclass() {
        sendEvent("login_success");
    }

    public void sendEvent(Object event) {
        // EventBus.getDefault().send(event);
    }

Gif:

After: 

public class BaseExtractDemo {
    public void sendEvent(Object event) {
        // EventBus.getDefault().send(event);
    }
}

public class ExtractDemo extends BaseExtractDemo {
    // 抽取到父类
    void testExtractSuperclass() {
        sendEvent("login_success");
    }
}
  • ExtractConstant，抽取常量

Before: 

// 抽取常量
    void testExtractConstant() {
        String email = "admin@123.com";
        String passwd = "1qaz2wsx";

        Bundle bundle = new Bundle();
        bundle.putString("email", email);
        bundle.putString("passwd", passwd);
    }

Gif:

After: 

public static final String KEY_EMAIL = "email";
    public static final String KEY_PASSWD = "passwd";

    // 抽取常量
    void testExtractConstant() {
        String email = "admin@123.com";
        String passwd = "1qaz2wsx";

        Bundle bundle = new Bundle();
        bundle.putString(KEY_EMAIL, email);
        bundle.putString(KEY_PASSWD, passwd);
    }
  • ExtractField，抽取成成员变量

Before: 

// 抽取成成员变量
    void testExtractField() {
        String testExtractField =  "testExtractField";
        System.out.println(testExtractField);
    }

After: 

private String testExtractField;

    // 抽取成成员变量
    void testExtractField() {
        testExtractField = "testExtractField";
        System.out.println(testExtractField);
    }
  • ExtractVariable，抽取成变量

Before: 

// 抽取成变量
    void testExtractVariable() {
        System.out.println("long name = " + getLoooooooooooooooooooooooooooooooooooooooooooooooooooooongName());
    }

    String getLoooooooooooooooooooooooooooooooooooooooooooooooooooooongName() {
        return "getLoooooooooooooooooooooooooooooooooooooooooooooooooooooongName";
    }

Gif:

After: 

// 抽取成变量
    void testExtractVariable() {
        String name = getLoooooooooooooooooooooooooooooooooooooooooooooooooooooongName();
        System.out.println("long name = " + name);
    }

    String getLoooooooooooooooooooooooooooooooooooooooooooooooooooooongName() {
        return "getLoooooooooooooooooooooooooooooooooooooooooooooooooooooongName";
    }

有时候，一行代码写的很长，可以使用这个方法，对代码进行重构。

  • ExtractParameter，抽取成方法的参数

Before: 

// 抽取成方法的参数
    void testExtractParameter() {
        printHelloString();
    }

    private void printHelloString() {
        String str = "printHello";
        System.out.println(str);
    }

Gif:

After: 

// 抽取成方法的参数
    void testExtractParameter() {
        String str = "printHello";
        printStringAndLength(str);
    }

    private void printStringAndLength(String paramStr) {
        System.out.println(paramStr + " -> " + paramStr.length());
    }

Android资源重构

  • ExtractLayout，布局文件抽取

Before: 

<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true">

    <android.support.design.widget.AppBarLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:theme="@style/AppTheme.AppBarOverlay">

        <android.support.v7.widget.Toolbar
            android:id="@+id/toolbar"
            android:layout_width="match_parent"
            android:layout_height="?attr/actionBarSize"
            android:background="?attr/colorPrimary"
            app:popupTheme="@style/AppTheme.PopupOverlay" />

    </android.support.design.widget.AppBarLayout>

    <include layout="@layout/content_main" />

    <android.support.design.widget.FloatingActionButton
        android:id="@+id/fab"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom|end"
        android:layout_margin="@dimen/fab_margin"
        android:src="@android:drawable/ic_dialog_email" />

</android.support.design.widget.CoordinatorLayout>

Gif:

After: 

<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:fitsSystemWindows="true">

    <include layout="@layout/view_top" />

    <include layout="@layout/content_main" />

    <include layout="@layout/view_button" />

</android.support.design.widget.CoordinatorLayout>
  • ExtractStyle，样式抽取

Before: 

<TextView  android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Hello World!" android:textAlignment="center" android:textColor="#f00ff0" android:textSize="18sp" android:textStyle="bold" android:typeface="normal" />

Gif:

After: 

<TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        style="@style/my_textview_style" />

    <style name="my_textview_style">
        <item name="android:textAlignment">center</item>
        <item name="android:textColor">#f00ff0</item>
        <item name="android:textSize">18sp</item>
        <item name="android:textStyle">bold</item>
        <item name="android:typeface">normal</item>
    </style>

综合示例

通过一个示例演示怎么样重构代码，示例是一个Activity里面有个RecyclerView，然后重构代码，演示怎么样分离Adapter,ViewHolder等。

Before: 

public class StartActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_start);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        RecyclerView recyclerView = (RecyclerView) findViewById(R.id.recyclerView);
        recyclerView.setLayoutManager(new LinearLayoutManager(this));

        final List<String> data = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            data.add("Text " + (i + 1));
        }

        recyclerView.setAdapter(new RecyclerView.Adapter<MyViewHolder>() {

            @Override
            public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
                LayoutInflater layoutInflater = (LayoutInflater) parent.getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
                return new MyViewHolder(layoutInflater.inflate(android.R.layout.simple_list_item_1, parent, false));
            }

            @Override
            public void onBindViewHolder(MyViewHolder holder, int position) {
                holder.bind(data.get(position));
            }

            @Override
            public int getItemCount() {
                return data.size();
            }
        });
    }

    class MyViewHolder extends RecyclerView.ViewHolder {

        TextView textView;

        public MyViewHolder(View itemView) {
            super(itemView);
            textView = (TextView) itemView.findViewById(android.R.id.text1);
        }

        void bind(String text) {
            textView.setText(text);
        }
    }
}

Gif: 

After: 

public class StartActivity extends AppCompatActivity {

    private RecyclerView recyclerView;
    private List<String> data;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_start);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        initData();
        initView();
    }

    private void initData() {
        data = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            data.add("Text " + (i + 1));
        }
    }

    private void initView() {
        recyclerView = (RecyclerView) findViewById(R.id.recyclerView);
        recyclerView.setLayoutManager(new LinearLayoutManager(this));
        recyclerView.setAdapter(new MyViewHolderAdapter(data));
    }
}

class MyViewHolderAdapter extends RecyclerView.Adapter<MyViewHolder> {

    private List<String> data;

    public MyViewHolderAdapter(List<String> data) {
        this.data = data;
    }

    @Override
    public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        return MyViewHolder.newInstance(parent);
    }

    @Override
    public void onBindViewHolder(MyViewHolder holder, int position) {
        holder.bind(data.get(position));
    }

    @Override
    public int getItemCount() {
        return data.size();
    }
}


class MyViewHolder extends RecyclerView.ViewHolder {

    public static final int LAYOUT_ID = android.R.layout.simple_list_item_1;

    @NonNull
    static MyViewHolder newInstance(ViewGroup parent) {
        Context context = parent.getContext();
        LayoutInflater layoutInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        return new MyViewHolder(layoutInflater.inflate(LAYOUT_ID, parent, false));
    }

    TextView textView;

    public MyViewHolder(View itemView) {
        super(itemView);
        textView = (TextView) itemView.findViewById(android.R.id.text1);
    }

    void bind(String text) {
        textView.setText(text);
    }
}

总结

至此，Android Studio的重构功能讲解完成，由于Android Studio更新很快，很多功能还需要自己去发掘。

『君子生非异也，善假于物也』，好好使用工具，可以偷个懒。

转载于:https://my.oschina.net/u/1780920/blog/657802

chuntianlong5227
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Androidstudio更新代码以及修改app版本号keystorepath生成apk的方法
weixin_44062039的博客
01-22 1124
之前已经从git上下下来了一些代码， 1、从git上更新代码 操作步骤：VCS——Git——Pull 啥也不改直接点击“pull” 2、修改版本号 3、生成新的APK 方法一： build——generate signed bundle/APK 点击“ok” ！！！这里flavors是文件夹，生成的apk应该在此位置： 出现这样的提示说明打包完成了： 这个路径下生成了apk： ...
android 代码重构（一）
hhbbeijing的专栏
09-02 985
今晚拿出一个小时来重温一下代码重构，发现定期的充电、学习是个很好的习惯。 1、1  实体类——凡是能够用到与实体类密切有关的方法，放到实体类中。发现有些时候放到工具类里，这是不明智的，当其他人用到这个类的时候，能够很清楚的查找到，注意：一定是只与该实体类有关！ 2、2 方法——凡是能够提取出私有或者公有 的方法，就有提取！这个听起来有些像代码的复用，不过这可不是老生常谈，很有必要的，当一个类写
代码重构——妙用Android Studio
LXB-89
06-26 1268
Android Studio是基于优秀的ide的，ide提供了丰富的功能，很方便的对代码进行重构，下图是我的Android Studio Refactor菜单，部分快捷键与默认快捷键不同是因为方便而修改的。如何使用鼠标光标选中或者放在代码上，按下快捷键就可以弹出当前代码可以使用的功能。 如下所示：代码与操作示例ChangeSignature，改变函数签名，可以修改函数的名字，参数的顺序，参数的名字...
Android Studio 真机debug或者运行过程中 更改代码或者 加入log后 重新打包 更新终端或者模拟器apk的操作
哈哈哈
02-08 411
1.删除手机的原有apk。2.重新运行debug。
（转载）使用Android Studio对代码进行重构
zhuhai__yizhi的专栏
09-12 509
（转载）https://blog.csdn.net/guijiaoba/article/details/50608606 简介 2013年Google I/O大会上，谷歌推出新的Android开发环境——Android Studio，从此Android程序员有了新的选择，使用Android Studio进行App开发。AndroidStudio是一项全新的基于IntelliJ IDEA的And...
使用AndroidStudio进行代码重构
卧龙跃马的博客
05-25 1140
使用AndroidStudio进行代码重构 Refactor菜单： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EaCIpili-1590391029038)(https://img2018.cnblogs.com/blog/472002/201911/472002-20191106122446987-960201700.png “Refactor菜单”)] Rename 说明：对类中的成员变量、方法等进行重命名 用法：把光标放在方法或字段上面，按Shift+F6（或
android studio复制代码,Android Studio：使用Android模块而无需复制代码
weixin_29176179的博客
05-26 216
由于我最近在自己的项目中有这个要求,我可能会给你一些建议.基本上这是你的选择：1.具有不同模块的单个项目如果AppA和AppB以某种方式相关(这是您必须决定的),您可以轻松实现.您的项目中已经有AppA和LibC,因此您只需要在Studio for AppB中创建另一个App模块(文件>新模块>应用程序模块)您可能会有趣地看到,您的项目目录最初的名称为AppA,而您的AppA模块名为a...
详解AndroidStudio中代码重构菜单Refactor功能
08-25
主要介绍了AndroidStudio中代码重构菜单Refactor功能详解,本文通过代码演示，功能截图来详细说明as为大名重构提供的各项功能，需要的朋友可以参考下
毕业设计安卓源码-RAndroid:代码异味重构AndroidStudio插件
06-06
用于代码异味重构的 Android Studio 插件。 它能够修复特定于 Android 的代码异味和/或建议适当的重构来解决它们。 该插件支持以下代码异味： 自动重构： 初始化 OnDraw (IOD) 重启动服务 (HSS) 刚性警报管理器 (RAM...
Android Studio的下载和安装详细教程.pdf
03-27
Android Studio拥有强大的代码编辑功能，包括代码高亮、自动补全、重构、代码格式化和快速导航等。它还支持代码分析和Lint检查，帮助开发者找出潜在的问题并改进代码质量。 实时布局编辑器： 使用Android Studio的...
Android Studio 2022+SQLite 5.4
06-22
Android Studio是一个由Google开发的，用于Android应用程序开发的...SQLite可以在各种操作系统和编程语言中使用，包括Android、iOS、Windows、Linux等，同时还可以使用多种编程语言进行开发，方便了对开发人员的使用。
Java开发案例-springboot-19-校验表单重复提交-源代码+文档.rar
05-31
Java开发案例-springboot-19-校验表单重复提交-源代码+文档.rar Java开发案例-springboot-19-校验表单重复提交-源代码+文档.rar Java开发案例-springboot-19-校验表单重复提交-源代码+文档.rar Java开发案例-springboot-19-校验表单重复提交-源代码+文档.rar Java开发案例-springboot-19-校验表单重复提交-源代码+文档.rarJava开发案例-springboot-19-校验表单重复提交-源代码+文档.rar Java开发案例-springboot-19-校验表单重复提交-源代码+文档.rar
基于android的公司员工考勤综合信息平台源码.zip
05-31
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
珍藏很久的一套源码升级了很多
05-31
很强大的阿凤飞飞的身份就把饭啦啊开房记录看妇科阿里看到就考虑是否就解放路口空间按时到路口附近开了房间卡拉的时间分开垃圾的浪费空间按可浪费阿克纠纷的看了觉得空房间看大神经费卡上的减肥快接啊看来积分卡时间分开拉丝机房里看见啦开恐怕为日文名弄法卡上的健康饭卡里解放开了哈嘎考虑对方好几万呢uaho时到路口附近开了房间卡拉的时间分开垃圾的浪费空间按可浪费阿克纠纷的看了觉得空房间看大神经费卡上的减肥快接啊看来积分卡时间分开拉丝机房里看见啦开恐怕为日文名弄法卡上的健康饭卡里解放开了哈嘎考虑对方好几万呢uaho上的健康饭卡里解放开了哈嘎考虑对方好几万呢uaho时到路口附近开了房间卡拉的时间分开垃圾的浪费空间按可浪费阿克纠纷的看了觉得空房间看大神经费卡上的减肥快接啊看来积分卡时间分开拉丝机房里看见啦开恐怕为日文名弄法卡上的健康饭卡里解放开了哈嘎考虑对方好几万呢uaho垃圾的浪费空间按可浪费阿克纠纷的看了觉得空房间看大神经费卡上的减肥快接啊看来积分卡时间分开拉丝机房里看见啦开恐怕为日文名弄法卡上的健康饭卡里解放开了哈嘎考虑对方好几万呢uaho上的健康饭卡里解放开了哈嘎考虑对方好几万呢uaho时到路口附近开
附件二六个指标与权重得分 - 副本.xlsx
05-31
附件二六个指标与权重得分 - 副本
自学助词自学助词自学助词
05-31
自学助词自学助词自学助词
ipywidgets-7.7.3.tar.gz
最新发布
05-31
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
Seay PHP代码审计工具2.1公测版.rar
05-31
Seay PHP代码审计工具是一个专门用于审核PHP代码安全性的工具，以下是关于该工具的一些关键信息： 功能特性： 源码浏览：允许用户通过文件列表浏览源代码，并可直接查看和分析含有特定关键字的代码。 关键字扫描：支持单个关键字扫描，方便查找特定模式的代码。 函数扫描：可以批量扫描指定的函数，检查其使用是否安全。 正则匹配：使用正则表达式进行批量匹配，提供高精度和高效率的扫描。 代码审计：自动化审计功能帮助检测常见的安全漏洞，如SQL注入、代码执行、命令执行等。 插件扩展：可能支持通过插件扩展审计功能。 自定义规则：允许用户配置自定义的审计规则。 代码调试：可能包含代码调试功能，帮助理解代码行为。 数据库执行监控：可能有监控数据库操作的功能，以检测潜在的安全问题。 安装与使用： Seay工具通常需要在Windows环境下运行，可能依赖.NET组件。 安装过程相对简单，一般提供一键安装或绿色版，无需复杂配置即可使用。 适用场景： 主要适用于PHP项目的安全测试和代码审查，尤其是对于需要确保代码安全性的开发者和安全分析师。
android studio中接口重构
08-19
在Android Studio中进行接口重构，你可以按照以下步骤来进行操作： 1. 找到你想要重构的接口。这可以是一个类中的接口，或者是一个独立的接口文件。 2. 使用Android Studio的重构功能来修改接口名称。你可以使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值