第1章课后习题

一、填空题

1．Java是一种____面对对象____语言，它是由___Sun_____公司（已被Oracle公司收购）开发的高级程序设计语言。

2．针对不同的开发市场，SUN公司将Java划分为三个技术平台，它们分别是____JavaSE____、__JavaEE______和__JavaME______。

3．Java语言的特点有简单性、___与平台无关性_____、___动态性_____、安全性，支持___多线程_____和分布式。

4．SUN公司提供了一套Java开发环境，简称__JDK______。

5．JDK中，存放可执行程序的目录是___bin_____。

二、判断题

1．Java是1995年5月正式发布的。√

2．JRE中包含了Java基本类库、JVM和开发工具。×

3．编译Java程序需要使用java命令。√

4．Java中的包是专门用来存放类的，通常功能相同的类存放在相同的包中。√

5．IDEA开发工具Dubug模式下不进入函数内部的单步调试快捷键是F7。×

三、选择题

1．Java属于那种语言？（ C）

A、机器语言

B、汇编语言

C、高级语言

D、以上都不对

2．Java语言的特点有哪些？（多选）（ ABCD）

A、简单性

B、面向对象

C、跨平台性

D、支持多线程

3．在JDK的bin目录下有许多exe可执行文件，其中java.exe命令的作用是（B ）

A、 Java文档制作工具。

B、 Java解释器。

C、 Java编译器。

D、 Java启动器。

4．IDEA开发工具Dubug模式下进入函数内部的单步调试快捷键是（ B）

A、F7。

B、F8。

C、Shift+F7。

D、Shift+F8。

5．下面那种类型的文件可以在Java虚拟机中运行？（ D）

A、.java。

B、.jre。

C、.exe。

D、.class。

四、简答题

1．简述Java的特点。

简单性、面向对象、安全性、跨平台性、支持多线程、分布性。

2．简述Java的运行机制。

Java程序运行时，必须经过编译和运行两个步骤。首先将后缀名为.java的源文件进行编译，生成后缀名为.class的字节码文件，然后Java虚拟机将字节码文件进行解释执行，并将结果显示出来。

五、编程题

使用记事本编写一个Hello World程序，并在命令行窗口编译运行，并打印输出结果。

1 1 public class HelloWorld {

2 2 public static void main(String[] args) {

3 3 System.out.println("这是第一个Java程序!");

4 4 }

5 5 }

第2章 Java编程基础

一、填空题

1．Java程序代码必须放在一个类中，类使用__class______关键词定义。

2．Java中的注释有三类，分别是__单行注释______、__多行注释______和__文档注释______。

3．在Java中，变量的数据类型分为两种，即基本___数据类型_____和__引用数据______类型。

4．在逻辑运算符中，运算符___&_____和___&&_____用于表示逻辑与，____||____表示逻辑或。

5．数组是一个__容器______，存储到数组中的每个元素，都有自己的自动编号，最小值为__0______。

二、判断题

1．Java语言不区分大小写。错

2．continue语句只用于循环语句中，它的作用是跳出循环。错

3．三元运算符的语法格式为“判断条件？表达式1：表达式2”。对

4．循环嵌套是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套。对

5．在switch条件语句和循环语句中都可以使用break语句。对

三、选择题

1．下列选项中，关于类的定义格式正确的是（AC ）（多选）

A、修饰符class类名{

程序代码

}

B、修饰符类名class {

程序代码

}

