14章类型信息--注册工厂---instandceof与Class的等价性--反射

1、先定义一个工厂接口：Factory

//: typeinfo/factory/Factory.java
package typeinfo.factory;
public interface Factory<T> { T create(); } ///:~

2、再定义基类：

class Part {
  public String toString() {
    return getClass().getSimpleName();
  }
  static List<Factory<? extends Part>> partFactories =
    new ArrayList<Factory<? extends Part>>();
  static {
    // Collections.addAll() gives an "unchecked generic
    // array creation ... for varargs parameter" warning.
    partFactories.add(new FuelFilter.Factory());
    partFactories.add(new AirFilter.Factory());
    partFactories.add(new CabinAirFilter.Factory());
    partFactories.add(new OilFilter.Factory());
    partFactories.add(new FanBelt.Factory());
    partFactories.add(new PowerSteeringBelt.Factory());
    partFactories.add(new GeneratorBelt.Factory());
    Collections.addAll(partFactories, new GeneratorBelt.Factory());
  }
  private static Random rand = new Random(47);
  public static Part createRandom() {
    int n = rand.nextInt(partFactories.size());
    return partFactories.get(n).create();
  }
}

3、定义继承类：下面的Filter和Belt是分类标示（Filter：滤波器；fuel [fjʊəl]燃料；cabin  英['kæbɪn]客舱，船舱，Cabin Air 机舱空气）

class Filter extends Part {}


class FuelFilter extends Filter {
  // Create a Class Factory for each specific type:
  public static class Factory
  implements typeinfo.factory.Factory<FuelFilter> {
    public FuelFilter create() { return new FuelFilter(); }
  }
}


class AirFilter extends Filter {
  public static class Factory
  implements typeinfo.factory.Factory<AirFilter> {
    public AirFilter create() { return new AirFilter(); }
  }
}


class CabinAirFilter extends Filter {
  public static class Factory
  implements typeinfo.factory.Factory<CabinAirFilter> {
    public CabinAirFilter create() {
      return new CabinAirFilter();
    }
  }
}


class OilFilter extends Filter {
  public static class Factory
  implements typeinfo.factory.Factory<OilFilter> {
    public OilFilter create() { return new OilFilter(); }
  }
}


class Belt extends Part {}


class FanBelt extends Belt {
  public static class Factory
  implements typeinfo.factory.Factory<FanBelt> {
    public FanBelt create() { return new FanBelt(); }
  }
}


class GeneratorBelt extends Belt {
  public static class Factory
  implements typeinfo.factory.Factory<GeneratorBelt> {
    public GeneratorBelt create() {
      return new GeneratorBelt();
    }
  }
}


class PowerSteeringBelt extends Belt {
  public static class Factory
  implements typeinfo.factory.Factory<PowerSteeringBelt> {
    public PowerSteeringBelt create() {
      return new PowerSteeringBelt();
    }
  }
}

最后是测试类：

public class RegisteredFactories {
  public static void main(String[] args) {
    for(int i = 0; i < 10; i++)
      System.out.println(Part.createRandom());
  }
}

------------------instandceof与Class的等价性----------------------------

instanceOf或者isInstance（）保持了类型的概念，它指的是“你是这个类吗，或者你是这个类的派生类吗？”而如果用==比较实际的class对象，就没有考虑继承，他比较的就是，要么是这个确切的类型，或者不是

------------------------------------------反射机制------------------------------------

（总结：不管是class类的getMethods()，getConstructors()，getFields()方法，都是只有是public的才会取到，其他权限的，都取不到）

import java.lang.reflect.*;
import java.util.regex.*;
import static net.mindview.util.Print.*;


public class ShowMethods {
  public static void main(String[] args) {
    try {
      Class<?> c = Class.forName("ShowMethods");
      Method[] methods = c.getMethods();
      Constructor[] ctors = c.getConstructors();
      Field[] fields = c.getFields();
        for(Method method : methods){
         
            print(
              method.toString());
        }
        for(Constructor ctor : ctors){
         
            print(ctor.toString());
         
        }
        for(Field field:fields){
        print(field.toString());
        }
    } catch(ClassNotFoundException e) {
      print("No such class: " + e);
    }
  }
} 

下面是通过指定构造器，创建对象：（declared 报错 英[dɪ'kleəd] 美[dɪ'klɛrd]已声明的，声明的，已宣告的）

import java.lang.reflect.InvocationTargetException;


class Toy {
Toy() {
System.out.println("Creating Toy() object");
}
Toy(int i) {
System.out.println("Creating Toy(" + i + ") object");
}
public static void main(String[] args) {
try {
Toy.class.getDeclaredConstructor(int.class).newInstance(1);
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}