Book09-No.14 部类信息
Book09-No.14 类型信息
1、创建Class对象:每个类都有一个Class对象
Class<?> classType = Class.forName("包.类名"); //在创建class对象的时候，初始化了类
或者
Class<?> classType = 类名.class; //没有初始化类
2、通过Class创建实例对象：
Class<T> classType = Class.forName("包.类名");
T obj = classType.newInstrance();
3、PetCount代码：
package Part14;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Random;
import java.util.Map.Entry;
public class PetCount {
private static class PetCounter extends HashMap<String, Integer> {
/**
*
*/
private static final long serialVersionUID = 1L;
public void count(String type) {
Integer index = this.get(type);
if(index == null) {
this.put(type, 1);
} else {
this.put(type, index + 1);
}
}
}
public static void countPets(PetCreator creator) {
PetCounter petCounter = new PetCounter();
for(Pet pet : creator.createArray(50)) {
if(pet instanceof Pet) {
petCounter.count("Pet");
}
if(pet instanceof Dogs) {
petCounter.count("Dogs");
}
if(pet instanceof Mutt) {
petCounter.count("Mutt");
}
if(pet instanceof Pug) {
petCounter.count("Pug");
}
if(pet instanceof Hamster) {
petCounter.count("Hamster");
}
if(pet instanceof Mouse) {
petCounter.count("Mouse");
}
if(pet instanceof Rat) {
petCounter.count("Rat");
}
if(pet instanceof Rodent) {
petCounter.count("Rodent");
}
if(pet instanceof Cymrix) {
petCounter.count("Cymrix");
}
if(pet instanceof Manx) {
petCounter.count("Manx");
}
if(pet instanceof Egy) {
petCounter.count("Egy");
}
if(pet instanceof Cat) {
petCounter.count("Cat");
}
}
System.out.println(petCounter);
}
public static void main(String[] args) {
countPets(new ForNameCreator());
countPets(Pets.creator);
}
}
class PetCount2 {
private static class PetCounter extends LinkedHashMap<Class<? extends Pet>, Integer> {
public PetCounter() {
map(LiteralPetCreator.allTypes, 0);
}
public void count(Pet pet) {
for(Entry<Class<? extends Pet>, Integer> pair : this.entrySet()) {
if(pair.getKey().isInstance(pet)) {
put(pair.getKey(), pair.getValue() + 1);
}
}
}
public void map(List<Class<? extends Pet>> list, Integer value) {
for(Class<? extends Pet> key : list) {
put(key, value);
}
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("{");
for(Entry<Class<? extends Pet>, Integer> pair : this.entrySet()) {
sb.append(pair.getKey().getSimpleName()).append("=").append(pair.getValue()).append(", ");
}
sb.delete(sb.length() - 2, sb.length());
sb.append("}");
return sb.toString();
}
}
public static void main(String[] args) {
PetCounter petCounter = new PetCounter();
for(Pet pet : Pets.createArray(50)) {
petCounter.count(pet);
}
System.out.println(petCounter);
}
}
class TypeCounter extends HashMap<Class<?>, Integer> {
private Class<?> baseType;
public TypeCounter(Class<?> type) {
this.baseType = type;
}
public void count(Object obj) {
Class<?> type = obj.getClass();
if(!baseType.isAssignableFrom(type)) {
throw new RuntimeException(obj + "is not type " + baseType);
}
countClass(type);
}
private void countClass(Class<?> type) {
Integer value = get(type);
put(type, value == null ? 1 : value + 1);
Class<?> superClass = type.getSuperclass();
if(superClass != null && baseType.isAssignableFrom(superClass)) {
countClass(superClass);
}
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("{");
for(Entry<Class<?>, Integer> pair : this.entrySet()) {
sb.append(pair.getKey().getSimpleName()).append("=").append(pair.getValue()).append(", ");
}
sb.delete(sb.length() - 2, sb.length());
sb.append("}");
return sb.toString();
}
}
class PetCount3 {
public static void main(String[] args) {
TypeCounter typeCounter = new TypeCounter(Pet.class);
for(Pet pet : Pets.createArray(50)) {
typeCounter.count(pet);
}
System.out.println(typeCounter);
}
}
abstract class PetCreator {
private Random ramdom = new Random();
public abstract List<Class<? extends Pet>> types();
public Pet getPet() throws InstantiationException, IllegalAccessException {
int index = ramdom.nextInt(types().size());
return types().get(index).newInstance();
}
public Pet[] createArray(int size) {
Pet[] pets = new Pet[size];
for(int i=0; i<size; ++i) {
try {
pets[i] = getPet();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return pets;
}
public List<Pet> createArrayList(int size) {
List<Pet> pets = new ArrayList<Pet>();
Collections.addAll(pets, createArray(size));
return pets;
}
}
class ForNameCreator extends PetCreator {
private static List<Class<? extends Pet>> types = new ArrayList<Class<? extends Pet>>();
public ForNameCreator() {
try {
road();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static String[] names = {
"Part14.Dogs",
"Part14.Mutt",
"Part14.Pug",
"Part14.Cat",
"Part14.Egy",
"Part14.Manx",
"Part14.Cymrix",
"Part14.Rodent",
"Part14.Rat",
"Part14.Mouse",
"Part14.Hamster"
};
@SuppressWarnings("unchecked")
private static void road() throws ClassNotFoundException {
for(String name : names) {
types.add((Class<? extends Pet>) Class.forName(name));
}
}
@Override
public List<Class<? extends Pet>> types() {
// TODO Auto-generated method stub
return types;
}
}
class LiteralPetCreator extends PetCreator {
@SuppressWarnings("unchecked")
public static final List<Class<? extends Pet>> allTypes =
Collections.unmodifiableList(Arrays.asList(
Pug.class, Pet.class, Dogs.class, Mutt.class,
Cat.class, Egy.class, Manx.class, Cymrix.class,
Rodent.class, Rat.class, Mouse.class, Hamster.class));
@SuppressWarnings("unused")
private static final List<Class<? extends Pet>> types =
allTypes.subList(allTypes.indexOf(Mutt.class), allTypes.size());
@Override
public List<Class<? extends Pet>> types() {
// TODO Auto-generated method stub
return allTypes;
}
}
class Pets {
public static final LiteralPetCreator creator = new LiteralPetCreator();
public static Pet randomPet() throws InstantiationException, IllegalAccessException {
return creator.getPet();
}
public static Pet[] createArray(int size) {
return creator.createArray(size);
}
public static List<Pet> createList(int size) {
return creator.createArrayList(size);
}
}
abstract class Indicidual {
private static long counter = 0;
private final long id = counter++;
private String name;
public Indicidual() {
}
public Indicidual(String name) {
this.name = name;
}
public long getId() {
return id;
}
@Override
public String toString() {
return name + " : id";
}
}
class Person extends Indicidual {
public Person(String name) {
super(name);
}
public Person() {
super();
}
}
class Pet extends Indicidual {
public Pet(String name) {
super(name);
}
public Pet() {
super();
}
}
class Dogs extends Pet {
public Dogs(String name) {
super(name);
}
public Dogs() {
super();
}
}
class Mutt extends Dogs {
public Mutt(String name) {
super(name);
}
public Mutt() {
super();
}
}
class Pug extends Dogs {
public Pug(String name) {
super(name);
}
public Pug() {
super();
}
}
class Cat extends Pet {
public Cat(String name) {
super(name);
}
public Cat() {
super();
}
}
class Egy extends Cat {
public Egy(String name) {
super(name);
}
public Egy() {
super();
}
}
class Manx extends Cat {
public Manx(String name) {
super(name);
}
public Manx() {
super();
}
}
class Cymrix extends Manx {
public Cymrix(String name) {
super(name);
}
public Cymrix() {
super();
}
}
class Rodent extends Pet {
public Rodent(String name) {
super(name);
}
public Rodent() {
super();
}
}
class Rat extends Rodent {
public Rat(String name) {
super(name);
}
public Rat() {
super();
}
}
class Mouse extends Rat {
public Mouse(String name) {
super(name);
}
public Mouse() {
super();
}
}
class Hamster extends Rodent {
public Hamster(String name) {
super(name);
}
public Hamster() {
super();
}
}
4、注册工厂设计模式：将对象的创建交给类自己去完成
package Part14;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
public class RegisteredFactories {
public static void main(String[] args) {
for(int i=0; i<50; ++i) {
System.out.println(Part.createRandom());
}
TypeCount counter = new TypeCount(Part.class);
for(Part part : Part.createArray(50)) {
counter.count(part);
}
System.out.println(counter);
}
}
interface Factory<T> {
T create();
}
class Part {
public static final List<Factory<? extends Part>> partsFactories = new ArrayList<Factory<? extends Part>>();
static {
partsFactories.add(new FuelFilter.Factory());
partsFactories.add(new AirFilyer.Factory());
partsFactories.add(new CabinAirFilter.Factory());
partsFactories.add(new OilFilter.Factory());
partsFactories.add(new GeneratorBelt.Factory());
partsFactories.add(new PowerSteeringBelt.Factory());
}
@Override
public String toString() {
return getClass().getSimpleName();
}
public static Random random = new Random();
public static Part createRandom() {
int index = random.nextInt(partsFactories.size());
return partsFactories.get(index).create();
}
public static Part[] createArray(int size) {
Part[] parts = new Part[size];
for(int i=0; i<size; ++i) {
parts[i] = createRandom();
}
return parts;
}
}
class Filter extends Part {
}
class FuelFilter extends Filter {
public static class Factory implements Part14.Factory<FuelFilter> {
@Override
public FuelFilter create() {
return new FuelFilter();
}
}
}
class AirFilyer extends Filter {
public static class Factory implements Part14.Factory<AirFilyer> {
@Override
public AirFilyer create() {
return new AirFilyer();
}
}
}
class CabinAirFilter extends Filter {
public static class Factory implements Part14.Factory<CabinAirFilter> {
@Override
public CabinAirFilter create() {
return new CabinAirFilter();
}
}
}
class OilFilter extends Filter {
public static class Factory implements Part14.Factory<OilFilter> {
@Override
public OilFilter create() {
return new OilFilter();
}
}
}
class Belt extends Part {
}
class GeneratorBelt extends Belt {
public static class Factory implements Part14.Factory<GeneratorBelt> {
@Override
public GeneratorBelt create() {
return new GeneratorBelt();
}
}
}
class PowerSteeringBelt extends Belt {
public static class Factory implements Part14.Factory<PowerSteeringBelt> {
@Override
public PowerSteeringBelt create() {
return new PowerSteeringBelt();
}
}
}
class TypeCount extends HashMap<Class<?>, Integer> {
private Class<?> baseType;
public TypeCount(Class<?> type) {
this.baseType = type;
}
public void count(Object obj) {
Class<?> type = obj.getClass();
if(!baseType.isAssignableFrom(type)) {
throw new RuntimeException(obj + "is not type " + baseType);
}
countClass(type);
}
private void countClass(Class<?> type) {
Integer key = get(type);
put(type, key == null ? 1 : key + 1);
Class<?> superClass = type.getSuperclass();
if(baseType.isAssignableFrom(superClass)) {
countClass(superClass);
}
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
for(Map.Entry<Class<?>, Integer> entry : this.entrySet()) {
sb.append(entry.getKey().getSimpleName()).append("=").append(entry.getValue()).append(", ");
}
sb.delete(sb.length() - 2, sb.length());
return sb.toString();
}
}
5、反射
package Part14;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.regex.Pattern;
public class ShowMethods {
private static Pattern pattern = Pattern.compile("(\\w+\\.)|(\\sfinal)|(\\snative)");
public static void main(String[] args) {
Class<?> myClass = null;
try {
myClass = Class.forName("Part14.ShowMethods");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Method[] methods = myClass.getMethods();
Constructor[] cons = myClass.getConstructors();
for(Method method : methods) {
System.out.println(pattern.matcher(method.toString()).replaceAll(""));
}
for(Constructor con : cons) {
System.out.println(pattern.matcher(con.toString()).replaceAll(""));
}
}
}
6、简单代理
package Part14;
/**
* 简单代理
* @author Administrator
*
*/
public class SimpleProxyDemo {
public static void main(String[] args) {
RealObject object = new RealObject();
consumer(object);
SimpleProxy proxy = new SimpleProxy(object);
consumer(proxy);
}
public static void consumer(Interface inter) {
inter.doSomething();
inter.somethingElse("baobo");
}
}
interface Interface {
void doSomething();
void somethingElse(String param);
}
class RealObject implements Interface {
@Override
public void doSomething() {
System.out.println("RealObject doSomething()");
}
@Override
public void somethingElse(String param) {
System.out.println("RealObject somethingElse()");
}
}
class SimpleProxy implements Interface {
private Interface proxied;
public SimpleProxy(Interface proxied) {
this.proxied = proxied;
}
@Override
public void doSomething() {
System.out.println("SimpleProxy doSomething()");
proxied.doSomething();
}
@Override
public void somethingElse(String param) {
System.out.println("SimpleProxy somethingElse()");
proxied.somethingElse(param);
}
}
7、