使用Android Studio对代码进行重构 - 简书
使用Android Studio对代码进行重构
使用Android Studio对代码进行重构
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，改变函数签名，可以修改函数的名字，参数的顺序，参数的名字。
// 改变签名
void testChangeSignature(int second, int first) {
System.out.println(first + "-&" + second);
// 改变签名
void testChangeSignature(int one, int two) {
System.out.println(one + "-&" + two);
修改前参数依次是second、first，修改是one、two。
ChangeClassSignatuere，改变类的签名，可以修改类的泛型签名
// 改变类的签名
void testChangeClassSignatuere() {
String second = "second";
int first = 100;
new ChangeClassSignatuere(second, first);
// **********************分割线*******************************
public class ChangeClassSignatuere {
public ChangeClassSignatuere(String second, int first) {
this.first =
this.second =
public String toString() {
return "ChangeClassSignatuere{" +
"second='" + second + '\'' +
",first=" + first +
改变类签名
// 改变类的签名
void testChangeClassSignatuere() {
String second = "second";
int first = 100;
new ChangeClassSignatuere&Activity&(second, first);
// **********************分割线*******************************
public class ChangeClassSignatuere&A& {
public ChangeClassSignatuere(String second, int first) {
this.first =
this.second =
public String toString() {
return "ChangeClassSignatuere{" +
"second='" + second + '\'' +
",first=" + first +
修改匿名类为内部类
// 匿名类改成内部类
void testConvertAnonymousToInner() {
View.OnClickListener clickListener = new View.OnClickListener() {
public void onClick(View v) {
System.out.println("onClick");
改变类签名
// 匿名类改成内部类
void testConvertAnonymousToInner() {
View.OnClickListener clickListener = new Abc123();
private static class Abc123 implements View.OnClickListener {
public void onClick(View v) {
System.out.println("onClick");
这个是我最喜欢的一个功能，有时候匿名类刚刚开始逻辑很简单，过不了多久逻辑太多，就可以使用快捷键变成一个内部类。
ConvertToInstanceMethod，修改一个方法变成成员方法
// 变成成员方法
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);
// 变成成员方法
void testConvertToInstanceMethod() {
this.convertToInstanceMethod("test");
void convertToInstanceMethod(String string) {
System.out.println("convertToInstanceMethod = " + this);
System.out.println("convertToInstanceMethod = " + string);
在修改前，调用convertToInstanceMethod方法，第一个参数相是RefactorDemo，传递是this， 修改后就那个方法直接移动到本类中。
Copy，复制一个类
// 复制一个类
void testCopy() {
new FirstClass();
public class FirstClass implements Serializable {
public String toString() {
return "FirstClass{" +
"first='" + first + '\'' +
复制一个类
public class SecondClass implements Serializable {
public String toString() {
return "SecondClass{" +
"first='" + first + '\'' +
EncapsulateFields，压缩一个字段，间接访问
String filed = "filed";
// 压缩一个字段，间接访问
void testEncapsulateFields() {
System.out.println(filed);
private String filed = "filed";
// 压缩一个字段，间接访问
void testEncapsulateFields() {
System.out.println(getFiled());
public String getFiled() {
public void setFiled(String filed) {
this.filed =
相当于简介访问一个field，自动生成setter和getter。
GenerifyRefactoring，泛型重构
// 泛型重构
void testGenerifyRefactoring() {
List list = new ArrayList();
list.add("one");
list.add("two");
list.add("three");
// 泛型重构
void testGenerifyRefactoring() {
List&String& list = new ArrayList&String&();
list.add("one");
list.add("two");
list.add("three");
自动添加泛型的参数。
Inline，内联函数
void testInline() {
int a = 100;
int b = 200;
System.out.println(add(a, b));
int add(int a, int b) {
return a +
void testInline() {
int a = 100;
int b = 200;
System.out.println(a + b);
原先需要调用一个函数的地方，直接把那个函数里面的代码复制过来。
InvertBoolean，重构Boolean
// 重构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) {
// 重构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，使类变成静态的
// 使类变成静态的
void testMakeClassStatic() {
new MyClass().fun();
String myClassField = "abc";
class MyClass {
void fun() {
System.out.println("myClassField = " + myClassField);
// 使类变成静态的
void testMakeClassStatic() {
new MyClass(myClassField).fun();
String myClassField = "abc";
static class MyClass {
private String myClassF
public MyClass(String myClassField) {
this.myClassField = myClassF
void fun() {
System.out.println("myClassField = " + myClassField);
修改前需要调用外部内的成员变量myClassField，实际编译过后MyClass的class是持有外部类的对象，这样才能访问myClassField，通过重构，使得myClassField通过构造方法传入进去，然后再在fun方法中使用，这样重构会减少类的依赖。
MakeMethodStatic，使方法变成静态的
// 使方法变成静态的
void testMakeMethodStatic() {
void myFun() {
System.out.println("myFun");
// 使方法变成静态的
void testMakeMethodStatic() {
static void myFun() {
System.out.println("myFun");
Move，移动一个类
// 移动一个类
void testMove() {
new MoveClass().fun();
static class MoveClass {
public String toString() {
return "MoveClass{" +
"movde='" + movde + '\'' +
void fun() {
System.out.println(this);
// 移动一个类
void testMove() {
new MoveClassxxxxxx().fun();
class MoveClassxxxxxx {
public String toString() {
return "MoveClass{" +
"movde='" + movde + '\'' +
void fun() {
System.out.println(this);
PullMenmberUp，上移
public class Base {
public String baseS
public Base(String baseString) {
this.baseString = baseS
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();
public class Base {
public String baseS
public Base(String baseString) {
this.baseString = baseS
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，下移
public class Base {
public String baseS
public Base(String baseString) {
this.baseString = baseS
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();
public class Base {
public String baseS
public Base(String baseString) {
this.baseString = baseS
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，重命名
这个功能也是我最喜欢的，只要选择重命名一个对象或者资源，所有使用到这个对象或者资源的地方，都会进行重新命名。
void testRename() {
String first = "second";
System.out.println(first);
void testRename() {
String second = "second";
System.out.println(second);
ReplaceConstructorWithBuilder，构造方法变成builder
还在羡慕Picasso，Fresco人性化调用方式吗？很简单，通过这个功能就可以快速生成代码
public class MyAlertDialog {
private String okB
private String cancelB
public MyAlertDialog(String title, String message, String okButton, String cancelButton) {
this.title =
this.message =
this.okButton = okB
this.cancelButton = cancelB
// 构造方法变成builder
void testReplaceConstructorWithBuilder() {
new MyAlertDialog("title", "message", "ok", "cancel").show();
// 构造方法变成builder
void testReplaceConstructorWithBuilder() {
new MyAlertDialog.Builder()
.setTitle("title")
.setMessage("message")
.setOkButton("ok")
.setCancelButton("cancel")
.createMyAlertDialog()
public static class Builder {
private String okB
private String cancelB
public Builder setTitle(String title) {
this.title =
public Builder setMessage(String message) {
this.message =
public Builder setOkButton(String okButton) {
this.okButton = okB
public Builder setCancelButton(String cancelButton) {
this.cancelButton = cancelB
public MyAlertDialog createMyAlertDialog() {
return new MyAlertDialog(title, message, okButton, cancelButton);
ReplaceConstructorWithFactory，构造方法变成工程方法
// 构造方法变成工程方法
void testReplaceConstructorWithFactory() {
new MyAlertDialog("title", "message", "ok", "cancel").show();
// 构造方法变成工程方法
void testReplaceConstructorWithFactory() {
MyAlertDialog.newInstance("title", "message", "ok", "cancel")
public class MyAlertDialog {
private MyAlertDialog(String title, String message, String okButton, String cancelButton) {
this.title =
this.message =
this.okButton = okB
this.cancelButton = cancelB
public static MyAlertDialog newInstance(String title, String message, String okButton, String cancelButton) {
return new MyAlertDialog(title, message, okButton, cancelButton);
通过上面代码发现，如果构造方法变成了工厂方式，那么它的构造参数是private的，这样调用者只能通过工厂方式来生成对象。
ReplaceInheritanceWithDelegation，代理代替继承
public abstract class AbsClass {
public abstract void sayHello();
public class ExtClass extends AbsClass {
public void sayHello() {
System.out.println("hello");
// 代理代替继承
void testReplaceInheritanceWithDelegation() {
new ExtClass().sayHello();
public class ExtClass {
private final AbsClassImpl abs = new AbsClassImpl();
public void sayHello() {
abs.sayHello();
private class AbsClassImpl extends AbsClass {
public void sayHello() {
System.out.println("hello");
// 代理代替继承
void testReplaceInheritanceWithDelegation() {
new ExtClass().sayHello();
书上说过，组合由于继承大概说的就是这个意思。
SafeDelete，安全删除
// 安全删除
void testSafeDelete() {
String unUsedString = "abc";
unUsedString = getUnUsedString();
System.out.println(new Date());
public String getUnUsedString() {
return unUsedS
// 安全删除
void testSafeDelete() {
System.out.println(new Date());
这个比较简单，如果某个变量没有使用，那么直接直接删除所有引用这个变量的地方。
WrapReturnValue，封装返回值
// 封装返回值
void testWrapReturnValue() {
System.out.println(getUserName());
private String getUserName() {
return "userName";
// 包装下返回值
void testWrapReturnValue() {
System.out.println(getUserName().getValue());
private UserInfo getUserName() {
return new UserInfo("userName");
public class UserInfo {
private final S
public UserInfo(String value) {
this.value =
public String getValue() {
RemoveMiddleMan，去除中间人
// 去除中间人
void testRemoveMiddleMan() {
OrderManager manager = new OrderManager();
manager.newOrder("new");
manager.confirm("confir");
manager.invalidOrder("invalid");
public static class OrderManager {
private List&String& unProcessOrderL
private List&String& processedOrderL
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);
// 去除中间人
void testRemoveMiddleMan() {
OrderManager manager = new OrderManager();
manager.getUnProcessOrderList().add("new");
manager.confirm("confir");
manager.getProcessedOrderList().remove("invalid");
public static class OrderManager {
private List&String& unProcessOrderL
private List&String& processedOrderL
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 unProcessOrderL
public List&String& getProcessedOrderList() {
return processedOrderL
用途就是，原先OrderManager持有一个List来保存Order，调用方直接使用OrderManager来处理订单，去除中间人的意思就是说，调用法直接获取保存Order的容器，调用方直接自己控制容器。
代码抽取在实际使用当中非常有用。
ExtraMethod，抽取一个方法
// 抽取一个方法
void testExtraMethod() {
Map&String, Integer& map = new HashMap&&();
map.put("one", 1);
map.put("two", 2);
map.put("three", 2);
System.out.println(map);
// 抽取一个方法
void testExtraMethod() {
Map&String, Integer& map = initMap();
System.out.println(map);
private Map&String, Integer& initMap() {
Map&String, Integer& map = new HashMap&&();
map.put("one", 1);
map.put("two", 2);
map.put("three", 2);
ExtraMethodObject，抽取一个方法到一个对象中
和上面那个差不多，只不过把方法移动到另外一个类中。
// 抽取一个方法到一个对象中
void testExtraMethodObject() {
Map&String, Integer& map = new HashMap&&();
map.put("one", 1);
map.put("two", 22);
map.put("three", 33);
System.out.println(map);
// 抽取一个方法到一个对象中
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);
ExtractParameterObject，抽取若干参数成一个类
这个比较使用，有时候一个方法参数太多，可以把这些参数合并成一个类。
// 抽取若干参数成一个类
void testExtractParameterObject() {
print(100, 200);
// widht,height --& Size Class
void print(int width, int height) {
System.out.println("width = " + width + ", height = " + height);
// 抽取若干参数成一个类
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 {
public Size(int width, int height) {
this.width =
this.height =
public int getWidth() {
public int getHeight() {
ExtractSuperclass，抽取到父类
// 抽取到父类
void testExtractSuperclass() {
sendEvent("login_success");
public void sendEvent(Object event) {
// EventBus.getDefault().send(event);
public class BaseExtractDemo {
public void sendEvent(Object event) {
// EventBus.getDefault().send(event);
public class ExtractDemo extends BaseExtractDemo {
// 抽取到父类
void testExtractSuperclass() {
sendEvent("login_success");
ExtractConstant，抽取常量
// 抽取常量
void testExtractConstant() {
String email = "";
String passwd = "1qaz2wsx";
Bundle bundle = new Bundle();
bundle.putString("email", email);
bundle.putString("passwd", passwd);
public static final String KEY_EMAIL = "email";
public static final String KEY_PASSWD = "passwd";
// 抽取常量
void testExtractConstant() {
String email = "";
String passwd = "1qaz2wsx";
Bundle bundle = new Bundle();
bundle.putString(KEY_EMAIL, email);
bundle.putString(KEY_PASSWD, passwd);
ExtractField，抽取成成员变量
// 抽取成成员变量
void testExtractField() {
String testExtractField =
"testExtractField";
System.out.println(testExtractField);
private String testExtractF
// 抽取成成员变量
void testExtractField() {
testExtractField = "testExtractField";
System.out.println(testExtractField);
ExtractVariable，抽取成变量
// 抽取成变量
void testExtractVariable() {
System.out.println("long name = " + getLoooooooooooooooooooooooooooooooooooooooooooooooooooooongName());
String getLoooooooooooooooooooooooooooooooooooooooooooooooooooooongName() {
return "getLoooooooooooooooooooooooooooooooooooooooooooooooooooooongName";
// 抽取成变量
void testExtractVariable() {
String name = getLoooooooooooooooooooooooooooooooooooooooooooooooooooooongName();
System.out.println("long name = " + name);
String getLoooooooooooooooooooooooooooooooooooooooooooooooooooooongName() {
return "getLoooooooooooooooooooooooooooooooooooooooooooooooooooooongName";
有时候，一行代码写的很长，可以使用这个方法，对代码进行重构。
ExtractParameter，抽取成方法的参数
// 抽取成方法的参数
void testExtractParameter() {
printHelloString();
private void printHelloString() {
String str = "printHello";
System.out.println(str);
// 抽取成方法的参数
void testExtractParameter() {
String str = "printHello";
printStringAndLength(str);
private void printStringAndLength(String paramStr) {
System.out.println(paramStr + " -& " + paramStr.length());
Android资源重构
ExtractLayout，布局文件抽取
&?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&
&?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，样式抽取
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" /&
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&
通过一个示例演示怎么样重构代码，示例是一个Activity里面有个RecyclerView，然后重构代码，演示怎么样分离Adapter,ViewHolder等。
public class StartActivity extends AppCompatActivity {
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&() {
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));
public void onBindViewHolder(MyViewHolder holder, int position) {
holder.bind(data.get(position));
public int getItemCount() {
return data.size();
class MyViewHolder extends RecyclerView.ViewHolder {
TextView textV
public MyViewHolder(View itemView) {
super(itemView);
textView = (TextView) itemView.findViewById(android.R.id.text1);
void bind(String text) {
textView.setText(text);
public class StartActivity extends AppCompatActivity {
private RecyclerView recyclerV
private List&String&
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&
public MyViewHolderAdapter(List&String& data) {
this.data =
public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
return MyViewHolder.newInstance(parent);
public void onBindViewHolder(MyViewHolder holder, int position) {
holder.bind(data.get(position));
public int getItemCount() {
return data.size();
class MyViewHolder extends RecyclerView.ViewHolder {
public static final int LAYOUT_ID = android.R.layout.simple_list_item_1;
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 textV
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更新很快，很多功能还需要自己去发掘。
『君子生非异也，善假于物也』，好好使用工具，可以偷个懒。
Android程序员&初级后端程序员
http://mycommons.cn
https://github.com/LiushuiXiaoxia
用两张图告诉你，为什么你的 App 会卡顿? - Android - 掘金Cover 有什么料？ 从这篇文章中你能获得这些料： 知道setContentView()之后发生了什么？ ... Android 获取 View 宽高的常用正确方式，避免为零 - 掘金相信有很多朋友...
用两张图告诉你，为什么你的 App 会卡顿? - Android - 掘金 Cover 有什么料？ 从这篇文章中你能获得这些料： 知道setContentView()之后发生了什么？ ... Android 获取 View 宽高的常用正确方式，避免为零 - 掘金 相信有很多...
Java 基础思维导图，让 Java 不再难懂 - 工具资源 - 掘金思维导图的好处 最近看了一些文章的思维导图，发现思维导图真是个强大的工具。了解了思维导图的作用之后，觉得把它运用到java上应该是个不错的想法，这样回顾知识点的时候一目了然，快速知道自己的短板。 思维导图...
写给 Android 开发者的混淆使用手册 - Android - 掘金本文转自：点击打开链接 毫无疑问，混淆是打包过程中最重要的流程之一，在没有特殊原因的情况下，所有 app 都应该开启混淆。 首先，这里说的的混淆其实是包括了代码压缩、代码混淆以及资源压缩等的优化过程。依...
作者：snowdream微信：sn0wdr1am原文地址：https://github.com/snowdream/awesome-android awesome-android Introduction android libs from github System re...
25岁之前，觉得自己还小，不谈恋爱，没关系，可25岁以后到26岁，瞬间觉得年龄大了。 前些年的时候，亲戚朋友逢年过节就会安排相亲，嘴里的推辞总是，我还小呢，不着急嫁人，可转眼已经26，再也不好意思对人说，我还小着呢。其实只有自己知道，想要什么样的生活。 因为我们在北京呆惯了...
ubuntu linux用了很久，可是对终端下的字体一直不是很满意，今天终于找到了一些比较好看的终端字体，尤其是droid sans mono字体，简直爱死了，linux迷在ubuntu下一直用的就是这款字体，很漂亮，极力推荐这几款漂亮的字体:1. Inconsolata安...
最近在和同学参与一个创业项目，用到了laravel，仔细研究了一下，发现laravel封装了很多开箱即用的方法，通过traits实现引入后，就可以使用这些方法，今天我们来分析一下 AuthenticatesAndRegistersUsers ThrottlesLogins ...
现在主流app里面经常需要有tableView上滑出现悬浮条样式的设计，宝宝看了下appleStore里面专题推荐用的scrollView 也有类似的悬浮效果，只不过它是下拉悬浮，而主流的是上滑悬浮！最终实现效果如以下gif图。 先别敲代码，想想悬浮条实现思路 上滑悬浮条样...
做计算器的时候，是否曾经有个这样的烦恼，取出输入框的值是String，我们这个时候应该怎么样转换一下我们得到的数学表达式呢？怎样才能得到正确的答案呢？是否曾经考虑过使用栈的原理，先进后出，括号匹配一大堆的东东，但最后发现实现起来还是挺困难的，这不，有一个玩意正好可以解决这个...