亚洲天堂福利视频,亚洲一级特黄无码片,亚洲精品高清视频

诅R��effective java》学习笔��C��

胡鹏 — Tue, 28 Jul 2009 12:30:00 GMT

�W�六�?在改写equals的时候请遵守通用规定
有一�U?#8220;值类”可以不要求改写equals�Ҏ��Q�类型安全枚丄��型，因�ؓ�c�d��安全枚�D�c�d��保证每一个��g��多只存在一个对象，所有对于这��L��c�而言�Q�Object的queals�Ҏ��{�同于逻辑意义上的equals�Ҏ��?br />
在改写equals�Ҏ��的时候，要遵循的规范�Q?nbsp;
        1�Q�自反性�?/span>对�Q意的引用值x,x.equals(x)一定是true
        2�Q�对�U�性�?/span>对于��L��的引用值x和y,当且仅当y.equals(x)�q�回true�Ӟ��x.equals(y)也一定返回true.
        3�Q�传递性�?/span>对于��L��的引用值x,y和z,如果x.equals(y)==true and y.equals(z)==true,so x.equals(z)==true.
        4�Q�一致性�?/span>对于��L��的引用值x和y,如果用于equals比较的对象信息没有被修改的话�Q�那么，多次调用x.equals(y)要么一致地�q�回true,要么一致地�q�回false.
        5�Q�非�I�性�?/span>对于��L��的非�I�引用值x,x.equals(null)一定返回false.

  自反性：要求一个对象必��ȝ��于其自��n。一个例子：你把该类的实例加入到一个集合中�Q�则该集合的contains�Ҏ��
��果断地告诉你，该集合不包含你刚刚加入的实例�Q?nbsp;

对称性：
例如�Q?br /> 　　　　　public final class CaseInsensitiveString{
           private String s;
           public CaseInsensitiveString(String s){
              if(s==null)   throw new NullPointerException();
              this.s=s;
           }
           public boolean equals(Object o){
              if(o instanceof CaseInsensitiveString)
                 return s.equalsIgnoreCase(((CaseInsensitiveString)o).s);
              if(o instanceof String)
                 return s.equalsIgnoreCase((String)o);
               return false;
            }
          }
调用�Q?br /> 　　　CaseInsensitiveString cis=new CaseInsensitiveString("Polish");
       String s="polish";
正如我们期望的：cis.equals(s)==true but s.equals(cis)==false
�q�就�q�反了对�U�性的原则�Q��ؓ了解册��个问题，只需把企图与String互操作的�q�段代码从equals�Ҏ��中去掉旧可以了．�q�样做之后，你可以重构代码，使他变成一条返回语句：
public boolean equals(Object o){
   return o instanceof CaseInsensitiveString && ((CaseInsensitiveString)o).s.equalsIgnoreCase(s);
}

传递�?/span>---卛_��果一个对象等于第二个对象�Q��ƈ且第二个对象又等于第三个对象�Q�则�W�一个对象一定等于第三个对象�?br /> 例如�Q?br />        public class Point{
           private final int x;
           private final int y;
           public Point(int x,int y){
                this.x=x;
                this.y=y;
          }
          public boolean equals(Object o){
             if(!(o instanceof Point))
             return false;
             Point p=(Point)o;
             return p.x==x&&p.y==y;
          }
     }
现在我们来扩展这个类�Q��ؓ一个点增加颜色信息�Q?br />    public class ColorPoint extends Point{
      private Color color;
      public ColorPoint(int x,int y,Color color){
          super(x,y);
          this.color=color;
      }
   }
分析�Q?equals�Ҏ��会怎么样呢�Q�如果你完全不提供equals�Ҏ��Q�而是直接从Point�l�承�q�来�Q�那么在equals座比较的时候颜色信息会被忽略掉。如果你�~�写一个equals�Ҏ��Q�只有当实参是另一个有色点�Q��ƈ且具有同��L��位置和颜色的时候，它才�q�回true:
       public boolean equals(Object o){
          if(!(o instanceof ColorPoint)) return false;
          ColorPoint cp=(ColorPoint)o;
          return super.equals(o) && cp.color==color;
       }
分析�Q�这个方法的问题在于�Q�我们在比较一个普通点和一个有色点�Q�以及反�q�来的情形的时候，可能会得��C��同的�l�果。前一�U�比较忽略了颜色信息�Q�而后一�U�比较��L��q�回false,因�ؓ实参的类型不正确。例如：
     Point p=new Point(1,2);
     ColorPoint cp=new ColorPoint(1,2,Color.RED);
