[Java Basics2] Iterable, Socket, Reflection, Proxy, Factory DP

Parent interface of Collection: Iterable Interface

A class that implements the Iterable can be used with the new for-loop.

The Iterable interface has only one method:

public interface Iterable<T> {
  public Iterator<T> iterator();
}

It is possible to use your own collection type classes with the new for-loop. To do so, your class must implement thejava.lang.Iterable<E> interface. Here is a very basic example:

public class MyCollection<E> implements Iterable<E>{

    public Iterator<E> iterator() {
        return new MyIterator<E>();
    }
}

And here is the corresponding implementation skeleton of the MyIterator class:

public class MyIterator <T> implements Iterator<T> {

    public boolean hasNext() {

        //implement...
    }

    public T next() {
        //implement...;
    }

    public void remove() {
        //implement... if supported.
    }
}

迭代器应用：
 list l = new ArrayList();
 l.add("aa");
 l.add("bb");
 l.add("cc");
 for (Iterator iter = l.iterator(); iter.hasNext();) {
  String str = (String)iter.next();
  System.out.println(str);
 }

Java sockets

A socket is one end-point of a two-way communication link between two programs running on the network. Socket classes are used to represent the connection between a client program and a server program. The java.net package provides two classes--Socket and ServerSocket--that implement the client side of the connection and the server side of the connection, respectively.

总： Client[port] <----->Server[listening port, communication port] ，

Server side: ServerSocket serverSocket = new ServerSocket(5000);  //Server will be listening to requests from clients on port 5000

Client side: Socket chatSocket = new Socket("192.1.168.100", 5000);  //The server is running on port 5000 at 192.1.168.100

Socket sock = serverSocket.accept();  //Server will return a new port to communicate with clients

InputStreamReader reader = new InputStreamReader(chatSocket.getInputStream());

BufferedReader breader = new BufferedReader(reader);

String msg = breader.readLine();

Reflection

1, Get Class: 如果compile time已知class，那可以A.class。如果runtime才知class name，那可以Class.forName("className");

Get Class以后就可以获取这个Class的所有信息，例如.getMethods(), .getConstructors(), .getInterfaces(), .getFields(), .getAnnotations()...

2, Get constructor以后可以Instantiate object：

Constructor constructor=A.class.getConstructor(String.class);

A a= (A) constructor.newInstance("StringArgument");

3, Get fields以后可以get 或set object里的这个field:

Field someField = A.class.getField("FieldName");  //.getField()方法只能获取public fields

A a = new A();

Object value = someField.get(a);

someField.set(a, value);

4,Get method以后可以invoke这个method on some object:

Method method = A.class.getMethod("MethodName", String.class);  //.getMethod()方法只能获取public methods

Object returnValue = method.invoke(new A(), "StringArgument");

5, Get private field/method

Field privateField = A.class.getDeclaredField("FieldName");  //or .getDeclaredMethod("MethodName");

privateField.setAccessible(true);

Object fieldValue = privateField.get(new A());

6, Get annotations

Annotations可以是在class上，或者method, field, parameter上...

在定义自己的@interface的时候，如果@Retention(RetentionPolicy.RUNTIME)表示在runtime时可以获取这个annotation.

Annotation annotation = A.class.getAnnotation(MyAnnotation.class);

if(annotation instanceof MyAnnotation) {annotation.getName();...}

Proxy

To create dynamic implementations of interface at runtime with the help of reflection.

InvocationHandler handler = new MyInvocationHandler(); //implement .invoke()方法

MyInterface proxy = (MyInterface) Proxy.newProxyInstance(MyInterface.class.getClassLoader(), new Class[] {MyInterface.class}, handler);

links

http://tutorials.jenkov.com/java-concurrency/blocking-queues.html

http://www.slideshare.net/JAX_London/java-core-understanding-the-disruptor-a-beginners-guide-to-hardcore-concurrency-trisha-gee-mike-barker

http://facultyfp.salisbury.edu/despickler/personal/Resources/AdvancedDataStructures/Handouts/AVL_TREES.pdf

https://www.google.co.uk/webhp?sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8#ie=UTF-8&q=CAS%20operations&sourceid=chrome-psyapi2

http://docs.oracle.com/javase/tutorial/essential/io/file.html

http://stackoverflow.com/questions/19966662/java-memory-model-and-final-fields

Factory design pattern

