<rt id="bn8ez"></rt>
<label id="bn8ez"></label>
  • 

    • <span id="bn8ez"></span>
    

    <label id="bn8ez"><meter id="bn8ez"></meter></label>
    

    
    

    




    







												


        

    
	

    Vincent.Chan‘s Blog
    

    

    


    
	
		

    常用鏈接
    

		

    統計
    
	
		

    積分與排名
    


		
		
    網站
    
		
				
			
	

		

    最新評論
	
    

		
	

    

    
	
					
	
    
		
    
			《Effective Java》Chapter 2
		
    
		Chapter 2. Creating and Destroying Objects

    Item 1: Consider providing static factory methods instread of constructs
    eg. A static factory method from the class Boolean, which translates a boolean primitive value into a Booleam object reference:
    

    public static Boolean valueOf(boolean b) {
            return (b ? Boolean.TRUE : Boolean.FLASE);
    }
    Advantages:
    a) unlike constructors, they have names.
    b) unlike constructors, they are not required to create a new object each time they're invoked.
    c) unlike constructors, they can return an object of any subtype of their return type.     (Atten plz: in JDK 5.0, there is Covariant Return Types)
    Disadvantages:
    a) classes without public or protected constructors cannot be subclassed.
    b) they are not readily distinguishable from other static methods.
       two names for static factory methods are becoming common:
          valueOf --- Return an instance that has, loosely speaking, the same value as its parameters.
          getInstance --- Return an instance that is described by its parameters but cannot be said to have the same value.

    Item 2: Enforce the singleton property with a private constructor
    One approach, the public static member is a final field:
    

    // Singleton with final field
    public class Elvis {
            public static final Elvis INSTANCE = new Elvis();
        
            private Elvis() {
            
        }
        
             // Remainder omitted
    }
    A second approach, a public static factory method is provided instead of the public static final field:
    

    // Singleton with static factory
    public class Elvis {
            private static final Elvis INSTANCE = new Elvis();
        
            private Elvis() {
            
        }
        
            public static Elvis getInstance() {
                return INSTANCE;
        }
        
             // Remainder omitted
    }

    Item 3: Enforce noninstantiability with a private constructor
    Attemping to enforce noninstantiablity by making a class abstract does not work.
    A class can be made noninstantiable by including a single explicit private constructor:
    

    // Noninstantiable utility class
    public class UtilityClass {
        
            // Suppress default constructor for noninstantiability
        private UtilityClass() {
                // This constructor will never be invoked
        }
        
             // Remainder omitted
    }

    Item 4: Avoid creating duplicate objects
    An object can always be reused if it is immutable.
    As an extreme example of what not to do:  

    String s = new String("silly"); // DON'T DO THIS!
    The improving version is simply the following:  

    String s = "No longer silly"
    You can often avoid creating duplicate objects by using static factory methods (Item 1) in preference to constructors on immutable classes that provide both.
    

    public class Person {
            private final Date birthDate;

            // Other fields omitted
        public Person(Date birthDate) {
                this.birthDate = birthDate;
        }

            // 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;
        }
    }
    The isBabyBoomer method unnecessarily creates a new Calendar, TimeZone, and two Date instances each time it is invoked. The version that follows avoids this inefficiency with a static initializer:
    

    class Person {
            private final Date birthDate;

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

            /**
         * The starting and ending dates of the baby boom.
             */
            private static final Date BOOM_START;

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

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

    Item 5: Eliminate obsolete object reference
    

    // Can you spot the "memory leak"?
    public class Stack {
            private Object[] elements;

            private int size = 0;

            public Stack(int initialCapacity) {
                this.elements = new Object[initialCapacity];
        }

            public void push(Object e) {
            ensureCapacity();
            elements[size    ++] = e;
        }

            public Object pop() {
                if (size == 0)
                    throw new EmptyStackException();
                return elements[--size];
        }

            /**
         * Ensure space for at least one more element, roughly doubling the capacity
         * each time the array needs to grow.
             */
            private void ensureCapacity() {
                if (elements.length == size) {
                Object[] oldElements     = elements;
                elements     = new Object[2 * elements.length + 1];
                System.arraycopy(oldElements,     0, elements, 0, size);
            }
        }
    }
    If
a stack grows and then shrinks, the objects that were popped off the
stack will not be garbage collected, even if the program using the
stack has no more references to them. This is because the stack
maintains obsolete references to these objects.
    

    public Object pop() {
            if (size==0)
                throw new EmptyStackException();
        Object result     = elements[--size];
        elements[size]     = null; // Eliminate obsolete reference
        return result;
    }

    Item 6: Avoid finalizers
    Nothing time-critical should ever be done by a finalizer.
    You should never depend on a finalizer to update critical persistent state.
    Explicit termination methods are often used in combination with the try-finally construct to ensure prompt termination.
    

    Foo foo = new Foo();
    try {
            // Do what must be done with foo
        
    }     finally {
        foo.terminate();     // Explicit termination method
    }
    It is important to note that “finalizer chaining” is not performed automatically. If a class (other than Object) has a finalizer and a subclass overrides it, the subclass finalizer must invoke the superclass finalizer manually.
    

    // Manual finalizer chaining
    protected void finalize() throws Throwable {
            try {
                // Finalize subclass state
            
        }     finally {
                super.finalize();
        }
    }
    Instead
of putting the finalizer on the class requiring finalization, put the
finalizer on an anonymous class (Item 18) whose sole purpose is to
finalize its enclosing instance. A single instance of the anonymous
class, called a finalizer guardian, is created for each instance of the enclosing class.
    

    // Finalizer Guardian idiom
    public class Foo {
            // Sole purpose of this object is to finalize outer Foo object
        private final Object finalizerGuardian = new Object() {
                protected void finalize() throws Throwable {
                    // Finalize outer Foo object
                
            }
        }    ;
             // Remainder omitted
    }
    
		
    
			posted on 2006-02-18 18:31 Vincent.Chen 閱讀(175) 評論(0)  編輯  收藏  所屬分類: Java 
		
    
	
    
	
	


	


    
	    
    




    








    

				

    




    







    
        
	



主站蜘蛛池模板：
亚洲色偷偷偷综合网|
亚洲av网址在线观看|
a级毛片视频免费观看|
亚洲男女内射在线播放|
一级人做人爰a全过程免费视频|
无限动漫网在线观看免费|
亚洲AV成人一区二区三区观看|
中文字幕在亚洲第一在线|
亚洲sm另类一区二区三区|
在线播放亚洲第一字幕|
av无码国产在线看免费网站
|
亚洲自偷精品视频自拍|
永久免费bbbbbb视频|
亚洲中文字幕乱码熟女在线|
亚洲综合色在线观看亚洲|
青青青国产在线观看免费网站|
一级特黄录像免费播放中文版|
亚洲图片校园春色|
亚洲综合在线另类色区奇米|
最新中文字幕电影免费观看|
13小箩利洗澡无码视频网站免费|
亚洲熟妇AV一区二区三区浪潮
|
亚洲免费观看视频|
永久在线毛片免费观看|
美女内射无套日韩免费播放|
亚洲综合日韩中文字幕v在线|
免费一级毛片在级播放|
无码日韩人妻AV一区免费l|
亚洲乱码一二三四五六区|
亚洲精品乱码久久久久66|
天黑黑影院在线观看视频高清免费
|
亚洲日本韩国在线|
成熟女人牲交片免费观看视频|
中文字幕在线免费看线人|
国产偷国产偷亚洲高清人|
亚洲第一区精品日韩在线播放|
巨胸狂喷奶水视频www网站免费|
亚洲成a∨人片在无码2023|
亚洲色欲色欲www|
亚洲视频一区在线|
久久亚洲精品AB无码播放|