1. java中有沒有類似C#委託功能的機制
線程，c#也有線程和java差不多，但是c#線程里操控控制項不允許，需要用委託，委託可以理解找人幫忙做某件事，就是去調用某個方法
2. 在java中有沒有委託
沒有，但有「代理」這樣的寫法，如自定義事件
~~~~
3. 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) 滑鼠按鍵在組件上移動（無按鍵按下）時調用
4. java語言中委託的實現方法
委託很簡單，就是本類的方法調用其他類的方法取工作。
func(A a) { a.dosomething();}
就是說我要做的一部分工作，別人可以替我做，ok，讓它做。
5. 深圳北大青鳥分享Java抽象類與介面的區別
在Java語言中，abstractclass和interface是支持抽象類定義的兩種機制。
正是由於這兩種機制的存在，才賦予了Java強大的面向對象能力。
abstractclass和interface之間在對於抽象類定義的支持方面具有很大的相似性，甚至可以相互替換，因此很多開發者在進行抽象類定義時對於abstractclass和interface的選擇顯得比較隨意。
其實，兩者之間還是有很大的區別的，對於它們的選擇甚至反映出對於問題領域本質的理解、對於設計意圖的理解是否正確、合理。
本文將對它們之間的區別進行一番剖析，試圖給開發者提供一個在二者之間進行選擇的依據。
理解抽象類abstractclass和interface在Java語言中都是用來進行抽象類（本文中的抽象類並非從abstractclass翻譯而來，它表示的是一個抽象體，而abstractclass為Java語言中用於定義抽象類的一種方法，請讀者注意區分）定義的，那麼什麼是抽象類，使用抽象類能為我們帶來什麼好處呢？在面向對象的概念中，我們知道所有的對象都是通過類來描繪的，但是反過來卻不是這樣。
並不是所有的類都是用來描繪對象的，如果一個類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類就是抽象類。
抽象類往往用來表徵我們在對問題領域進行分析、設計中得出的抽象概念，是對一系列看上去不同，但是本質上相同的具體概念的抽象。
比如：如果我們進行一個圖形編輯軟體的開發，就會發現問題領域存在著圓、三角形這樣一些具體概念，它們是不同的，但是它們又都屬於形狀這樣一個概念，形狀這個概念在問題領域是不存在的，它就是一個抽象概念。
正是因為抽象的概念在問題領域沒有對應的具體概念，所以用以表徵抽象概念的抽象類是不能夠實例化的。
在面向對象領域，抽象類主要用來進行類型隱藏。
我們可以構造出一個固定的一組行為的抽象描述，但是這組行為卻能夠有任意個可能的具體實現方式。
這個抽象描述就是抽象類，而這一組任意個可能的具體實現則表現為所有可能的派生類。
模塊可以操作一個抽象體。
由於模塊依賴於一個固定的抽象體，因此它可以是不允許修改的；同時，通過從這個抽象體派生，也可擴展此模塊的行為功能。
熟悉OCP的讀者一定知道，為了能夠實現面向對象設計的一個最核心的原則OCP(Open-ClosedPrinciple)，抽象類是其中的關鍵所在。
從語法定義層面看abstractclass和interface在語法層面，Java語言對於abstractclass和interface給出了不同的定義方式，下面以定義一個名為Demo的抽象類為例來說明這種不同。
使用abstractclass的方式定義Demo抽象類的方式如下：abstractclassDemo｛abstractvoidmethod1();abstractvoidmethod2();?｝使用interface的方式定義Demo抽象類的方式如下：interfaceDemo{voidmethod1();voidmethod2();?}在abstractclass方式中，Demo可以有自己的數據成員，也可以有非abstract的成員方法，而在interface方式的實現中，Demo只能夠有靜態的不能被修改的數據成員（也就是必須是staticfinal的，不過在interface中一般不定義數據成員），所有的成員方法都是abstract的。
從某種意義上說，interface是一種特殊形式的abstractclass。
從編程的角度來看，abstractclass和interface都可以用來實現"designbycontract"的思想。
但是在具體的使用上面還是有一些區別的。
首先，abstractclass在Java語言中表示的是一種繼承關系，一個類只能使用一次繼承關系(因為Java不支持多繼承--轉注)。
但是，一個類卻可以實現多個interface。
也許，這是Java語言的設計者在考慮Java對於多重繼承的支持方面的一種折中考慮吧。
其次，在abstractclass的定義中，我們可以賦予方法的默認行為。
但是在interface的定義中，方法卻不能擁有默認行為，為了繞過這個限制，必須使用委託，但是這會增加一些復雜性，有時會造成很大的麻煩。
在抽象類中不能定義默認行為還存在另一個比較嚴重的問題，那就是可能會造成維護上的麻煩。
因為如果後來想修改類的界面（一般通過abstractclass或者interface來表示）以適應新的情況（比如，添加新的方法或者給已用的方法中添加新的參數）時，就會非常的麻煩，可能要花費很多的時間（對於派生類很多的情況，尤為如此）。
但是如果界面是通過abstractclass來實現的，那麼可能就只需要修改定義在abstractclass中的默認行為就可以了。
同樣，如果不能在抽象類中定義默認行為，北大青鳥深圳計算機學院http://www.kmbdqn.cn/認為會導致同樣的方法實現出現在該抽象類的每一個派生類中，違反了"onerule，oneplace"原則，造成代碼重復，同樣不利於以後的維護。
因此，在abstractclass和interface間進行選擇時要非常的小心。
6. .net 中的委託 和java中的有什麼 區別
.net中的委託概念java中沒有相同的，只有事件模式是一樣的，java中有一個叫Obserable介面，可以添加IEventListener，使用內部類可以構建類似於委託的概念
7. java的處理事件的方式基於委託事件模型，什麼是委託事件模型
gava事件的方式基於事件的模型，你想問的是委託什麼事件的模型，這件事情非常的專業我希望用在電腦方面軟體方面，程序，方面都比較了解的可以提供一下，准確的答案。
8. 北大青鳥雲南計算機學院分享Java抽象類與介面的區別
在Java語言中， abstract class 和interface 是支持抽象類定義的 兩種機制。正是由於這兩種機制的存在，才賦予了Java強大的 面向對象能力。abstract class和interface之間在對於抽象類定義的支持方面具有很大的相似性，甚至可以相互替換，因此很多開發者在進 行抽象類定義時對於abstract class和interface的選擇顯得比較隨意。其實，兩者之間還是有很大的區別的，對於它們的選擇甚至反映出對 於問題領域本質的理解、對於設計意圖的理解是否正確、合理。本文將對它們之間的區別進行一番剖析，試圖給開發者提供一個在二者之間進行選擇的依據。
理解抽象類
abstract class和interface在Java語言中都是用來進行抽象類（本文中的抽象類並非從abstract class翻譯而來，它表示的是一個抽象體，而abstract class為Java語言中用於定義抽象類的一種方法， 請讀者注意區分）定義的，那麼什麼是抽象類，使用抽象類能為我們帶來什麼好處呢？
在面向對象的概念中，我們知道所有的對象都是通過類來描繪的，但是反過來卻不是這樣。並不是 所有的類都是用來描繪對象的，如果一個類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類就是抽象類。抽象類往往用來表徵我們在對問題領域進行分析、 設計中得出的抽象概念，是對一系列看上去不同，但是本質上相同的具體概念的抽象。比如：如果我們進行一個圖形編輯軟體的開發，就會發現問題領域存在著圓、 三角形這樣一些具體概念，它們是不同的，但是它們又都屬於形狀這樣一個概念，形狀這個概念在問題領域是不存在的，它就是一個抽象概念。正是因為抽象的概念 在問題領域沒有對應的具體概念，所以用以表徵抽象概念的抽象類是不能夠實例化的。
在面向對象領域，抽象類主要用來進行類型隱藏。 我們可以構造出一個固定的一組行為的抽象描 述，但是這組行為卻能夠有任意個可能的具體實現方式。這個抽象描述就是抽象類，而這一組任意個可能的具體實現則表現為所有可能的派生類。模塊可以操作一個 抽象體。由於模塊依賴於一個固定的抽象體，因此它可以是不允許修改的；同時，通過從這個抽象體派生，也可擴展此模塊的行為功能。熟悉OCP的讀者一定知 道，為了能夠實現面向對象設計的一個最核心的原則OCP(Open-Closed Principle)，抽象類是其中的關鍵所在。
從語法定義層面看abstract class 和 interface
在語法層面，Java語言對於abstract class和interface給出了不同的定義方式，下面以定義一個名為Demo的抽象類為例來說明這種不同。
使用abstract class的方式定義Demo抽象類的方式如下：
abstract class Demo｛
abstract void method1();
abstract void method2();
｝
使用interface的方式定義Demo抽象類的方式如下：
interface Demo{
void method1();
void method2();
}
在abstract class方式中，Demo可以有自己的數據成員，也可以有非 abstract的成員方法，而在interface方式的實現中，Demo只能夠有靜態的不能被修改的數據成員（也就是必須是static final 的，不過在interface中一般不定義數據成員），所有的成員方法都是abstract的。從某種意義上說，interface是一種特殊形式的 abstract class。
從編程的角度來看，abstract class和interface都可以用來實現 "design by contract" 的思想。但是在具體的使用上面還是有一些區別的。
首先，abstract class 在 Java 語言中表示的是一種繼承關系，一個類只能使用一次繼承關系(因為Java不支持多繼承 -- 轉注)。但是，一個類卻可以實現多個interface。也許，這是Java語言的設計者在考慮Java對於多重繼承的支持方面的一種折中考慮吧。
其次，在abstract class的定義中，我們可以賦予方法的默認行為。但是在interface的定義中，方法卻不能擁有默認行為，為了繞過這個限制，必須使用委託，但是這會增加一些復雜性，有時會造成很大的麻煩。
在抽象類中不能定義默認行為還存在另一個比較嚴重的問題，那就是可能會造成維護上的麻煩。因 為如果後來想修改類的界面（一般通過 abstract class 或者interface來表示）以適應新的情況（比如，添加新的方法或者給已用的方法中添 加新的參數）時，就會非常的麻煩，可能要花費很多的時間（對於派生類很多的情況，尤為如此）。但是如果界面是通過abstract class來實現的，那 么可能就只需要修改定義在abstract class中的默認行為就可以了。
同樣，如果不能在抽象類中定義默認行為，北大青鳥雲南計算機學院http://www.kmbdqn.com/認為會導致同樣的方法實現出現在該抽象類的每一個派生類中，違反了 "one rule，one place" 原則，造成代碼重復，同樣不利於以後的維護。因此，在abstract class和interface間進行選擇時要非常的小心。
9. 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();
}
}
10. 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了，防止了重復載入 也加大了安全性。
純手打，有問題指正。