委托模式java

‘壹’ java中的单例模式 和c#中的委托是不是同一模式 具体讲解一下

C#的委托 相当于C语言中的函友燃宏数指针 只不过委托指向的段渣是一个方法/事件 道理是一样的，java的单例模式 是设计模式中的一种 ；分为三种情况 一好册种是饿汉模式 一种是懒汉模式 还一个登记式单例 所以两者不一样

‘贰’ java中有没有类似C#委托功能的机制

线程，c#也有线程灶盯和java差隐告和不多，但是c#线程里操控控件不允许，需要用委托，委托可以理解找人帮忙做某件事，就是去友册调用某个方法

‘叁’ java双亲委托机制是什么意思

这个机制是 java class loader 范畴的内容。‘樱和

java 虚拟机要将被用到的java类文件通过classLoader 加载到JVM内存中。
首先classloader 分三个级别，最上级 ： bootstrap classLoader 中间级：extension classLoader 最低级 app classLoader.
当需要加载某个类的时候，会看看这个类是否已经被加载了，如果没有，会请求app 级来加载，app 请求 extension 级 extension 请求 bootstrap级， 由最高级来负责加载（这个就是双亲委派，委托 上两级的loader来做加载），如果高级的无法加载 则会将人物返回给 下一级 以此类推 最后如果双亲都不行 就由自己来加载。 为什么要用这个机制橘陵？ 比如 java.lang.String 这个类，这个是jdk提圆颂戚供的类， 如果我们自定义个 包名：java.lang 然后在里面创建一个String 类， 当我在用String类的时候，根据前面所说，是由bootstrap级的loader 来进行加载的，这个时候它发现其实已经加载过了jdk的String了，那么就不会去加载自定义的String了，防止了重复加载 也加大了安全性。
纯手打，有问题指正。

‘肆’ 委托代理模式的举例

下面的代码，则是作为一个委托的例子，实现Map的功好伍姿能。
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Hashtable;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.bs2.core.UtilLog;
/**
* @author Liusheng
* 本代码主橘歼要用于演示RelegateTo的使用方法
*/
public class Delegator4Map extends Delegator {
private static Log _log = LogFactory.getLog(Delegator4Map.class);
private Map orginClass = null; //原始友绝对象
private Map proxyClass = null; //代理对象
public Map getOrgin() { return orginClass; }
public Map getProxy() { return proxyClass; }
public Delegator4Map(Map orgin) {
super(orgin);
orginClass = orgin;
proxyClass = (Map)super.obj_proxy;
}
public Object invoke(Object obj, Method method, Object[] args)
throws Throwable {
if (method.getName().equals(size)) { //修改close处理逻辑
_log.debug(原始 size()=+super.invoke(obj, method, args));
Object res2 = new Integer(-1);
_log.debug(修改 size()=+res2);
return res2;
}else {
return super.invoke(obj, method, args);
}
}
public static void main(String[] args) throws IOException {
UtilLog.configureClassPath(resources/log4j.properties, false);
Delegator4Map rtm = new Delegator4Map(new Hashtable());
Map m = rtm.getProxy();
m.size();
_log.debug(代理：+m.toString());
}
}

‘伍’ Java中什么是委托事件处理模型

什么是委托事件模型
在教材上的图中，我们可以发现，用户通过键盘、鼠标等进行操纵的行为，最终都传递给了JVM，那么JVM在接收到这些事件以后该如何处理呢？我们把这种处理事件的方案，称之为事件模型。

Java中采用的是委托事件模型：jdk1.1以后，引入的一种新的事件代理模块，通过它，事件源发出的事件被委托给（注册了的）事件监听器（Listener），并由它负责执行相应的响应方法。比如：病人生病请医生。

基于这种模型，我们使用两种类型的对象来执行事件机制，这两种对象是：
事件源对象
事件的侦听对象

委托事件模型的实现步骤
在java语言中委托事件模型的处理步骤如下：
1.建立事件源对象。如各种GUI的组件。
2.为事件源对象选择合适的事件监听器。比如事件源对象如果是“按钮”，那么我们能想到的发生在按钮身上最多的，应该是单击事件了。这时我就应该选择鼠标单击事件的监听器。
3.为监听器添加适当的处理程序。比如当按钮单击事件发生后，希望完成的代码。
4.为监听器与事件源建立联系。

窗体自身实现事件监听
我们在刚才的例子中使用了两个对象，一个是事件源对象，即JFrame窗体，另外还创建了一个监听器对象。事实上在实际开发过程中，我们往往，将这两个类写在一起，就是说一个窗体类自己监听自己的事件

其他事件监听器接口的使用
Java支持的事件监听器接口非常多，常见的主要有：

