代理模式
代理模式分为静态代理和动态代理
public interface IAnimal{
void eat();
}
/**
*目标对象实现了某一个接口
*/
public class Cat implements IAnimal{
public void eat(){
System.out.println("小猫爱吃鱼");
}
}
/**
* 代理对象和目标对象实现相同的接口
*/
public class AniamlProxy implements IAnimal{
//接收目标对象
private IAnimal target;
public getDaoProxy(IAnimal){
this.target = target;
}
//对对象的eat方法进行功能扩展
public void eat(){
System.out.println("去市场买鱼");
target.eat();
}
}
/**
* 测试类
*/
public class Test{
public static void main(String[] args){
//目标对象
IAnimal target = new Cat();
//代理对象
IAnimal proxy = new AniamlProxy(target);
//执行的是代理的方法
proxy.eat();
}
}
动态代理
JDK代理----JDK动态代理实现则是使用的反射机制。
//动态代理不需要实现接口,但是需要指定接口类型
public class Test{
//维护一个目标对象
private Object target;
public ProxyFactory(Object target){
this.target=target;
}
public Object getProxyInstance(){
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler(){
//invoke的三个参数、第一个参数就是代理者,如果你想对代理者做一些操作可以使用这个参数;第二个就是被执行的方法,第三个是执行该方法所需的参数。
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before method excute!");
//1.传入的对象通过反射获取数据
Object return = method.invoke(target, args);
System.out.println("after method excute!");
return result;
}
}
);
}
}
简单工厂
程序在接口和子类之间加入一个过渡端,通过此过渡端可以动态取得实现了共同的接口的子类实例化对象
interface Animal{
public void say();
}
//定义子类Cat
class Cat implements Animal{
@Override
public void say(){
System.out.println("我是猫咪,喵!!!");
}
}
//定义子类Dog
class Dog implements Animal{
@Override
public void say(){
System.out.println("我是小狗,汪!!!");
}
}
//关键的来了 (定义工厂类)
class Factory{
public static Animal getInstance(String className){
//定义接口对象
Animal a = null;
//判断是那个子类的标记
if("Cat".equals(className)){
a = new Cat();
}
if("Dog".equals(className)){
a = new Dog();
}
return a;
}
}
public class FactoryDemo{
public static void main(String[] args){
Animal a = null;
//通过工厂获取实例
a = Factory.getInstance(arg[0]);
if(a != null){
a.say();
}
}
}