然后�Q�p.equals(cp)==true but cp.equals(p)==false

修正�Q�让ColorPoint.equals在进�?#8220;混合比较”的时候忽略颜色信息：
   public boolean equals(Object o){
       if(!(o instanceof Point)) return false;
       if(!(o instanceof ColorPoint)) return o.equals(this);
       ColorPoint cp=(ColorPoint)o;
       return super.equals(o) && cp.color==color;
   }
�q�种�Ҏ��实提供了对�U��?但是却牺牲了传递�?
   ColorPoint p1=new ColorPoint(1,2,Color.RED);
   Point p2=new Point(1,2);
   ColorPoint p3=new ColorPoint(1,2,Color.BLUE);
此时�Q�p1.equals(p2)==true and p2.equals(p3)==true but p1.equals(p3)==false很显然违反了传递性。前两个比较不考虑颜色信息�Q�而第三个比较考虑了颜色信息�?/p>

�l�论�Q�要惛_��扩展一个可实例华的�cȝ��同时�Q�既要增加新的特征，同时�q�要保留equals�U�定�Q�没有一个简单的办法可以做到�q�一炏V�?span style="color: red">�Ҏ��"复合优于�l�承"�Q�这个问题还是有好的解决办法�Q�我们不让ColorPoint扩展Point�Q�而是在ColorPoint中加入一个私有的Point域，以及一个公有的视图�Ҏ��Q�此�Ҏ��q�回一个与该有�?点在同一位置上的普通Point对象�Q?br />     public class ColorPoint{
       private Point point;
       private Color color;
       public ColorPoint(int x,int y,Color color){
         point=new Point(x,y);
         this.color=color;
       }
       public Point asPoint(){
           return point;
       }

       public boolean equals(Object o){
           if(!(o instanceof ColorPoint)) return false;
           ColorPoint cp=(ColorPoint)o;
           return cp.point.equals.(point) && cp.color.equals(color);
       }
    }

注意�Q�你可以在一个抽象类的子�c�M��增加新的特征�Q�而不会违反equals�U�定�?/p>

