class Gun extends Weapon{
@Override
public void shoot() {
}
}
class Knife extends Weapon{
@Override
public void shoot() {
}
}
class MG extends Weapon{
@Override
public void shoot() {
}
}
class Riefle extends Weapon{
@Override
public void shoot() {
}
}
public abstract class Weapon {
public abstract void shoot();
}
package strategy;
import java.util.List;
public class People {
private List<Weapon> weapons=null;
private Integer current_pos=null;
public void fire() throws Exception{
if(weapons==null || weapons.size()==0) {
throw new NullPointerException("index out of array's length");
}
if(current_pos>=weapons.size()){
throw new Exception("index out of array's length");
}
else{
weapons.get(current_pos).shoot();
}
}
public void change(Integer index){
if(weapons==null || weapons.size()==0) {
throw new NullPointerException("index out of array's length");
}
current_pos=(current_pos+index)%weapons.size();
}
public People(List<Weapon> weapons) {
super();
this.weapons = weapons;
current_pos=0;
}
}
package factory;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import util.ClassUtil;
public class WeaponSimpleFactory {
private WeaponSimpleFactory() {
}
private static WeaponSimpleFactory INSTANCE = null;
private static Map<String, Class<?>> WEAPONS = null;
static {
INSTANCE = new WeaponSimpleFactory();
WEAPONS =new HashMap<String, Class<?>>();
List<Class<?>> classes=ClassUtil.getClasses("strategy");
for(Class<?> clazz : classes){
WEAPONS.put(clazz.getSimpleName(), clazz);
}
System.out.println(WEAPONS);
}
public synchronized static WeaponSimpleFactory newInstance() {
return INSTANCE;
}
public synchronized Object createWeapon(String name)
throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException,
NoSuchMethodException, SecurityException {
Class c = WEAPONS.get(name);
if (c == null) {
throw new NullPointerException("null");
}
Constructor<Class<?>> constructor = c.getConstructor(null);
return constructor.newInstance(null);
}
}
package util;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import strategy.Weapon;
/**
* 类相关的工具类
* @author wwhhff11
* @since 2016/03/03
*
*/
public class ClassUtil {
/**
* 取得某个接口下所有实现这个接口的类
* @author wwhhff11
* @since 2016/03/03
* @param c
* @return
*/
public static List<Class> getAllClassByInterface(Class c) {
List<Class> returnClassList = null;
if (c.isInterface()) {
String packageName = c.getPackage().getName();
List<Class<?>> allClass = getClasses(packageName);
if (allClass != null) {
returnClassList = new ArrayList<Class>();
for (Class classes : allClass) {
if (c.isAssignableFrom(classes)) {
if (!c.equals(classes)) {
returnClassList.add(classes);
}
}
}
}
}
return returnClassList;
}
/**
* 取得某一类所在包的所有类名 不含迭代
* @author wwhhff11
* @since 2016/03/03
* @param classLocation
* @param packageName
* @return
*/
public static String[] getPackageAllClassName(String classLocation,
String packageName) {
String[] packagePathSplit = packageName.split("[.]");
String realClassLocation = classLocation;
int packageLength = packagePathSplit.length;
for (int i = 0; i < packageLength; i++) {
realClassLocation = realClassLocation + File.separator
+ packagePathSplit[i];
}
File packeageDir = new File(realClassLocation);
if (packeageDir.isDirectory()) {
String[] allClassName = packeageDir.list();
return allClassName;
}
return null;
}
/**
* 从包package中获取所有的Class
* @author wwhhff11
* @since 2016/03/03
* @param pack
* @return
*/
public static List<Class<?>> getClasses(String packageName) {
List<Class<?>> classes = new ArrayList<Class<?>>();
boolean recursive = true;
String packageDirName = packageName.replace('.', '/');
Enumeration<URL> dirs;
try {
dirs = Thread.currentThread().getContextClassLoader()
.getResources(packageDirName);
while (dirs.hasMoreElements()) {
URL url = dirs.nextElement();
String protocol = url.getProtocol();
if ("file".equals(protocol)) {
String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
findAndAddClassesInPackageByFile(packageName, filePath,
recursive, classes);
} else if ("jar".equals(protocol)) {
JarFile jar;
try {
jar = ((JarURLConnection) url.openConnection())
.getJarFile();
Enumeration<JarEntry> entries = jar.entries();
while (entries.hasMoreElements()) {
JarEntry entry = entries.nextElement();
String name = entry.getName();
if (name.charAt(0) == '/') {
name = name.substring(1);
}
if (name.startsWith(packageDirName)) {
int idx = name.lastIndexOf('/');
if (idx != -1) {
packageName = name.substring(0, idx)
.replace('/', '.');
}
if ((idx != -1) || recursive) {
if (name.endsWith(".class")
&& !entry.isDirectory()) {
String className = name.substring(
packageName.length() + 1,
name.length() - 6);
try {
classes.add(Class
.forName(packageName + '.'
+ className));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return classes;
}
/**
* 以文件的形式来获取包下的所有Class
*
* @param packageName
* @param packagePath
* @param recursive
* @param classes
*/
public static void findAndAddClassesInPackageByFile(String packageName,
String packagePath, final boolean recursive, List<Class<?>> classes) {
File dir = new File(packagePath);
if (!dir.exists() || !dir.isDirectory()) {
return;
}
File[] dirfiles = dir.listFiles(new FileFilter() {
public boolean accept(File file) {
return (recursive && file.isDirectory())
|| (file.getName().endsWith(".class"));
}
});
for (File file : dirfiles) {
if (file.isDirectory()) {
findAndAddClassesInPackageByFile(
packageName + "." + file.getName(),
file.getAbsolutePath(), recursive, classes);
} else {
String className = file.getName().substring(0,
file.getName().length() - 6);
try {
classes.add(Class.forName(packageName + '.' + className));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}