自考Java语言程序设计（一）课后习题及答案.doc

更多优质自考资料尽在百度贴吧自考乐园俱乐部
（
自考Java语言程序设计（一）课后习题及答案

自考Java语言程序设计（一）第一章Java语言概述课后习题
　一、Java语言概述
　　1．Java语言有哪些特点？
　　2．什么叫做类？什么叫做对象？
　　3．简述Java的运行机制。
　　4．简述Java应用程序的开发流程。
　　5．当初Sun公司发展Java的原因是：来源：
　　（a）要发展航空仿真软件
　　（b）要发展人工智能软件
　　（c）要发展消费性电子产品
　　6.Java是从哪种语言改进并重新设计？
　　（a）Ade来源：
　　（b）C++
　　（c）Pascal
　　7.Java因为什么快速发展而走红？
　　（a）个人计算机与网络
　　（b）游戏软件
　　（c）系统软件
　　8.Java程序的种类有：
　　（a）内嵌于Web文件中，由浏览器来观看的__________
　　（b）可独立运行的__________考试大论坛
　　（c）服务器端的_________
　　9.Java是面向对象语言，对象是客观事物的，对象与之是一一对应的，它是很具体的概念。
　　10. 判断：用Javac编译Java源文件后得到代码叫字节码。()
　　参考答案
　　1．答：面向对象、简单、平台无关性、安全性、内存管理、分布式应用、多线程、动态、解释运行，高效能
　　2．答：在面向对象编程中，具体的客观实体称为对象，对象就是数据加方法。对象在程序中是通过一种抽象数据类型来描述的，这种抽象数据类型称为类。类是对具有相同属性和方法的一组相似对象的抽象，或者说类是对象的模板。来源：考试大
　　3．答：Java程序的运行必须经过编写、编译、运行三个步骤。编写是指在Java开发环境中进行程序代码的输入过程，最终形成后缀名为.java源文件。编译是指使用Java编译器对源文件进行错误排查的过程，编译后将生成后缀名为.class的字节码文件。运行是指使用Java解释器 将字节码文件翻译成机器代码，在cpu上运行并显示结果的过程。这一过程如图所示。考试大－全国最大教育类网站(www．Examda。com)
　　4．Java应用程序的运行经过编写、编译、运行三个步骤。
　　第1步，编写程序。使用记事本或其他软件编写程序的源代码，将源代码保存为文件filename.java文件。
　　第2步，编译程序。在MS-DOS命令窗口，将当前目录转换到Java源程序所在的保存目录；输入“javame.java”形式的命令进行程序编译。
　　第3步，执行程序。在同样的命令窗口中输入“javame”形式的命令执行程序。来源：考试大
　　完成了程序的开发，查看相应t目录，其中应该具有两个文件，分别是XXXX.java和XXXX.class。考试大收集整理
　　5.c
　　6.b
　　7.a
　　8.AppletApplicationServlets
　　9.软件模型
10.true

自考Java语言程序设计（一）第二章数据类型和流程控制课后习题

