1. 方法只使用一级缩进。
重构前：
class App{
public String action(int[][] data){
List<Integer> list = new ArrayList<>();
for(int i = 0;i<10;i++){
for (int j = 0;j<10;j++){
list.add(data[i][j]);
}
}
return String.join(",",list);
}
}
重构后：
class App{
public String action(int[][] data){
List<Integer> list = new ArrayList<>();
return String.join(",",list);
}
private void collectDatas(int[][] data,List<Integer> list){
for(int i = 0;i<10;i++){
collectData(data,i,list);
}
}
private void collectData(int[][] data,int row,List<Integer> list){
for (int j = 0;j<10;j++){
list.add(data[row][j]);
}
}
}
2. 拒绝使用else关键字。
重构前：
class App{
void action(int type){
if(type == 1){
action1();
}else{
action2();
}
}
void action1(){};
void action2(){};
}
重构后：
class App{
void action(int type){
if(type == 1){
action1();
return;
}
action2();
}
void action1(){};
void action2(){};
}
3. 封装所有的原生类型和字符串。
重构前：
public class User{
private String id;
private int age;
}
重构后:
public class User{
private Id id;
private Age age;
}
class Id{
private String value;
}
class Age{
private int value;
}
4. 一行代码只有一个“.”运算符。
重构前：
class User{
private Address address;
public Address getAddress{
return address;
}
}
class Address{
private String val;
public void setVal(String val){
this.val = val;
}
}
class App{
public void changeUserAddress(String userId,String address){
User user = userRepo.findById(userId);
user.getAddress().setVal(address);
userRepo.save(user);
}
}
重构后：
class Address{
private String val;
public void setVal(String val){
this.val = val;
}
}
class User{
private Address address;
public Address getAddress{
return address;
}
public void changeAddress(String address){
address.setAddress(address);
}
}
class App{
public void changeUserAddress(String userId,String address){
User user = userRepo.findById(userId);
user.changeAddress(address);
userRepo.save(user);
}
}
5. 不要使用缩写。
重构前：
class App{
void saveUAdd(Address address){};
}
重构后：
class App{
void saveUserAddress(Address address){};
}
6. 保持实体对象简单清晰。
- 这意味着每个类的长度都不能超过50行，每个包所包含的文件不超过10个。代码超过50行的类所做的事情通常都不止一件，这会导致它们难以被理解和重用。小于50行代码的类还有一个妙处：它可以在一屏幕内显示，不需要滚屏，这样程序员可以很容易、很快速地熟悉这个类。创建这样小的类会遇到哪些挑战呢？通常会有很多成组的行为，它们逻辑上是应该在一起的。这时就需要使用包机制来平衡。随着类变得越来越小，职责越来越少，加之包的大小也受到限制，你会逐渐注意到，包中的类越来越集中，它们能够协作完成一个相同的目标。包和类一样，也应该是内聚的，有一个明确的意图。保证这些包足够小，就能让它们有一个真正的标识。
7. 任何类中的实例变量都不要超过两个。
重构前：
class User {
private String nickName;
private String loginName;
private String address;
}
重构后：
class User {
private Name nickName;
private Name loginName;
private Address address;
}
class Name {
private String value;
}
class Address {
private String value;
}
8. 使用一流的集合。
重构前：
class User{
}
class App{
private List<User> users;
public void register(User user){
users.add(user);
}
}
重构后：
class User{
}
class App{
private Users users;
public void register(User user){
users.register(user);
}
}
class Users{
private List<User> users;
public void register(User user){
users.add(user);
}
}
9. 不使用任何Getter/Setter/Property。
- 参考4
