Java程序设计实例与操作答案
第一章认识Java
一．选择题
1．D
2．B
3．D
4．D
二．简答题
1．Java语言有三个技术分支，并且产生了三个版本的Java运行平台，分别是J2SE 标准版，主要用于开发桌面应用程序、低端服务器应用程序和Java Applet程序；J2EE 企业版，主要用于开发分布式网络程序，如电子商务网站和ERP系统等；J2ME 精简版，主要用于嵌入式系统开发，如移动电话、掌上电脑（PDA）以及其他无线设备。
2．Java应用程序和Java Applet程序。Java应用程序要依赖JRE或JDK中的解释器来运行，而Java Applet程序的调用命令嵌入在网页的HTML代码文件中，显示网页时由Web 浏览器内置的Java解释器解释执行，并将其内容显示网页中。
3．Java虚拟机JVM是Java V irtual Machine的缩写。JVM是一个虚构出来的计算机，它有自己完善的硬件架构，如处理器、堆栈、寄存器等，还具有相应的指令系统。Java字节码文件包括的代码就是基于JVM的。
4．Java语言主要有简单、面向对象、分布式、健壮、安全、跨平台、解释执行、多线程和动态执行的特点。
5．开发Java应用程序时，首先使用任何文本编辑器创建和编辑Java源程序，保存源程序文件时，文件的扩展名为“*.java”。然后使用“javac 程序名.java”命令把源程序编译为字节码文件，最后使用“java 程序名”将字节码文件翻译为计算机可以理解的指令并运行。
开发Java小程序时，首先使用任意纯文本编辑器编写Java源程序和HTML文件，并分别以扩展名“.java”和“.html”保存。其中，HTML文件中应包含调用Java字节码文件的指令。HTML文件可以使用IE浏览器浏览，也可以使用JDK提供的Appletviewer工具浏览。三．编程题
1．解答
//Test.java
class Person {
String name;
String address;
String telephone;
Person(String name1, String address1, String telephone1) {
name = name1; address = address1; telephone = telephone1;
}
String getName() {
return name; }
String getAddress() {
return address; }
String getTelephone() {
return telephone; }
}
public class Test {
public static void main(String[] args) {
Person lily = new Person("lily", "金企鹅18号", "158********");
System.out.println("姓名：" + lily.getName());
System.out.println("地址：" + lily.getAddress());
System.out.println("电话号码：" + lily.getTelephone());
}
}
2．解答
文件TestApplet.java与TestApplet.html都放在d盘根目录下。
//TestApplet.java
import java.applet.Applet;
import java.awt.Graphics;
public class TestApplet extends Applet {
public void paint(Graphics g) {
g.drawString("姓名：lily", 20, 20);
g.drawString("地址：金企鹅18号", 20, 40);
g.drawString("电话号码：158********", 20, 60);
}
}
//TestApplet.html
第二章Java编程基础
一．选择题
1. C
2. D
3. C
4. C
5. B
6. C
7. B
二．简答题
1、Java语言有byte（字节型）、short（短整型）、int（整型）、long（长整型）、float （单精度）、double（双精度）、char（字符型）、boolean（布尔型）8中基本类型。
2、变量是指在程序运行过程中可以发生变化的量，它用于在程序运行时临时存放数据。常量是指在程序运行过程中不能改变的量，它用来记忆一个固定的数值。
3、在参与运算的数据包含多种数据类型，或者赋值语句中左侧赋值变量和右侧表达式结果类型不同时，如果赋值变量的数据类型优先级低于表达式结果数据类型的优先级，或者两者同级，则表达式结果的数据类型必须强制转换为赋值变量的数据类型。
4、break语句可以用在循环语句的内部，用来结束循环。continue语句只能用在循环语句内部，用来跳过本次循环，继续执行下一次循环。
三．编程题
1、解答
// IsTriangle.java
public class IsTriangle {
public static void main(String[] args) {
int a = 0, b = 0, c = 0; //定义三边长
System.out.println("请输入三角形的三条边长：（注意：边长为整数）");
Scanner in = new Scanner(System.in);
a = in.nextInt();
b = in.nextInt();
c = in.nextInt();
if (a + b > c && a + c > b && b + c > a) { //判断是否两边之和大于第三边
System.out.println(a + "," + b + "," + c + "三条边能组成三角形！");
} else {
System.out.println(a + "," + b + "," + c + "三条边不能组成三角形！");
}
}
}
2、解答
// ComputeDay.java
public class ComputeDay {
static final int SUN_SELL = 20; //定义晴天卖花的数量
static final int RAIN_SELL = 12; //定义雨天卖花的数量
public static void main(String[] args) {
int Flowers, sunDays = 0, rainDays = 0;
System.out.println("请输入总共卖出的鲜花数：");
Scanner in = new Scanner(System.in);
Flowers = in.nextInt(); //得到卖花的总数
int days = Flowers / 14; //计算总共卖花的天数
for (rainDays = 1; rainDays <= days; rainDays++) {
sunDays = days - rainDays;
if (SUN_SELL * sunDays + RAIN_SELL * rainDays == Flowers)
break;
}
System.out.println("一共有" + sunDays + "个晴天!");
System.out.println("一共有" + rainDays + "个阴天!");
}
}
第三章Java面向对象程序设计
一．选择题
1．D
2．C
3．A
4．B
5．B
6．D
二．简答题
1、如果用stati c关键字修饰成员变量，则该变量是一个类变量（又称静态变量）。不加static修饰的成员变量称为实例变量。
类变量跟实例变量的区别是，第一次调用类的时候，系统为类变量分配一次内存。不管以后类创建多少个对象，所有对象都共享该类的类变量。声明实例变量之后，每次创建类的新对象的时候，系统就会为该对象创建实例变量的副本，即该对象每个实例变量都有自己的内存空间。
2.、在方法体中声明的变量称为局部变量，它只能在方法体内使用。局部变量的作用域开始于它的声明处，结束于当前代码块结束处。如果没有声明代码块，则其开始于声明处，结束于方法体结束处。
3、访问控制修饰符有4个等级：private、protected、public以及默认（即不指定修饰符）。用private修饰的变量只能被所属类访问；用protected修饰的变量能被同一包中的类以及不同包中的子类访问；用public修饰的变量能被所有类访问；默认修饰的变量只能被同一包中的类访问。
4、多个方法共享一个名字，但方法参数的个数、类型或顺序会有所区别。
5、this用来表示当前类。当成员变量的名字和局部变量的名字相同时，如果要在方法中访问成员变量，可以使用this关键字。在方法体中，通过this关键字可访问当前类的成员变量和方法。在类的构造方法中可以调用其他形式的构造方法。
6、包是Java语言中有效管理类的一个机制。在程序中可以使用“import 包名.类名”的形式引用其他包中的类。
三．编程题
1、解答
public class Box {
private int length; //定义长度
private int width; //定义宽度
private int height; //定义高度
Box(int length, int width, int height) { //构造方法，初始化成员变量
this.length = length;
this.width = width;
this.height = height;
}
public void showMessage() {
System.out.println("盒子的长是：" + length);
System.out.println("盒子的宽是：" + width);
System.out.println("盒子的高是：" + height);
}
public static void main(String[] args) {
Box box = new Box(1, 5, 7); //创建对象
box.showMessage(); //调用显示属性的方法}
}
2、解答
import java.util.Scanner;
public class Compute {
static int x, y; //定义两个数
Compute(int x, int y) { //构造方法，初始化成员变量
Compute.x = x;
Compute.y = y;
}
void add() { //定义加法方法
System.out.println("两数的和为：" + (x + y));
}
void sub() { //定义减法方法
System.out.println("两数的差为：" + (x - y));
}
void Multiplication() { //定义乘法方法
System.out.println("两数的积为：" + (x * y));
}
void division() { //定义除法方法
System.out.println("两数的商为：" + (x / y));
}
public static void main(String[] args) {
System.out.println("请输入两个数：（注意：中间以空格分隔）");
Scanner in = new Scanner(System.in);
Compute data = new Compute(in.nextInt(), in.nextInt()); //创建对象
data.add();
data.sub();
data.Multiplication();
data.division();
}
}
第四章类的深入解析
一．选择题
1、D
2、D
3、D
4、C
二．简答题
1、方法的覆盖是指子类定义与父类名字相同、参数相同、返回类型相同的方法。重载方法是指在类中定义同名的几个方法，但方法的参数、类型和个数要有所区别。
2、多态性可以用“一个对外接口，多个内在实现方法”来表示。我们可以在一个类中定义多个同名方法，程序在调用某个方法时，系统会自动根据参数类型和个数的不同调用不同的方法。方法的覆盖和方法的重载是实现多态的两种形式。
3、定义类和方法时在声明时用abstract关键字修饰则就称为了抽象类和抽象方法。抽象方法只能在抽象类中定义，而抽象类中除了可以定义抽象方法，还可以定义一般的变量和方法。
4、接口的定义包括接口声明和接口体。定义接口的形式如下：
interface 接口名[extends 父接口名列表]{
//常量声明
//抽象方法声明
}
为了声明一个类来实现一个接口，在类的声明中要包括一条implements语句，可以在implements后面列出要实现的多个接口，这些接口名称之间应以逗号分隔。。
5、接口中只能定义抽象方法，而抽象类中可以定义非抽象方法。接口中只能定义public static final类型常量，而不能包含成员变量。抽象类则不然，它可以包含各种形式的成员变量和常量。类可以继承（实现）多个接口，但只能继承一个抽象父类。
三．编程题
1、解答
public class Employee extends Person { //定义子类
private String office; //定义办公室
private double salary; //定义薪水
private int date; //定义入职日期
Employee(String office, double salary, int date) {//构造方法
super();
this.office = office;
this.salary = salary;
this.date = date;
}
void showMessage() {
System.out.println("办公室：" + office);
System.out.println("入职日期：" + date);
System.out.println("薪水：" + salary);
}
public static void main(String[] args) {
Person xiaoli = new Person("xiaoli", "北京市海淀区大钟寺", "159********",
"xiaoli_111@https://www.360docs.net/doc/1512725500.html,"); //创建父类对象
xiaoli.showMessage(); //调用父类方法
Employee xiaowang = new Employee("事业部", 2500, 20100611);//定义子类对象
xiaowang.showMessage(); //调用子类方法}
}
class Person { //定义父类
private String name; //定义姓名
private String address; //定义地址
private String telephone; //定义电话号码
private String email; //定义邮箱
Person() {
}
Person(String name, String address, String telephone, String email) {
https://www.360docs.net/doc/1512725500.html, = name;
this.address = address;
this.telephone = telephone;
this.email = email;
}
void showMessage() {
System.out.println("姓名：" + name);
System.out.println("地址：" + address);
System.out.println("电话号码：" + telephone);
System.out.println("邮箱：" + email);
}
}
2、解答
interface Graphices {
// 计算面积的抽象方法，分号";"必不可少
public abstract double area();
}
abstract class PlaneGraphics {
protected String shape; // 形状
// 构造方法，将形状类型字符串赋予变量shape
public PlaneGraphics(String shape) {
this.shape = shape;
}
// 无参构造方法，图形类型为"未知图形"
public PlaneGraphics() {
this("未知图形");
}
public void print() {
}
// 设计长方形类Rectangle，继承平面图形类并实现图形接口
class Rectangle extends PlaneGraphics implements Graphices {
protected double length; // 长度
protected double width; // 宽度
// 长方形构造方法
public Rectangle(double length, double width) {
super("长方形");
this.length = length;
this.width = width;
}
// 正方形构造方法，正方形是长方形的特例
public Rectangle(double width) {
super("正方形");
this.length = width;
this.width = width;
}
// 无参构造方法，将length和width均赋0，此时图形形状为"未知图形"
public Rectangle() {
}
// 计算长方形面积，实现父类的抽象方法
public double area() {
return width * length;
}
public void print() {
System.out.println(shape + "面积为" + this.area());
}
}
// 设计椭圆类Eclipse，继承平面图形类并实现图形接口
class Eclipse extends PlaneGraphics implements Graphices {
protected double radius_a; // a轴半径
protected double radius_b; // b轴半径
// 椭圆构造方法
public Eclipse(double radius_a, double radius_b) {
super("椭圆");
this.radius_a = radius_a;
this.radius_b = radius_b;
}
// 圆构造方法，圆是椭圆的特例
public Eclipse(double radius_a) {
super("圆");
this.radius_a = radius_a;
this.radius_b = radius_a;
// 无参构造方法，将radius_a和radius_b均赋0，此时图形形状为"未知图形"
public Eclipse() {
}
// 计算椭圆的面积，实现父类的抽象方法
public double area() {
return Math.PI * radius_a * radius_b;
}
public void print() {
System.out.println(shape + "面积为" + this.area());
}
}
// 设计三角形类Triangle，继承平面图形类并实现图形接口
class Triangle extends PlaneGraphics implements Graphices {
protected double bottom;
protected double height;
Triangle(double bottom, double height) {
super("三角形");
this.bottom = bottom;
this.height = height;
}
public double area() {
return 0.5 * bottom * height;
}
public void print() {
System.out.println(shape + "面积为" + this.area());
}
}
public class PlaneGraphics_ex {
public static void main(String[] args) {
// 获得长方形子类实例
PlaneGraphics g = new Rectangle(10, 20);
// 调用抽象类中的print()方法
g.print();
g = new Eclipse(10, 20); // 椭圆
g.print();
g = new Triangle(10, 20);//三角形
g.print();
}
}
第五章数组和字符串
一．选择题
1、B
2、B
3、B
4、D
5、B
6、D
二．简答题
1、创建数组分为数组声明和数组初始化，声明一个数组指定了数组名和元素的数据类型，并未指定数组元素的个数和初始值。数组的初始化分为静态初始化和动态初始化，静态初始化是指声明的同时为数组元素赋值；动态初始化是指利用new运算符为数组分配内存空间。
2、使用“数组名[下标值]”的形式访问数组元素，但要注意的是下标值是从0开始的。
3、使用String类的valueOf方法可将byte、int、long、float、double等类型的数值转换为字符串。
4、，String类的对象一旦被初始化，它的值和所分配的内存就不能被改变了。如果想要改变它的值，则必须创建一个新的String对象。StringBuffer类用于创建和操作动态字符串，为该类对象分配的内存会自动扩展以容纳新增的文本，StringBuffer类适合于处理可变字符串。
三．编程题
1、解答
public class NumberSort {
public static void main(String[] args) {
int[] array = { 3, 1, 6, 2, 9, 0, 7, 4, 5, 8 };
int temp; // 存储交换的变量值
for (int i = 0; i < array.length - 1; i++) { // 比较n-1轮
for (int j = 0; j < array.length - i - 1; j++) { // 每轮比较
if (array[j] > array[j + 1]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
System.out.println("数组中最大值为：" + array[array.length - 1]);
System.out.println("数组中最小值为：" + array[0]);
System.out
.println("最大值与最小值的差为：" + (array[array.length - 1] - array[0]));
}
}
2、解答
public class Number {
public static void main(String[] args) {
int[] array = { 3, 1, 6, 2, 9, 0, 7, 4, 5, 8 };
for (int i = array.length - 1; i >= 0; i--) { // 比较n-1轮
System.out.print(array[i]+ " ");
}
}
3、解答
public class NumberSort {
public static void main(String[] args) {
int[][] array = new int[3][4];
System.out.println(array.length);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i].length + " ");
}
}
}
4、解答
public class StringChange {
public static void main(String[] args) {
StringBuffer ss = new StringBuffer("abetsea");
ss.replace(0, 3, "adc");
ss.insert(1, "hello");
System.out.println(ss);
}
}
第六章异常处理
一．选择题
1、D
2、B
3、B
4、D
二．简答题
1、在Java程序运行期间，如果出现了异常事件，系统会自动生成一个异常对象。当出现这样的异常时，总是由虚拟机接管。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果没有处理代码，到最上层后，如果程序是多线程就由Thread.run() 抛出，如果程序是单线程就被main() 抛出。抛出之后，如果是线程，这个线程也就退出了；如果是主程序，那么整个程序也就退出了。
2、对于异常的处理，我们可以在方法体中增加try-catch语句，从而告知系统，当try 代码块出现异常时，利用catch语句捕捉异常，并利用catch代码块对异常加以处理，从而让程序能继续运行。为方法名增加throws声明，抛出一些异常。如果用户能够明确预测到
异常，则可通过在程序中增加throw语句，让程序自身而不是系统来抛出异常。
3、如果希望在程序退出异常处理代码时对程序进行一些统一处理，可以将必须执行的代码放在finally代码块中。不一定需要finally语句。
4．利用throw语句可以明确地抛出一个异常。而对于方法中可能出现的异常，如果不想在方法中进行捕获，可以在方法声明时利用throws声明进行抛出。
三．编程题
1、解答
public class Loan {
private double total; //定义总额
private double rate; //定义利率
private int year; //定义年数
Loan(double total, double rate, int year) {
this.total = total;
this.rate = rate;
this.year = year;
}
public static void main(String[] args) {
Loan la = new Loan(2025.6, 0, 10);
if (la.rate <= 0 || la.total <= 0 || la.year <= 0) {
throw new IllegalArgumentException(); //抛出IllegalArgumentException异常}
}
}
2、解答
import java.util.InputMismatchException;
import java.util.Scanner;
public class ElectricityFree {
double free; //定义电费
double computeFree(double count) {
if (count < 240) {
free = count * 0.15;
}
if (count > 240 && count < 540) {
free = count * 0.25;
}
if (count > 540) {
free = count * 0.45;
}
return free;
}
public static void main(String[] args) {
System.out.println("请输入用电度数：");
Scanner in = new Scanner(System.in);
boolean dataright = false;
double count = 0.0;
do {
try {
count = in.nextDouble();
if (count <= 0) { //抛出自定义异常
throw new ElectNotNegativeException();
}
dataright = false;
ElectricityFree ef = new ElectricityFree();
https://www.360docs.net/doc/1512725500.html,puteFree(count);
System.out.println("本月电费和用电量的比值为：" + (ef.free / count));
} catch (InputMismatchException e) {
System.out.println("你输入的用电数不合法，请重新输入:");
dataright = true;
String x = in.nextLine();
} catch (ElectNotNegativeException ee) {
System.out.println("你输入的用电数不能小于等于0，请重新输入:");
dataright = true;
String x = in.nextLine();
}
} while (dataright);
}
}
class ElectNotNegativeException extends Exception { //定义用电度数小于等于零时异常ElectNotNegativeException() {
}
}
第七章数据输入输出
一．选择题
1、C
2、A
3、AB
4、AD
5、A
6、A
7、B
二．简答题
1、字节流以字节的形式读取数据，字符流以字符的形式读取数据。
2、①创建字节或字符输入/输出流对象，若创建的是文件字节/字符输入/输出流对象，此时文件自动打开或创建；②读写数据；③关闭数据流，同时关闭了文件。
3、File类的构造方法①File(String pathname) ②File(String parent, String child) ③
File(File parent, String child)。
查询文件名和路径名的方法：String getName()，String getPath()。
抽象路径查询的方法：boolean exists()，boolean isDirectory()，boolean isFile()
文件与目录操作的方法：boolean cteateNewFile()，boolean mkdir()，boolean delete()，String[] list()。
三．编程题
1、解答
import java.io.*
import java.util.Scanner;
public class FileInputTest{
public static void main(String[] args) throws IOException {
System.out.println("请输入字符串：");
Scanner in = new Scanner(System.in);
String line = in.nextLine();
line = line.toUpperCase(); //将输入的字符串转换为大写字母
System.out.println(line);
FileWriter out = new FileWriter("d:\\test.txt");
out.write(line);
out.close();
}
}
2、解答
import java.io.*;
public class FileWrite {
public static void main(String[] args) throws IOException {
File file = new File("d:\\test.txt");
BufferedOutputStream bufout = null;
try {
if (!file.exists()) {
file.createNewFile();
} else {
bufout = new BufferedOutputStream(new FileOutputStream(file));
DataOutputStream da_out = new DataOutputStream(bufout);
for (int i = 0; i < 100; i++) {
int ram = (int) (Math.random() * 10);
da_out.writeInt(ram);
}
}
bufout.close();
} catch (IOException e) {
System.out.println(e);
}
}
}
第八章Java的多线程机制
一、选择题
1、D
2、D
3、D
4、D
5、D
6、B
二、简答题
1、进程是程序的一次动态执行的过程。一个进程既包括程序的代码，同时也包括了系统的资源，如CPU、内存空间等，但不同的进程所占用的系统资源都是独立的。
线程是比进程更小的执行单位。一个进程中可以运行多个线程，线程可以共享进程的系统资源，进程不能脱离线程独立运行。
2、线程的生命周期分为创建、就绪、运行、阻塞、死亡五种状态，新建的线程调用start()方法便处于就绪状态；就绪状态的线程获得CPU资源后即可处于运行状态，系统将自动调用run()方法。线程调用sleep()方法或缺少某些资源会使线程处于阻塞状态。当线程运行完run()方法或被强制终止时，线程处于死亡状态。
3、创建线程一种方式是继承线程类Thread，另一种方法是实现Runnable接口。
4、线程调度的sleep()方法使线程处于休眠，使线程状态转向阻塞状态。yield()方法使线程让步，但只让给高优先级或同等优先级的线程，线程转向就绪状态。join()方法是当前线程运行结束才执行其他线程。
5、为了解决资源共享的问题，线程中引入了同步机制。只要在方法的声明中使用synchronized关键字修饰，该方法就称为同步方法，可以实现对共享资源进行加锁，避免了多线程之间共享资源的竞争问题。
三．编程题
1、解答
// TicketThreadMain.java
public class TicketThreadMain implements Runnable {
static Thread MrZhang, MrLi, MrWang;
static TicketThread MissWang;
public void run() {
if (Thread.currentThread() == MrZhang) { // 判断当前的线程
MissWang.sellRegulate(20); // 调用买票的方法
} else if (Thread.currentThread() == MrLi) {
MissWang.sellRegulate(5);
} else if (Thread.currentThread() == MrWang) {
MissWang.sellRegulate(10);
}
}
public static void main(String[] args) {
TicketThreadMain t = new TicketThreadMain();
MissWang = new TicketThread();
MrZhang = new Thread(t);
MrWang = new Thread(t);
MrLi = new Thread(t);
MrZhang.start(); // 启动张先生的线程
MrWang.start(); //启动王先生的线程
MrLi.start(); // 启动李先生的线程
}
}
class TicketThread {
int sumFive = 3, sumTwenty = 0, sumTen = 0; // 定义5元钱、10元钱与20元钱的个数public synchronized void sellRegulate(int money) {
if (money == 5) {
sumFive = sumFive + 1;
System.out.println("先生，您给的钱数正好。");
} else if (money == 10) {
while (sumFive < 1) {
try {
wait(); // 如果5元的个数少于2张，则线程等待
} catch (InterruptedException e) {
}
}
sumFive = sumFive - 1;
sumTen = sumTen + 1;
System.out.println("先生，您给我10元，找您5元。");
} else if (money == 20) {
while (sumFive < 3) {
try {
wait(); // 如果5元的个数少于3张，则线程等待
} catch (InterruptedException e) {
}
}
sumFive = sumFive - 3;
sumTwenty = sumTwenty + 1;
System.out.println("先生，您给我20元，找您15元。");
}
notifyAll(); // 通知等待的线程
}
}
2、解答
// PrimeNumberMain.java
class PrimeNumberOne extends Thread {
public void run() {
int n, i;
for (n = 2; n <= 1000; n++) {
for (i = 2; i <= n; i++) {
if (n % i == 0) {
break;
}
}
if (i == n) {
System.out.print(n + " ");
}
}
System.out.println();
}
}
class PrimeNumberTwo extends Thread{
public void run() {
int n, i;
for (n = 1000; n <= 2000; n++) {
for (i = 2; i <= n; i++) {
if (n % i == 0) {
break;
}
}
if (i == n) {
System.out.print(n + " ");
}
}
System.out.println();
}
}
public class PrimeNumberMain {
public static void main(String[] args) {
new PrimeNumberOne().start();
new PrimeNumberTwo().start();
}
}
第九章图形用户界面
一．选择题
1、B
2、C
3、B
4、D
5、D
6、B
7、A
8、B
二、简答题
1、label lb=new Label("Address");使用setText()方法可以重设标签的名字。
2、TextArea txa=new TextArea(5,10);
3、Checkbox apple = new Checkbox("apple"); apple.setState(true);
4、使用Checkbox类的getState()方法可以获得是否被选中，使用setState()方法可以设置其状态。
5、①创建一个CheckboxGroup对象，假定对象命名为chBtnGrp。
②使用Checkbox类的构造方法创建若干个复选框对象。
③对每个复选框对象，通过调用其setCheckboxGroup(chBtnGrp)方法将它们加入到CheckboxGroup对象chBtnGrp中，即可将它们转变为一组单选按钮。
6、为了使我们生成的图形用户界面具有良好的平台无关性，Java语言提供了布局管理器这个工具来管理组件在容器中的布局，从而使得用户不必再直接设置组件的位置和大小。窗体的默认布局为边界布局，面板的默认布局为顺序布局。
7、为组件实例注册一个或多个事件侦听器，其参数为一个对应的事件处理类对象，如btn.addActionListener(new btnHandler());其中，如果方法名为addXXXListerer，则事件侦听器名为XXXListener，事件名为XXXEvent。实现侦听器接口需要实现其中的为实现的抽象方法。
三．编程题
1、解答
// Questionnaire.java
import java.awt.*;
import java.awt.event.*;
import javax.swing.JOptionPane;
public class Questionnaire extends Frame implements ActionListener {
TextField name = new TextField(30); // 企业名称，宽度为30
TextField funds = new TextField(30);// 注册资金
// 员工数量，初始值为50，文本域宽度为4
TextField employeeCount = new TextField("50", 4);
Choice industry = new Choice(); // 从事行业
TextField turnover = new TextField(30);// 年营业额
TextField margin = new TextField(30);// 利润率
Button btn1 = new Button("确认"); // 确认、取消和退出按钮
Button btn2 = new Button("取消");
Button btn3 = new Button("退出");
Label l = new Label("企业信息调查表");
Label l1 = new Label("企业名称"), l2 = new Label("注册资金");
Label l3 = new Label("员工数量"), l4 = new Label("从事行业");
Label l5 = new Label("年营业额"), l6 = new Label("利润率");
// 构造方法，用于设置窗体标题、大小，并取消窗体的布局管理器
public Questionnaire(String title) {
super(title); // 调用父类构造方法
this.setSize(400, 400); // 设置窗体的尺寸
this.setLayout(null); // 取消窗体的布局管理器
l.setBounds(150, 50, 100, 20);// 企业信息调查表
l1.setBounds(50, 100, 60, 20);// 企业名称标签
name.setBounds(110, 100, 150, 20);// 企业名称文本域
l2.setBounds(230, 200, 60, 20);// 注册资金标签
funds.setBounds(290, 200, 80, 20);// 注册资金
l3.setBounds(50, 150, 60, 20);// 员工数量标签
employeeCount.setBounds(110, 150, 80, 20);// 员工数量文本域
l4.setBounds(230, 150, 60, 20);// 从事行业标签
industry.add("机构组织");// 设置选项框内容
industry.add("信息产业");
industry.add("医药卫生");
industry.add("机械机电");
industry.setBounds(290, 150, 80, 20);// 从事行业
l5.setBounds(50, 200, 60, 20);// 年营业额标签
turnover.setBounds(110, 200, 80, 20);// 年营业额
l6.setBounds(50, 250, 60, 20);// 利润率标签
margin.setBounds(110, 250, 80, 20);// 利润率
btn1.setBounds(110, 300, 50, 20);// 确认
btn2.setBounds(180, 300, 50, 20);// 取消
btn3.setBounds(250, 300, 50, 20);// 退出
this.add(l);// 将各组件添加到窗体中
this.add(l1); this.add(name); this.add(l2); this.add(funds);
this.add(l3); this.add(employeeCount); this.add(l4); this.add(industry);
this.add(l5); this.add(turnover); this.add(l6); this.add(margin);
this.add(btn1); this.add(btn2); this.add(btn3);
setLocationRelativeTo(null); // 使窗体在屏幕上居中放置
btn1.addActionListener(this); // 为三个按钮注册事件侦听器
btn2.addActionListener(this); btn3.addActionListener(this);
employeeCount.addActionListener(this); // 为员工数量文本域注册焦点事件侦听器funds.addActionListener(this);// 为注册基金文本域注册焦点事件侦听器
turnover.addActionListener(this);// 为年企业额文本域注册事件侦听器
margin.addActionListener(this);// 为利润率文本域注册焦点事件侦听器
}
// 窗体的ActionEvent事件处理方法
public void actionPerformed(ActionEvent e) {
try {
Integer.parseInt(employeeCount.getText());
Integer.parseInt(funds.getText());
Float.parseFloat(turnover.getText());
Float.parseFloat(margin.getText());
} catch (Exception e2) {
JOptionPane.showMessageDialog(null, "员工数量和注册基金为整数,年营
业额和利润率为浮点数","错误提示", JOptionPane.ERROR_MESSAGE);
employeeCount.setText("50");
funds.setText(""); turnover.setText(""); margin.setText("");
}
Object ob = e.getSource(); // 获取事件对象
if (ob == btn3) { // 单击退出按钮
System.exit(0); // 退出系统
} else if (ob == btn1) {// 单击确认按钮
System.out.println("企业名称：" + name.getText());
System.out.println("员工数量：" + employeeCount.getText());
System.out.println("从事行业：" + industry.getSelectedItem());
System.out.println("年营业额：" + turnover.getText());
System.out.println("注册资金：" + funds.getText());
System.out.println("利润率：" + margin.getText());
} else if (ob == btn2) { // 单击取消按钮
name.setText(""); // 清空姓名文本域
employeeCount.setText("50");
turnover.setText(""); funds.setText(""); margin.setText("");
}
}
}
2、解答
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
public class TextEditor extends Frame implements ActionListener {
MenuBar mainmenubar = new MenuBar(); // 声明菜单条
Menu file; // 声明主菜单项
MenuItem nw; // 声明各子菜单项
MenuItem op;
MenuItem cl;
MenuItem sf;
MenuItem ex;
Menu edit;
MenuItem copy;
MenuItem cut;
MenuItem paste;
JTextArea tx; // 声明文本区对象
Clipboard clipboard;
public TextEditor(String title) {
super(title); // 调用父类构造方法
CloseHandler handler = new CloseHandler(); // 定义窗体事件的侦听器对象
this.addWindowListener(handler); // 为当前窗体注册侦听器对象
Java程序设计实例教程考试题
Java程序设计练习题 一、选择题 1、为使Java程序独立于平台，Java虚拟机把字节码与各个操作系统及硬件（ A ） A）分开B）结合 C）联系D）融合 2、Java语言与C++语言相比，最突出的特点是（ C ） A）面向对象B）高性能 C）跨平台D）有类库 3、下列Java源程序结构中前三种语句的次序，正确的是（D） A）import,package,public class B）import必为首，其他不限 C）public class,package,import D）,import,public class 4、在JDK目录中，Java程序运行环境的根目录是( A ) A）bin B）demo C）lib D）jre 5、下列运算符中属于关系运算符的是（A ） A）== B）.= C）+= D）-= 6、下列布尔变量定义中，正确并且规范的是( B ) A）BOOLEAN canceled=false; B）boolean canceled=false; C）boolean CANCELED=false; D）boolean canceled=FALSE; 7、下列关键字中可以表示常量的是（ A ） A)final B)default C)private D)transient 8、下列运算符中，优先级最高的是( A ) A）++ B）+ C）* D）> 9、Java中的基本数据类型int在不同的操作系统平台的字长是（ B ） A）不同的B）32位 C）64位D）16位
10、给一个short类型变量赋值的范围是( C ) A）-128 至 +127 B）-2147483648至 +2147483647 C）-32768至 +32767 D）-1000至 +1000 11、下列运算中属于跳转语句的是（ D ） A）try B）catch C）finally D）break 12、switch语句中表达式（expression)的值不允许用的类型是（ C ） A)byte B)int C)boolean D)char 13、下列语句中，可以作为无限循环语句的是（ A ） A）for(;;) {} B）for(int i=0; i<10000;i++) {} C）while(false) {} D）do {} while(false) 14、下列语句中执行跳转功能的语句是（ C ） A）for语句B）while语句 C）continue语句D）switch语句 15、下列表达式中，类型可以作为int型的是（ C ） A）“abc”+”efg”B）“abc”+’efg’ C）‘a’+’b’D）3+”4” 17、数组中各个元素的数据类型是（ A ） A）相同的B）不同的 C）部分相同的D）任意的 18、在Java语言中，被成为内存分配的运算符是（ A ） A)new B)instance of C)[] D)() 19、接口中，除了抽象方法之外，还可以含有（ B ） A)变量B)常量 C)成员方法D)构造方法 20、下列能表示字符串s1长度的是（ A ） A）s1.length（）B）s1.length C）s1.size D）s1.size（） 21、StringBuffer类字符串对象的长度是（ C ） A)固定B)必须小于16个字符 C)可变D)必须大于16个字符 22、构造方法名必须与______相同，它没有返回值，用户不能直接调用它，只能通过new调用。（ A ） A）类名B）对象名 C）包名D）变量名 23、子类继承了父类的方法和状态，在子类中可以进行的操作是（ D ） A）更换父类方法B）减少父类方法 C）减少父类变量D）添加方法 24、String、StingBuffer都是______类，都不能被继承。（ C ）
Java语言程序设计基础教程习题解答
《Java语言程序设计基础教程》练习思考题参考答案
第1章 Java程序设计概述 练习思考题 1、 Java运行平台包括三个版本，请选择正确的三项：（） A. J2EE B. J2ME C. J2SE D. J2E 解答：A，B，C 2、 Java JDK中反编译工具是：（） A. javac B. java C. jdb D. javap 解答：D 3、 public static void main方法的参数描述是：（） A. String args[] B. String[] args C. Strings args[] D. String args 解答：A，B 4、在Java中，关于CLASSPATH环境变量的说法不正确的是：（） A. CLASSPATH一旦设置之后不可修改，但可以将目录添加到该环境变量中。 B. 编译器用它来搜索各自的类文件。 C. CLASSPATH是一个目录列表。 D. 解释器用它来搜索各自的类文件。 解答：A 5、编译Java Application源文件将产生相应的字节码文件，扩展名为（） A. .java B. .class C. .html D. .exe 解答：B 6、开发与运行Java程序需要经过的三个主要步骤为____________、____________和____________。 7、如果一个Java Applet源程序文件只定义有一个类，该类的类名为MyApplet，则类MyApplet必须是______类的子类并且存储该源程序文件的文件名为______。 8、如果一个Java Applet程序文件中定义有3个类，则使用Sun公司的JDK编译器编译该源程序文件将产生______个文件名与类名相同而扩展名为______的字节码文件。 9、开发与运行Java程序需要经过哪些主要步骤和过程？ 10、Java程序是由什么组成的？一个程序中必须要有public类吗？Java源文件的命名规则是怎么样的？ 11、编写一个简单的Java应用程序，该程序在命令行窗口输出两行文字：“你好，很高兴学习Java”和“We are students”。
java程序设计基础(含参考答案)
“Java程序设计基础”课程习题 一、填空 1.Java程序分两类___Applet___和application，Java Application 类型的程序，程序从 ___main方法___开始执行。 2.定义一个Java类时，通过关键字__extends____指明该类的父类。一个类可以有___1___ 个父类。 3.用public修饰的类称为_公有类或公用类__。用public修饰的类成员称为公有成员。被 说明为public的内容可以被__所有其他类___ 使用。如果public类文件与使用它的类文件不在同一目录中，需要通过__import____语句引入。 4.用___private___ 修饰的类成员称为私有成员。私有成员只能在__本类__ 中使用。 5.如果子类定义的成员变量与父类的成员变量同名，称为___方法覆盖___ ，要表明使用 子类的成员变量，可以在成员变量前加上关键字__super___ 。 6.____Object__ 类是Java类库中所有类的父类。 7.Java字符使用__16位的字符集,该字符集成为__Unicode____ 。 8.当子类中定义的方法与父类方法同名时，称子类方法___覆盖___ 父类方法，子类默认 使用自己的方法。使用父类的同名方法，必须用关键字__super__ 说明。 9.Java源程序文件名的后缀是___.java___，Java字节码文件名的后缀是_.class_____。 10.Java类名的第一个字母通常要求___大写___。 11.Java程序由____类__组成，每个程序有一个主类，Java程序文件名应与____主__类的 名称相同。 12.Java__Application_类型的程序需要main()方法，程序从__main____开始执行。 13.布尔型数据类型的关键字是_boolean__ ，占用位数是___1位___ ，有__true__ 和_false_ 两种值。整型数可以采用_十_ 、__八_ 和__十六_三种进制表示。 14.八进制整数以数字__0_开头。十六进制整数以_0x或0X_ 开头。 15.int整型数占用__32位内存。long整型数占用__64 位内存。 16.127L表示__长整型____ 常量。 17.根据占用内存长度将浮点常量分为_double_____ 和__float____ 两种。 18.单精度浮点常量占用__32_ 位内存，双精度浮点常量占用__64 位内存。 19.在Java语言中，字符串“ABC\tD\b\n”中包括__7个字符。 20.数学关系4
Java程序设计习题附答案(一)
Java程序设计题库 第一部分绪论 1、下列关于Java语言的特点，描述错误的是（C） A．Java是跨平台的编程语言B．Java支持分布式计算 C．Java是面向过程的编程语言D．Java支持多线程 2、Java语言具有许多优点和特点，下列选项中，哪个反映了Java程序并行机制的特点？（B） A、安全性 B、多线性 C、跨平台 D、可移植 3、Java JDK中调试器的命令是（C）。 A、javac B、java C、jdb D、avah 4、运行jar文件中class文件需要在java命令后面加的参数为（A）。 A、-cp B-g C-d D-verbose 5、下面哪项在java中是不合法的标识符？（C） A、$user B、point C、You&me D、_endline 6、下面关于Java语言说法正确的是（ABCD）。 A、Java语言是面向对象的、解释执行的网络编程语言。 B、Java语言具有可移植性，是与平台无关的编程语言。 C、Java语言可对内存垃圾自动收集。 D、Java语言编写的程序虽然是“一次编译，到处运行”，但必须要有Java的运行环境。 7、在Java程序设计中，程序员创建（）文件，然后编译器把它们转化为（）文件。( B) A、源, HTML B、源, 字节代码 C、字节代码, 源 D、HTML, 字节代码 8、Java的JVM是指（B）。 A、由Java操作的家用设备（通常是一个漂亮的小烤箱） B、Java字节代码的解释程序 C、Java源代码的编译器 D、运行Java 所需的硬件设备 9、在Java中，关于CLASSPA TH环境变量的说法不正确的是（A）。 A、CLASSPATH一旦设置之后不可修改，但可以将目录添加到该环境变量中。 B、编译器用它来搜索各自的类文件。 C、CLASSPATH是一个目录列表。 D、解释器用它来搜索各自的类文件。 10、一个可以独立运行的Java应用程序（D）。
Java程序设计实用教程_习题解答
习题 1 1．James Gosling 2．需3个步骤： 1)用文本编辑器编写源文件 2)使用Java编译器（javac.exe）编译源文件，得到字节码文件。 3)使用java解释器（java.exe）来解释执行字节码文件。 3．D:\JDK 1) 设置path 对于Windows 2000/2003/XP，右键单击“我的电脑”，在弹出的快捷菜单中选择“属性”，弹出“系统特性”对话框，再单击该对话框中的“高级选项”，然后单击“环境变量”按钮，添加系统环境变量path。如果曾经设置过环境变量path，可单击该变量进行编辑操作，将需要的值d:\jdk\bin加入即可（注意：修改系统环境变量path后要重新打开DOS窗口编译）。或在DOS窗口输入命令行: set path=d:\jdk\bin（注意：用此方法修改环境变量每次打开DOS窗口都需要输入该命令行重新进行设置）。 2) 设置classpath 对于Windows 2000/2003/XP，右键单击“我的电脑”，在弹出的快捷菜单中选择“属性”，弹出“系统特性”对话框，再单击该对话框中的“高级选项”，然后单击“环境变量”按钮，添加系统环境变量classpath。如果曾经设置过环境变量classpath，可单击该变量进行编辑操作，将需要的值d:\jdk\jre\lib\rt.jar;.;加入即可。或在DOS窗口输入命令行: set classpath= d:\jdk\jre\lib\rt.jar;.;。 4．（B）javac 5．Java源文件的扩展名是”.java”,Java字节码的扩展名是”.class” 6．Java应用程序主类的main申明（D）public static void main(String args[])
JSP程序设计与项目实训教程_第2版_课后习题和参考答案
第1章Web技术简介 1.7 习题 1.7.1 选择题 1. Web技术的设想于哪一年提出（）。 A.1954年 B.1969年 C.1989年 D.1990年 2. JSP页面在第一次运行时被JSP引擎转化为（）。 A.HTML文件 B.CGI文件 C.CSS文件 D.Servlet文件 3. JavaEE体系中Web层技术是（）。 A.HTML B.JavaBean C.EJB D.JSP 参考答案：1.C 2.D 3.D 1.7.2 填空题 1.当前主流的三大动态Web开发技术是：PHP、ASP/https://www.360docs.net/doc/1512725500.html,和______________。 2. JSP的两种体系结构是：______________和______________。 3. JSP开发Web站点的主要方式有：直接JSP、JSP+JavaBean、______________、______________和SSH。 参考答案： 1.JSP 2.JSP Model1和JSP Model2 3.JSP+JavaBean+Servlet、J2EE/JavaEE 1.7.3 简答题 1. 简述JSP的工作原理。 答：所有的JSP应用程序在首次载入时都被翻译成Servlet文件，然后再运行，这个工作主要是由JSP引擎来完成。当第一次运行一个JSP页面时，JSP引擎要完成以下操作： ●将JSP文件翻译成Servlet文件，Servlet文件是Java应用程序。 ●JSP引擎调用Java编译器，编译Servlet文件得到可执行的代码文件（.class文件）。 ●JSP引擎调用Java虚拟机解释执行.class文件，并将运行结果返回给服务器。 ●服务器将运行结果以HTML形式作为响应返回给客户端的浏览器。 由于一个JSP页面在第一次被访问时要经过翻译、编译和执行这几个步骤，所以客户端得到响应所需要的时间比较长。当该页面再次被访问时，它对应的.class文件已经生成，不需要再次翻译和编译，JSP引擎可以直接执行.class文件，因此JSP页面的访问速度会大为提高。 2. 简述JSP两种体系结构。
java编程题全集题及答案
J a v a程序设计总复习题 1、编写一个Java程序，用if-else语句判断某年份是否为闰年。(分支) // Programme Name LeapYear.java public class LeapYear{ public static void main(String args[]){ int year=2010; if(args.length!=0) year=Integer.parseInt(args[0]); if((year%4==0 && year%100!=0)||(year%400==0)) 年是闰年。"); else 年不是闰年。"); } }//if-else语句 2、编写一个Java程序在屏幕上输出1！+2！+3！+……+10！的和。（循 环） // programme name ForTest.java public class ForTest { public static void main( String args[] ) { int i,j,mul,sum=0; for(i=1;i<=10;i++) { mul=1; for(j=1,j<=i;j++) { mul=mul*j; } sum=sum+mul; } “1！+2！+3！+……+10！= ”+sum); } } 3、依次输入10个学生成绩，判断学生（优秀、良好、中等、及格、不及格） 并计算人数（switch） 4、使用冒泡排序（数组） public class BubbleSort { public static void main(String[] args) {
Java程序设计基础习题答案
Ｊavａ程序设计基础课后习题参考答案 第2章 1、关于Jａｖa Applicａｔion得入口方法maｉn（）得检验: ｍａin（）方法得参数名就是否可以改变? maｉｎ（）方法得参数个数就是否可以改变？ 该方法名就是否可以改变？ 参考答案:（1)maｉn（）方法得参数名可以改变.(2）maiｎ()方法得参数个数不可以改变。（3）该方法名不可以改变。 2、当一个程序没有main（)方法时，能编译吗?如果能编译，能运行吗? 参考答案:当一个程序没有ｍaｉn(）方法就是，就是可以编译通过得,但就是不能给运行,因为找不到一个主函数入口。 3、下列语句能否编译通过？ bytｅi =127； ｂｙｔｅj = １28； longｌ1 = ９99９９９； ｌoｎg l２= ９9９9999999； 参考答案：ｂyｔe i 与long l１可以编译通过。而bｙte j 与ｌongｌ2 超出自身数据类型范围,所以编译失败。 4、下列语句能否编译通过？ float f1 =3、５； floａt f2 = 3.5f; 参考答案：java中浮点型得数据在不声明得情况下都就是doublｅ型得，如果要表示一个数据就是ｆloaｔ型得,必须在数据后面加上“Ｆ”或“ｆ”；因此,floatｆ1 无法编译通过。 5、验证ｉnt 与char，ｉnt与doｕbｌｅ等类型就是否可以相互转换。 参考答案:(１）cｈar类型可以转换为iｎt 类型得，但就是inｔ类型无法转换为chａｒ类型得;（２）iｎt 可以转换为ｄoubｌe类型得，但就是ｄｏuble类型无法转换为int 类型得。 6、计算下列表达式,注意观察运算符优先级规则。若有表达式就是非法表达式,则指出不合法之处且进行解释。 （1)4+5 ＝= 6＊2 ?（2) （4=5）/6?? (3）９%2*7/3＞17（4）(4＋5）<=6/3 ? (5) 4＋5％３！=7－2????（６）４+5/6〉=10％2 参考答案：表达式（２）为不合法表达式，只能将值赋值给一个变量,因此其中（4=5）将5赋值给4就是不合法得. 7、下列（）就是合法得Ｊava标识符。 (１）Counter1 ??（2）$indeｘ， (3) nａmｅ-7 ??(4）_bytｅ
Java程序设计-习题参考答案
参考答案 第1章 3、计算机系统由哪两部分组成的？计算机硬件结构由哪几部分组成？它们各自有什么作用？ 一台计算机由硬件和软件组成。一台典型的计算机由五大部分组成。这五大部分是：运算器，控制器，存储器，输入设备和输出设备。 运算器是执行算术运算和逻辑运算的部件。 控制器是向计算机其他部分发送命令的部件。 存储器是计算机用来存储数据、信息的部件。 输入设备就是外界向计算机输入信息设备。 输出设备恰好与输入设备的作用相反，它将处理过后的信息输出呈现给用户。 9、将以下十进制数转换为对应的二进制数 （1）32 （2）97 （3）256 （4）500 （1）100000 （2）1100001 （3）100000000 （4）111110100 第2章 1．Java语言有哪些主要特点。 平台独立性 安全性 多线程 网络化 面向对象 3．Java Application的开发步骤有哪些。 Java Application的开发步骤： （1）下载JDK软件并安装； （2）配置相应的环境变量（path和classpath）； （3）编写Java源程序（文本编辑器或集成开发环境IDE）； （4）编译Java源程序，得到字节码文件（javac *.java）； （5）执行字节码文件（java 字节码文件名）。
4．什么是环境变量，设置环境变量的主要目的是什么。 环境变量的配置主要是为了进行“寻径”，也即让程序能找到它需要的文件，所以设置的内容就是一些路径。 第3章 1．Java语言对于合法标识符的规定是什么？指出以下哪些为合法标识符。 a a2 3a *a _a $a int a% 在Java语言中，标识符必须以字母、美元符号或者下划线打头，后接字母、数字、下划线或美元符号串。另外，Java语言对标识符的有效字符个数不做限定。 合法的标识符： a a2 _a $a 5．数据类型强制转换的原则是什么？如何转换？ 对于变窄转换，如long到short、double到float，或者不兼容转换：float到short、char 到short等，则需要进行强制转换。 float f = 11.5; short b ; b = （short）f; （强制转换） 第4章 5．用穷举法求出3位数中百、十、个位数的立方和就是该数的数。 public class Test { public static void main(String[] args) { int a,b,c,x=100; while(x<1000){ a=x%10; b=(x%100-a)/10; c=(x-x%100)/100; if(a*a*a+b*b*b+c*c*c==x) System.out.println(x); x+=1;
JavaWeb程序设计教程课后练习答案
第1章 Web应用开发简介 习题答案 1．Web在组成上包括______和______两部分。 答案： 服务器 客户端 2．谈谈对面向对象的认识。 答案： 面向对象将将要解决的问题分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙解决问题中的各个步骤中的行为。面向对象编程方式是建立在面向过程编程方式基础上，其最重要的改变在于面向对象编程中，程序将围绕被操作的对象来设计，而不是操作本身。面向对象编程方式以类作为构造程序的基本单位，具有封装、抽象、继承、多态性等特点。 3．介绍几种常用的框架技术。 答案： Java中常用的框架。 1．Struts Struts是Apache 基金会Jakarta 项目组的一个开源项目，是一个基于Sun J2EE平台的MVC框架，它将Servlet和JSP标签作为实现自身功能的一部分。 2．WebWork WebWork是由OpenSymphony组织开发的，是一个基于Web的MVC框架。它在运行时通过Interceptor（拦截器）自动应用，因此脱离了Action类。 3．Struts 2 Struts 2是Apache基金会的一个开源项目，它建立在Struts框架与WebWork框架基础之上，继承了二者的优点，是目前非常流行的一个Web框架。 4．Spring Spring是一个以IoC和AOP为核心的轻量级容器框架。它提供了一系列的Java EE开发解决方案，包括表示层的Spring MVC、持久层的Spring JDBC以及业务层事务管理等众
多的企业级应用技术。 5．Hibernate Hibernate是一个ORM（对象关系映射）框架，它对JDBC进行了轻量级的封装。通过使用Hibernate框架，开发人员能够以面向对象的思维方式来操作数据库。 6．Ibatis 相对于Hibernate而言，Ibatis是一个“半自动化”的ORM实现框架，它主要致力于POJO与SQL之间的映射关系，是对“全自动化”ORM框架的一种有益补充。 7．EasyJWeb EasyJWeb是一个核心基于模板技术实现的MVC框架，主要致力于Java Web应用程序的快速开发。 4．IDE的用途是什么？ 答案： IDE是一种用于辅助开发人员开发应用程序的应用软件，它一般包括代码编辑器、编译器、调试器和图形用户界面工具，有的还包括版本控制系统、性能分析器等更多工具，因此IDE也就具有了编写、编译、调试等多种功能。正是基于这些功能，使用IDE能够减少项目的开发周期，减轻程序员的工作量，提高应用程序的开发效率等。 5．Web应用服务器的用途是什么？ Web应用服务器是为创建、部署、运行以及管理Web应用提供多种运行时服务（如事务、安全等等）的分布式系统，它是应用程序运行的一个基本环境。
《JAVA程序设计》(含答案)
《JA V A程序设计》练习题 一、单选择题 1、编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( B )。 A. java B. .class C. html D. .exe 2、设x = 1 , y = 2 , z = 3，则表达式y＋＝z－－/＋＋x 的值是( A)。 A. 3 B. 3. 5 C. 4 D. 5 3、不允许作为类及类成员的访问控制符的是( C )。 A. public B. private C. static D. protected 4、为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为( A)。 A. static void method( ) B. public void method( ) C. final void method( ) D. abstract void method( ) 5、关于选择结构下列哪个说法正确？( B ) A．if语句和else语句必须成对出现 B．if语句可以没有else语句对应 C．switch结构中每个case语句中必须用break语句 D．switch结构中必须有default语句 6、while循环和do…while循环的区别是：( D) A．没有区别，这两个结构任何情况下效果一样 B．while循环比do…while循环执行效率高 C．while循环是先循环后判断，所以循环体至少被执行一次 D．do…while循环是先循环后判断，所以循环体至少被执行一次 7、关于for循环和while循环的说法哪个正确？( B) A．while循环先判断后执行，for循环先执行后判断。 B．while循环判断条件一般是程序结果，for循环的判断条件一般是非程序结果C．两种循环任何时候都不可以替换 D．两种循环结构中都必须有循环体，循环体不能为空
《Java程序设计》课后习题参考答案
习题1参考答案 1．Java语言的特点有哪些？ 答：参考1.1.2 防止直接访问数据变量看起来有些奇怪，但它实际上却对使用类的程序质量有极大的好处。既然数据的单个项是不可访问的，那么惟一的办法就是通过方法来读或写。因此，如果要求类成员内部的一致性，就应该通过类本身的方法来处理。 这种数据隐藏技术就是面向对象的重要特性——封装。它将类的外部界面与类功能的实现区分开来，隐藏实现细节，(通过公共方法)保留有限的对外接口，迫使用户使用外部界面，通过访问接口实现对数据的操作。即使实现细节发生了改变，还可通过界面承担其功能而保留原样，确保调用它的代码还继续工作，这使代码维护更简单。 2．简述封装的优点。 答：封装是一个简单而有效的思想，优点有：（1）模块化，对内成为一个结构完整、可进行自我管理、自我平衡、高度集中的整体。（2）信息隐蔽，对外则是一个功能明确、接口单一、可在各种适合的环境下都能独立工作的有机单元。 面向对象的程序设计实现了对象的封装，使得用户不必关心诸如对象的行为是如何实现的这样一些细节。通过对对象的封装，实现了模块化和信息隐藏，有利于程序的可移植性和安全性，同时也有利于对复杂对象的管理。类的封装性使得代码的可重用性大为提高，这样的有机单元特别适合构建大型标准化的软件系统，具有很高的开发效率。 3．Java的基本工具有哪些？ （1）javac 编译器 （2）java 解释器 （3）jdb Java 语言调试器 （4）javadoc API文档管理器 （5）javah 头文件生成器 （6）appletviewer 小应用程序浏览器 （7）javap 类文件反汇编器 4．Java开发环境是如何配置的？ 答：对于Windows 2000以上版本的操作系统，可以打开[控制面板]窗口，双击其中的[系统]图标，在[系统特性]窗口中单击[高级]选项卡，进而单击[环境变量]按钮。在出现的[环境变量]窗口中，在[系统变量]框中选择[Path]项，单击[编辑]按钮，在弹出的[编辑系统变量]窗口的[变量值]框后加上上面两条语句。 习题2参考答案 1．Java语言包含哪些数据类型? 答：包含基本数据类型和复合数据类型。基本类型包括整数类型、浮点数类型、布尔类型。复合类型包括类类型(Class Type)、接口类型(Interface Type)与数组类型(Array Type)。 2．Java有多少关键字？ 答：abstract, continue, for, new, switch，boolean, default, goto*, null, synchronized，break, do, if, package, this，byte, double, implements, private, threadsafe，byvalve*, else, import, protected, throw，case, extends, instanceof, public, transient，catch, false, int, return, true，char, final,
非常经典的JAVA编程题全集(50题及答案)
【程序1】 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少 //这是一个菲波拉契数列问题 public class lianxi01 { public static void main(String[] args) { System.out.println("第1个月的兔子对数: 1"); System.out.println("第2个月的兔子对数: 1"); int f1 = 1, f2 = 1, f, M=24; for(int i=3; i<=M; i++) { f = f2; f2 = f1 + f2; f1 = f; System.out.println("第" + i +"个月的兔子对数: "+f2); } } } 【程序2】 题目：判断101-200之间有多少个素数，并输出所有素数。 程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。 public class lianxi02 { public static void main(String[] args) { int count = 0; for(int i=101; i<200; i+=2) { boolean b = false; for(int j=2; j<=Math.sqrt(i); j++) { if(i % j == 0) { b = false; break; } else { b = true; } } if(b == true) {count ++;System.out.println(i );} } System.out.println( "素数个数是: " + count); } } 【程序3】 题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。 public class lianxi03 { public static void main(String[] args) { int b1, b2, b3; for(int m=101; m<1000; m++) {
java语言程序设计作业答案
Java语言程序设计(郑莉) 第二章习题答案 1.什么是对象、类，它们之间的联系？ 答：1）对象是包含现实世界物体特征的抽象实体，它反映系统为之保存信息和与它交互的能力。对象是一些属性及服务的封装体，在程序设计领域，可以用“对象=数据+作用于这些数据上的操作”来表示。现实生活中对象是指客观世界的实体；在程序中对象是指一组变量和相关方法的集合。 2）类是既有相同操作功能和相同的数据格式的对象的集合与抽象！ 3）两者的关系：对象是类的具体实例.。 4．请解释类属性、实例属性及其区别。 答：实例属性，由一个个的实例用来存储所有实例都需要的属性信息，不同实例的属性值可能会不同。 5．请解释类方法、实例属性及其区别。 答：实例方法表示特定对象的行为，在声明时前面不加static修饰符，在使用时需要发送给一个类实例。 类方法也称为静态方法，在方法声明时前面需加static修饰符，类方法表示具体实例中类对象的共有行为。 区别：实例方法可以直接访问实例变量，调用实例方法，实例方法可以直接访问类变量，调用类方法；类方法可以直接调用类变量和类方法，类方法不能直接调用实例变量和实例方法； 6．类的访问控制符有哪几种？具体含义及其区别。 答：类的访问控制符只有public（公共类）及无修饰符（默认类）两种。 区别：当使用public修饰符时表示所有其他的类都可以使用此类；当没有修饰符时，则只有与此类处于同一包中的其他类可以使用类。 7类成员的访问控制符有哪几种?他们对类成员分别有哪些访问限制的作用? 答: 类成员的访问控制符有public,private,protecte及无修饰符. public(公有的):用public修饰的成分表示公有的,也就是它可以被其他任何对象访问(前提是对累成员所在的类访问有访问权限). P rivate(保护的)：类中限定为private的成员只能被这个类本身访问，在类外不可见。proteced（保护的）用该关键字修饰的成分是受保护的，只可以被同一类及其子类的实例对象访问。 无修饰符（默认的）：public，private，protected这个三个限定符不是必须写的。如果不写，则表明是“friendly”，相应的成分可以被所在保重的各类访问。 8简述构造方法的特点? 答： 构造方法主要有以下特点： （1）构造方法的方法名与类名相同； （2）构造方法没有返回类型（修饰符void也不能有）； （3）构造方法通常被声明为公有的（public）；
Java程序设计与实践教程_王薇主编_答案
第1章JAVA简介 一、判断题 1.√ 2.√ 3.? 4.? 5.? 6.√ 7.√ 8.√ 9.? 10.? 二、填空题 1.Application Applet 2. 类(字节码文件、目标文件) .class 3.对象 4. 主 5. J2SE J2EE J2ME 三、选择题 1.B 2. D 3.B 4.B 5. A 四、简答题 1．参考答案 Java语言是简单的、面向对象的、分布式的、健壮的、安全的、体系结构中立的、可 移植的、编译解释型的、高性能的、多线程的、动态的等等。 2．参考答案 Java程序执行的具体过程如图1所示。 图1 Java程序的运行机制 3．参考答案 Java程序在计算机在执行要经历以下几个阶段： （1）使用文字编辑软件（例如记事本、写字板、UltraEdit等）或集成开发环境 （JCreater、Eclipse、MyEclipse等）编辑Java源文件，其文件扩展名为.java。 （2）通过编译使.java的文件生成一个同名的.class文件。 （3）通过解释方式将.class的字节码文件转变为由0和1组成的二进制指令执行。 在以上阶段中可以看出Java程序的执行包括了编译和解释两种方式。 第2章Java 语法基础 一、判断题
1. ? 2.√ 3. ? 4.? 5.? 二、填空题 1.10 2. 单精度双精度 3. n%13 !=0？false:true 4.接口 5. false 三、选择题 1.D 2. C 3.D 4.A 5. C 第3章程序流程控制 一、判断题 1.错误 2.? 3.? 4.? 5.√ 二、填空题 1.循环 2. if 3.case switch 4. while do-while 5. continue 三、选择题 1.D 2. C 3.C 4.B 5. C 第4章数组 一、判断题 1. ? 2. √ 3. √ 4. √ 5.? 二、填空题 1.类型 2. new 3.长度 4. 分配空间 5. 3 6 9 三、选择题 1.D 2. A 3.C 4.B 5. B 第5章类和对象 一、判断题 1.√ 2.√ 3.? 4.? 5.√ 6.? 7.√ 8.? 9.? 10.√ 11.√ 12.√ 13.? 14.? 15. ? 二、填空题 1.public default 2. class 属性方法 3.public static void main(String args[]){} 4. new
大学《java程序设计》考试题库及答案
若有定义int a＝2,b＝2; 则表达式(a++)+(++b) 的值是( )。 A. 5 监听器接口的方法返回值的类型是（）。C. void 在浏览器中执行applet 程序，以下选项中的哪个方法将被最先执行（）。 D. init() 以下哪个不是Java的原始数据类型（） B. Boolean 向Applet传递参数的正确描述是（）。C. C. PARAM name＝"age,value＝20" 阅读下列代码; public class Test{ String s＝"One World One Dream"; public static void main(String args[]){ System.out.println(s); } } 其运行结果是＿ C. 编译时出错//除非创建Text类的对象 如果容器组件p的布局是BorderLayout，则在p的下边中添加一个按钮b，应该使用的语句是（）。 A. p.add(b,"South"); 编译和运行下面的应用程序，并在命令行界面输入12345 ，则回车后屏幕输出的结果是( )。public class A { public static void main(String args[]) throws IOException{ BufferedReader buf＝new BufferedReader( new I nputStreamReader(System.in)); String str＝buf.readLine(); int x＝Integ er.parseInt(str); System.out.println(x/100); } } B. 123 构造函数何时被调用？（） B. 创建对象时 以下哪项可能包含菜单条（）。 D. Frame
java语言程序设计课后习题答案解析
习题2 3．使用“= =”对相同内容的字符串进行比较，看会产生什么样的结果。 答：首先创建一个字符串变量有两种方式：String str = new String("abc"); String str = "abc"； 使用“= =”会因为创建的形式不同而产生不同的结果： String str1 = "abc"; String str2 = "abc"; System.out.println(str1= =str2); //true String str1 = new String("abc"); String str2 = "abc"; System.out.println(str1= =str2); //false String str1 = new String("abc"); String str2 = new String("abc"); System.out.println(str1= =str2); //false 因此自符串如果是对内容进行比较，使用equals方法比较可靠。 String str1 = "abc"; String str2 = "abc"; System.out.println(str1= =str2); //true String str1 = new String("abc"); String str2 = "abc"; System.out.println(str1.equals(str2)); //true String str1 = new String("abc"); String str2 = new String("abc"); System.out.println(str1.equals(str2)); //true 5．编写一个程序，把变量n的初始值设置为1678，然后利用除法运算和取余运算把变量的每位数字都提出来并打印，输出结果为：n=1678。n的每位数字是1，6，7，8。若n为任意值呢？ 法一： public class Exercise5{ public static void main(String[] args){ int n=1678; int unit; int decimal; int hundred; int thousand; int count; thousand=n/1000; count=n%1000; hundred=count/100; count=count%100; decimal=count/10; count=count%10; unit=count; System.out.println("1678包含的数 字分别是： "+thousand+','+hundred+','+decimal+', '+unit); } } //如果n为任意值 import java.io.*; public class Exercise51{ public static void main(String[] args) throws IOException{ System.out.print("请输入一个整数："); InputStreamReader isStream=new InputStreamReader(System.in); BufferedReader bfReader=new BufferedReader(isStream); String input=bfReader.readLine(); int length=input.length()-1; int n=new