简单工厂模式就是客户选择一个工厂来生产不同区域的产品，The Simple Factory isn’t actually a Design Pattern; it’s more of a programming idiom.

由一个工厂来生产不同区域的产品，当区域太多时逻辑就变很多，所以工厂方法模式就是出现多个工厂来生产对应区域的不同类型的产品，所以这里有抽象工厂和具体工厂的分别。

例子：(Abstract class)PizzaStore-->(Sub classes)ItalyPizzaStore, SpainPizzaStore, SwedenPizzaStore...

defined orderPizza() method                    defined different details of createPizza() method to make ItalianStylePizza...

The Factory Method Pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

Examples：java.util.ResourceBundle#getBundle(), java.util.Calendar#getInstance().

对于抽象工厂，Abstract factory记住，Product interface->Product1, Product2..., Factory Interface->Factory1, Factory2, ...These factories will produces different combinations of products, so the abstract factory will return you the correct Factory# to use.

抽象工厂的区别是这里不只有一种产品(前面的pizza)，还有薯条，比如具体工厂A生产芝士皮萨配细薯条， 工厂B生产西兰花皮萨配粗薯条。所以产品方面会有多个:抽象产品Pizza&Fries，具体产品CheesePizza_BroccoliPizza & ..。

An Abstract Factory gives us an interface for creating a family of products. By writing code that uses this interface, we decouple our code from the actual factory that creates the products. That allows us to implement a variety of factories that produce products meant for different contexts—such as different regions, different operating systems, or different look and feels.

This pattern separates the details of implementation of a set of objects from their general usage and relies on object composition, as object creation is implemented in methods exposed in the factory interface.

多个抽象产品，多个抽象factory，一个factory producer class。

• javax.xml.parsers.DocumentBuilderFactory#newInstance()

• javax.xml.transform.TransformerFactory#newInstance()

• javax.xml.xpath.XPathFactory#newInstance()

Advantage:

• Factory methods eliminate the need to bind application-specific classes into your code.
• The code only deals with the product interfaces; therefore, it can work with any user-defined concrete product classes.
• Factory methods provide hooks for sub-classes to create different concrete products. In the example below, the Factory method MakeUISpecificCtrls provides the hook for creating the UI component specific controls. In the default CUIComponent, a simple edit control is created; however, we can change this behavior in the derived class to create an edit control which accepts only floating point values.
• Factory methods connect parallel class hierarchies in such a way that it localizes the knowledge of which classes belong together. In the example below, the CUIComponent and CEditCtrl class hierarchies can be connected with each other. Also notice how the Factory method defines the connection between the two class hierarchies.

Disadvantage:

• A potential disadvantage of Factory methods is that clients might have to sub-class the creator class just to create a particular concrete product object.
• Subclassing is fine when the client has to subclass the creator class anyway, but otherwise, the client now must deal with another point of evolution.
• In Factory Method pattern, the factory used for creating the objects is bound with the client code, i.e., it is difficult to use a different factory for creating objects.

Java runtime exception & checked exception

Runtime: NullPointerException, IndexOutOfBoundException, ArithmeticException(除0), ClassCastException, IllegalArgumentException.

CheckedException: 除了以上的这几个runtime的，其余都是checked，例如IOException, ClassNotFoundException, SQLException...

Clone() method:

When the clone method is invoked upon an array, it returns a reference to a new array which contains (or references) the same elements as the source array.

　　int[] a = {1,2,3};
    int[] b = a.clone();
    System.out.println(a == b ? "Same Instance":"Different Instance");
    //Outputs different instance

If were to modify int[] b the changes would not be reflected on int[] a since the two are separate object instances. This becomes slightly more complicated when the source array contains objects. The clone method will return a reference to a new array, which references the same objects as the source array.

　　Dog[] myDogs = new Dog[2];
    myDogs[0] = new Dog("Wolf");
    myDogs[1] = new Dog("Pepper");

Dog[] myDogsClone = myDogs.clone();

System.out.println(myDogs[0] == myDogsClone[0] ? "Same":"Different"); //same

myDogsClone[0].setName("Ruff"); System.out.println(myDogs[0].getName()); //Outputs Ruff, However, changes to the array itself will only affect that array.

所以对于只包含primitive type的array, clone()就直接返回一个新的object，里面的内容和原object没关系。但如果原array里包含的是Object, 那么新的array Object里包含的是指向同一些objects的reference, 所以对新array里elements做修改会影响原array的Object。