Coding Notes 1
Builder Pattern
The intention is to abstract steps of construction of objects so that different implementations of these steps can construct different representations of objects.
Usage
The client calls a constructor (or static factory) with all of the required parameters and gets a builder object. Then the client calls setter-like methods on the builder object to set each optional parameter of interest. Finally, the client calls a parameter-less build method to generate the object, which is immutable.
NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8).
calories(100).sodium(35).carbohydrate(27).build();
The Builder pattern is a good choice when designing classes whose constructors or static factories would have more than a handful of parameters, especially if most of those parameters are optional.
Telescoping constructor pattern
Provide a constructor with only the required parameters, another with a single optional parameter, a third with two optional parameters, and so on, culminating in a constructor with all the optional parameters.
Disadvantages:
Long sequences of identically typed parameters can causesubtle bugs.
JavaBeans constructor pattern
Disadvantages:
It allows inconsistency, mandates mutability
Factory pattern is typically used to create an object in a single step.
If you need to create an object in multiple steps, and those steps may change (some times you may want to ignore some steps), in this case you would use the builder pattern.
Method chaining enables terser and more natural interaction with objects.
To achieve this, return this in method such as setter instead of return void.
toast.makeText(text).setGravity(Gravity.TOP,
0, 0).setView(layout).show();
Status transition
private static final String[] STATUS = new String[] { // used in toString()
"STATUS1",
"STATUS2",
"STATUS3",
"STATUS4",
};
private static final boolean STATUS_CONVERTIBLE[][] = new boolean[][] {
/*********** STATUS1 STATUS2 STATUS3 STATUS4 */
/* STATUS1 */{ false, true, true, true},
/* STATUS2 */{ false, false, true, true},
/* STATUS3 */{ false, false, false, true},
/* STATUS4 */{ false, false, false, false}};
public boolean accept(int newStatus)
{
return STATUS_CONVERTIBLE[this.status][newStatus];
}
Use ByteArray Stream to deep clone object
Sometimes we want to create a deep clone object, but we don't want to implement the class's clone method, maybe this way we have to implement clone method in many classes.
In this situation, we can use stream to create a new same object.
public class DeepClone
{
public static void main(String[] args) throws IOException, ClassNotFoundException
{
Student ra = new Student("Jane", 20);
byte[] resultBtye = serialize(ra);
Student rb = (Student) deserialize(resultBtye);
System.err.println("ra == rb: " + (ra == rb)); // false
System.err.println(ra.name.equals(rb.name)); // true
System.err.println(ra.age == rb.age); // true
}
private static byte[] serialize(Object o) throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(o);
return baos.toByteArray();
}
private static Object deserialize(byte[] data) throws IOException, ClassNotFoundException
{
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
}
}
class Student implements Serializable
{
private static final long serialVersionUID = 1L;
public String name;
public int age;
public Student(String name, int age)
{
this.name = name;
this.age = age;
}
}
Interface Names
public interface Closeable {
public void close() throws IOException;
}