二、数据类型和流程控制
　　1. 现有语句：String s = "Example";则下面哪些语句是合法语句？
　　A. s >>> = 3;B. s[3] = "x";
　　C. int i = s.length();D. String t = "For " + s;
　　E. s = s + 10;
　　2．下面哪些是保留字？
　　A. run B. default C. implement D. import
　　3．下面声明float变量的语句合法的有：
　　A. float foo = -1; B. float foo = 1.0;
　　C. float foo = 42e1; D. float foo = 2.02f;
　　E. float foo = 3.03d; F. float foo = 0x0123;
　　4. 下面方法中的“返回类型无效”应该是什么？
　　public class ReturnIt{ 来源：考试大
　　return无效 methodA(byte x, double y){
　　return (short)x / y * 2;
　　}
　　}
　　5．以下哪两个表达式是等价的：
　　A. 3/2 B. 3<2 C. 3*4
　　D. 3<<2 E. 3*2^2F. 3<<<2
　　6.指出正确的表达式
　　A、 byte=128; 来源：考试大
　　B、 Boolean=null;
　　C、 long l=0xfffL;
　　D、 double=0.9239d;
　　7．分析下列程序的执行结果：
　　（1）public class Test{
　　public static void main(String args[]){
　　int i = oxFFFFFFF1;
　　int j = ~i;
　　System.out.println("j=" + j);
　　}
　　}
　　（2）public class Test{
　　public static void main(String[] args){
　　System.out.println(6 ^ 3);
　　}
　　}
　　（3）public class FooBar{
　　public static void main(String[] args){
　　int i = 0, j = 5;
　　tp:
　　for(; ; i++){
　　for( ; ; --j)
　　if(i > j)
　　break tp;
　　}
　　System.out.println("i=" + i + ",j=" + j);
　　}
　　}
　　（4）public class Test{
　　public static void main(){
　　int i = 1, j = 10;
　　do{
　　if(i++ > --j)
　　continue;
　　}while(i < 5);
　　System.out.println("i=" + i + " j=" + j);
　　}
　　}
　　（5）class Value{
　　public int i = 15;
　　}
　　public class Test{
　　public static void main(String argv[]){
　　Test t = new Test();
　　t.first();
　　}
　　public void first(){
　　int i = 5;
　　Value v = new Value();
　　v.i = 25;
　　second(v, i);
　　System.out.println(v.i);
　　}
　　public void second(Value v, int i){
　　i = 0;
　　v.i = 20;
　　Value val = new Value(); 来源：考试大的美女编辑们
　　v = val;
　　System.out.println(v.i + " " + i);
　　}
　　}
　　8.选出合理的标识符
　　A、 _sys1_lll
　　B、 2mail
　　C、 $change
　　D、 class
　　9. 判断：一个方法最多能有一个return语句()
　　10. Java语言中一个Char类型的数据占用2个字节大小的内存空间()
　　参考答案
　　1．cde
　　2．b,d
　　3．a,d,f
　　4．double
　　5．c,d
　　6. d
　　7．（1）c（2）5（3）i = 0, j = -1
　　（4）i=5 j=6（5）15 0 20
　　8. a c
　　9. true
　　10.ture

自考Java语言程序设计（一）第三章类与对象课后习题

三、类与对象
　　1．什么叫引用类型，对象是引用类型吗？
　　2．什么是类成员，什么是实例成员？他们之间有什么区别？
　　3. 判断：数组、类和接口都是引用数据类型（）
　　4.判断：类A和类B位于同一个包中，则除了私有成员，类A可以访问类B的所有其他成员()
　　5.下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的（）
　　A、publicB、privateC、staticD、final采集者退散
　　6.下面关于java中类的说法哪个是不正确的（）
　　A、类体中只能有变量定义和成员方法的定义，不能有其他语句。
　　B、构造函数是类中的特殊方法。
　　C、类一定要声明为public的，才可以执行。采集者退散
　　D、一个java文件中可以有多个class定义。
　　7.下列哪个类声明是正确的()
　　A abstract final class H1｛…｝
　　B abstract private move()｛…｝
　　C protected private number；
　　D public abstract class Car｛…｝
　　8.下述哪些说法是正确的？ （多选）
　　A、 实例变量是类的成员变量
　　B、 实例变量是用static关键字声明的
　　C、 方法变量在方法执行时创建
　　D、方法变量在使用之前必须初始化
　　9．设计一个动物类，它包含动物的基本属性。例如名称、大小、重量等，并设计相应的动作，例如跑、跳、走等。
　　10．设计一个长方形类，成员变量包括长和宽。类中有计算面积和周长的方法，并有相应的set方法和get方法设置和获得长和宽。编写测试类测试是否达到预定功能。要求使用自定义的包。
　　参考答案
　　1．答：引用类型是指该类型的标识符表示的是一片内存连续地址的首地址。对象是引用类型。来源：考试大
　　2．答：Java中使用static修饰的变量和方法称为类变量（或称静态变量）和类方法（或称静态方法），没用static修饰符的变量和方法称为实例变量和实例方法。
　　类成员是指该成员属于这个类，由这个类所创建的所有对象共同拥有，该成员仅在类的存储单元中存在，这个类所创建的所有对象中仅存储一个指向该成员的 引用。任何一个该类的对象改变了类成员，其他对象同样会发生改变。对于类成员既可以使用对象访问，也可以使用类名直接进行访问，并且在类方法中只能访问类 变量，而不能访问实例变量。
　　实例成员是指该成员由每一个对象个体独有，对象的存储空间中的确有一块空间用来存储该成员，不同对象的实例成员不同，任何一个对象改变了实例成员， 只会影响这个对象本身，其他对象中的实例成员不会发生改变。对于实例成员只能通过对象来访问，不能通过类名进行访问，在实例方法中既可以访问实例变量，也 可以访问类变量。考试大收集整理
　　3. true
　　4. true
　　5. C
　　6．C
　　7. D
　　8. A C D
　　9.答：
　　public class Animal{
　　private String name;
　　private double weight;
　　private int length;
　　privateString sex;
　　public void run(){
　　System.out.println("the animal is running!");
　　}
　　public void jump(){
　　System.out.println("the animal is jumping!");
　　}
　　public void walk(){
　　System.out.println("the animal is walking!");
　　}
　　}
　　10．答：
　　package mypackage.math;
　　class Rectangle{
　　private int length;
　　private int width;
　　public Rectangle(int length,int width){
　　this.length=length;
　　this.width=width;
　　}
　　public void set(int length,int width){
　　this.length=length;
　　this.width=width;
　　}
　　public void get(){
　　System.out.println("此长方形的长为"+length+"宽为"+width);
　　}
　　public int getLength(){
　　return length;
　　}
　　public int getWidth(){
　　return width;
　　}
　　public int calculatePerimeter(){
　　return 2*(length+width);
　　}
　　public int calculateArea(){
　　return (length*width);
　　}
　　public void print(){
　　System.out.println("此长方形的周长为"+calculatePerimeter()+"面积为"+calculateArea());
　　}
　　}
　　class Test{
　　public static void main(String [ ] args){
　　Rectangle myrectangle=new Rectangle(15,10);
　　myrectangle.get();
　　myrectangle.print();
　　myrectangle.set(20,15);
　　System.out.println("长方形的长是"+myrectangle.getLength()+"宽是"+ myrectangle .getWidth());
　　myrectangle.print();
　　}
　　}

