Java重构示例

最新推荐文章于 2024-05-09 12:43:24 发布
最新推荐文章于 2024-05-09 12:43:24 发布
阅读量446 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/mcyy568/blog/655193
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

1.尽量简洁

1.1重构前

if ( flag == 1 ){
    return true;
}
else{
    return false;
}

1.2重构后 

return flag == 1;

2.使用三位运算符

2.1重构前

if ( "Male".equals(gender) ) {
    return "Mr.";
}
else{
    return "Mrs.";
}

2.2重构后 

return "Male".equals(gender) ? "Mr." : "Mrs.";

3.使用常量替换硬编码

3.1重构前

for (int i = 0; i < 12; i++) {
    this.getDays(i);
    //skip...
}

3.2重构后 

int YEAR_MONTHS = 12;
for (int month = 0; month < Month.YEAR_MONTHS; month++) {
    this.getDays(month);
    //skip...
}

4.使用方法替换反复出现的表达式

4.1重构前

public boolean isStartAfter(Date date) {
    Calendar calendar = BusinessCalendar.getCalendar();
    calendar.setTime(date);
    int hour = calendar.get(Calendar.HOUR_OF_DAY);
    int minute = calendar.get(Calendar.MINUTE);
    
    return ((hour<fromHour) || ((hour==fromHour) && (minute<=fromMinute)));
  }


  public boolean includes(Date date) {
    Calendar calendar = BusinessCalendar.getCalendar();
    calendar.setTime(date);
    int hour = calendar.get(Calendar.HOUR_OF_DAY);
    int minute = calendar.get(Calendar.MINUTE);
    
    return (((fromHour<hour) || ((fromHour==hour) && (fromMinute<=minute))) && ( (hour<toHour) || ( (hour==toHour) && (minute<=toMinute))));
  }

4.2重构后 

private boolean tailGreatHead(int headHour, int headMinute, int tailHour, int tailMinute, boolean includeEqual) {
    boolean tailGreatHeadHour = (headHour < tailHour);
    boolean tailEqualHeadHour = (headHour == tailHour);
    boolean tailGreatHeadMinute = (headMinute < tailMinute);
    boolean tailEqualHeadMinute = (headMinute == tailMinute);

    boolean tailGreatEqualHeadMinute = tailGreatHeadMinute || includeEqual && tailEqualHeadMinute;

    return (tailGreatHeadHour || (tailEqualHeadHour && tailGreatEqualHeadMinute));
  }

  private boolean tailGreatHead(int headHour, int headMinute, int tailHour, int tailMinute) {
    return tailGreatHead(headHour, headMinute, tailHour, tailMinute, false);
  }

  private boolean tailGreatEqualHead(int headHour, int headMinute, int tailHour, int tailMinute) {
    return tailGreatHead(headHour, headMinute, tailHour, tailMinute, true);
  }

  public boolean isStartAfter(Date date) {
    Calendar calendar = BusinessCalendar.getCalendar();
    calendar.setTime(date);
    int hour = calendar.get(Calendar.HOUR_OF_DAY);
    int minute = calendar.get(Calendar.MINUTE);
    
    return this.tailGreatEqualHead(hour, minute, fromHour, fromMinute);
  }


  public boolean includes(Date date) {
    Calendar calendar = BusinessCalendar.getCalendar();
    calendar.setTime(date);
    int hour = calendar.get(Calendar.HOUR_OF_DAY);
    int minute = calendar.get(Calendar.MINUTE);
    
    return this.tailGreatEqualHead(fromHour, fromMinute, hour, minute) && this.tailGreatEqualHead(hour, minute, toHour, toMinute);
  }

5.及早结束非正常逻辑

5.1重构前

int count = 0;
if(taskList != null && !taskList.isEmpty()){

  //skip...

  return count;
} else {
  return count;
}

5.2重构后 

int count = 0;
if(taskList == null || taskList.isEmpty()){
  return 0;
}

//skip...

return count;

6.满足条件立即跳出循环

6.1重构前

public boolean contain(int year, Month month, int day) {
  boolean found = false;
  for (IPolyDate date : dateList) {
    if (date.same(year, month.getMonth(), day)) {
      found = true;
      break;
    }
  }

  return found;
}

6.2重构后 

public boolean contain(int year, Month month, int day) {
  for (IPolyDate date : dateList) {
    if (date.same(year, month.getMonth(), day)) {
      return true;
    }
  }

  return false;
}

7.使用表结构分离公共逻辑，避免重复（坚持DRY原则）

7.1重构前