ActionListener 行为监听接口
AdjustmentListener 调整监听接口
ItemListener 选项监听接口
TextListener 文本监听接口
ComponentListener 组件监听接口
KeyListener 键盘监听接口
MouseListener 鼠标点击监听接口
MouseMotionListener 鼠标移动监听接口
FocusListener 光标聚焦监听接口
WindowListener 窗体监听接口
ContainerListener 容器监听接口

KeyListener接口与KeyAdapter类
KeyListener接口：监听键盘事件。

该接口中定义了如下三个方法：
keyPressed() 键盘按下时触发
keyReleased() 键盘释放时触发
keyTyped() 键盘单击一次时触发

KeyAdpeter适配器：即使我们只想使用上述三个方法中的一种，那么我们也必须在KeyListener接口的实现类中对这三种方法进行重写，这种方式显然增加了很多无效代码，我们可以使用适配器模式解决。

匿名内部类

WindowListener接口与WindowAdapter类
WindowListener接口：监听窗体的行为。

windowListener接口常用方法：
windowActivated(WindowEvent e) 将 Window 设置为活动 Window 时 调用。

windowClosed(WindowEvent e) 因对窗口调用 dispose 而将其关闭 时调用。
windowClosing(WindowEvent e) 用户试图从窗口的系统菜单中关闭窗 口时调用。
windowDeactivated(WindowEvent e) 当 Window 不再是活动 Window 时调用。
windowDeiconified(WindowEvent e) 窗口从最小化状态变为正常状 态时调用。

windowIconified(WindowEvent e) 窗口从正常状态变为最小化状态 时调用。

windowOpened(WindowEvent e) 窗口首次变为可见时调用。

MouseListener接口与MouseAdapter类
MouseListener接口：监听鼠标点击的行为。

MouseListener接口常用方法：
mouseClicked(MouseEvent e) 鼠标按键在组件上单击（按下并释放）时调用。
mouseEntered(MouseEvent e) 鼠标进入到组件上时调用。
mouseExited(MouseEvent e) 鼠标离开组件时调用。
mousePressed(MouseEvent e) 鼠标按键在组件上按下时调用。
mouseReleased(MouseEvent e) 鼠标按钮在组件上释放时调用。

MouseMotionListener接口与MouseMotionAdapter类
MouseMotionListener接口：监听鼠标移动的行为。

MouseMotionListener接口常用方法：
mouseDragged(MouseEvent e) 鼠标按键在组件上按下并拖动时调用。
mouseMoved(MouseEvent e) 鼠标按键在组件上移动（无按键按下）时调用

‘陆’ java语言中委托的实现方法

委托是C、OC和C#中的才有，在java中是叫接口(interface )。

嫌瞎袜实现接口可芹激以使用关键字implements，假设有接口神模Animal，那么实现接口代码示范如下：

classcatimplementsAnimal
{
publicvoidshout()
{
int(“喵喵”);
}
}

‘柒’ Java：如何编写自己的Java类加载器

给你简单介绍一下类加载器

1.类加载器就加载字节码文件(.class)

