Ⅰ java 事件委託機制 是什麼
java 事件委託機制的概念,一個源產生一個事件並將它送到一個或多個監聽器那裡。在這種方案中，監聽器簡單的等待，直到它收到一個事件。一旦事件被接受，監聽器將處理這個事件，然後返回
Ⅱ 在事件委託類的繼承體系中，最高層次的類是哪項
在事件委託類的繼承體系中，最高層次的類是哪項？（）
A.java.util.EventListener
B.java.util.EventObject
C.java.awt.AWTEvent
D.java.awt.event.AWTEvent
正確答案是：B java.util.EventObject
Ⅲ Java的事件委託模型是什麼
public void add<EvenType>Listener(EvenTypeListener) //添加事件監聽器 再實現具體的實現處理事件的方法
Ⅳ 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) 滑鼠按鍵在組件上移動（無按鍵按下）時調用
Ⅳ 簡述委任事件模型的事件處理過程
委託事件模型
教材圖我發現用戶通鍵盤、滑鼠等進行操縱行終都傳遞給JVMJVM接收些事件該何處理呢我種處理事件案稱事件模型
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考題,筆試題
Java面向對象
1. super()與this()的區別？
This（）：當前類的對象,super父類對象。
Super（）：在子類訪問父類的成員和行為,必須受類繼承規則的約束
而this他代表當前對象,當然所有的資源都可以訪問.
在構造函數中,如果第一行沒有寫super(),編譯器會自動插入.但是如果父類沒有不帶參數的構造函數,或這個函數被私有化了(用private修飾).此時你必須加入對父類的實例化構造.而this就沒有這個要求,因為它本身就進行實例化的構造.
而在方法中super和this使用的方法就差不多了.只不過super 要考慮是否能訪問其父類的資源.
2. 作用域public,protected,private,以及不寫時的區別？
Public:不同包、 同一包、 類內都可用
Private： 類內
Protected:不同包的子類、同一包、 類內都可用
不寫時: 同一包內、類內
3. 編程輸出如下圖形。
* * * * *
* * * *
* * *
* *
*
代碼如下：
public class Print {
publicstatic void main(String[] args) {
for(int i = 0; i < 5; i++) {
for(int j = 5; j > i; j--) {
System.out.print("*");
}
System.out.println();
}
}
}
4. JAVA的事件委託機制和垃圾回收機制
Java事件委託機制的概念,一個源產生一個事件並將它送到一個或多個監聽器那裡。在這種方案中，監聽器簡單的等待，直到它收到一個事件。一旦事件被接受，監聽器將處理這個事件，然後返回。
垃圾回收機制垃圾收集是將分配給對象但不再使用的內存回收或釋放的過程。如果一個對象沒有指向它的引用或者其賦值為null,則次對象適合進行垃圾回收
5. 在JAVA中，如何跳出當前的多重嵌套循環？
用break; return 方法。
6. 什麼是java序列化，如何實現java序列化？(寫一個實例)
序列化:處理對象流的機制，所謂對象流也就是將對象的內容進行流化。可以對流化後的對象進行讀寫操作，也可將流化後的對象傳輸於網路之間。序列化是為了解決在對對象流進行讀寫操作時所引發的問題。
序列化的實現：將需要被序列化的類實現Serializable介面，該介面沒有需要實現的方法，implementsSerializable只是為了標注該對象是可被序列化的，然後使用一個輸出流(如：FileOutputStream)來構造一個ObjectOutputStream(對象流)對象，接著，使用ObjectOutputStream對象的writeObject(Object obj)方法就可以將參數為obj的對象寫出(即保存其狀態)，要恢復的話則用輸入流。
7. 一個".java"源文件中是否可以包括多個類（不是內部類）？有什麼限制？
可以。如果這個類的修飾符是public，其類名與文件名必須相同。
8. 排序都有哪幾種方法？請列舉。用JAVA實現一個快速排序？
排序的方法有：插入排序（直接插入排序、希爾排序），交換排序（冒泡排序、快速排序），選擇排序（直接選擇排序、堆排序），歸並排序，分配排序（箱排序、基數排序）
快速排序的偽代碼。
9. Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型?
重寫Override，子類覆蓋父類的方法，將子類傳與父類的引用調用的還是子類的方法。
重載Overloading 一個類多個方法，名稱相同，參數個數類型不同。
兩者都是Java多態性的不同表現。
Overloaded的方法是可以改變返回值的類型。
1， public class Ctest(){
Public static void main(){
System.out.prinln(8+8+」88」+8+8);
}
} 168888
（方法的重寫Overriding和重載Overloading是Java多態性的不同表現。重寫Overriding是父類與子類之間多態性的一種表現，重載Overloading是一個類中多態性的一種表現。如果在子類中定義某方法與其父類有相同的名稱和參數，我們說該方法被重寫 (Overriding)。子類的對象使用這個方法時，將調用子類中的定義，對它而言，父類中的定義如同被「屏蔽」了。如果在一個類中定義了多個同名的方法，它們或有不同的參數個數或有不同的參數類型，則稱為方法的重載(Overloading)。
Overloaded的方法是可以改變返回值的類型。）
10. Final類有什麼特點？
屬性常量 方法不可以overridding 類不可以繼承
11. 繼承時候類的執行順序問題,一般都是選擇題,問你將會列印出什麼?
答:父類：
package test;
public class FatherClass {
public FatherClass() {
System.out.println("FatherClassCreate");
}
}
子類:
package test;
import test.FatherClass;
public class ChildClass extends FatherClass{
public ChildClass() {
System.out.println("ChildClassCreate");
}
public static void main(String[] args) {
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}
輸出結果：
C:>java test.ChildClass
FatherClass Create
FatherClass Create
ChildClass Create
12. 內部類的實現方式?
package test;
public class OuterClass {
private class InterClass {
Public Interlass(){
System.out.println("InterClassCreate");
}
}
public OuterClass(){
InterClass ic = new InterClass();
System.out.println("OuterClassCreate");
}
public static void main(String[] args){
OuterClass oc = new OuterClass();
}
}
輸出結果:
C:>java test/OuterClass InterClass Create OuterClass Create
13. 用JAVA實現一種排序，JAVA類實現序列化的方法(二種)？
14. 如在COLLECTION框架中，實現比較要實現什麼樣的介面？
15. 用插入法進行排序代碼如下
package test;
import java.util.*;
class InsertSort {
ArrayList al;
public InsertSort(int num,int mod) {
al = new ArrayList(num);
Random rand = new Random();
System.out.println("The ArrayList SortBefore:");
for (int i=0;i<num ;i++ ){
al.add(new Integer(Math.abs(rand.nextInt())% mod + 1));
System.out.println("al["+i+"]="+al.get(i));
}
}
public void SortIt(){
Integer tempInt;
int MaxSize=1;
for(int i=1;i<al.size();i++){
tempInt = (Integer)al.remove(i);
if(tempInt.intValue()>=((Integer)al.get(MaxSize-1)).intValue()){
al.add(MaxSize,tempInt);
MaxSize++;
System.out.println(al.toString());
} else {
for (int j=0;j<MaxSize ;j++ ){
if(((Integer)al.get(j)).intValue()>=tempInt.intValue()){
al.add(j,tempInt);
MaxSize++;
System.out.println(al.toString());
break;
}
}
}
}
System.out.println("The ArrayList SortAfter:");
for(int i=0;i<al.size();i++) {
System.out.println("al["+i+"]="+al.get(i));
}
}
public static void main(String[] args) {
InsertSort is = new InsertSort(10,100);
is.SortIt();
}
}
JAVA類實現序例化的方法是實現java.io.Serializable介面
Collection框架中實現比較要實現Comparable 介面和 Comparator 介面
16. 編程：編寫一個截取字元串的函數，輸入為一個字元串和位元組數，輸出為按位元組截取的字元串。但是要保證漢字不被截半個，如"我ABC"4，應該截為"我AB"，輸入"我ABC漢DEF"，6，應該輸出為"我ABC"而不是"我ABC+漢的半個"。
public static void split(String source,intnum) throws Exception{
intk=0;
Stringtemp="";
for(int i = 0; i <source.length(); i++){
byte[]b=(source.charAt(i)+"").getBytes();
k=k+b.length;
if(k>num){
break;
}
temp=temp+source.charAt(i);
}
System.out.println(temp);
}
15、Java編程,列印昨天的當前時刻
public class YesterdayCurrent{
public void main(String[] args){
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DATE, -1);
System.out.println(cal.getTime());
}
}
16、文件讀寫,實現一個計數器
public int getNum(){
int i = -1;
try{
String stri="";
BufferedReader in = new BufferedReader(newFileReader(f));
while((stri=in.readLine())!=null){
i = Integer.parseInt(stri.trim());
}
in.close();
}catch(Exception e){
e.printStackTrace();
}
return i;
}
public void setNum(){
int i = getNum();
i++;
try{
PrintWriter out=new PrintWriter(newBufferedWriter(new FileWriter(f,false)));
out.write(String.valueOf(i)); //可能是編碼的原因，如果直接寫入int的話，將出現java編碼和windows編碼的混亂，因此此處寫入的是String
out.close() ;
}catch(Exception e){
e.printStackTrace();
}
}
17、指出下面程序的運行結果。
class A{
static{
System.out.print("1");
}
public A(){
System.out.print("2");
}
}
class B extends A{
static{
System.out.print("a");
}
public B(){
System.out.print("b");
}
}
public class Hello{
public static void main(String[] ars){
A ab = new B(); //執行到此處,結果: 1a2b
ab = new B(); //執行到此處,結果: 1a2b2b
}
}注:類的static 代碼段,可以看作是類首次載入(被虛擬機載入)執行的代碼,而對於類的載入,首先要執行其基類的構造,再執行其本身的構造
18、抽象類和介面的區別？
(1)介面可以被多重implements,抽象類只能被單一extends(2)介面只有定義,抽象類可以有定義和實現(3)介面的欄位定義默認為:publicstatic final, 抽象類欄位默認是"friendly"(本包可見)
當功能需要累積時用抽象類，不需要累積時用介面。
19、什麼是類的反射機制?
通過類(Class對象)，可以得出當前類的fields、method、construtor、interface、superClass、modified等，同是可以通過類實例化一個實例、設置屬性、喚醒方法。Spring中一切都是返射、struts、hibernate都是通過類的返射進行開發的。
20、類的返射機制中的包及核心類?
①java.lang.Class②java.lang.refrection.Method③java.lang.refrection.Field
④java.lang.refrection.Constructor⑤java.lang.refrection.Modifier⑥java.lang.refrection.Interface
21、得到Class的三個過程是什麼?
①對象.getClass()②類.class或Integer.type(int) Integer.class(java.lang.Integer)③Class.forName();
22、如何喚起類中的一個方法？
①產生一個Class數組，說明方法的參數②通過Class對象及方法參數得到Method③通過method.invoke(實例,參數值數組)喚醒方法
23、如何將數值型字元轉換為數字（Integer，Double）？
Integer.parseInt(「1234」) Double.parseDouble(「123.2」)
24、如何將數字轉換為字元？
1+」」 1.0+」」
25、如何去小數點前兩位，並四捨五入。
double d=1256.22d; d=d/100; System.out.println(Math.round(d)*100);
26、如何取得年月日，小時分秒？
Calendar c=Calendar.getInstance();
c.set(Calendar.YEAR,2004);
c.set(Calendar.MONTH,0);
c.set(Calendar.DAY_OF_MONTH,31);
System.out.println(c.get(Calendar.YEAR)+" "+(c.get(Calendar.MONTH)+1)+" "+c.get(Calendar.DAY_OF_MONTH));
27、如何取得從1970年到現在的毫秒數
Java.util.Date dat=new Date(); long now=dat.getTime();
或System.currentTimeMillis()
28、如何獲取某個日期是當月的最後一天？
當前日期加一天，若當前日期與結果的月份不相同，就是最後一天。
取下一個月的第一天，下一個月的第一天-1
public static void main(String[] args){
Calendarc=Calendar.getInstance();
c.set(Calendar.YEAR,2004);
c.set(Calendar.MONTH,0);
c.set(Calendar.DAY_OF_MONTH,30);
Calendarc1=(Calendar)c.clone();
System.out.println(c.get(Calendar.YEAR)+""+(c.get(Calendar.MONTH)+1)+" "+c.get(Calendar.DAY_OF_MONTH));
c.add(Calendar.DAY_OF_MONTH,1);
if(c.get(Calendar.MONTH)!=c1.get(Calendar.MONTH)){
System.out.println("是最後一天");
}else{
System.out.println("不是取後一天");
}
}
29、如何格式化日期？
Import java.text. SimpleDateFormat;
SimpleDateFormat sdf=newSimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date dat=new Date();
String str=sdf.format(dat); //把日期轉化為字元串
System.out.println(str);
Java.util.Date d1=sdf.parse(「yyyy-mm-dd」); //將字元串轉化為日期
30、編碼轉換，怎樣實現將GB2312編碼的字元串轉換為ISO-8859-1編碼的字元串。
String a=new String("中".getBytes("gb2312"),"iso-8859-1");
String a=new String("中".getBytes("iso-8859-1"));
應該是String a=new String("中".getBytes("gb2312"),"iso-8859-1");
String a1=newString(a.getBytes("iso-8859-1"));
Ⅶ javascritp，事件委託流程
設計模式的委託分三部分吧
首先是代理event proxy
然後是需要執行的流程process
然後是返回結果callback
具體我就以jquery為例
$(...).on('') 這個就是創建代理，至於說是不是onclick這個都另說，因為即使是DOM事件我們也視作是一個事件代理
$(..).fire(callback)這個就是執行你的代理事件，當中的callback就是你的返回結果
這樣你就只需要關心事件本身
Ⅷ 關於JAVA的10個問題請教
1.
final—修飾符（關鍵字）如果一個類被聲明為final，意味著它不能再派生出新的子類，不能作為父類被繼承。被聲明為final的
方法也同樣只能使用，不能重載。
finally—拋出一個異常，那麼相匹配的 catch 子句就會執行，然後控制就會進入 finally 塊（如果有的話）。
finalize—方法名。Java 技術允許使用 finalize() 方法在垃圾收集器將對象從內存中清除出去之前做必要的清理工作。
2.
（1）
int sum=0;//奇數和
int count=100；取值區間
for(int i=0;i<=count;i+=2){
sum+=i;
}
System.out.println("奇數和："+sum);
（2）
Math.pow(2.5, 3)); //沒試 不一定對
（3）
public class test {
public static void main(String[] args) {
int x = 1;
while(x <= 20){
if(x%5==0){ System.out.print(x +"\n"); x++; }
else{ System.out.print(x +" ");x++; }
}
}
}
3.
return 返回一個值給調用該方法的語句
break 流程跳出本層循環體，從而提前結束本層循環
continue 跳過本次循環，執行下一次循環
4.
JAVA異常分2種 ：
一種是異常JAVA運行時的系統異常Error,由Java虛擬機生成並拋出,一般來說 Error表示恢復不是不可能但很困難的情況下的一種
嚴重問題。
另一種是 Exception異常，表示一種設計或實現問題上的錯誤（如 數組越界）。
異常處理功能提供了處理程序運行時出現的任何意外或異常情況的方法。異常處理使用 try、catch 和 finally 關鍵字來嘗試可
能未成功的操作，處理失敗，以及在事後清理資源。
5.
按數據流方向：輸入流 和輸出流，一個輸入一個輸出，不用說了吧
按處理數據的單位： 位元組流和字元流。位元組流主要用在處理二進制數據，它是按位元組來處理的。但實際中很多的數據是文本，又
提出了字元流的概念，它是按虛擬機的encode來處理，也就是要進行字元集的轉化
按功能： 節點流和處理流。節點流：從特定的地方讀寫的流類，例如：磁碟或一塊內存區域。
處理流：使用節點流作為輸入或輸出。是使用一個已經存在的輸入流或輸出流連接創建的。
6.
同4
7.
介面就是給出一些沒有內容的方法，類似於C++中的虛類。到具體用的時候再由用的方法自己定義內容，要注意的是想用介面必須
實現介面的所有方法，其實是因為java不支持多繼承才產生了介面
定義public interface UsersDao {
public void add(Users user) throws Exception;
public void update(Users user) throws Exception;
}
實現public class UserDaoImpl implements UsersDao {
public void add(Users user) throws Exception {
//實現代碼
}
public void update(Users user) throws Exception {
//實現代碼
}
}
Java介面和Java抽象類最大的一個區別，就在於Java抽象類可以提供某些方法的部分實現，而Java介面不可以，這大概就是Java
抽象類唯一的優點吧，但這個優點非常有用。如果向一個抽象類里加入一個新的具體方法時，那麼它所有的子類都一下子都得到
了這個新方法，而Java介面做不到這一點，如果向一個Java介面里加入一個新方法，所有實現這個介面的類就無法成功通過編譯
了，因為你必須讓每一個類都再實現這個方法才行，這顯然是Java介面的缺點。
8.
封裝就是將屬性私有化，提供公有的方法訪問私有的屬性。
封裝的優點：
（1）隱藏類的實現細節；
（2）讓使用者只能通過事先定製好的方法來訪問數據，可以方便地加入控制邏輯，限制對屬性的不合理操作；
（3）便於修改，增強代碼的可維護性；
實現：封裝：將復雜的處理過程寫進類的方法中，外部只需要調用一個函數就能實現。
class A{
public long sum(int begin,int end,int step)
{
long sum=0;
for(int i=begin;i<=end;i+=step)
sum+=i;
return sum;
}
}
class Test{
static public void main(String[] str){
A a=new A();
System.out.println(a.sum(1,1000,1)); //求從1到1000步長為1的和
}
}
將求階加封裝到方法，Test類只需要調用A類的一個方法就行，提高程序的簡易度。
9.
對於幾個已有的類來說，如果A繼承了B，則B為A的超類（Superclass），A為B的子類（Subclass）。
在Java中，一個類只能繼承一個超類，這種方式就是所謂的單繼承。雖然一個類只可以有一個超類，但是一個超類卻可以被多個
子類所繼承。通過繼承機制，子類擁有超類的成員變數和方法。當然，基於類的多態性特性，子類也可以擁有自己的成員變數和
方法。Java提供了一個最頂層的根類Object（java.lang.Object），它是所有類的超類。例如，下面的代碼聲明了一個Object對
象o1：Object o1;
10.
java 事件委託機制的概念,一個源產生一個事件並將它送到一個或多個監聽器那裡。在這種方案中，監聽器簡單的等待，直到它
收到一個事件。一旦事件被接受，監聽器將處理這個事件，然後返回
JAVA的事件處理機制的核心內容是:事件的發生與事件的處理。也就是說,某一個組件發生了一些變化,則該組件只需要產生一個事
件,而不用關心該事件如何被處理。其它組件如果對該事件感興趣,則編寫相應的事件處理代碼。
事件源:產生事件的對象;
監聽者:負責處理事件的方法。
java swing中的事件模型:
事件源：即各種可以被操作從而產生相應的組件。
事件類型：對於一個組件可以產生很多類型的事件，比如滑鼠單雙擊、changed等；一種事件可以被不同的組件產生
事件處理介面：這也就是真正處理事件的地方，針對各種事件提供了不同的介面，你只需要新建一個class
implements這些介面，這些類的實例稱為監聽器listener，實現其中與特定事件相關的方法。
注冊：事件源有了，監聽器有了，那麼下一步就是把二者聯系起來，component.addXXXListener(監聽器對象)；
Ⅸ 在java中有沒有委託
沒有，但有「代理」這樣的寫法，如自定義事件
~~~~
Ⅹ 用jAVAswing寫一個用戶登錄的界面，要求使用事件委託模型，要求對主要語句進行說明
這個我開發過，怎麼給你呢？
我把部分代碼貼出來把
import Zhujiemian.*;
import java.awt.*;
import java.sql.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.JOptionPane;
public class DengLu2 extends Frame implements ActionListener
{
static int i;//用來統計輸入次數
JieMian jinru;
Label userName,code;
TextField input_name,input_code;
Panel panel;
Button confirm,cancel;
JButton zuce;
DengLu2(String s)
{ super(s);
setLayout(null);
setBounds(400,400,300,200);
userName=new Label("用戶名"); code=new Label("密碼");
panel=new Panel();
input_name=new TextField();
input_code=new TextField();input_code.setEchoChar('*');
confirm=new Button("確定");
cancel=new Button("取消");
Icon iconzhuce=new ImageIcon("zhuce.gif");
zuce=new JButton("注冊",iconzhuce);
input_name.addActionListener(this);
input_code.addActionListener(this);
confirm.addActionListener(this);
cancel.addActionListener(this);
zuce.addActionListener(this);
userName.setBounds(40,50,40,20);
input_name.setBounds(110,50,80,20);
zuce.setBounds(220,140,70,20);
code.setBounds(40,90,40,20);
input_code.setBounds(110,90,80,20);
confirm.setBounds(60,130,60,30);
cancel.setBounds(140,130,60,30);
add(userName); add(code); add(input_name); add(input_code);
add(confirm); add(cancel); add(zuce);
setVisible(true);
seti();
validate();
addWindowListener( new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
setVisible(false);
}
}
);
}
public void actionPerformed(ActionEvent e)
{
Connection con;
Statement sql;
ResultSet rs;
if(e.getSource()==confirm||e.getSource()==input_name||e.getSource()==input_code)
{
String name,mima,quanxian;
try
{ Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");}
catch(ClassNotFoundException ae)
{System.out.println(""+ae);}
try
{
con=DriverManager.getConnection("jdbc:odbc:20404");
sql=con.createStatement();
rs=sql.executeQuery("SELECT * FROM yonghuxinxi");
while(rs.next())
{
name=rs.getString(1);
mima=rs.getString(2);
quanxian=rs.getString(3);
if(input_name.getText().equals(name)&&input_code.getText().equals(mima))
{
jinru=new JieMian("學生檔案管理系統");
jinru.kejian(quanxian);
con.close();
setVisible(false);
return ;
}
}
JOptionPane.showMessageDialog(this,"用戶名或密碼錯誤","哈哈",JOptionPane.WARNING_MESSAGE);
i++;
if(i==3)
{
JOptionPane.showMessageDialog(this,"您已三次輸入錯誤!!系統將自我保護性退出","哈哈",JOptionPane.WARNING_MESSAGE);
System.exit(0);
}
con.close();
}
catch(SQLException ee)
{System.out.println(""+ee);}
}
else if(e.getSource()==cancel)
{
System.exit(0);
}
else if(e.getSource()==zuce)
{
new zucekuang("注冊框");
}
}
//用來統計輸入數據變數i的賦值
public void seti()
{
i=0;
}
}
class zucekuang extends Frame implements ActionListener
{
TextField text1,text2,text3;
Label panel1,panel2,panel3,panel4;
Button button1,button2;
Choice choice;
String name,mima,quanxian,beizhu;
Connection con;
Statement sql;
ResultSet rs;
public zucekuang(String s)
{
super(s);
setLayout(null);
setBounds(300,300,300,250);
panel1=new Label("姓名");
add(panel1); panel1.setBounds(10,30,50,20);
text1=new TextField();
add(text1); text1.setBounds(70,30,100,20);
panel2=new Label("密碼");
add(panel2); panel2.setBounds(10,60,50,20);
text2=new TextField();
add(text2); text2.setBounds(70,60,100,20);
panel3=new Label("許可權");
add(panel3); panel3.setBounds(10,90,50,20);
choice=new Choice();
add(choice); choice.setBounds(70,90,100,20);
choice.add("管理員");choice.add("學生");
panel4=new Label("備注");
add(panel4); panel4.setBounds(10,120,50,20);
text3=new TextField();
add(text3); text3.setBounds(70,120,200,30);
button1=new Button("確定");
add(button1); button1.setBounds(70,160,50,20);
button1.addActionListener(this);
button2=new Button("取消");
add(button2); button2.setBounds(180,160,50,20);
button2.addActionListener(this);
setBackground(Color.yellow);
addWindowListener( new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
setVisible(false);
}
}
);
validate();
setVisible(true);
}
public void actionPerformed(ActionEvent e)
{
if(e.getSource()==button1)
{
if(check())
JOptionPane.showMessageDialog(this,"元組已存在","哈哈",JOptionPane.WARNING_MESSAGE);
else
{try{Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");}
catch(ClassNotFoundException f)
{System.out.println(""+f);}
try{
con=DriverManager.getConnection("jdbc:odbc:20404","","");
sql=con.createStatement();
name=text1.getText();mima=text2.getText();
quanxian=choice.getSelectedItem();beizhu=text3.getText();
String update,insert;
insert="("+"'"+name+"'"+","+"'"+mima+"'"+","+"'"+quanxian+"'"+","+"'"+beizhu+"'"+")";
update="INSERT INTO yonghuxinxi VALUES "+insert;
sql.executeUpdate(update);
con.close();
JOptionPane.showMessageDialog(this,"注冊成功","哈哈",JOptionPane.WARNING_MESSAGE);
setVisible(false);
}
catch(SQLException a)
{
System.out.println(""+a);
}
}
}
else if(e.getSource()==button2)
{
setVisible(false);
}
}
public boolean check()
{
String name1,mima1,quanxian1;
try{ Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");}
catch(ClassNotFoundException e)
{System.out.println(""+e);}
try{ con=DriverManager.getConnection("jdbc:odbc:20404","","");
sql=con.createStatement();
rs=sql.executeQuery("SELECT * FROM yonghuxinxi");
while(rs.next())
{ name1=rs.getString(1);
mima1=rs.getString(2);
quanxian1=rs.getString(3);
if(text1.getText().equals(name1)&&
choice.getSelectedItem().equals(quanxian1))
{return true;}
}
con.close();
}
catch(SQLException e)
{
System.out.println(""+e);
}
return false;
}
}
class DengLu
{
public static void main(String args[])
{
new DengLu2("登陸界面");
}
}
這個是用odbc來鏈接資料庫的，給你看看，當然完成的代碼現在還不能貼出來，希望給你參考參考，基本的swing度在裡面。