C、class类名{

程序代码

D、类名class {

程序代码

}

2．下列选项中，那些属于合法的标识符？（A ）

A、username

B、class

C、123username

D、Hello World

3．下列选项中，使用比较运算符正确的是（BD ）

A、4！=3结果为false

B、4==3结果为false

C、4<=3结果为true

D、4>=3结果为true

4．请阅读下面代码。

int a=3；

int b=2；

switch (b){

case 1:

a--；

break;

case 2:

a++；

case 3:

a=a+3；

default:

a++;

break;

}

System.out.println(“a=”+a);

上述程序运行结束时，变量a的值为（ A）

A、4

B、5

C、7

D、8

5．假设int x=2,三元表达式x>0？x+1：5（ C）

A、0

B、2

C、3

D、5

四、简答题

1．简述Java语言中的8中基本数据类型，并说明每种数据类型所占用的空间大小。

2．简述跳转语句break与continue的作用和区别。

在循环语句中，可以用break语句跳出循环，用continue语句结束本次循环。

区别：
1、
1）continue语句只结束本次循环，而不是终止整个循环的执行；
2）break语句则是结束整个循环过程，不再判断执行循环的条件是否成立。

2、
break可以用在switch结构和循环结构中
continue只能用在循环结构中

五、编程题

1.请编写程序，实现计算“1+3+5+7+…+99”的值，要求如下。

（1）使用循环语句实现自然数1~99的遍历。

（2）在遍历过程中，通过条件判断当前遍历的书是否为奇数，如果是就累加，否则不加。

2.请编写程序，实现获取数组{22，24，76，12，21，33}的最大数。

答案跟在每章后面

第3章面向对象（上）

一、填空题

1．面向对象的三大特征是________、________、________。

2．定义类的关键字为________。

3．针对类、成员方法和属性，Java提供了4种访问控制权限，分别是________、 ________、________和defualt。

4．静态方法必须使用________关键字来修饰。

5．类的封装是指在定义一个类时，将类中的属性私有化，即使用________关键字来修饰。

二、判断题

1．在成员方法中出现的this关键字，代表的是调用这个方法的对象。

2．静态变量只能在静态方法中使用。

3．与普通方法一样，构造方法也可以重载。

4．私有属性只能在它所在类中被访问，为了能让外界访问私有属性，需要提供一些使用public修饰的公有方法。

5．封装就是隐藏对象的属性和实现细节，仅对外提供公有的方法。

三、选择题

1．下列关于this的说法中，错误的是（）

A、只能在构造方法中使用this调用其它的构造方法，不能在成员方法中使用。

B、在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。

C、this关键字可以用于区分成员变量与局部变量。

D、this可以出现在任何方法中。

2．阅读下列程序：

class Test {

private static String name;

static {

name = "World";

System.out.print (name);

}

public static void main(String[] args) {

System.out.print("Hello");

Test test = new Test();

}

下列选项中，程序运行结果是（）

A、HelloWorld

B、WorldHello

C、Hello

D、World

3．下列关于构造方法的描述中，错误的是（）

A、构造方法的方法名必须和类名一致。

B、构造方法不能写返回值类型。

C、构造方法可以重载。

D、构造方法的访问权限必须和类的访问权限一致。

4．被声明为private，protected 及public 的类成员，在类外部可以被访问的成员是（）

A、只能访问到声明为public的成员

B、只可能访问到声明为protected和public的成员

C、都可以访问

D、都不能访问

5．阅读下列程序：

class A{

int x;

static int y;

void fac(String s){

System.out.println(“字符串：”+s);

}

下列选项中描述正确的是（）

A、x,y和s都是成员变量

B、x是实例变量，y是类变量，s是局部变量

C、x和y是实例变量，s是参数

D、x,y和s都是实例变量

四、简答题

1．简述你对面向对象的三大特征的理解。

2．简述成员变量与局部变量的区别。

五、编程题

定义一个表示学生信息的类Student，要求如下：

（1）类Student的成员变量：

sNO表示学号；sName表示姓名；sSex表示性别；sAge表示年龄；sJava：表示Java课程成绩。

（2）类Student带参数的构造方法：

在构造方法中通过形参完成对成员变量的赋值操作。

（3）类Student的方法成员：

getNo（）：获得学号；
getName（）：获得姓名；
getSex（）：获得性别；
getAge（）获得年龄；
getJava（）：获得Java课程成绩

根据类Student的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生Java语言成绩的平均值，以及计算并输出他们Java语言成绩的最大值和最小值。

答案：

第3章面向对象（上）

一、填空题

1．封装、继承、多态

2．class

3．private、protected、public

4．static

5．private

二、判断题

1．错

2．错

3．对

4．对

5．对

三、选择题

1．D

2．B

3．D

4．A

5．B

四、简答题

1．封装、继承、多态

面向对象的特点主要可以概括为封装性、继承性和多态性。

其中封装是面向对象核心思想","将对象的属性和行为封装起来","不需要让外界知道具体实现细节","这就是封装思想。

继承性主要描述的是类与类之间的关系","通过继承","可以在无需重新编写原有类的情况下","对原有类的功能进行扩展。

多态性指的是在程序中允许出现重名现象","它指在一个类中定义的属性和方法被其它类继承后","它们可以具有不同的数据类型或表现出不同的行为","这使得同一个属性和方法在不同的类中具有不同的语义。

2．在Java中，定义在类中的变量被称为成员变量。定义在方法中的变量被称为局部变量。如果在某一个方法中定义的局部变量与成员变量同名，这种情况是允许的。此时，在方法中通过变量名访问到的是局部变量，而并非成员变量。

五、编程题

Student.java

public class Student {
private String sNo;
private String sName;
private String sSex;
private int sAge;
private int sJava;
//getter&setter方法
public String getsNo() {
return sNo;
}
public void setsNo(String sNo) {
this.sNo = sNo;
}
public String getsName() {
return sName;
}
public void setsName(String sName) {
this.sName = sName;
}
public String getsSex() {
return sSex;
}
public void setsSex(String sSex) {
this.sSex = sSex;
}
public int getsAge() {
return sAge;
}
public void setsAge(int sAge) {
this.sAge = sAge;
}
public int getsJava() {
return sJava;
}
public void setsJava(int sJava) {
this.sJava = sJava;
}
public Student(String sNo, String sName, String sSex, int sAge, int sJava) {
this.sNo = sNo;
this.sName = sName;
this.sSex = sSex;
this.sAge = sAge;
this.sJava = sJava;
}
}

Test.java

public class Test {
public static void main(String[] args) {
Student[] students = new Student[5];
students[0] = new Student("220110", "Tom", "男", 18, 85);
students[1] = new Student("220111", "Tohm", "男", 18, 82);
students[2] = new Student("220112", "Tomf", "女", 18, 79);
students[3] = new Student("220113", "WTom", "男", 18, 85);
students[4] = new Student("220114", "seTom", "男", 18, 90);
int sum = 0;
int average = 0;
int max = students[0].getsJava();
int min = students[0].getsJava();
for (Student student : students) {
int java = student.getsJava();
sum += java;
if (max < java) {
max = java;
}
if (min > java) {
min = java;
}
}
average = sum/(students.length);
System.out.println("Java语言的平均成绩是:"+average);
System.out.println("Java语言成绩的最大值是:"+max);
System.out.println("Java语言成绩的最小值是:"+min);
}

第4章面向对象（下）

一、填空题

1．Java中一个类最多可以继承________个类。

2．在继承关系中，子类会自动继承父类中的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行________。

3．________关键字可用于修饰类、变量和方法，它有“这是无法改变的”或者“最终”的含义。

4．Java提供了一个关键字________，可以判断一个对象是否为某个类(或接口)的实例或者子类实例。

5．一个类如果要实现一个接口，可以通过关键字________来实现这个接口。

二、判断题

1．Exception类称为异常类，它表示程序本身可以处理的错误，在开发Java程序中进行的异常处理，都是针对Exception类及其子类。

2．在try…catch语句中，try语句块存放可能发生异常的语句。

3．当一个类实现接口时，沒有必要实现接口中的所有方法。

4．父类的引用指向自己子类的对象是多态的一种体现形式。

5．方法重写时，子类抛出的异常类型大于等于父类抛出的异常类型。

三、选择题

1．下面程序运行的结果是（）

class Demo{

public static void main(String[] args){

int x = div(1,2);

try{

}catch(Exception e){

System.out.println(e);

}

System.out.println(x);

}

public static int div(int a,int b){

return a / b ;

}

A、输出1

B、输出0

C、输出0.5

D、编译失败

2．现有两个类A、B，以下描述中表示B继承自A的是（）

A、class A extends B.class

B、class B implements A

C、class A implements B

D、class B extends A

3．函数重写与函数重载的相同之处是（）

A、权限修饰符

B、函数名

C、返回值类型

D、形参列表

4．下列关于接口的说法中，错误的是（）

A、接口中定义的方法默认使用“public abstract”来修饰

B、接口中的变量默认使用“public static final”来修饰

C、接口中的所有方法都是抽象方法

D、接口中定义的变量可以被修改

5．阅读下段代码：

class Dog {

public String name;

Dog(String name){

this.name =name;

}

public class Demo1 {

public static void main(String[] args){

Dog dog1 = new Dog("xiaohuang");

Dog dog2 = new Dog("xiaohuang");

String s1 = dog1.toString();

String s2 = dog2.toString();

String s3 = "xiaohuang";

String s4 = "xiaohuang";

}

返回值为true的是（）

A、dog1.equals(dog2)

B、s1.equals(s2)

C、s3.equals(s4)

D、dog1==dog2

四、简答题

1．请简述Java中继承的概念以及使用继承的好处。

2．简要概述多态的作用。

五、编程题

某公司的雇员分为以下若干类：

(1) Employee：这是所有员工总的父类。

① 属性：员工的姓名,员工的生日月份

② 方法：getSalary(int month)根据参数月份来确定工资，如果该月员工过生日，则公司会

额外奖励100元。

(2) SalariedEmployee：Employee的子类，拿固定工资的员工。

① 属性：月薪。

(3)HourlyEmployee：Employee的子类，按小时拿工资的员工，每月工作超出160小时的部分按照1.5倍工资发放。

① 属性：每小时的工资、每月工作的小时数。

(4) SalesEmployee：Employee的子类，销售，工资由月销售额和提成率决定。

① 属性：月销售额、提成率。

(5) BasePlusSalesEmployee：SalesEmployee的子类，有固定底薪的销售人员，工资由底薪加

上销售提成部分。

① 属性：底薪。

要求：

创建一个Employee数组，分别创建若干不同的Employee对象，并打

印某个月的工资。

注意：要求把每个类都做成完全封装，不允许非私有化属性。

答案

第4章面向对象（下）

一、填空题

1．1

2．重写

3．final

4．instanceof

5．implements

二、判断题

1．对

2．对

3．错

4．对

5．错

三、选择题

1．B

2．D

3．B

4．D

5．C

四、简答题

1．概念：在Java中","类的继承是指在一个现有类的基础上去构建一个新的类","构建出来的新类被称作子类","现有类被称作父类","子类会自动拥有父类所有可继承的属性和方法。

好处：继承性主要描述的是类与类之间的关系","通过继承","可以无需重新编写原有类的情况下","对原有类的功能进行使用和扩展。

2．1、应用程序不必为每一个子类编写功能调用","只需要对抽象父类进行处理即可。大大提高程序的可复用性。

2、子类的功能可以被父类的方法或引用变量所调用","这叫向后兼容","可以提高可扩充性和可维护性。

3、使用多态可以解决项目中紧偶合的问题","提高程序的课扩展性.是OCP原则的一个具体的实现。

五、编程题

Employee.java

abstract class Employee{
private String name; //定义姓名name并私有化属性
private int month; //定义生日月份month并私有化属性
public Employee(){} //无参构造器
public Employee(String name,int month){ //有参构造方法
this.name = name; //给属性name初始化赋值
this.month = month; //给属性month初始化赋值
}
//获取属性name的方法
public String getName(){
return name; //返回name属性
}
//获取属性month的方法
public int getMonth(){
return month; //返回month属性
}
//给属性name赋初始值
public void setName(String name){
this.name = name; //本类中的属性name
}
//给属性month赋初始值
public void setMonth(int month){
this.month = month; //本类中的属性month
}
//创建getSalary()方法计算工资，参数month是月份，如果当月是员工生日，奖励100元
public double getSalary(int month){
double salary = 0; //定义工资变量
//判断当前月份是否是员工的生日月份，如果是奖励100元
if(this.month == month){
salary = salary + 100;
return salary; //返回工资salary
}
}
}

SalariedEmployee.java

class SalariedEmployee extends Employee{
private double monthSalary; //封装monthSalary属性
public SalariedEmployee(){} //无参构造方法
//有参构造方法参数姓名生日月份月薪
public SalariedEmployee(String name,int month,double monthSalary){
super(name,month); //调用父类有参构造方法
this.monthSalary = monthSalary; //为属性monthSalary初始化赋值
}
//获取monthSalary的值
public double getMonthSalary(){
return monthSalary;
}
//给monthSalary赋值
public void setMonthSalary(double monthSalary){
this.monthSalary = monthSalary;
}
//覆盖父类中的方法
public double getSalary(int month){
//定义工资变量
double salary = monthSalary+super.getSalary(month);
return salary;
}
}

HourlyEmployee.java

class HourlyEmployee extends Employee{
private double hourlySalary; //定义属性hourlySalary每小时的工资
private int hours; //定义属性hours每月工作的小时数
public HourlyEmployee(){} //无参构造方法
//有参构造方法参数姓名生日月份每小时的工资每月工作的小时数
public HourlyEmployee(String name,int month,double hourlySalary,int hours){
super(name,month); //调用父类有参构造方法
this.hourlySalary = hourlySalary ; //为属性hourlySalary初始化赋值
this.hours = hours; //为属性hours 初始化赋值
}
public double getHourlySalary(){ //获取hourlySalary的值
return hourlySalary;
}
public int getHours(){ //获取hours的值
return hours;
}
//定义set方法设置hourlySalary hours的值
public void setHourlySalary(double hourlySalary){
this.hourlySalary =hourlySalary;
}
public void setHourly(int hours){
this.hours = hours;
}
//覆盖父类方法
public double getSalary(int month){
if(hours < 0){ //如果工作小时数小于0 输出数据错误
System.out.println("数据错误");
return 0;
}
//小于160个小时的按照每个月的工作小时数乘以每小时的工资
else if(hours <= 160)
return hourlySalary*hours+super.getSalary(month);
//超出160个小时的小时数按照1.5倍计算
else return hourlySalary*160+hourlySalary*1.5*(hours- 160)+super.getSalary(month);
}
}

SalesEmployee.java

class SalesEmployee extends Employee{
private double sales ; //定义销售额sales
private double rate; //定义提成率rate
public SalesEmployee(){}
public SalesEmployee(String name,int month,double sales,double rate){
super(name,month);
this.sales = sales;
this.rate = rate;
}
public double getSales(){
return sales;
}
public double getRate(){
return rate;
}
public void setSales(double sales){
this.sales = sales;
}
public void setRate(double rate){
this.rate = rate;
}
public double getSalary(int month){
return this.getSales()*(1+this.getRate())+super.getSalary(month);
}
}

BasePlusSalesEmployee.java

class BasePlusSalesEmployee extends SalesEmployee{
private double baseSalary; //定义基础工资baseSalary
//无参构造方法
public BasePlusSalesEmployee(){}
//有参构造方法
public BasePlusSalesEmployee(String name,int month,double sales,double rate,double baseSalary){
super(name,month,sales,rate);
this.baseSalary = baseSalary;
}
//get/set方法对私有属性的调用和设置
public double gatBaseSalary(){
return baseSalary;
}
public void setBaseSalary(){
this.baseSalary = baseSalary;
}
public double getSalary(int month){
return baseSalary+super.getSalary(month);
}
}

Test.java

//定义一个测试类
public class Test{
public static void main(String[] args){
//声明一个Employee类型的数组，并创建不同子类型的对象
Employee[] employee = {new SalariedEmployee(“张三”,1,6000),new HourlyEmployee(“李四”,2,50,180),new SalesEmployee(“王五”,3,6500,0.15),new BasePlusSalesEmployee(“赵六”,4,5000,0.15,2000)};
//打印每个员工的工资
for(int i = 0; i < employee.length ;i++)
System.out.println(Math.round(employee[i].getSalary(10)));
}
}

第5章 Java API

一、填空题

1．在Java中定义了两个类来封装对字符串的操作，他们分别是________和________。

2．在程序，获取字符串长度的方法是________。

3．Math类中，用于获取一个数的绝对值的方法是________。

4．java.util包中的Random类的作用是可以在指定的取值范围内________。

5．Instant类代表的是某个时间。其内部是由两个________组成，第一部分保存的是________到现在的秒数，第二部分保存的是________。

二、判断题

1．String对象和StringBuffer对象多事字符串变量，创建后都可以修改。

2．Math.round(double d)方法的作用是，将一个数四舍五入,并返回一个double数。

3．StringBuffer类和String类一样，都是不可变对象。

4．Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式，它的构造方法是私有的，不可以直接创建。

5．每次使用java命令启动虚拟机都对应一个Runtime实例，并且只有一个实例。

三、选择题

1．以下关于String类的常见操作中，哪个是方法会返回指定字符ch在字符串中最后一次出现位置的索引（）

A、int indexOf(int ch)

B、int lastIndexOf(int ch)

C、int indexOf(String str)

D、int lastIndexOf(String str)

2．String s=”itcast”；则s.substring(3,4)返回的字符串是以下选项中的那个？（）

A、ca

B、c

C、a

D、as

3．下列选项中，可以正确实现String初始化的是（）

A、String str = "abc";

B、String str = 'abc';

C、String str = abc;

D、String str = 0;

4．下面关于Math.random()方法生成的随机数，正确的是哪项（）

A、0.8652963898062596

B、-0.2

C、3.0

D、1.2

5．下列选项中，哪个是程序正确的输出结果？（）

class StringDemo{
public static void main(String[] args){
String s1 = “a”;
String s2 = “b”;
show(s1,s2);
System.out.println(s1+s2);
}
public static void show(String s1,String s2){
s1 = s1 +”q”;
s2 = s2 + s1;
}
}

A.ab

B.aqb

C.aqbaq

D.aqaqb

四、简答题

1．简述StringBuffer和StringBuilder有什么区别。

2．简述8中基本数据类型及其对应的包装类。

五、编程题

1.编写一个每次随机生成10个0（包括）到100之间的随机正整数。

2. 编写一个程序,实现字符串大小写的转换并倒序输出。要求如下:

（1）使用for循环将字符串“ITcastHeiMa”从最后一个字符开始遍历。

（2）遍历的当前字符如果是大写字符，就使用toLowerCase()方法将其转换为小写字

符，反之则使用toUpperCase()方法将其转换为大写字符。

（3）定义一个StringBuffer对象，调用append()方法依次添加遍历的字符，最后调用

StringBuffer对象的toString( )方法，并将得到的结果输出。

答案

第5章 Java API

一．填空

1.String StringBuffer

2. length()

3. Math.abs();

4.随机产生数字

5. Long字段标准Java计算时代（就是1970年1月1日开始）纳秒数

二．判断

1.错2.错3.错 4.对 5.对

三．选择

1.B 2.C 3.A 4.A 5.A

四．简答

1. StringBuffer类和StringBuilder类的对象都可以被多次修改，并不产生新的未使用对象，StringBuilder类是JDK5中新加的类，它与StringBuffer之间最大不同在于StringBuilder的方法是线程安全的，也就是说StringBuffer不能被同步访问，而StringBuilder可以。

2．

基本数据类型	对应的包装类
byte	Byte
char	Character
int	Integer
short	Short
long	Long
float	Float
double	Double
boolean	Boolean

五．编程

1.参考答案

public static void main(String args) {
for(int i=0;i<10;i++){
System.out.println(new Random().nextInt(100));
}
}

2.参考答案

public class Test0 {
public static void main(String[] args) {
String str = "HelloWorld";
// 字符串转成char数组
char[] ch = str.toCharArray();
StringBuffer buffer = new StringBuffer();
for (int i = str.length() - 1; i >= 0; i--) {
if (ch[i] >= 'A' && ch[i] <= 'Z') {
buffer.append(String.valueOf(ch[i]).toLowerCase());
} else if (ch[i] >= 'a' && ch[i] <= 'z') {
buffer.append(String.valueOf(ch[i]).toUpperCase());
}
}
System.out.println(buffer.toString());
}
}

剩余篇章在下一文章。

原文链接：https://blog.csdn.net/Tir_zhang/article/details/125266380

第1章 课后习题

第2章 Java编程基础

第3章 面向对象（上）

答案：

第3章 面向对象（上）

第4章 面向对象（下）

答案

第4章 面向对象（下）

第5章 Java API

答案

第5章 Java API

剩余篇章在下一文章。

第1章课后习题

第3章面向对象（上）

第3章面向对象（上）

第4章面向对象（下）

第4章面向对象（下）