Ⅰ 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度在里面。