自考Java语言程序设计（一）第四章方法与构造函数课后习题

四、方法与构造函数
　　1．Java的访问限定修饰符有几种，各自的访问权限是什么？
　　2．如何创建自己的包，如何引入包？
　　3．下面哪一个是类Myclass的构造函数？
　　class Myclass{www.Ｅxamda.CoM
　　public void Myclass(){}
　　public static Myclass(){}
　　public Myclass(){}
　　public static void Myclass(){}
　　}
　　4. 判断：类体中private修饰的变量在本类中能访问，类生成的对象也能访问。()
　　5. 判断：一个类中，只能拥有一个构造器方法。()
　　6.Java中类成员的限定词有以下几种：private, public, ________, ________。其中，________的限定的范围最大。
　　7、被关键字__________修饰的方法是不能被当前类的子类重新定义的方法
　　8．设计Point类用来定义平面上的一个点，用构造函数传递坐标位置。编写测试类，在该类中实现Point类的对象。
　　9．编写程序说明静态成员和实例成员的区别。
　　10．设计雇员Employee类，记录雇员的情况，包括姓名、年薪、受雇时间，要求定义MyDate类作为受雇时间，其中包括工作的年、月、日，并用相应的方法对Employee类进行设置。编写测试类测试Employee类。要求使用自己的包。
　　参考答案
　　1．答：Java的访问限定修饰符有4种，分别使public、protected、private和默认修饰符。用public修饰的类或成员拥 有公共作用域，表明此类或类的成员可以被任何Java中的类所访问，是最广泛的作用范围。用protected修饰的变量或方法拥有受保护作用域，可以被 同一个包中所有的类及其他包中该类的子类所访问。用private修饰的变量或方法拥有私有作用域，只能在此类中访问，在其他类中，包括该类的子类也是不 允许访问的，private是最保守的作用范围。没有任何修饰符拥有默认访问权限（友好访问权限），表明此类或类的成员可以被同一个包中的其它类访问本文来源:考试大网
　　2．答：创建自己的包只要将package语句作为Java源文件的第一句就可以了。例
　　package myPackage; 声明创建了一个名为myPackage的包。
　　Java使用import语句来引入包及其中的类。例如import myPackage.*；就引入了myPackage包中所有的类。
　　3．答：public Myclass(){}是类Myclass的构造函数。
　　4. false
　　5. false
　　6. friendly、 protected、public
　　7．Private
　　8. 答：
　　class Point
　　{ int x,y;
　　Point(int a,int b)
　　{ x=a;
　　y=b;
　　}
　　}
　　public class A
　　{ public static void main(String [ ] args)
　　{ Point p1,p2;
　　p1=new Point(10,10);
　　p2=new Point(23,35);
　　}
　　}
　　9．答：
　　class StaticTest{
　　int i=5;
　　static int j=5;
　　void print(){
　　System.out.println("i="+i);
　　System.out.println("j="+j);
　　}
　　static void classprint(){
　　//System.out.println("i="+i);
　　System.out.println("j="+j);
　　}
　　}
　　class Test{
　　public static void main(String [] args){
　　//System.out.println(StaticTest.i);
　　System.out.println(StaticTest.j);
　　//StaticTest.print();
　　StaticTest.classprint();
　　StaticTest st=new StaticTest();
　　System.out.println(st.j);
　　System.out.println(st.j);
　　st.print();
　　st.classprint();
　　}
　　}
　　10．答：
　　package mypackage.employee;
　　class MyDate{
　　private int year;
　　private int month;
　　private int day;
　　public MyDate(int year,int month,int day){
　　this.year=year;
　　this.month=month;
　　this.day=day;
　　}
　　public int getYear(){
　　return year;
　　}
　　}
　　public class Employee{
　　private String name;
　　private double salary;
　　private MyDate hireDay;
　　public Employee(String name,double salary,MyDate day){
　　this.name=name;
　　this.salary=salary;
　　hireDay=day;
　　}
　　public void print(){
　　System.out.println(name+ ""+salary+""+hireYear());
　　}
　　public int hireYear(){
　　return hireDay.getYear();
　　}
　　}
　　class TestEmployee{
　　public static void main(String [] args){
　　Employee a=new Employee("李明",20000,new MyDate(2000,10,1));
　　Employee b=new Employee("王强",24000,new MyDate(1995,8,12));
　　a.print();
　　b.print();
　　}
　　}