public void testGetIntPart() throws Exception {
  assertEquals("0", digitTransform.getIntPart("0.01");
  assertEquals("1", digitTransform.getIntPart("1.2");
  assertEquals("1234", digitTransform.getIntPart("1234");
  assertEquals("1", digitTransform.getIntPart("1.01");
  assertEquals("0", digitTransform.getIntPart("0.01");
  assertEquals("11111", digitTransform.getIntPart("11111");
  assertEquals("1000", digitTransform.getIntPart("1000.11");
}

7.2重构后 

public void testGetIntPart() throws Exception {
   String[][] cases = new String[][] {{"0.01","0"},{"1.2","1"},
        {"1234","1234"},{"1.01","1"},{"0","0"},
        {"11111","11111"},{"1000.11","1000"}};

   for (int i = 0, len = cases.length; i < len; i++) {
       assertEquals(cases[i][1], digitTransform.getIntPart(cases[i][0]));
   }
}

8.分离变化参数，使用格式化方法

8.1重构前

public class ExceedMaxWeekIndexOfMonthException extends
    IndexOutOfBoundsException {

  private static final long serialVersionUID = 1L;

  public ExceedMaxWeekIndexOfMonthException(String message) {
    super(message);
  }

}

8.2重构后 

public class ExceedMaxWeekIndexOfMonthException extends
    IndexOutOfBoundsException {

  private static final long serialVersionUID = 1L;

  public ExceedMaxWeekIndexOfMonthException(int index, int maxCountOfWeekDay,
      Month month) {
    super(formatMessage(index, maxCountOfWeekDay, month));
  }

  private static String formatMessage(int index, int maxCountOfWeekDay,
      Month month) {
    return "Arguement index[" + index + "] exceeds max week index["
        + maxCountOfWeekDay + "] of month[" + month.toString() + "].";
  }

}

9.使用方法抽取公共逻辑

9.1重构前

public int getYear() {
  Calendar date = this.getCalendarDate();

  return date.get(Calendar.YEAR);
}

public int getMonth() {
  Calendar date = this.getCalendarDate();

  return date.get(Calendar.MONTH);
}

public int getDay() {
  Calendar date = this.getCalendarDate();

  return date.get(Calendar.DAY_OF_MONTH);
}

public int getHour() {
  Calendar date = this.getCalendarDate();

  return date.get(Calendar.HOUR_OF_DAY);
}

public int getMinute() {
  Calendar date = this.getCalendarDate();

  return date.get(Calendar.MINUTE);
}

public int getSecond() {
  Calendar date = this.getCalendarDate();

  return date.get(Calendar.SECOND);
}

public int getMillisSecond() {
  Calendar date = this.getCalendarDate();

  return date.get(Calendar.MILLISECOND);
}

9.2重构后 

private int get(int field) {
    Calendar date = this.getCalendarDate();

    return date.get(field);
  }

  public int getYear() {
    return this.get(Calendar.YEAR);
  }

  public int getMonth() {
    return this.get(Calendar.MONTH);
  }

  public int getDay() {
    return this.get(Calendar.DAY_OF_MONTH);
  }

  public int getHour() {
    return this.get(Calendar.HOUR_OF_DAY);
  }

  public int getMinute() {
    return this.get(Calendar.MINUTE);
  }

  public int getSecond() {
    return this.get(Calendar.SECOND);
  }

  public int getMillisSecond() {
    return this.get(Calendar.MILLISECOND);
  }

10.尽量使用已有的Java API

10.1重构前

protected String[] getConfigLocations() {
    String[] baseCfgs = this.getBaseCfgs();
    String[] extra = this.getExtraCfgs();
    if (extra != null && extra.length > 0) {
      int baseCfgLen = baseCfgs.length;
      int extraLen = extra.length;
      String[] cfgLocations = new String[baseCfgLen + extraLen];
      for(int i = 0; i < baseCfgLen; i++){
        cfgLocations[i] = baseCfgs[i];
      }

      for(int i = 0; i < extraLen; i++){
        cfgLocations[baseCfgLen + i] = extra[i];
      }
     
      return cfgLocations;
    } else {
      return baseCfgs;
    }
 }

10.2重构后 

protected String[] getConfigLocations() {
    String[] baseCfgs = this.getBaseCfgs();
    String[] extra = this.getExtraCfgs();
    if (extra != null && extra.length > 0) {
      int baseCfgLen = baseCfgs.length;
      int extraLen = extra.length;
      String[] cfgLocations = new String[baseCfgLen + extraLen;
      System.arraycopy(baseCfgs, 0, cfgLocations, 0, baseCfgLen);
      System.arraycopy(extra, 0, cfgLocations, baseCfgLen,
          extraLen;
     
      return cfgLocations;
    } else {
      return baseCfgs;
    }
}

11.使方法通用化

11.1重构前

public DayPart[] sortDayPart() {
  if (dayParts == null || dayParts.length == 0) {
    return dayParts;
  }
  List<DayPart> dayPartList = Arrays.asList(dayParts);

  Collections.sort(dayPartList, new Comparator<DayPart>() {
    public int compare(DayPart o1, DayPart o2) {
      if (o1.getIndex() < o2.getIndex()) {
        return -1;
      } else if (o1.getIndex() > o2.getIndex()) {
        return 1;
      } else {
        return 0;
      }
    }
  });

  return dayPartList.toArray(new DayPart[dayPartList.size()]);
}

11.2重构后 

public DayPart[] sortDayPart() {
  return this.sortDayPart(SortMode.ASC);
}

public DayPart[] sortDayPart(final SortMode sortMode) {
  if (dayParts == null || dayParts.length == 0) {
    return dayParts;
  }
  List<DayPart> dayPartList = Arrays.asList(dayParts);

  Collections.sort(dayPartList, new Comparator<DayPart>() {
    public int compare(DayPart o1, DayPart o2) {
      if (o1.getIndex() < o2.getIndex()) {
        return sortMode.isAsc() ? -1 : 1;
      } else if (o1.getIndex() > o2.getIndex()) {
        return sortMode.isAsc() ? 1 : -1;
      } else {
        return 0;
      }
    }
  });

  return dayPartList.toArray(new DayPart[dayPartList.size()]);
}

12.避免空语句

12.1重构前

public int getRemainMinutes(int hour, int minute) {
  int startHour = fromHour;
  int startMinute = fromMinute;
  if (this.fromAfterEqual(hour, minute)) {
    // ------from-------position------to--------
    ;//use default init value
  } else if (this.toAfterEqual(hour, minute)) {
    // ------from-------position------to--------
    startHour = hour;
    startMinute = minute;
  } else {
    // --------from-------to--------position-------
    startHour = toHour;
    startMinute = toMinute;
  }

  return this.getMinutes(startHour, startMinute, toHour, toMinute);
}

12.2重构后 

public int getRemainMinutes(int hour, int minute) {
  // --------from-------to--------position-------
  int startHour = toHour;
  int startMinute = toMinute;

  if (this.fromAfterEqual(hour, minute)) {
    // ------position------from-------to--------
    startHour = fromHour;
    startMinute = fromMinute;
  } else if (this.toAfterEqual(hour, minute)) {
    // ------from-------position------to--------
    startHour = hour;
    startMinute = minute;
  }

  return this.getMinutes(startHour, startMinute, toHour, toMinute);
}

13.公共逻辑后置

13.1重构前

public int getRemainMinutes(int hour, int minute) {
  if (this.fromAfterEqual(hour, minute)) {
    // ------position------from-------to--------
    return (toHour * 60 + toMinute) - (fromHour * 60 + fromMinute);
  } else if (this.toAfterEqual(hour, minute)) {
    // ------from-------position------to--------
    return (toHour * 60 + toMinute) - (hour * 60 + minute);
  }
  else {
    // --------from-------to--------position-------
    return 0; //(toHour * 60 + toMinute) - (toHour * 60 + toMinute);
  }
}

13.2重构后 

private int getMinutes(int startHour, int startMinute, int endHour, int endMinute) {
  int minutes = 0;
  minutes = (endHour * 60 + endMinute) - (startHour * 60 + startMinute);

  return minutes;
}

public int getRemainMinutes(int hour, int minute) {
  // --------from-------to--------position-------
  int startHour = toHour;
  int startMinute = toMinute;

  if (this.fromAfterEqual(hour, minute)) {
    // ------position------from-------to--------
    startHour = fromHour;
    startMinute = fromMinute;
  } else if (this.toAfterEqual(hour, minute)) {
    // ------from-------position------to--------
    startHour = hour;
    startMinute = minute;
  }

  return this.getMinutes(startHour, startMinute, toHour, toMinute);
}

14.公共逻辑前置

14.1重构前

private StringBuffer transformDialect(String intPart, String fracPart) {
  StringBuffer cn = new StringBuffer();

  if (isIntegerZero(intPart)) {
    return cn;
  }

  if (this.isFractionZero(fracPart)) {
// 无小数，增加附加信息(整)
    cn.append("元").append("整");
  } else {
// 有小数，增加附加信息(零)
    cn.append("元").append("零");
  }

  return cn;
}

14.2重构后 

private StringBuffer transformDialect(String intPart, String fracPart) {
  StringBuffer cn = new StringBuffer();

  if (isIntegerZero(intPart)) {
    return cn;
  }

  cn.append("元");
  if (this.isFractionZero(fracPart)) {
// 无小数，增加附加信息(整)
    cn.append("整");
  } else {
// 有小数，增加附加信息(零)
    cn.append("零");
  }

  return cn;
}

15.使用清晰的布尔型变量替换逻辑表达式

15.1重构前

public boolean tailGreatHead(int headHour, int headMinute, int tailHour,
      int tailMinute, boolean includeEqual) {

  return ((headHour < tailHour) || ((headHour == tailHour) && ((headMinute < tailMinute) || includeEqual && (headMinute == tailMinute))));
}

15.2重构后 

public boolean tailGreatHead(int headHour, int headMinute, int tailHour, int tailMinute, boolean includeEqual) {
  boolean tailGreatHeadHour = (headHour < tailHour);
  boolean tailEqualHeadHour = (headHour == tailHour);
  boolean tailGreatHeadMinute = (headMinute < tailMinute);
  boolean tailEqualHeadMinute = (headMinute == tailMinute);

  boolean tailGreatEqualHeadMinute = tailGreatHeadMinute || includeEqual && tailEqualHeadMinute;

  return (tailGreatHeadHour || (tailEqualHeadHour && tailGreatEqualHeadMinute));
}

16.减少重复计算

16.1重构前

if(list != null && list.size() > 0){
  for(int i = 0; i < list.size(); i++){
    //skip...
  }
}

16.2重构后 

if(list != null){
  for(int i = 0, len = list.size(); i < len; i++){
    //skip...
  }
}

17.何时需要何时创建

17.1重构前

public static Date parseDate(String date) throws ParseException {
  SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");

  if ((date == null) || (date.equals(""))) {
    return null;
  } 
  else {
    try {
      return formatter.parse(date);
    } catch (ParseException pe) {
      throw new ParseException(pe.getMessage(), pe.getErrorOffset());
    }
  }
}

17.2重构后 

public static Date parseDate(String date) throws ParseException {
  if ((date == null) || (date.equals(""))) {
    return null;
  } 
  else {
    try {
      SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
      return formatter.parse(date);
    } catch (ParseException pe) {
      throw new ParseException(pe.getMessage(), pe.getErrorOffset());
    }
  }
}

18.利用已有的计算结果

18.1重构前

public static final String DAY = "DAY";
public static final String MONTH = "MONTH";
public static final String YEAR = "YEAR";
public static final String HOUR = "HOUR";
public static final String MINUTE = "MINUTE";
public static final String SECOND = "SECOND";
public static final String WEEK = "WEEK";

public long toMilliseconds(String unit) {
  if (unit == null) {
    return 0L;
  } else if (unit.equals(SECOND)) {
    return 1 * 1000L;
  } else if (unit.equals(MINUTE)) {
    return 60 * 1000L;
  } else if (unit.equals(HOUR)) {
    return 60 * 60 * 1000L;
  } else if (unit.equals(DAY)) {
    return 24 * 60 * 60 * 1000L;
  } else if (unit.equals(WEEK)) {
    return 7 * 24 * 60 * 60 * 1000L;
  } else if (unit.equals(MONTH)) {
    return 30 * 24 * 60 * 60 * 1000L;
  } else if (unit.equals(YEAR)) {
    return 365 * 24 * 60 * 60 * 1000L;
  } else {
    return 0L;
  }
}

18.2重构后 

public class Unit {
  private static final long SECOND_MILLIS = 1000;
  private static final long MINUTE_MILLIS = 60 * SECOND_MILLIS;
  private static final long HOUR_MILLIS = 60 * MINUTE_MILLIS;
  private static final long DAY_MILLIS = 24 * HOUR_MILLIS;
  private static final long WEEK_MILLIS = 7 * DAY_MILLIS;
  private static final long MONTH_MILLIS = 30 * DAY_MILLIS;
  private static final long YEAR_MILLIS = 365 * DAY_MILLIS;
  private static final long CENTURY_MILLIS = 100 * YEAR_MILLIS;

  static Map<String, Unit> units = new HashMap<String, Unit>();

  public static final Unit SECOND = new Unit(SECOND_MILLIS, "SECOND");
  public static final Unit MINUTE = new Unit(MINUTE_MILLIS, "MINUTE");
  public static final Unit HOUR = new Unit(HOUR_MILLIS, "HOUR");
  public static final Unit DAY = new Unit(DAY_MILLIS, "DAY");
  public static final Unit WEEK = new Unit(WEEK_MILLIS, "WEEK");
  public static final Unit MONTH = new Unit(MONTH_MILLIS, "MONTH");
  public static final Unit YEAR = new Unit(YEAR_MILLIS, "YEAR");
  public static final Unit CENTURY = new Unit(CENTURY_MILLIS, "CENTURY");

  static {
    units.put(SECOND.name, SECOND);
    units.put(MINUTE.name, MINUTE);
    units.put(HOUR.name, HOUR);
    units.put(DAY.name, DAY);
    units.put(WEEK.name, WEEK);
    units.put(MONTH.name, MONTH);
    units.put(YEAR.name, YEAR);
    units.put(CENTURY.name, CENTURY);
  }

  private long millis;
  private String name;

  private Unit(long millis, String name) {
    this.millis = millis;
    this.name = name;
  }

  public long getMillis() {
    return millis;
  }

  public String getName() {
    return name;
  }

  public String toString() {
    StringBuffer buffer = new StringBuffer();
    buffer.append(this.getName());
    buffer.append("[");
    buffer.append(this.getMillis());
    buffer.append("]");
    return buffer.toString();
  }
}

public long toMilliseconds(Unit unit) {
  return unit.getMillis();
}

19.替换switch结构

19.1重构前

public boolean isLeap(int year) {
  return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

public static int getMonthDays(int year, int month) {
  int numberDays = 0;

  switch (month) {
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
      numberDays = 31;
      break;

    case 4:
    case 6:
    case 9:
    case 11:
      numberDays = 30;
      break;

    case 2:
      numberDays = isLeap(year) ? 29 : 28;
      break;
  }

  return numberDays;
}

19.2重构后 

public boolean isLeap(int year) {
  return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

private int getFebruaryDays(int year) {
  return this.isLeap(year) ? 29 : 28;
}

public int getMonthDays(int year, int month) {
  int[] months = new int[] { 31, this.getFebruaryDays(year), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

  return months[month];
}

20.避免对参数赋值

20.1重构前

public Date getStartTime(Date date) {
  date.setMinutes(fromMinute);
  date.setDate(fromHour);
  date.setDate(fromHour);
  date.setSeconds(0);

  return date;
}

20.2重构后 

public Date getStartTime(final Date date) {
  Calendar calendar = Calendar.getInstance();
  calendar.setTime(date);
  calendar.set(Calendar.HOUR_OF_DAY, fromHour);
  calendar.set(Calendar.MINUTE, fromMinute);
  calendar.set(Calendar.SECOND, 0);

  return calendar.getTime();
}

21.使用类替换类型代码

21.1重构前

public class LabelComparator implements Comparator, Serializable {

  private static final long serialVersionUID = 1L;

  public static final int ASC = 1;
  public static final int DESC = 2;

  private int sortType = ASC;

  public LabelComparator() {
  }

  public LabelComparator(int sortType) {
    this.sortType = sortType;
  }

  public int compare(Object o1, Object o2) {
    if (o1 == null && o2 == null) {
      return 0;
    }
    if (o1 == null) {
      return -1;
    }
    if (o2 == null) {
      return -1;
    }

    if (((Label) o1).getIndex() < ((Label) o2).getIndex()) {
      return (sortType == ASC) ? -1 : 1;
    } else if (((Label) o1).getIndex() > ((Label) o2).getIndex()) {
      return (sortType == ASC)  ? 1 : -1;
    } else {
      return 0;
    }
  }
}

21.2重构后 

public final class SortMode implements Serializable {

  private static final long serialVersionUID = 1L;

  private static final Map<String, SortMode> INSTANCES = new HashMap<String, SortMode>();

  private final int type;
  private final String name;

  private SortMode(int type, String name) {
    this.type = type;
    this.name = name;
  }

  public String toString() {
    return name;
  }

  public static final SortMode ASC = new SortMode(1, "ASC");

  public static final SortMode DESC = new SortMode(2, "DESC");

  static {
    INSTANCES.put(ASC.name, ASC);
    INSTANCES.put(DESC.name, DESC);
  }

  public boolean isAsc() {
    return ASC.type == this.type;
  }

  public boolean isDesc() {
    return DESC.type == this.type;
  }

  private Object readResolve() {
    return INSTANCES.get(name);
  }

  public static SortMode parse(String name) {
    return (SortMode) INSTANCES.get(name);
  }
  
  public boolean equals(Object obj) {
    if (obj instanceof SortMode) {
      SortMode that = (SortMode) obj;
        if (that.type == this.type) {
          return true;
        }
        return false;
    } else {
      return false;
    }
  }
}

public class LabelComparator implements Comparator, Serializable {

  private static final long serialVersionUID = 1L;
  public SortMode mode = SortMode.ASC;

  public LabelComparator() {
  }

  public LabelComparator(SortMode mode) {
    this.mode = mode;
  }

  public int compare(Object o1, Object o2) {
    if (o1 == null && o2 == null) {
      return 0;
    }
    if (o1 == null) {
      return -1;
    }
    if (o2 == null) {
      return -1;
    }

    if (((Label) o1).getIndex() < ((Label) o2).getIndex()) {
      return mode.isAsc() ? -1 : 1;
    } else if (((Label) o1).getIndex() > ((Label) o2).getIndex()) {
      return mode.isAsc() ? 1 : -1;
    } else {
      return 0;
    }
  }
}

22.使用对象封装参数

22.1重构前

public int getRemainMinutes(int hour, int minute, int fromHour, int fromMinute, int toHour, int toMinute) {
  // --------from-------to--------position-------
  int startHour = toHour;
  int startMinute = toMinute;
  
  if (this.fromAfterEqual(hour, minute)) {
    // ------position------from-------to--------
    startHour = fromHour;
    startMinute = fromMinute;
  } else if (this.toAfterEqual(hour, minute)) {
    // ------from-------position------to--------
    startHour = hour;
    startMinute = minute;
  }

  return this.getMinutes(startHour, startMinute, toHour, toMinute);
}

22.2重构后 

public class DayPart implements Serializable {

  int fromHour = -1;
  int fromMinute = -1;
  int toHour = -1;
  int toMinute = -1;

  public int getFromHour() {
    return fromHour;
  }

  public void setFromHour(int fromHour) {
    this.fromHour = fromHour;
  }

  public int getFromMinute() {
    return fromMinute;
  }

  public void setFromMinute(int fromMinute) {
    this.fromMinute = fromMinute;
  }

  public int getToHour() {
    return toHour;
  }

  public void setToHour(int toHour) {
    this.toHour = toHour;
  }

  public int getToMinute() {
    return toMinute;
  }

  public void setToMinute(int toMinute) {
    this.toMinute = toMinute;
  }
}

public int getRemainMinutes(int hour, int minute, DatePart datePart) {
  int fromHour = datePart.getFromHour();
  int fromMinute = datePart.getFromMinute();
  int toHour = datePart.getToHour();
  int toMinute = datePart.getToMinute();

  // --------from-------to--------position-------
  int startHour = toHour;
  int startMinute = toMinute;
  
  if (this.fromAfterEqual(hour, minute)) {
    // ------position------from-------to--------
    startHour = fromHour;
    startMinute = fromMinute;
  } else if (this.toAfterEqual(hour, minute)) {
    // ------from-------position------to--------
    startHour = hour;
    startMinute = minute;
  }

  return this.getMinutes(startHour, startMinute, toHour, toMinute);
}

23.封装集合操作

23.1重构前

public Class Group{

  private List<User> userList = new ArrayList<User>();

  public void setUserList(List<User> userList){
    this.userList = userList;
  }

  public List<User> getUserList(){
    return this.userList;
  }
}

23.2重构后 

public Class Group{

  private List<User> userList = new ArrayList<User>();

  public void setUserList(List<User> userList){
    this.userList = userList;
  }

  public List<User> getUserList(){
    return this.userList;
  }

  public void addUser(User user){
    this.getUserList().add(user);
    user.setGroup(this);
  }

  public void removeUser(User user){
    this.getUserList().remove(user);
    user.setGroup(null);
  }
}

24.避免一次性临时变量

24.1重构前

public int countWeekDay(Month month, WeekDay weekDay) {
  int count = 0;
  int[][] weeks = this.getDates()[month.getMonth()];
    for (int week = 0, weekLen = weeks.length; week < weekLen; week++) {
      int date = weeks[week][weekDay.getDay()];
      if (date > 0) {
        count++;
      }
    }

  return count;
}

24.2重构后 

public int countWeekDay(Month month, WeekDay weekDay) {
  int count = 0;
  int[][] weeks = this.getDates()[month.getMonth()];
  for (int week = 0, weekLen = weeks.length; week < weekLen; week++) {
    if (weeks[week][weekDay.getDay()] > 0) {
      count++;
    }
  }

  return count;
}

25.一个变量一种作用

25.1重构前

public IPolyDate getIndexWeekDay(Month month, int index, WeekDay weekDay) {
  int count = this.countWeekDay(month, weekDay);
  if (index > count) {
    throw new ExceedMaxWeekIndexOfMonthException("Arguement index[" + index + "] exceeds max week index[" + count + "] of month[" + month.toString() + "].");
  }

  count = 0;
  int[][] weeks = this.getDates()[month.getMonth()];
  for (int week = 0, weekLen = weeks.length; week < weekLen; week++) {
    int date = weeks[week][weekDay.getDay()];
    if (date > 0) {
      if (++count == index) {
        return new PolyDate(year, month.getMonth(), date);
      }
    }
  }

  return null;
}

25.2重构后 

public IPolyDate getIndexWeekDay(Month month, int index, WeekDay weekDay) {
  int maxCountOfWeekDay = this.countWeekDay(month, weekDay);
  if (index > maxCountOfWeekDay) {
    throw new ExceedMaxWeekIndexOfMonthException("Arguement index[" + index + "] exceeds max week index["+ maxCountOfWeekDay + "] of month[" + month.toString() + "].");
  }

  int count = 0;
  int[][] weeks = this.getDates()[month.getMonth()];
  for (int week = 0, weekLen = weeks.length; week < weekLen; week++) {
    int date = weeks[week][weekDay.getDay()];
    if (date > 0) {
      if (++count == index) {
        return new PolyDate(year, month.getMonth(), date);
      }
    }
  }

  return null;
}




转载于:https://my.oschina.net/mcyy568/blog/655193

weixin_34301132
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java编程中的性能提升问题
大鹏_James的专栏
04-21 1655
java编程中的性能提升   软件产品犹如一栋大楼，大楼在建设初期，会有楼房规划，建筑构想，打牢地基，后面才是施工人员进行进行实质性的建设。要保证软件产品的高质量，优秀的架构，优秀的产品设计，是产生高质量的前提。同时，没有过硬的编码实现，一样得不到预期的效果。纵观现在的产品，产品架构没多大差别，基本运用基线版本进行局点定制。而系统中的一些功能性能常常不过关，问题往往就出在编码实现上。这块是开发人
Java 代码重构实例
03-20
Java 代码 重构 实例 指南 ，欢迎下载
Java中的后台重构
qq_44688715的博客
09-03 158
Request public class Request{ private int AskNo; public void setAskNo(int AskNo){ this.AskNo = AskNo; } public int getAskNo(){ return AskNo; } private Map<String,String> params = new HashCode(); public void setParameter(String k, String v){
2024年最新【Java】代码重构时，为什么禁止在方法内对对象类型的入参赋值，10天拿到字节跳动Java岗位offer
最新发布
2401_84002294的博客
05-09 259
手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取禁止在方法内对对象类型的入参赋值（简单类型和string类型的入参允许赋值）。那么大多数初学者会有疑问，这个规范提出的主要意义是什么呢？本文就来探究这个规范背后的目的。引用传递和值传递。
Java代码重构学习笔记-重新组织数据
Logan_addoil的博客
05-10 1128
它的主要目的是通过使用 getter 和 setter 方法来访问类的私有属性，以提高代码的可维护性和灵活性。举个例子，假设有一个名为 Customer 的类，用于表示一个客户对象，该类包含了客户的姓名、地址等信息。现在需要在该类中添加一个新的属性，即客户的信用度 credit，但同时要限制信用度的范围在 0 到 100 之间，并且在修改信用度时要触发相应的事件通知。
Java中的重载、重写和重构的区别
热门推荐
pan_junbiao的博客
12-11 1万+
1、重载 重载（overloaded）：重载就是在同一个类中允许同时存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可。 我们知道构造方法的名称已经由类名决定，所以构造方法只有一个名称，但如果希望以不同的方式来实例化对象，就需要使用多个构造方法来完成。由于这些构造方法都需要根据类名进行命名，为了让方法名相同而形参不同的构造方法同时存在，必须用到“方法重载”，虽然方法重载起源于构造方...
Java重构示例一.docx
03-06
Java重构是一种重要的软件开发实践，旨在提升代码质量、可读性以及可维护性，而不会改变软件的功能。在本文中，我们将深入探讨四个常见的重构原则和技术，这些技术可以帮助开发人员优化他们的Java代码。 首先，我们...
Java重构示例五.pdf
10-08
总结来说，这个重构示例展示了以下几个重要的重构原则和技术： 1. **封装变化**：将变化的部分（如排序方式）封装到单独的类中，使其独立于其他代码。 2. **使用有意义的命名**：将整数值替换为具有描述性的枚举，...
Java 代码重构示例
09-26
Java代码重构示例 Java代码重构示例 Java代码重构示例 Java代码重构示例 Java代码重构示例 Java代码重构示例 Java代码重构示例
Java重构示例五[定义].pdf
10-11
总结来说，这个重构示例展示了如何通过创建一个新类（`SortMode`）来分离代码中的不同职责，提高了代码的可读性、可维护性和复用性。这种做法遵循了面向对象设计原则，如单一职责原则和开闭原则，使得代码更容易理解...
重构示例
02-13
2. **Java重构的基本原则**： - 小步前进：每次只做一小部分改动，确保每次重构后都能通过所有测试。 - 保留原有行为：重构时，必须确保修改后的代码与原代码在功能上保持一致。 3. **反射API简介**： - Java...
重构到设计模式的经典案例，超完美详细（java源码）
08-08
/* * 原始需求背景： * 网宿CDN要按月收取客户的服务费用，根据流量的大小、 * 服务的类型等，收取不同的费用，收费规则如下： * web应用：1000元/M * 流媒体应用：1000元/M*0.7 * 下载应用：1000元/M*0.5 * 月末打印报表时，要罗列每个用户每个频道的费用、客户总费用， * 还要打印该客户的重要性指数,重要性指数=网页流/100+下载流量/600； * * 需求变更场景： * 系统已经开发出来了，接下来，运维部门现在希望对系统做一点修改， * 首先，他们希望能够输出xml，这样可以被其它系统读取和处理，但是， * 这段代码根本不可能在输出xml的代码中复用report()的任何行为，唯一 * 可以做的就是重写一个xmlReport()，大量重复report()中的行为，当然， * 现在这个修改还不费劲，拷贝一份report()直接修改就是了。 * 不久，成本中心又要求修改计费规则，于是我们必须同时修改xmlReport() * 和report()，并确保其一致性，当后续还要修改的时候，复制-黏贴的问题就 * 浮现出来了，这造成了潜在的威胁。 * 再后来，客服部门希望修改服务类型和用户重要性指数的计算规则， * 但还没决定怎么改，他们设想了几种方案，这些方案会影响用户的计费规则， * 程序必须再次同时修改xmlReport()和report()，随着各种规则变得越来越复杂， * 适当的修改点越 来越难找，不犯错误的机会越来越少。 * 现在，我们运用所学的OO原则和方法开始进行改写吧。 */
java重构pdf书籍
04-01
主要是java的重构，为什么重构，以及怎么重构
重构 改善既有代码的设计(清晰版)
09-14
重构 改善既有代码的设计(清晰版)比JVM虚拟机的那个PDF清楚多了 里面的内容 代码加解释 很容易理解 对自己写代码帮助很大
重构--改善既有代码的设计_中文版
09-19
java开发经典书籍，重构--改善既有代码的设计_中文版 java开发经典书籍，重构--改善既有代码的设计_中文版 java开发经典书籍，重构--改善既有代码的设计_中文版
java代码重构经验总结
rdhj5566的专栏
05-09 1139
如果你看到了这种丢弃（而不是抛出)异常的情况，可以百分之九十九地肯定代码存在问题（在极少数情况下，这段代码有存在的理由，但最好加上完整的注释，以免引起别人误解)。5)这次总结的方式方法，经验形成文档，要求以后在工作中是随时做的，当增加功能时，修改bug时或复审代码时都应该想到是否将原有的代码重构，以提高系统的可复用性和可扩展性。3)重构完成后，向服务器提交代码时，需采用更保险的方法，将原文件备份为以***.class.20060809.jeff的文件，不能简单的覆盖，否则那是很危险的。
java代码重构的思路Java代码重构的几种模式
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
11-13 1107
Java代码重构的几种模式 Java代码的重构模式主要有三种：重命名方法重构模式、引入解释性变量重构模式、以查询取代临时变量重构模式重命名方法重构模式建议执行如下的步骤来完成：1.建立一个具有新名称的方法2.将旧方法的方法体复制进新方法3.讲旧方法的方法体修改为调用新方法4.将所有引用旧方法的地方修改为引用新方法5.删除...
5个重构原理示例
最佳 Java 编程
06-12 877
这篇文章介绍了重构真正的开源代码（ Gradle Modules Plugin ）时应用的五​​种（最著名的）重构原理。 语境 当我为Gradle Modules Plugin （PR ＃73 ） 单独编译 module-info.java ，我注意到了一些重构的潜力。 结果，我提交了问题＃79 ，后来又通过PR ＃88 （尚未合并）解决了该问题，在其中重构了代码。 事实证明，重构比...
一本介绍如何将现有的 Java 代码重构为 Kotlin 代码的书籍
02-21
3. 实用示例：书中通过大量的实际例子和案例，展示了如何将Java代码中的常见模式和功能无缝迁移到Kotlin，使读者能够直观地理解重构过程，并学会在实践中应用这些策略。 4. 最佳实践与经验分享：作者不仅提供技术性...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值