一致�?
如果两个对象相等的话�Q�那么它们必��d��l�保持相�{�，除非有一个对象被修改了。由于可变对象在不同的时候可以与不同的对象相�{�，而非可变对象不会�q�样�Q�这个约定没有严格界定�?br />

非空�?没什么好说的�?/p>

1�Q��?=操作�W�检�?#8220;实参是否为指向对象的一个应�?#8221;。如果是的话�Q�则�q�回true�?br />        2�Q��用instanceof操作�W�检�?#8220;实参是否为正��的�c�d��”。如果不是的话，则返回false�?br />        3�Q�把实参转换到正��的�c�d��?br />        4�Q�对于该�c�M��每一�?#8220;关键�Q�significant�Q?#8221;域，��查实参中的域与当前对象中对应的域值是否匹�?br />      if (!(this.field == null ? o.field == null : this.equals(o.field)))
     //或者写�?if(!(this.field == o.field || (this.field != null && this.field.equals(o.field)))) 对于this.field和o.field通常是相同的对象引用�Q�会更快一些�?br />        return false;
     //比较下一个field
     //都比较完�?br />      return true;

5.最后还要确认以下事�?br />    5.1�Q�改写equals的同�Ӟ��L��Q�必��）要改写hashCode�Ҏ��Q�见【第8条】）�Q�这是极�Ҏ��被忽略的�Q�有极�ؓ重要�?br />    5.2�Q�不要企图让equals�Ҏ��q�于聪明
   5.3�Q�不要��用不可靠的资源。如依赖�|�络�q�接
   5.4�Q�不要将equals声明中的Object对象替换为其他类型�?br />          public boolean equals(MyClass) �q�样的声明�ƈ不鲜见，往外�ɽE�序员数��时搞不清楚��Z��么不能正常工�?br />          原因是这里是重蝲�Q�overload�Q�而�ƈ不是改写�Q�override�Q�（或称��盖、重写）
         相当于给equals又增加了一个实参类型�ؓMyClass的重载，而实参�ؓObject的那个equals�q�没有被改写�Q�依然还是从Object�l�承来的最初的那个equals�Q�所��L��看不到程序员惌��的效果。因为类库或其他人写的代码都是调用实参�ؓObject型的那个equals�Ҏ��的（别�h又如何在事前知晓你今天写的MyClass呢？�Q?br />

胡鹏 2009-07-28 20:30 发表评论

诅R��effective java》学习笔��C��

胡鹏 — Thu, 23 Jul 2009 11:31:00 GMT

该书介绍了在Java�~�程中极具实用�h值的�l�验规则�Q�这些经验规则涵盖了大多数开发�h员每天所面��的问题的解决�Ҏ��。通过对Java�q�_��设计专家所使用的技术的全面描述�Q�揭�C�Z��应该做什么，不应该做什么才能��生清晰、健壮和高效的代码�?br /> 每天下班��q��旉��学习下吧�Q�尽量在一个星期内把它看完�Q��ȝ��出来�Q�大多数内容都来自书上，个�h觉得该书不错的地�Ҏ��出来�?br />
�W�一条：考虑用静态工厂方法代替构造函�?br /> 静态工厂方�?优点)�Q?br /> 1.每次调用的时候，不一定要创徏一个新的对象，�q�个可以自由控制�?br /> 2.它可以返回一个原�q�回�c�d��的子�c�d��的对象�?br />

�W�二条：使用�U�有构造函数强化singleton属�?/span>
�W�一�U�：提供共有的静态final�?br />

public class Elvis{
public static final Elvis INSTANCE = new Elvis();
private Elvis(){

}

}

�W�二�U�：提供一个共有的静态工厂方�?/strong>

1public class Elvis{
2 private static final Elvis INSTANCE = new Elvis();
3 private Elvis(){
4
5 }
6
7 public static Elvis getInstance(){
8  return INSTANCE;
9 }
10
11}

�W�一�U�性能上会�E�微好些
�W�二�U�提供了灉|��性，在不改变API的前提下�Q�允许我们改变想法，把该�c�d��成singleton�Q�或者不做，�Ҏ��被修攏V�?/font>

注意点：��Z��使一个singleton�c�d��成克序列��q��(Serializable),仅仅在声明中加上implements Serializable是不够的�Q?br /> ��Z��l�护singleton性，必须也要提供一�?
private Object readResolve() throws ObjectStreamException{
return INSTANCE;
}

�W�三条：通过�U�有构造函数强化不可实例化的能�?/span>
只要让这个类包含单个昑ּ�的私有构造函敎ͼ�则它��׃��可被实例�?

1 public class UtilityClass{
2  private UtilityClass(){
3
4  }
5
6 }

企图通过��一个类做成抽象�c�L��强制该类不可被实例化�Q�这是行不通的。该�c�d��以被子类化，�q�且该子�c�M��可以被实例化�?br /> 更进一步，�q�样做会误导用户�Q�以��U�类是专门�ؓ了��承而设计的�?/p>

�W�四条：避免创徏重复的对�?/span>
String s = new Sting("silly");//�q�么恶心的代码就不要写啦。。�?/p>
1.静态工厂方法可几乎��L��优先于构造方�?Boolean.valueOf(...) > Boolean(...),构造函数每�ơ被调用的时候都会创��Z��个新的对象，
而静态工厂方法从来不要求�q�样做�?/p>
2.

public class Person {
    private final Date birthDate;

    public Person(Date date){
        this.birthDate = date;
    }

    //don't do this
    public boolean isBabyBoomer(){
        Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
        gmtCal.set(1946,Calendar.JANUARY,1,0,0,0);
        Date boomStart = gmtCal.getTime();
        gmtCal.set(1965,Calendar.JANUARY,1,0,0,0);
        Date boomEnd = gmtCal.getTime();
        return birthDate.compareTo(boomStart) >=0 && birthDate.compareTo(boomEnd) <0;
    }
}

isBabyBoomer每次被调用的时候，都会创徏一个新的Calendar�Q�一个新的TimeZone和两个新的Date实例。。�?/p>
下面的版本避免了�q�种低效率的动作�Q�代之以一个static 块初始化Calendar对象�Q�而且最体现效率的是�Q�他的生命周期只实例化一�ơCalendar�q�且�?br /> 80�q�_��90�q�的出生的��D��值给�c�静态变量BOOM_START和BOOM_END

class Person {
private final Date birthDate;

public Person(Date birthDate) {
  this.birthDate = birthDate;
}

private static final Date BOOM_START;
private static final Date BOOM_END;
static {
  Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
  gmtCal.set(1980, Calendar.JANUARY, 1, 0, 0, 0);
  BOOM_START = gmtCal.getTime();
  gmtCal.set(1990, Calendar.JANUARY, 1, 0, 0, 0);
  BOOM_END = gmtCal.getTime();
}

public boolean isBabyBoomer() {
  return birthDate.compareTo(BOOM_START) >= 0
    && birthDate.compareTo(BOOM_END) < 0;
}

胡鹏 2009-07-23 19:31 发表评论