自考Java语言程序设计（一）第五章类的继承课后习题

五、类的继承
　　l．什么是继承?什么是父类?什么是子类?继承的特性可给面向对象编程带来什么好处?什么是单重继承?什么是多重继承?
　　2．观察下面的程序片断，指出其中的父类和子类，以及父类和子类的各个域和方法。
　　class SuperClass
　　{
　　int data;
　　voidsetData(intnewData)
　　{
　　data=newData~
　　}
　　intgetData()
　　{
　　return data~
　　}
　　}
　　class SubClass extends SuperClass
　　{
　　int suhData;
　　void setSubData(intnewData)
　　{
　　suhData=new Data;
　　}
　　intgetData()
　　{
　　return subData;
　　}
　　}
　　3．“子类的域和方法的数目一定大于等于父类的域和方法的数目”，这种说法是否正确?为什么?
　　4. 在Java程序中，通过类的定义只能实现单重继承()
　　5.下列哪些说法是正确的？
　　A、 Java 语言只允许单一继承
　　B、 Java 语言只允许实现一个接口
　　C、 Java 语言不允许同时继承一个类并实现一个接口
　　D、 Java 语言的单一继承使得代码更加可靠
　　6.Java中所有类都是类________的子类。
　　7.　请写出下面程序的运行结果。
　　public class Test extends TT{
　　public void main(String args[]){
　　Test t = new Test("Tom");
　　}
　　public Test(String s){
　　super(s);
　　System.out.println("How do you do?");
　　}
　　public Test(){
　　this("I am Tom");
　　}
　　} www.Ｅxamda.CoM
　　class TT{
　　public TT(){
　　System.out.println("What a pleasure!");
　　}
　　public TT(String s){
　　this();
　　System.out.println("I am "+s);
　　}
　　}
　　结果：________
　　8.父类的成员在子类中的访问权限由决定。
　　9.对象的使用包括引用对象的成员变量和方法。通过运算符就能实现对对象成员变量的访问和对象
　　10.Java是面向对象语言，对象是客观事物的，对象与之是一一对应的，它是很具体的概念。
　　参考答案：
　　l．答：继承是面向对象程序设计中两个类之间的一种关系。当一个类获取另一个类中所有非私有的数据和操作的定义作为它自己的部分或全部成分时，就称这两个类之间具有继承关系。被继承的类称为父类或超类，继承了父类或超类的所有数据和操作的类称为子类。
　　面向对象程序设计中的继承，可使得程序结构更加清晰，降低了编码和维护的工作量。如果一个类只能有一个父类，则这种继承关系称为单重继承；如果一个类可以有多个父类，则这种继承关系称为多重继承。
　　2．答：
　　父类SuperClass
　　父类的域data来源：考试大的美女编辑们
　　父类的方法setData()，getData()
　　子类SubClass
　　子类的域data，subData
　　子类的方法setSubData()，setData()，getData()采集者退散
　　3．答：这种说法是错误的，因为子类不一定能继承父类的所有域和方法，它只能继承所有非私有的域和方法。如果子类在继承之外自己定义的域和方法数目小于父类中私有成员的数目，则子类的域和方法的数目小于父类的域和方法的数目|考试大收集整理
　　4. true
　　5. A D
　　6. Object
　　7. 答：
　　What a pleasure!
　　I am Tom
　　How do you do?
　　8. 访问权限修饰符
　　9. “.”
　　10.软件模型

