Java基础入门第三版课后习题答案.docx
《Java基础入门第三版课后习题答案.docx》由会员分享，可在线阅读，更多相关《Java基础入门第三版课后习题答案.docx（31页珍藏版）》请在冰豆网上搜索。
第1章 Java开发入门
一、
1．对象
2．面向对象、跨平台性
3．javac
4．Java虚拟机（或JVM）
5．JRE
二、
1．错
2．错
3．错
4．对
5．对
三、
1．C
2．ABCD
3．D
4．ABCD
5．D
四、
1．简答性、面向对象、安全性、跨平台性、支持多线程、分布性。
2.Java程序运行时，必须经过编译和运行两个步骤。
首先将后缀名为.java的源文件进行编译，生成后缀名为.class的字节码文件，然后Java虚拟机将字节码文件进行解释执行，并将结果显示出来。
五、
HelloWorld.java
1 publicclassHelloWorld{
2 publicstaticvoidmain（String[]args）{
3 System.out.println（"这是第一个Java程序!
"）;
4 }
5 }
第2章 Java编程基础
一、
1．class
2．单行注释、多行注释、文档注释
3．4
4．==
5．容器、0
二、
1．对
2．错
3．对
4．错
5．对
三、
1．AC
2．A
3．BD
4．C
5．C
四、
1.Java语言的八种基本数据类型有：
byte字节型，占一个字节。
short短整型，占两个字节。
int整型，占4个字节。
long长整型，占8个字节。
float单精度浮点型，占4个字节。
double双精度浮点型，占8个字节。
char字符型，占两个字节。
boolean型，表示逻辑值，有true和false两个值，分别占一个字节。
2.在switch条件语句和循环语句中都可以使用break语句。
当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。
当它出现在循环语句中，作用是跳出循环语句，执行循环后面的代码；continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。
五、
1.
1publicclassgetSum{
2 publicstaticvoidmain（String[]args）{
3 intsum=0;
4 for（inti=1;i<100;i++）{
5 if（i%2!
=0）
6 sum+=i;
7 }
8 System.out.println（sum）;
9 }
10}
2.
1publicclassTest{
2 publicstaticvoidmain（String[]args）{
3 inti=1;
4 longsum=1;
5 do{
6 sum*=i;
7 i++;
8 }while（i<=5）;
9 System.out.println（sum）;
10 }
11}
第3章 面向对象（上）
一、
1．封装、继承、多态
2．private、default、protected、public
3．static
4．private
5．参数类型参数个数
6．this
二、
1．对
2．对
3．错
4．对
5．对
三、
1．C
2．B
3．D
4．B
5．C
四、
1．
面向对象的特点主要可以概括为封装性、继承性和多态性。
其中封装是面向对象核心思想","将对象的属性和行为封装起来","不需要让外界知道具体实现细节","这就是封装思想。
继承性主要描述的是类与类之间的关系","通过继承","可以在无需重新编写原有类的情况下","对原有类的功能进行扩展。
多态性指的是在程序中允许出现重名现象","它指在一个类中定义的属性和方法被其它类继承后","它们可以具有不同的数据类型或表现出不同的行为","这使得同一个属性和方法在不同的类中具有不同的语义。
2．
（1）构造方法名与类名相同
（2）在构造方法名的前面没有返回值类型的声明
（3）在构造方法中不能使用return语句返回一个值
五、
Example.java
classResume{
privateStringname;
privateStringsex;
privateintage;
publicResume（）{
}
publicResume（Stringname,Stringsex,intage）{
this.name=name;
this.sex=sex;
this.age=age;
}
publicStringgetName（）{
returnname;
}
publicStringgetSex（）{
returnsex;
}
publicintgetAge（）{
returnage;
}
publicvoidintroduce（）{
System.out.println（"姓名：
"+this.getName（）+"\n性别：
"+this.getSex（）+"\n年龄：
"+this.getAge（））;
}
}
publicclassExample{
publicstaticvoidmain（String[]args）{
Resumere=newResume（"李四","男",20）;
re.introduce（）;
}
}
第4章 面向对象（下）
一、
1．继承
2．重写
3．final
4．implements
5．抽象类
6．super
二、
1．错
2．对
3．对
4．对
5．对
6．错
7．对
三、
1．B
2．D
3．C
4．D
5．C
四、
1．概念：
在Java中","类的继承是指在一个现有类的基础上去构建一个新的类","构建出来的新类被称作子类","现有类被称作父类","子类会自动拥有父类所有可继承的属性和方法。
好处：
继承性主要描述的是类与类之间的关系","通过继承","可以无需重新编写原有类的情况下","对原有类的功能进行使用和扩展。
2．
1、应用程序不必为每一个子类编写功能调用","只需要对抽象父类进行处理即可。
大大提高程序的可复用性。
2、子类的功能可以被父类的方法或引用变量所调用","这叫向后兼容","可以提高可扩充性和可维护性。
3、使用多态可以解决项目中紧偶合的问题","提高程序的课扩展性.是OCP原则的一个具体的实现。
五、
Employee.java
abstractclassEmployee{
privateStringname; //定义姓名name并私有化属性
privateintmonth; //定义生日月份month并私有化属性
publicEmployee（）{} //无参构造器
publicEmployee（Stringname,intmonth）{//有参构造方法
this.name=name;//给属性name初始化赋值
this.month=month;//给属性month初始化赋值
}
//获取属性name的方法
publicStringgetName（）{
returnname;//返回name属性
}
//获取属性month的方法
publicintgetMonth（）{
returnmonth;//返回month属性
}
//给属性name赋初始值
publicvoidsetName（Stringname）{
this.name=name;//本类中的属性name
}
//给属性month赋初始值
publicvoidsetMonth（intmonth）{
this.month=month;//本类中的属性month
}
//创建一个方法getSalary（）用来计算工资，参数month是月份，如果当月是员工生日，奖 励100元
publicdoublegetSalary（intmonth）{
doublesalary=0;//定义工资变量
//判断当前月份是否是员 工的生日月份，如果是奖励100元
if（this.month==month）{
salary=salary+100;
returnsalary;//返回工资salary
}
}
}
SalariedEmployee.java
classSalariedEmployeeextendsEmployee{
privatedoublemonthSalary; //封装monthSalary属性
publicSalariedEmployee（）{} //无参构造方法
//有参构造方法参数姓名生日月份月薪
publicSalariedEmployee（Stringname,intmonth,doublemonthSalary）{
super（name,month）;//调用父类有参构造方法
this.monthSalary=monthSalary;//为属性monthSalary初始化赋值
}
//获取monthSalary的值
publicdoublegetMonthSalary（）{
returnmonthSalary;
}
//给monthSalary赋值
publicvoidsetMonthSalary（doublemonthSalary）{
this.monthSalary=monthSalary;
}
//覆盖父类中的方法
publicdoublegetSalary（intmonth）{
doublesalary=monthSalary+super.getSalary（month）;//定义工资变量
returnsalary;
}
}
HourlyEmployee.java
classHourlyEmployeeextendsEmployee{
privatedoublehourlySalary;//定义属性hourlySalary每小时的工资
privateinthours;//定义属性hours每月工作的小时数
publicHourlyEmployee（）{}//无参构造方法
//有参构造方法参数姓名生日月份每小时的工资每月工作的小时数
publicHourlyEmployee（Stringname,intmonth,doublehourlySalary,int hours）{
super（name,month）; //调用父类有参构造方法
this.hourlySalary=hourlySalary; //为属性hourlySalary初始化赋值
this.hours=hours; //为属性hours初始化赋值
}
publicdoublegetHourlySalary（）{//获取hourlySalary的值
returnhourlySalary;
}
publicintgetHours（）{//获取hours的值
returnhours;
}
//定义set方法设置hourlySalaryhours的值
publicvoidsetHourlySalary（doublehourlySalary）{
this.hourlySalary=hourlySalary;
}
publicvoidsetHourly（inthours）{
this.hours=hours;
}
//覆盖父类方法
publicdoublegetSalary（intmonth）{
if（hours<0）{//如果工作小时数小于0输出数据错误
System.out.println（"数据错误"）;
return0;
}
//小于160个小时的按照每个月的工作小时数乘以每小时的工资
elseif（hours<=160）
returnhourlySalary*hours+super.getSalary（month）;
//超出160个小时的小时数按照1.5倍计算
elsereturnhourlySalary*160+hourlySalary*1.5*（hours- 160）+super.getSalary（month）;
}
}
SalesEmployee.java
classSalesEmployeeextendsEmployee{
privatedoublesales; //定义销售额sales
privatedoublerate;//定义提成率rate
publicSalesEmployee（）{}
publicSalesEmployee（Stringname,intmonth,doublesales,doublerate）{
super（name,month）;
this.sales=sales;
this.rate=rate;
}
publicdoublegetSales（）{
returnsales;
}
publicdoublegetRate（）{
returnrate;
}
publicvoidsetSales（doublesales）{
this.sales=sales;
}
publicvoidsetRate（doublerate）{
this.rate=rate;
}
publicdoublegetSalary（intmonth）{
returnthis.getSales（）*（1+this.getRate（））+super.getSalary（month）;
}
}
BasePlusSalesEmployee.java
classBasePlusSalesEmployeeextendsSalesEmployee{
privatedoublebaseSalary;//定义基础工资baseSalary
//无参构造方法
publicBasePlusSalesEmployee（）{}
//有参构造方法
publicBasePlusSalesEmployee（Stringname,intmonth,doublesales,double rate,doublebaseSalary）{
super（name,month,sales,rate）;
this.baseSalary=baseSalary;
}
//get/set方法对私有属性的调用和设置
publicdoublegatBaseSalary（）{
returnbaseSalary;
}
publicvoidsetBaseSalary（）{
this.baseSalary=baseSalary;
}
publicdoublegetSalary（intmonth）{
returnbaseSalary+super.getSalary（month）;
}
}
Test.java
//定义一个测试类
publicclassTest{
publicstaticvoidmain（String[]args）{
//声明一个Employee类型的数组，并创建不同子类型的对象
Employee[]employee={newSalariedEmployee（“张三”,1,6000）,new HourlyEmployee（“李 四”,2,50,180）,newSalesEmployee（“王 五”,3,6500,0.15）,newBasePlusSalesEmployee（“赵 六”,4,5000,0.15,2000）};
//打印每个员工的工资
for（inti=0;i System.out.println（Math.round（employee[i].getSalary（10）））;
}
}
第5章 异常
一、
1．RuntimeException
2．运行时异常编译时异常
3．throw
4．throws
5．Exception
二、
1．错
2．对
3．对
4．对
5．错
三、
1．C
2．A
3．C
4．C
5．A
四、
1.
try、catch、finally、throw、throws。
2.
程序通过try语句捕获可能出现的异常，如果try语句没有捕获到异常，则直接跳出try…catch语句块执行其他程序；如果在try语句中捕获到了异常，则程序会自动跳转到catch语句中找到匹配的异常类型进行相应的处理。
如果try语句捕获到的异常与catch语句例的异常匹配，则先执行catch中的语句，最后执行其他程序语句。
3.
处理编译时期的异常有两种方式如下：
（1）使用try…catch语句对异常进行捕获处理。
（2）使用throws关键字声明抛出异常，调用者对异常进行处理。
第6章 JavaAPI
一、
1．StringStringBufferStringBuilder
2．length（）
3．DateFormat
4．Random
5．edcba
二、
1．错
2．错
3．对
4．对
5．错
三、
1．B
2．C
3．A
4．B
5．A
四、
1．
String类表示的字符串是常量，一旦创建后，内容和长度都是无法改变的。
而StringBuilder和StringBuffer表示字符容器，其内容和长度可以随时修改。
在操作字符串时，如果该字符串仅用于表示数据类型，则使用String类即可，但是如果需要对字符串中的字符进行增删操作，则使用StringBuffer与StringBuilder类。
如果有大量字符串拼接操作，不要求线程安全的情况下，采用StringBuilder更高效。
相反如果需要线程安全则需要使用StringBuffer。
2．
基本数据类型
对应的包装类
byte
Byte
char
Character
int
Integer
short
Short
long
Long
float
Float
double
Double
boolean
Boolean
五、
1.
Example.java
1importjava.util.Random;
2publicclassExample{
3publicstaticvoidmain（String[]args）{
4for（inti=0;i<10;i++）{
5System.out.println（newRandom（）.nextInt（100））;
6}
7}
8}
2.
Test.java
1importjava.text.DateFormat;
2importjava.util.Calendar;
3importjava.util.Date;
4publicclassTest{
5 publicstaticvoidmain（String[]args）{
6 Calendarcalendar=Calendar.getInstance（）;
7 calendar.add（Calendar.DATE,100）;
8 Datedate=calendar.getTime（）;
9 DateFormatformat=DateFormat.getDateInstance（DateFormat.FULL）;
10 Stringstring=format.format（date）;
11 System.out.println（string）;
12 }
13}
第7章 集合类
一、
1．Collection
2．hashNext（）next（）
3．Comparable
4．Key（键）、Value（值）
5．数组
二、
1．错
2．对
3．对
4．对
5．对
三、
1．D
2．D
3．C
4．A
5．C
四、
1．
List的特点是元素有序、可重复。
List接口的主要实现类有ArrayList和LinkedList。
Set的特点是元素无序、不可重复。
Set接口的主要实现类有HashSet和TreeSet。
Map的特点是存储的元素是键（Key）、值（Value）映射关系，元素都是成对出现的。
Map接口的主要实现类有HashMap和TreeMap。
2．
由于ArrayList集合的底层是使用一个数组来保存元素，在增加或删除指定位置的元素时，会导致创建新的数组，效率比较低，因此不适合做大量的增删操作。
但这种数组的结构允许程序通过索引的方式来访问元素，因此使用ArrayList集合查找元素很便捷。
五、
1.
Example.java
1publicclassExample{
2 publicstaticvoidmain（String[]args）{
3 ArrayListlist=newArrayList<>（）;
4
升级会员 