注意！！！（单选题答案里面的粗黑的有分号是代表同时满足；填空题答案里面的粗黑的有分号是代表其中一个就满足）
(做错的题目）
判断题
java有垃圾回收机制，内存回收程序可在指定的时间释放内存对象。（×）
解释：
Java是一种纯面向对象的语言，支持封装性、继承性和多态性等三个特点。（√）
单选题
填空题
(做对的题目）
判断题
一个".java"源文件中可以包括多个公共类。（×）
解释： 可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。一个文件中可以只有非public类，如果只有一个非public类，此类可以跟文件名不同。
Java的源代码中定义几个类，编译结果就生成几个以.class为后缀的字节码文件。（√）
由于Java的平台无关性使得Java程序经过一次编译后可以移植到别的任意平台上解释执行，即Java具有可移植性。（√）
Java内置了多线程技术，定义了一些类和方法等来建立和管理用户定义的多线程，它具有并发性。（√）
Java语言自带的虚拟机很好地实现了跨平台性，它提供了一个字节码到底层硬件平台及操作系统的屏障，使得Java源程序代码经过编译后生成二进制的字节码是与平台无关的，但可被Java虚拟机解释执行。（√）
Java语言不区分大小写。（×）
Java提供自动垃圾回收机制，异常处理机制，进行严格的类型检查，它具有健壮性。（√）
Java的源代码中定义几个类，编译结果就生成几个以.class为后缀的字节码文件。（√）
Java语言是一种解释执行的语言。（√）
Java风格类似于C++，但它摒弃了C++中容易引起程序错误的地方，它是一种比较难学和比较复杂的编程语言。（×）
Java在语言级安全性、编译时安全性、运行时安全性、可执行代码安全性等四个层面都采取相关技术。（√）
单选题
java语言的执行模式是 半编译和半解释型。
在当前的java实现中，每个编译单元就是一个以 java 为后缀的文件。
以下叙述中不属于Java语言特点的是 宏定义。
Java语言具有许多优点和特点，下列选项中，哪个反映了Java程序并行机制的特点？多线性
下列关于虚拟机说法错误的是：虚拟不可以用硬件实现
下列关于java语言的叙述中，正确的是 面向对象的语言
命令“Java.exe”的作用：java编译器
编译Java程序时，用于指定生成class文件位置的选项是 -d
JDK中，用 javac.exe 命令对其源文件进行编译，生成字节码文件。
Java属于以下哪种语言 高级语言
java语言是1995年由 Sun 公司发布的。
下列说法哪个正确？ 一个程序可以包含多个源文件
编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为 .class
下面哪种类型的文件可以在Java虚拟机中运行？ .class
Java SE的命令文件（java、javac、javadoc等）所在目录是 %JAVA_HOME%\bin
Java为移动设备提供的平台是 J2ME
每个java的编译单元可包含多个类或界面，但是每个编译单元最多只能有 一个 类或者界面是公共的。
下列不属于java语言鲁棒性特点的是：java能运行虚拟机实现跨平台
下列语句哪一个正确 Java程序经编译后会产生byte code
下列哪些语句关于Java内存回收的说明是正确的? 内存回收程序负责释放无用内存
java程序的执行过程中用到一套JDK工具，其中javac.exe指: java语言编译器
在以下供选择的概念中，不属于面向对象语言概念的是 函数
下列选项中，不属于Java语言特点的一项是 编译执行
填空题
java是一个网络编程语言，简单易学，利用了 面向对象 的技术基础，但又独立于硬件结构，具有可移植性、健壮性、安全性、高性能。
在JAVA语言中，将源代码翻译成 字节码 文件时产生的错误称为编译错误，而将程序在运行中产生的错误称为运行错误。
java可以跨平台的原因是 java虚拟机 。
Java源程序经过编译后的程序的扩展名是 .class。
1991年，SUN公司的Jame Gosling和Bill Joe等人，为电视、控制烤面包机等家用电器的交互操作开发了一个 Oak 软件，它是java的前身。
如果将类MyClass声明为public，它的文件名称必须是 MyClass.java 才能正常编译。
如果一个Java Applet程序文件中定义有3个类，则使用Sun公司的JDK编译器javac.exe编译该源程序文件将产生3个文件名与类名相同而扩展名为 .class 的字节码文件。
在JAVA语言中，将后缀名为 java 的源代码文件编译后形成后缀名为.class的字节码文件。
JAVA的产品主流操作系统平台是Solaris、Windows 和Macintosh。
JAVA的体系结构中，最下层是移植接口，上面一层是虚拟机，虚拟机的上层是java基本类和基本API，它们都是具有可扩展性。
Java源程序的扩展名是 .java
类库主要包括核心JAVA包、javax 和org扩展包。
Java程序中的单行注释符是 // 。
Java程序中的多行注释符是 /* */
J2ME是为嵌入式和 移动设备 提供的Java平台，它的体系结构由Profiles、Configuration和OptionalPackages组成。
JAVA程序包括源代码（.java文件）、由编译器生成的类（.class文件） 、由归档工具jar生成的.jar文件、对象状态序列化.ser文件。
JAVA语言的执行模式是半编译和 半解释型。
每个java应用程序可以包括许多方法，但必须有且只能有一个 main 方法。
JAVA的体系结构中，最下层是 移植接口 ，由适配器和JAVA OS组成，保证JAVA体系结构可以跨平台。
JAVA系统运行时，通过 垃圾回收 机制周期性的释放无用对象所使用的内存，完成对象的清除。
如果一个Java Applet源程序文件只定义有一个类，该类的类名为MyFirstApplet，则存储该源程序的文件名必须为 MyFirstApplet.java 。
JAVA解释器采用生成与体系结构无关的 字节代码 指令的技术，只需安装JAVA运行系统，就可保证JAVA程序可以在网络的任何地方运行。
(做错的题目）
单选题
填空题
(做对的题目）
单选题
下列声明和赋值语句错误的是 float z=6.74567
自定义类型转换是由按 char-int-long-float-double 优先关系从低级数据转换为高级数据。
JAVA中，数据类型值中不可能出现的符号是 /
在字符串中，下列表示双引号的是 \"
java中，用 final 关键字定义常量。
下列属于条件运算符的是 ?
在java中语句：37.2 % 10的运算结果为 7.2
在java语句中，位运算操作数只能为整型或 字符型 数据。
～0010101语句的执行结果为 1101010
下列不属于分支语句关键字的是 while
以下哪个不是Java的原始数据类型 Boolean
如下哪个是Java中的标识符 width
关于选择结构下列哪个说法正确？if语句可以没有else语句对应
设 x = 2 , y = 4 , z = 3，则表达式 y＋＝z－－/＋＋x 的值是 5
解释： y＋＝z－－/＋＋x -> y = y + (z–)/(++x)
下列各选项中属于合法标识符的是 _vacl
设 y = 2 , z = 3 , n = 4，则表达式 n＝n+－y*z/n 的值是 3
解释：n＝n+－y*z/n -> n += -y*z/n
下列各选项中属于不合法标识符的是 2$_million
已知i为整形变量，关于一元运算＋＋i和i++，下列说法正确的是 在任何情况下变量i的值都增1
下列数据类型转换，必须进行强制类型转换的是 int->char
假设int x=2，三元表达式 x>0?x+1:5 的运行结果是以下哪个？3
下列不属于简单数据类型的是 类
java中，八进制数以 0 开头。
在java中，Integer.MAX_VALUE表示 整数类型最大值
下列语句片断中，four得值为 '4’
int three=3;
char one=‘1’;
char four=(char)(three+one);
int类型变量在内存中的位数为 32
解释：4个字节，24
关于变量的作用范围，下列说法错误的是 异常处理参数作用域为整个类
00101010 & 00010111语句的执行结果为 00000010
在java语句中，运算符 && 实现 逻辑与
00101010 | 00010111语句的执行结果为 00111111
复合语句是用 大括号{} 括起来的一段代码。
多分支语句 switch（表达式）｛｝中，表达式不可以返回哪种类型的值 接口型
三元条件运算符ex1 ? ex2：ex3，相当于下面 if(ex1) ex2; else ex3 语句。
一个循环一般应包括哪几部分内容 初始化部分，循环体部分，迭代部分，终止部分
在java中，字符串由java.lang.String和 java.lang.StringBuffer 定义。
有以下方法的定义，请选择该方法的返回类型 double
returnType method(byte x, double y)
{
return (short) x/y*2;
}
下列 0x7E 代表十六进制整数。
以下关于JAVA程序的叙述中正确的是 JAVA程序中必须有一个主函数
填空题
设 x = 2 ，则表达式 ( x + + )／( - - x) 的值是 2
在java语言中，boolean型常量只有true和 false 两个值。
数据类型包括简单数据类型和复合数据类型。复合数据类型又包括类、数组和 接口 。
java语言中的各种数据类型之间提供自动转换，如第1操作数是byte类型，第2操作数是float类型，其结果是 float 类型。
在java语言中，如果实数后没有字母，计算机默认值为 double 类型。
设 x == 2 ，则表达式 ( x + + )／3 的值是 0 。
Java中用于定义小数的关键字有两个：float 和 double ，后者精度高于前者。
在Java中定义一个字符串类型的变量str的语句是：String str; 。
当声明一个数组int arr[] = new int[5]; 时，这代表这个数组所保存的变量类型是int，数组名是 arr 。
当声明一个数组int arr[] = new int[5]; 时，这代表这个数组元素下标的使用范围是0到 4。
假设x=13，y=4，则表达式x%y != 0的数据类型是 boolean。
JAVA应用程序运行的第一个函数是 main
int a=6,b=5; float c; c=a/b; 则c的值为 1.0
Java的三目运算符是 ?:
int x=2,y=5; boolean b;b=++x>4&++y<3，则x、y、b的值为3 ,6 和 false
以下程序段的输出结果是 三角形
int x = 5, y = 6, z = 4;
if (x + y > z && x + z > y && z + y > x)
System.out.println(“三角形”);
else
System.out.println(“不是三角形”);
else子句不能单独作为语句使用，它必须和if子句配对使用，那么else子句与if子句的配对原则是:else子句总是与离它 最近 的if子句配对使用。
递归的基本思想就是“自身调用自身”，一个使用递归技术的方法将直接或间接地调用 自身 的方法。
在Java的基本数据类型中，char型采用Unicode编码方案，无论是中文字符还是英文字符，每个Unicode码都是占用 2个字节内存空间。
语句boolean b1= 5 != 8；是声明一个变量并赋值，b1的值是 true。
浮点型数据属于实型数据，分为float和 double 两种类型。
标识符是以 字母、下划线、美元符号作为首字母的字符串序列。
八进制整数012表示十进制的 10
若x = 5，y = 10，则x >= y的逻辑值为 false
Java中用于两个数相等比较的运算符是 ==
当声明一个数组int arr[] = new int[5]; 时，这代表这个数组的大小为 5
假设x=13，y=4，则表达式 x%y != 0 的值是 true 。
已知：int a =8,b=6; 则：表达式 ++a-b++ 的值为 3。
短路逻辑运算符包括 && 和|| 。
定义一个单精度浮点型变量f，并赋值为1.56，JAVA语句为 float f =1.56F;float f =1.56f
循环语句包括while、do while和 for 三种。
java的跳转语句中 不包含 (包含/不包含)goto语句。
(做错的题目）
判断题
单选题
填空题
(做对的题目）
判断题
单选题
在Java语言中，封装是借助于 类 实现的。
定义一个类，必须使用的关键字是 class
关于对象的删除，下列说法正确的是 java把没有引用的对象作为垃圾收集起来并释放
关于方法main（）的说法哪个正确？ 一个类中可以没有main()方法
关于构造函数的说法哪个正确？构造函数与类同名
下列关于构造方法的叙述中，错误的是 构造方法不可以重载，但可以继承
解释：Java 构造函数不可以继承，因此不能被重写，但可以被重载（重写是父类的方法被子类重修改写了，重写在子类；重载就是一个类里面的同名方法，重载在同一个类，参数个数或类型）
参考：理解 Java 构造函数不可以继承
在编写Java Applet程序时，需在程序的开头写上 import java.applet.Applet 语句。
下列哪种说法是正确的 实例方法可直接调用本类的类方法
return语句：方法中可以有多句return
Java application中的主类需包含main方法，以下哪项是main方法的正确形参？String[] args
下列不属于面向对象编程的三个特征的是 指针操作
不允许作为类及类成员的访问控制符的是 static
解释：只有公有，保护，私有，默认有访问权限，没有static
下列修饰符中与访问控制无关的是 final
关于对象成员占用内存的说法哪个正确？同一个类的对象使用不同的内存段，但静态成员关系相同的内存空间
构造函数何时被调用？创建对象时
下列static符号修饰成员后，可以在Java中用类名前缀直接调用。
解释：Java中static的用法
填空题
(做错的题目）
判断题
填空题
(做对的题目）
判断题
单选题
填空题
(做错的题目）
单选题
填空题
(做对的题目）
单选题
填空题
(做错的题目）
(做对的题目）
判断题
单选题
填空题
(做错的题目）
判断题
单选题
填空题
(做对的题目）
判断题
单选题
填空题
(做对的题目）
判断题
单选题
填空题
(做错的题目）
单选题
填空题
(做对的题目）
判断题
单选题
填空题
(做错的题目）
单选题
填空题
(做对的题目）
单选题
语句RandomAccessFile raf2 = new RandomAccessFile(“1.txt”,“rw” )的功能是打开当前目录下的文件1.txt，既可以向文件写数据，也可以从文件读数据。
字符流与字节流的区别在于每次读写的字节数不同
凡是从中央处理器流向外部设备的数据流称为输出流
流的传递方式是串行的
下列不是java的输入输出流的是文本流
java中，实现通过网络使用URL访问对象的功能的流是URL输入流
当把一个程序、线程或代码段的输出连接到另一个程序、线程或代码段的输入时，应使用PipedOutput流。
下列不属于FileInputStream输入流的read（）成员函数的是int read(int line);
获取一个不包含路径的文件名的方法为String getName( )
当处理的数据量很多，或向文件写很多次小数据，一般使用BufferedOutput流。
FilterOutputStream是BufferedOutputStream、DataOutputStream及PrintStream的父类，以下哪个类可能是FilterOutputStream构造函数的参数类型？OutputStream
如果需要从文件中读取数据，则可以在程序中创建哪一个类的对象FileInputStream
下面的程序段创建了BufferedReader类的对象in，以便读取本机c盘my文件夹下的文件1.txt。File构造函数中正确的路径和文件名的表示是 “c:\my\1.txt”。
File f = new File(填代码处);
FileReader file =new FileReader(f);
BufferedReader in=new BufferedReader(file);
下面的程序段的功能不正确的是在当前目录下生成子目录：\xxx\yyy\zzz；生成目录： e:\xxx\yyy\zzz；在当前目录下生成文件xxx.yyy.zzz
File file1=new File(“d:\xxx\yyy\zzz”);
file1.mkdirs();
下列流中哪个不属于字节流InputStreamReader
填空题
(做错的题目）
(做对的题目)
单选题
填空题
如果有两个类A、B（注意不是接口），你想同时使用这两个类的功能，那么你会如何编写这个C类呢？
答：因为类 A、B 不是接口，所以是不可以直接继承的，但可以将 A、B 类定义成父子类，那么 C 类就能实现 A、B 类的功能了。假如 A 为 B 的父类，B 为 C 的父类，此时 C 就能实现 A、B 的功能。
接口有什么优点？
答：接口有以下优点：
1）接口只是一个框架而没有实现，因此在接口定义时不需要考虑接口中的方法如何实现；
2）利用接口可达到实现多继承的目地；
3）可以在不暴露对象的类的前提下，暴露对象的编程接口；
4）不用强迫类关系在无关类中截获相似处(采用适配器就可以了)；
5）声明想执行的一个或多个方法。
在java中如果声明一个类为final，表示什么意思？
答：final 是最终的意思，final 可用于定义变量、方法和类但含义不同，用
final 定义变量时表示它常量，用 final 定义方法时表示该方法不能被重写，声明为 final 的类不能被继承。
请简述重载和重写的区别。
答：方法的重写 Overriding 和重载 Overloading 是 Java 多态性的不同表现。重写 Overriding 是父类与子类之间多态性的一种表现，重载 Overloading
是一个类中多态性的一种表现。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。
如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded 的方法是可以改变返回值的类型。
什么是继承？
答：通过必要的说明能够实现某个类无需重新定义就拥有另一个类的某些属性和方法，并把这种关系称为继承，先定义的类称为父类，后定义的类称为子类， 并且允许多层的继承关系。
在Java中，怎样创建一个线程？
答：
⑴ 定义类来实现 Runnable 接口
class TestThread implements Runnable {
public void run() { …}
}
⑵ 继承 Thread 类来实现
class TestThread extends Thread {
TestThread(String name) {
super(name);
}
public void run() {…}
}
abstract class SuperAbstract{
void a(){...}
abstract int c(int i);
}
interface AsSuper{
void x();
}
abstract class SubAbstract extends SuperAbstract implements AsSuper {
public void b(){...}
abstract String f();
}
public class InheritAbstract extends SubAbstract{
public void x(){...}
public int c(int i){...}
public String f(){...}
public static void main(String args[]){
InheritAbstract instance = new InheritAbstract();
instance.x();
instance.a();
instance.b();
instance.c(100);
System.out.println(instance.f());
}
}
在以上这段程序中：
抽象类有：SuperAbstract 和 (SubAbstract) (写出类名)
非抽象类有：(InheritAbstract) (写出类名)
接口有：(AsSuper) （写接口名）
AsSuper中的x()方法是（抽象）方法，所以在InheritAbstract中必须对它进行（覆盖和实现）
class Animal {
public void shout(){
System.out.println("动物叫!");
}
}
class Cat implements Animal {
public void shout(){
super.shout();
System.out.println("喵喵...");
}
}
public class Example01{
public static void main(String[] args){
Animal an = new Cat();
an.shout();
}
}
答：程序编译不能通过，因为 Animal 类不是接口，所以 Cat 类必须继承 Animal 类，也就是说如果将 Cat 类中的 implements 关键字改为 extends 就可以，其输出结果为“动物叫！”和“喵喵…”。
下面是People和Child类的定义。请问：在执行new Child（“mike”）的时候都有哪些构造方法被顺序调用？请写出其运行结果。
class People{
String name;
public People(){
System.out.println("People1");
}
public People(String name){
System.out.println("People2:"+name);
this.name = name;
}
}
class Child extends People{
People father;
public Child(){
System.out.println("Child1");
}
public Child(String name){
System.out.println("Child2:"+name);
this.name = name;
father = new People(name + "'F");
}
}
答：按 People()、Child(String name)、People(String name)顺序调用构造方法，运行结果如下：
People1
Child2:mike
People2:mike'F
阅读以下程序，写出输出结果。
class Animal{
Animal(){System.out.print("Animal ");}
}
public class Dog extends Animal{
Dog(){System.out.print("Dog");}
public static void main(String[] args){
Dog snoppy = new Dog();
}
}
答：输出结果：Animal Dog
public void actionPerformed(ActionEvent e){
InetAddress SguAddress = InetAddress.getByName("www.sgu.edu.cn");
System.out.println(SguAddress);
System.out.println(SguAddress.getHostName());
System.out.println(SguAddress.getHostAddress());
}
答：根据域名 www.sgu.edu.cn 返回一个 InetAddress 对象，并输出其计算机名或域名，以及其 IP 地址。
public class HelloWorld{
public static void main(String[] args){
int i=0;
String greetings[] = {"Hello world!","No,I mean it!","HELLO WORLD!!"};
while(i<4){
try
{
System.out.println("greeting[i]");
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("Re-setting Index Value");
}
finally{
System.out.println("This is always printed");
}
i++;
}
}
}
答：try catch
在一个数组元素值递增的数组中插入一个元素值，要求按原来的规律将它插入数组中合适的位置（使用折半查找）
import java.util.*;
public class HelloWorld {
public static void main(String[] args) {
int[] a = { 1, 2, 6, 14, 25, 36, 37, 55 };
int[] b = new int[a.length + 1];
int lower = 0, higher = a.length - 1;
int i = 0;
Scanner s = new Scanner(System.in);
System.out.print("请输入一个整数：");
int num = s.nextInt();
while (lower <= higher) {
if (num >= a[(lower + higher) / 2]) {
lower = (lower + higher) / 2 + 1;
} else {
higher = (lower + higher) / 2 - 1;
}
}
for (i = 0; i < lower; i++) {
b[i] = a[i];
}
b[i] = num;
for (i = lower + 1; i < b.length; i++) {
b[i] = a[i - 1];
}
for (i = 0; i < b.length; i++) {
System.out.println(b[i]);
}
}
}
import java.awt.*;
import java.awt.event.*;
public class Test3{
public static void main(String args[]){
MyMenuFrame mf = new MyMenuFrame();
mf.setSize(new Dimension(300,200));
mf.setVisible(true);
}
}
class MyMenuFrame extends Frame{
MenuBar m_MenuBar;
Menu menuFile;
MenuItem mi_File_Open, mi_File_Close, mi_File_Exit;
MyMenuFrame() {
super("拥有菜单的窗口");
m_MenuBar = new MenuBar();
menuFile = new Menu("文件");
mi_File_Open = new MenuItem("打开" ,new MenuShortcut('O'));
mi_File_Close = new MenuItem("关闭");
mi_File_Exit = new MenuItem(" 退 出 ");
mi_File_Exit.setShortcut(new MenuShortcut('X'));
menuFile.add(mi_File_Open);
menuFile.add(mi_File_Close);
menuFile.addSeparator();
menuFile.add(mi_File_Exit);
m_MenuBar.add(menuFile);
this.setMenuBar(m_MenuBar);
}
}
1）界面设计部份
package test04;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class menuTest implements ItemListener,ActionListener{
JFrame frame = new JFrame ("菜单测试");
JTextField tf = new JTextField();
public static void main(String[] args) {
menuTest x=new menuTest();
JMenuBar menubar = new JMenuBar(); //菜单栏
JMenu menu; //菜单
JMenuItem menuItem; //菜单项
x.frame.setJMenuBar(menubar);
// 建立文件菜单
menu = new JMenu("文件"); menubar.add(menu);
menuItem = new JMenuItem("保存(S)",KeyEvent.VK_S );
menuItem.addActionListener(x);
menu.add(menuItem);
menu.add(new JSeparator());//加入分隔线
menuItem = new JMenuItem("退出(E)" );
menuItem.setMnemonic(KeyEvent.VK_E);
menuItem.addActionListener(x); menu.add(menuItem);
// 建立选项菜单
menu = new JMenu("选项" );
menubar.add(menu);
JCheckBoxMenuItem cm = new JCheckBoxMenuItem("复选");
cm.addItemListener(x);
menu.add(cm);
JRadioButtonMenuItem rm = new JRadioButtonMenuItem(" 单 选
",true);
rm.addItemListener(x); menu.add(rm);
x.tf.setEditable(false); //设置为不可编辑的
Container cp = x.frame.getContentPane();
cp.add(x.tf,BorderLayout.SOUTH);
x.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
x.frame.setSize(300,200);
x.frame.setVisible(true);
}
2)实现 ItemListener 接口中的方法
public void itemStateChanged(ItemEvent e) {
int state = e.getStateChange();
JMenuItem amenuItem = (JMenuItem)e.getSource();
String command = amenuItem.getText();
if (state==ItemEvent.SELECTED)
tf.setText(command+" 已经选中");
else
tf.setText(command+" 没有选中");
}
3)实现 ActionListener 接口中的方法
public void actionPerformed(ActionEvent e) {
tf.setText(e.getActionCommand());
if (e.getActionCommand()=="退出(E)") {
System.exit(0);
}
}
}
package test_dialog;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class DialogTest implements ActionListener{
JFrame frame;
JDialog dialog;
JButton button;
public static void main(String[] args) {
DialogTest jd=new
DialogTest(); jd.go();
}
public void go(){
frame = new JFrame ("对话框测试");
JLabel Linfo = new JLabel (" 韶关学院 2013 JAVA 综合测试题");
button = new JButton(" 输 入 用 户 信 息 ");
button.addActionListener(this);
Container cp = frame.getContentPane();
cp.add(Linfo,BorderLayout.CENTER);
cp.add(button,BorderLayout.SOUTH);
dialog=new JDialog(frame,"用户信息输入框",true);
Container dp = dialog.getContentPane();
JLabel Lname = new JLabel ("姓名:");
JLabel Ltel = new JLabel ("电话:");
JLabel Lemail = new JLabel ("E-Mail 地址:");
JTextField Tname = new JTextField("", 9);
JTextField Ttel = new JTextField("", 10);
JTextField Temail = new JTextField("", 20);
JButton buttonQ = new JButton(" 确 定 ");
JButton buttonC = new JButton(" 取 消 ");
JPanel jpane1 = new JPanel();
JPanel jpane2 = new JPanel();
JPanel jpane3 = new JPanel();
JPanel jpane123 = new JPanel();
jpane1.setLayout(new FlowLayout(FlowLayout.LEFT));
jpane2.setLayout(new FlowLayout(FlowLayout.LEFT));
jpane3.setLayout(new FlowLayout(FlowLayout.RIGHT));
jpane1.add(Lname);
jpane1.add(Tname);
jpane1.add(Ltel);
jpane1.add(Ttel);
jpane2.add(Lemail);
jpane2.add(Temail);
jpane3.add(buttonQ);
jpane3.add(buttonC);
jpane123.setLayout(new GridLayout(0,1));
jpane123.add(jpane1);
jpane123.add(jpane2);
jpane123.add(jpane3);
dp.add(jpane123);
dialog.pack();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(200,150);
frame.setVisible(true);
}
public void actionPerformed(ActionEvent e){
dialog.setVisible(true);
}
}
import java.awt.Color;
import java.awt.Frame;
import java.awt.Menu;
import java.awt.MenuBar;
import java.awt.MenuItem;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
/*
* 主窗体
*/
public class MyFrame extends Frame {
private static final long serialVersionUID = 6895463895656626294
private Frame frmMain; // 窗体
MenuBar mb; // 菜单栏
Menu mnuFile; // "文件"菜单
Menu mnuEdit; // "编辑"菜单
MenuItem miOpen; // "打开"菜单项
MenuItem miSave; // "保存"菜单项
MenuItem miClose; // "关闭"菜单项
MenuItem miCopy; // "复制"菜单项
MenuItem miPaste; // "粘贴"菜单项
public MyFrame() {
frmMain = new Frame("主窗体");
// 创建菜单栏
mb = new MenuBar();
// 创建菜单
mnuFile = new Menu("文件"); mnuEdit = new Menu("编辑");
// 创建菜单项
miOpen = new MenuItem("打开");
miSave = new MenuItem("保存");
miClose = new MenuItem("关闭");
miCopy = new MenuItem("复制");
miPaste = new MenuItem("粘贴");
}
public void showFrame() {
frmMain.setSize(800, 600);
frmMain.setLocation(100, 100);
frmMain.setBackground(Color.white);
frmMain.setVisible(true); frmMain.setLayout(null);
frmMain.addWindowListener(new WindowHandler());// 注册窗口监听器
// 将菜单栏放入窗体中
frmMain.setMenuBar(mb);
// 将菜单放入菜单栏中
mb.add(mnuFile);
mb.add(mnuEdit);
// 将菜单项放入菜单中
mnuFile.add(miOpen);
mnuFile.add(miSave);
mnuFile.add(miClose);
mnuEdit.add(miCopy);
mnuEdit.add(miPaste);
// 注册动作事件监听器
miClose.setActionCommand("miClose_Clicked");
miClose.addActionListener(new MenuHandler());
}
// 定义一个内部类，在这个类中编写窗口关闭事件处理程序。
private class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0); // 退出应用程序，状态码 0 表示正常终止，非 0 表示异常终止。
}
}
// 定义一个内部类，在这个类中编写动作事件处理程序。
private class MenuHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand() == "miClose_Clicked") {
System.exit(0); // 退出应用程序
}
}
}
}
public class TestMyFrame {
public static void main(String[] args) {
// 启动主窗体
MyFrame guiWindow = new MyFrame(); guiWindow.showFrame();
}
}
import java.io.*;
import java.util.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;
import java.applet.*;
public class multiAudio extends Applet implements ActionListener{
String hUr11,hUr12;
AudioClip audio1,audio2;
boolean hState1=false;
boolean hState2=false;
public void init(){
reize(300,100);
hUr11=＂/test.wav＂;
hUr12=＂/test.mid＂;
try{
audio1=getAudioClip(new URL(getDocumentBase(),hUr11));
audio2=getAudioClip(new URL(getDocumentBase(),hUr12));
}
catch(Exception e){ }
this.setBackground(Color.lightGray); Pane1 p1=new Pane1();
Button myButton1=new Button(＂播放 1＂);
myButton1.addActionListener(this);
p1.add(myButton1);
Button myButton2=new Button(＂停止 1＂);
myButton2.addActionListener(this);
p1.add(myButton2);
Button myButton3=new Button(＂循环 1＂);
myButton3.addActionListener(this);
p1.add(myButton3);
this.add(p1);
Pane1 p2=new Pane1();
Button mybutton4=new Button(＂播放 2＂);
myButton4.addActionListener(this); p2.add(myButton4);
Button myButton5=new Button(＂停止 2＂);
myButton5.addActionListener(this);
p2.add(myButton5);
Button myButton6=new Button(＂循环 2＂);
myButton6.addActionListener(this); p2.add(myButton6);
this.add(p2);
}
public void actionPerformed(ActionEvent e){
if(e.getActionCommand()==＂播放 1＂){
if(hState1==false){
audio1.play(); hState1=true;
}
}
else{
if(e.getActionCommand()==＂播放 2＂)){
if(hState2==false){
audio2.play(); hState2=ture;
}
}
else{
if(e.getActionCommand()==＂停止 1＂){
if(hState1==true){
audio1.stop(); hState1=false;
}
}
else{
if(e.getActionCommand()==＂停止 2＂){
if(hState2==true){
audio2.stop();
hState2=false;
}
}
else{
if(e.getActionCommand()==＂循环 1＂)
audio1.loop();
else audio2.loop();
}
}
}
}
}
}