自考Java语言程序设计（一）第六章重载与多态课后习题

六、重载与多态
　　1.判断：接口中的所有方法都没有被实现。()
　　2.方法重载是指 ( )
　　A.两个或两个以上的方法取相同的方法名，但形参的个数或类型不同考试大论坛
　　B.两个以上的方法取相同的名字和具有相同的参数个数，但形参的类型可以不同
　　C.两个以上的方法名字不同，但形参的个数或类型相同
　　D.两个以上的方法取相同的方法名，并且方法的返回类型相同
　　3．什么是方法的覆盖?方法的覆盖与域的隐藏有何不同?与方法的重载有何不同?
　　4．解释this和super的意义和作用。
　　5．什么是多态?面向对象程序设计为什么要引人多态的特性?使用多态有什么优点?
　　6．Java程序如何实现多态?有哪些方式?
　　7．根据下面的要求编程实现复数类ComplexNumber。
　　(1)复数类ComplexNumber的属性
　　·m_dRealPart实部，代表复数的实数部分。
　　·m_dlmaginPart虚部，代表复数的虚数部分。
　　(2)复数类ComplexNumber的方法
　　·ComplexNumber()构造方法，将实部、虚部都置为0。
　　·ComplexNumber(doubler，doublei)构造方法，创建复数对象的同时完成复数的实部、虚部的初始化；r为实部的初值，i为虚部的初值。
　　·getRealPart()获得复数对象的实部。
　　·getlmaginaryPart()获得复数对象的虚部。
　　·setRealPart(doubled)把当前复数对象的实部设置为给定的形参的数字。
　　·setlmaginaryPart(doubled)把当前复数对象的虚部设置为给定形参的数字。
　　·complexAdd(ComplexNumberc)当前复数对象与形参复数对象相加，所得的结果也是复数值，返回给此方法的调用者。
　　·complexAdd(doublec)当前复数对象与形参实数对象相加，所得的结果仍是复数值，返回给此方法的调用者。
　　·complexMinus(ComplexNumberc)当前复数对象与形参复数对象相减，所得的结果也是复数值，返回给此方法的调用者。
　　8．什么是接口?为什么要定义接口?接口与类有何异同?来源：考试大的美女编辑们
　　9．一个类如何实现接口?实现某接口的类是否一定要重载该接口中的所有抽象方法?
　　10．接口是否可以被继承?阅读下面的代码，试写出SubInterface中的抽象方法。
　　interface SupInterface
　　{
　　public abstract int supMethod()；
　　}
　　interface SubInterface extends SupInterface
　　{
　　public abstract string subMethod()；
　　}
　　参考答案：
　　1. true
　　2.A
　　3．答：子类重新定义父类中已经存在的方法，称为方法的覆盖。注意：方法覆盖与域的隐藏不同。子类重新定义父类已有的域，并不能完全取代它从父类那 里继承的同名的域，这个域仍然占用子类的内存空间，在某些情况下会被使用；而当子类重新定义父类的方法时，从父类那里继承来的方法将被新方法完全取代，不 再在子类的内存空间中占一席之地。与方法的覆盖不同，重载不是子类对父类同名方法的重新定义，而是在一个类中定义了同名的不同方法。
　　4．答：关键字this指代当前类的当前对象，关键字super指代当前类的直接父类对象。考试大－全国最大教育类网站(www．Examda。com)
　　5．答：一个类中存在多个同名的方法，称为多态。把抽象功能和目的相同，而具体实现因不同情况而异的方法命名为同名方法，符合面向对象程序设计中抽象、提升概念，封装、隐藏细节的特点，从而提高了程序的简洁性和可读性，降低了类和程序模块直接的相互耦合和依赖。
　　6．答：Java程序通过覆盖和重载两种方式来实现多态。覆盖是子类重新定义父类中已有的方法，重载是在一个类内部定义与已存在的方法同名但是参数列表不同的方法。
　　7．答：
　　public class ch5_e5_12
　　{
　　public static void main(String args[])
　　{
　　ComplexNumber cNumber_1 =
　　new ComplexNumber(3,-5);
　　ComplexNumber cNumber_2 = 本文来源:考试大网
　　new ComplexNumber(2,2);
　　double d = 10.0;
　　System.out.println(cNumber_1.toString() + " 加 "
　　+ cNumber_2.toString() + " 等于 "
　　+ cNumber_plexAdd(cNumber_2).toString());
　　System.out.println(cNumber_1.toString() + " 加 "
　　+ d + " 等于 "
　　+ cNumber_plexAdd(d).toString());
　　System.out.println(cNumber_1.toString() + " 减 "
　　+ cNumber_2.toString() + " 等于 "
　　+ cNumber_plexMinus(cNumber_2).toString());
　　System.out.println(cNumber_1.toString() + " 减 "
　　+ d + " 等于 "
　　+ cNumber_plexMinus(d).toString());
　　System.out.println(cNumber_1.toString() + " 乘 "
　　+ cNumber_2.toString() + " 等于 "
　　+ cNumber_plexMulti(cNumber_2).toString());
　　System.out.println(cNumber_1.toString() + " 乘 "
　　+ d + " 等于 "
　　+ cNumber_plexMulti(d).toString());
　　}
　　}
　　class ComplexNumber
　　{
　　//域
　　private double m_dRealPart;
　　private double m_dImaginPart;
　　//构造方法
　　ComplexNumber()
　　{
　　m_dRealPart = 0.0;
　　m_dImaginPart = 0.0;
　　}
　　ComplexNumber(double r,double i)
　　{
　　m_dRealPart = r;
　　m_dImaginPart = i;
　　}
　　ComplexNumber(ComplexNumber c)
　　{
　　m_dRealPart = c.getRealPart();
　　m_dImaginPart = c.getImaginaryPart();
　　}
　　//get,set方法
　　double getRealPart()
　　{
　　return m_dRealPart;
　　}
　　double getImaginaryPart()
　　{
　　return m_dImaginPart;
　　}
　　void setRealPart(double d)
　　{
　　m_dRealPart = d;
　　}
　　void setImaginaryPart(double d)
　　{
　　m_dImaginPart = d;
　　}
　　//复数运算方法
　　ComplexNumber complexAdd(ComplexNumber c)
　　{
　　return new ComplexNumber(
　　this.m_dRealPart + c.getRealPart(),
　　this.m_dImaginPart + c.getImaginaryPart());
　　}
　　ComplexNumber complexAdd(double c)
　　{
　　return new ComplexNumber(
　　this.m_dRealPart + c, this.m_dImaginPart);
　　}
　　ComplexNumber complexMinus(ComplexNumber c)
　　{
　　return new ComplexNumber(
　　this.m_dRealPart - c.getRealPart(),
　　this.m_dImaginPart - c.getImaginaryPa