public class FileClassLoader extends ClassLoader {String rootDir=null;public FileClassLoader(String rootDir) {this.rootDir = rootDir;}@Overrideprotected Class<?> findClass(String className) throws ClassNotFoundException {//首先检查是否已经被加载了。Class<?> c = findLoadedClass(className);String path = rootDir + "/" + className.replace('.', '/') + ".class";if (c != null) {return c;} else {/*双亲委托模式*/ClassLoader loaderParent = this.getParent();c = loaderParent.loadClass(className);if (c != null) {return c;} else {/*如果再不行的话，就再进行加载。因为字节码的本质就是一个字节数组*/InputStream is = null;ByteArrayOutputStream outputStream = new ByteArrayOutputStream();try {is = new FileInputStream(path);byte[] buffer = new byte[1024];int len = 0;while ((len = is.read(buffer)) != -1) {outputStream.write(buffer, 0, len);}c = defineClass(className, buffer, 0, buffer.length);}catch (Exception e) {e.printStackTrace();}finally {if (is != null) {try {is.close();}让亮蠢catch (IOException e) {键枣e.printStackTrace();}}}}return c;}}

}

/*

相同的类加载器对同一个类进行加载，得到的hascode是相同的

* 不同的类加载器对同一类进行加载，得到的hascode是不一样的*/public class Demo {public static void main(String[] args) {FileClassLoader loader = new FileClassLoader("c://myjava");FileClassLoader loader2=new FileClassLoader("c://myjava");try {Class<?> c = loader.findClass("com.lg.test.HelloWorld");Class<?> c0=loader.findClass("com.lg.test.HelloWorld");Class<?> c1=loader2.findClass("com.lg.test.HelloWorld");Class<?> c2=loader.findClass("com.lg.test.Demo01");Class<?> c3=loader.findClass("java.lang.String"坦陪);System.out.println(c.hashCode());System.out.println(c.getClassLoader());System.out.println(c0.hashCode());System.out.println(c0.getClassLoader());System.out.println(c1.hashCode());System.out.println(c1.getClassLoader());System.out.println(c2.hashCode());System.out.println(c2.getClassLoader());System.out.println(c3.hashCode());System.out.println(c3.getClassLoader());}catch (ClassNotFoundException e) {e.printStackTrace();}}}

‘捌’ java中的委托

委托模式是软件设计模式中的一项基本技巧。在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。委托模式是一项基本技巧，许多其他的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式。委托模式使得我们可以用聚合来替代继承，它还使我们可以模拟mixin。
“委托”在C#中是一个语言级特性，而在Java语言中没有直接的对应，但是我们可以通过动态代理来实现委托！代码如下：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/*
* @author Liusheng
* 实现“委托”模式，用户需要实现InvocationHandler接口；
* 参考：http://www.uml.org.cn/j2ee/200411036.htm
*/
public abstract class Delegator implements InvocationHandler {
//--------------------------------------------

protected Object obj_orgin = null; //原始对象
protected Object obj_proxy = null; //代理对象
//--------------------------------------------

public Delegator() {
}

public Delegator(Object orgin) {
this.createProxy(orgin);
}
/*
* 完成原始对象和委托对象的实例化
* @param orgin 原始对象实例
*/

protected Object createProxy(Object orgin) {
obj_orgin = orgin;
//下面语句中orgin.getClass().getClassLoader()为加载器，orgin.getClass().getInterfaces()为接口集
obj_proxy = Proxy.newProxyInstance(orgin.getClass().getClassLoader(), orgin.getClass().getInterfaces(), this); //委托
return obj_proxy;
}
/*
* 对带有指定参数的指定对象调用由此 Method 对象表示的底层方法，具体请参见Java API
* @param args 参数
* @param method 方法类实例
*/

protected Object invokeSuper(Method method, Object[] args) throws Throwable {
return method.invoke(obj_orgin, args);
}
//--------------实现InvocationHandler接口，要求覆盖------------
//下面实现的方法是当委托的类调用toString()方法时，操作其他方法而不是该类默认的toString()，这个类的其他方法则不会。

public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
// 缺省实现：委托给obj_orgin完成对应的操作
if (method.getName().equals("toString")) { //对其做额外处理
return this.invokeSuper(method, args) + "$Proxy";
} else { //注意，调用原始对象的方法，而不是代理的（obj==obj_proxy）
return this.invokeSuper(method, args);
}
}
}

下面的代码，则是作为一个委托的例子，实现Map的功能。
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Hashtable;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.bs2.core.UtilLog;
/**
* @author Liusheng
* 本代码主要用于演示RelegateTo的使用方法
*/
public class Delegator4Map extends Delegator {
private static Log _log = LogFactory.getLog(Delegator4Map.class);
private Map orginClass = null; //原始对象
private Map proxyClass = null; //代理对象

public Map getOrgin() {
return orginClass;
}

public Map getProxy() {
return proxyClass;
}

public Delegator4Map(Map orgin) {
super(orgin);
orginClass = orgin;
proxyClass = (Map) super.obj_proxy;
}

public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
if (method.getName().equals("size")) { //修改size处理逻辑
Object res2 = new Integer(-1);
System.out.println("调用委托的方法");
return res2;
} else {
System.out.println("调用原始的方法");
return super.invoke(obj, method, args);
}
}

public static void main(String[] args) throws IOException {
Delegator4Map rtm = new Delegator4Map(new Hashtable());
Map m = rtm.getProxy();
m.size();
}
}

‘玖’ 在Java中没有C#的delegate类型,ref和out类型的参数,那在Java中如何变通地实现相同功能

delegate你可以用相关对象的addXXXListener实现，如果没有你想要的listener，你可以自己写一个，然后在set方法里面通知这些listener就可以了，比方你要监视Obj的属性变化，可以这样，先定义一个借口PropertyChangeListener{public void execute();}
class Obj{
List<PropertyChangeListener> listeners;
void firePropertyChanged(PropertyChangeEvent e){
for (PropertyChangeListener l:listeners){
l.execute(e);
}
}
void addPropertyChangeListener(PropertyChangeListener l){
listeners.add(l);
}
}

ref就是传引用，随便一个对象就可以传引用，除了String，还有out，你直接在函数里面修改传引用的参数就ok

‘拾’ javascritp，事件委托流程

设计模式的委托分三部分吧
首先是代理event proxy
然后是需要执行的流程process

然后是返回结果callback
具体我就以jquery为例
$(...).on('') 这个就是创建代理，至于说是不是onclick这个都另说，因为即使是DOM事件我们也视作是一个事件代理
$(..).fire(callback)这个就是执行你的代理事件，当中的callback就是你的返回结果
这样你就只需要关心事件本身