EffecJava Method

坚持使用Overrider注解，可以预防我们并没有重载的情况出现。

除非使用者绝对安全，不然使用保护性拷贝，可以使程序安全。

public class Period {//没有拷贝安全
    private final Date start;
    private final Date end;

    public Period(Date start, Date end) {
        if (start.compareTo(end) > 0) {
            throw new IllegalArgumentException("开始时间比结束时间晚");
        }

        this.start = start;
        this.end = end;

    }

    public Date getStart() {
        return this.start;
    }

    public Date getEnd() {
        return this.end;
    }
}

public class PeriodProtect {
    private final Date start;
    private final Date end;

    public PeriodProtect(Date start, Date end) {//使用了保护性拷贝，保证安全
        this.start = new Date(start.getTime());
        this.end = new Date(end.getTime());

        if (this.start.compareTo(this.end) > 0) {//先拷贝后检查，是因为防止一个叫TOCTOU的一种漏洞攻击。
            throw new IllegalArgumentException("开始时间比结束时间晚");
        }
    }

    public Date getStart() {
        return this.start;
    }

    public Date getEnd() {
        return this.end;
    }
}

public class Test {

    public static void main(String[] args) {
      Date start = new Date();
      try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
      Date end  = new Date();

      Period p =  new Period(start, end);
      PeriodProtect pro = new PeriodProtect(start, end);

      end.setYear(88);

      Date d = p.getEnd();
      Date dp =  pro.getEnd();

      System.out.println(d);//输出  Sat Aug 20 21:04:56 CDT 1988 ，没有保护性拷贝，会根据修改end的参数被修改period里面的值，比较不安全。
      System.out.println(dp);//会正确输出Sat Aug 20 21:04:56 CDT 2018，使用了拷贝安全之后就能够保证不会被篡改。
    }
}

重载（Overload）和覆盖（Overrider）

public class CollectionClassfier {//测试重载Overloded，在Overloading的时候是编译时选择，所以会是选择collection
    public static String classfier(List<?> list) {
        return "list";
    }

    public static String classfier(Set<?> set) {
        return "set";
    }

    public static String classfier(Collection<?> col) {
        return "collection";
    }

    public static void main(String[] args) {
        Collection<?>[] col = { new ArrayList<String>(), new HashMap<String, String>().values(),
                new HashSet<String>() };

        for (Collection<?> c : col) {
             System.out.println(classfier(c));
        }
/*        输出
        collection
        collection
        collection
*/
    }

}

//////////////////////////////////////////测试覆盖//////////////////////////////////

public class Wine {
    String name() {
        return "Wine";
    }
}

public class BWine extends Wine{
      @Override
      String name(){
          return "BWine";
      }
}

public class CWine extends BWine {
    @Override
    String name() {
    return "CWine";
    }
}

public class TestForOverride {//测试覆盖

    public static void main(String[] args) {
        Wine[] wine = {new Wine(),new BWine(),new CWine()};
        for(Wine w:wine){
         System.out.println(w.name());
        }
    }
}
/*输出
 * Wine
   BWine
   CWine

 * */

会发现在第一个例子里面，使用的是重载，而重载是在编译时就选择好方法，在for循环中使用了Collection<?> c，所以之后执行的方法也是在选择重载的Collection，

而在覆盖中Wine w:wine，即使我们传入的是Wine，因为覆盖是在程序运行时确定，所以，可以正确识别我们需要执行的方法。

一个关于List 重载的小陷阱

public class SetList {

    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<Integer>();
        List<Integer> list = new ArrayList<Integer>();
        for (int i = -3; i < 3; i++) {
            set.add(i);
            list.add(i);
        }
        for (int i = 0; i < 3; i++) {
            set.remove(i);//这里是renmove object
            list.remove(i);//这里是remove index
        }
        System.out.println(list + "   " + set);

    }
/*
 *
 * 输出
 * [-2, 0, 2]   [-3, -2, -1]
 *
 *
 * */
}

我们想要在数组[-3,-2,-1,0,1,2]中剔除[0,1,2]这三个数值，然而set成功了list却失败了。原因是因为，在java引入了自动封装后，我们可以在set里面直接传入 int类型数值，java会自动封装成Integer类型，而list却不会，因为list的remove有两种，一种是remove（object o），一种是 remove（int index），我们传入的是int，他会执行的是remove（int index），第一次执行remove（0），剔除-3 变成[-2,-1,0,1,2]，第二次remove（1），变成[-2,0,1,2]，第三次remove（2）变成[-2, 0, 2] ，如果想要remove对应对象，要把int变成Integer。