超级无敌神奇的java期末考试题库

一、选择题

1.已知X和Y均为boolean型变量，则X&&Y的值为true的条件是什么？ C

A)至少其中一个为true B)至少其中一个为false

C)X和Y均为true D)X和Y均为false

2.设有定义float X=3.5f，Y=4.6f，Z=5.7f；则以下的表达式中，值为true的是 B

A) X>Y||X>Z B)X!=Y C)X>(Y+Z) D)Y>Z

3.对于一个三位数的正整数n，取出它的十位数k（k为整数）的表达式是 A

A)K=n/10%10 B)K=n%10%10 C)K=n%10 D)K=n/10

4.设int x=2，则表达式（x++）*3的值是 A

A6 B)9 C)6.0 D)9.0

5.关于数据类型转换的说法那个是不正确的 C

A)Java共有两种数据类型的转换方式，自动转换和强制转换

B)Java中当两个类型不同的运算对象进行算术运算时，Java自动把精确度较低的类型转换成另一个精度较高的类型

C)boolean型数据能和其它数据类型进行转换

D)char型和int型数据可以相互转换

6.定义变量int i=3；那么表达式i/6*5的计算结果是 A

A)0 B)1 C)2.5 D)2

7.指出下列类型转换中正确的是 D

A)int i=8.3； B)Long L=8.4f；

C)int i=（boolean）8.9； D)double d=100

8.下面哪一个是合法的标识符 D

A)12class B)+viod C)-5 D)_black

9.下面哪个标识符是合法的 D

A)#_pound B)$123+w C)5Interstate D)a_b

10.下列单词中，不属于Java关键字的是 A

A)NULL B)class C)this D)byte

11.以下的选项中能正确表示Java语言中的一个整数常量的是 B

A)12． B)-20 C)1,000 D)4 5 6

12.下列数据类型的精度由高变低的顺序是 B

A)float，double，int，long

B)double，float，int，byte

C)byte，long，double，float

D)double，int，float，long

13.现有一个变量声明为boolean aa，下面赋值语句中正确的是 A

A)aa=false B)aa=False C)aa=“true” D)aa=0

语句中，占用32位储存空间的是 D

A)long，double B)long，float C)int，double D)int，float

15.设int x=1，y=2，z=3，则表达式y+=z--/++x中y的值 A

A)3 B)3.5 C)4 D)4.5

支持的3种跳转语句不包括 D

A)break语句 B) continue语句 C)return语句 D)goto语句

17.下列语句中执行跳转功能的语句是 C

A)for语句 B)while语句 C) continue语句 D)switch语句

1

18.在switch（expression）语句中，expression的数据类型不正确的是 C

A)byte B)char C)float D)short

19.关于Java源文件下列说法正确的是 A

A)一个Java源文件只能有一个public修饰的类

B)一个Java源文件只能有一个缺省的类

C)一个Java源文件可以有多个protected修饰的类

20.下面正确的main方法是 C

A)public static void main(String args)

B)public static int main (String[] args)

C)public static void main(String[] args)

D)public final void main (String args)

21.下面方法定义中，正确的是 D

A)int x （int a，b）{return a-b;}

B)double x （int a，int b）{int w；w=a-b;}

C)double x（a，b）{return b;}

D)int x(int a,int b,){return a-b;}

22.下面定义中，不正确的是 D

A)float x(int a,int b){return a-b;}

B)int x(int a,int b){return a-b;}

C)int x (int a,int b){return a*b;}

D)int x(int a,int b){return 1.2*(a-b);}

23.下面方法定义中，正确的是 A

A)int x（）{char ch=’a’;return (int)ch;}

B)void x() {return true;}

C)int x (){return true;}

D)int x(int a,b){return a-b;}

24、设x、y均为已定义的类名，下列声明类x的对象x1的语句正确的是

A)X x1=new X(); B)X x1=X();

C)X x1=new Y(); D)Int X x1;

25设A为已定义的类名，下列声明并创建A类的对象a的语句中正确的是

A)A a=new A（）； B)Public A a=A（）；

C)A a=new class（）； D)a A；

26、下面类的定义中结构正确的是 A

A)class A B)Class 2A C)Int class A D)Public class A（）

下面关于类的结构的说法正确的是（B）

A)类只能包含一个构造方法

B)类可以没有属性

C)类只能包含方法

D)类只能包含属性

27、下面那个关键字在定义类头时用不到（D）

A)Class B)Public C)Extends D)Int

28、面向对象程序不包含下面的哪个组成部分（D）

A)类 B)对象 C)接口 D)程序员

29、下列不属于面向对象的三大特征的是（B）

A

A

2

A)继承 B)方法 C)封装 D)多态

32、设X，Y是已定义的类名，下列声明x类的对象x1的语句正确的是（B）

A)static X x1（123）；

B)Public X x1=new X（123）；

C)Y x1；

D)X x1=X（）；

33this在程序中代表的是（A）

A)类的对象

B)属性

C)方法

D)父类

34、下列对构造方法的调用方式的描述中正确的是（A）

A)使用new调用

B)使用类名调用

C)使用对象名调用

D)调用方法为对象名.方法名（）

35、以下关于构造函数的描述错误的是（A）

A)构造函数的返回类型只能是void型

B)构造函数是类的一种特殊函数，它的方法名必须与类名相同

C)构造函数的主要作用是完成对类的对象的初始化工作

D)一般在创建新对象时，系统会调用构造函数

36、下列构造方法的调用方式中，正确的是（C）

A）按照一般方法调用

B)由用户直接调用

C)只能通过new自动调用

D)不能调用，自动执行

37、有一个类A，以下为其构造方法的声明，其中正确的是（B）

A)void A（int x）

B)A（int x）

C)a （int x）

D)Void a（int x）

38、下列关于静态方法的描述中，错误的是（C）

A)静态方法指的是被static关键字修饰的方法

B)静态方法不占用对象的内存空间，而非静态方法占用对象的内存空

C)静态方法内可以使用this关键字

D)静态方法内部只能访问被static修饰的成员

39、下列关于静态方法的描述，错误的是（C）

A)静态方法属于类的共享成员

B)静态方法是通过“类名.方法名”的方式来调用

C)静态方法只能被类调用，不能被对象调用

D)静态方法中可以访问静态变量

40、下面那个关键字用来修饰静态（A）

A）static B)protected C）public D）private

41、下面哪个关键字用来修饰常量（B）

间

3

A）static B)final C）public D）private

42、下面关于常量的描述，正确的是（B）

A)常量在主函数中可以被修改

B)常量在主函数中不可以被修改

C)常量一般用static来定义

D)常量一定会被调用

43、已知类的继承关系如下：class A

Class B extends A

Class C extends A

则以下语句中能够通过编译的是（A）

A) A a=new B（）；

B) C c=new B（）；

C) C c=new A（）；

D) B b=new C（）；

44下面关于super的说法，错误的是（D）

A)使用super，可以调用父类的构造方法

B)使用super，可以调用父类的属性

C)使用super，可以调用父类的方法

D)使用super，可以调用对象自己的属性和方法

45、继承的关键字是（B）

A)extend

B)Extends

C)Extend

D)Extends

46、父子类在同一个包中，子类不能继承父类的那个属性（D）

A）default B)protected C）public D）private

47、下列选项中关于super关键字的说法正确的是（A）

A)super关键字是在子类对象内部指代其父类对象的引用

B)Super关键字不仅可以指代子类的直接父类，还可以指代父类中的父类

C)子类通过super关键字只能调用父类的方法，而不能调用父类的属性

D)子类通过super关键字只能调用父类的属性，而不能调用父类的方法

48、关于super的说法正确的是（B）

A)是指当前对象的内存地址

B)是指当前对象的父类对象的内存地址

C)是指当前对象的父类

D)可以在main（）方法中

E)

49、父子类不在同一个包中，子类能继承父类的哪个属性（B）

A)default B)protected C）static D）private

50、下列修饰符中，成员内部被修饰后，不可以被外界访问（D）

A)default B)protected C）public D）private

51、被声明为private，protected及public的类成员，在类的外部则（B）A）只能访问到声明为public的成员

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

4

C）都可以访问

D）都不能访问

52、下面那个关键字用于将类中的属性私有化（D）

A)default B)protected C）public D）private

53、下面哪两个关键字是类的可见性修饰符（A）

A）public和默认的

B）Public和private

C）Private和默认的

D）Protected和默认的

54、下面关于属性的修饰符，那个只能在当前类中使用（D）

A）default B)protected C）public D）private

55、下面关于方法的修饰符，那个只能在当前类中使用（D）

A)default B)protected C）public D）private

56、下面关于get和set方法的叙述，正确的是（C）

A)两个方法一般都有返回值

B)两个方法一般都没有返回值

C)Get方法一般有返回值

D)Set方法一般有返回值

57、下面关于get和set方法的叙述，正确的是（A）

A)两个方法一般都使用this关键字

B)两个方法一般都不使用this关键字

C)Set方法不能使用this关键字

D)Get方法不能使用this关键字

58、关于类的继承的描述，正确的是（B）

A)一个类可以继承多个父类

B)一个类可以具有多个子类

C)子类可以使用父类的所有方法

D)子类一定比父类有更多的成员方法

59、在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，返回的值也可以不相同。这种面向对象程序特性称为（C）

A)隐藏 B)覆盖 C)重载 D)Java不支持此特性

60、方法的重载是指，两个方法具有相同名称和不同的参数形式。其中不同的参数形式是指（A）

A)参数个数或类型不同

B)参数有无返回值

C)方法的修饰符不同

D)以上都不对

61、以下关于方法的覆盖的说法，错误的是（D）

A)子类的方法与父类的方法，方法名必须相同

B)子类的方法与方法的方法，参数形式必须相同

C)子类的方法与父类的方法，返回值类型必须相同

D)以上都不对

62、覆盖与重载的关系是（A）

A)覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中

B)覆盖方法可以不同名，而重载方法必须同名

5

C)Final修饰的方法可以可以被覆盖，但不能被重载

D)覆盖于重载是同一回事

63、下面关于多态性的说法，正确的是（C）

A）一个类中不能有同名的方法

B）子类中不能有和父类中同名的方法

C）子类中可以有和父类中同名且参数相同的方法

D）多态性就是方法的名字可以一样，但返回的类型必须不一样

64、定义抽象类的关键字是（A）

A)abstract class

B)Final class

C)Static class

D)Public class

65、下面关于抽象类的描述，错误的是（D）

A)抽象类的修饰符可以是public

B)抽象类的修饰符可以说默认的

C)抽象类中可以有抽象方法，也可以有非抽象方法

D)抽象类中可以有抽象方法，但不可以有非抽象方法

66、下面说法正确的是（A）

A)final可修饰类、属性、方法

B)Abstract可修饰类、属性、方法

C)定义抽象方法需要给出方法的返回值类型、方法名、参数列表和方法名

D)用final修饰的变量，在程序中可对这个变量的值进行修改

67、以下哪个接口的定义是正确的（D）

A)interface B{ void print（）；}

B)Abstract interface B{void print（）；}

C)Abstract interface B extendsA1，A2{abstract void print（）；}

D)Interface B{void print（）；}

68、定义一个接口时，下列哪个关键字用不到（D）

A)Public B)Extends C)Interface D)Class

69、在使用interface声明一个接口时，只可以使用哪个修饰符修饰该接口（D）A)Private

B)Protected

C)Private或者protected

D)Public

70、下列类头定义中，错误的是（A）

A)public x extends y

B)Public class x extends y

C)Public x extends yimplements y1

D) Class x

71、下列叙述正确的是（C）

A)Java中允许多重继承

B)Java中一个类只能实现一个接口

C)Java中只能单重继承

D)Java中一个类可以继承多个抽象类

6

72、声明一个数组，_[]a=new String[]{};空格处应该填写的内容是为（C）

A)Int B)Double C)String D)string

73、int a[]={45,4,67,23,65,87,34,52,56};数组中a[5]的值为（D）

A)23 B)45 C)65 D)87

74、下面哪种写法可以实现访问数组arr的第一个元素（A）

A)Arr[0] B)Arr(0) C)Arr[1] D)Arr(1)

75、下列对长度为4的数组a的定义中，正确的是（C）

A)int[4] a=new int[];

B)Int a[]=new int[5];

C)Int a[]={2,4,2,1};

D)Int[4] a=new int[4]

76、下面关于对象数组的叙述正确的是（B）

A)对象数组的长度可以修改

B)对象数组里的每个元素都是那个对象的引用

C)对象数组的索引是从1 开始的

D)数组中可以存放多种类型的对象

二、填空

重载和覆盖：

1.定义绝对值得方法abs（），利用方法的重载实现既能求整数的绝对值，又能求浮点数的绝对值。

pubic class Test{

public static int abs（int n）{

If（n<=0）;

return -n;

else return n;

}

Public static double abs （double n）{

if(n<=0)

return -n;

else return n;

}

2.利用方法重载定义平均值的方法average（），既能求三个整数的平均值，又能求两个整数的平均值。

Public static Test2{

Public static int average（int a,int b,int c）{

Return （a+b+c）/3.0;

}

Public static double average（int a,int b）{

Return （a+b）/2.0;

}

3.利用方法重载定义求最大值的方法max（），既能求两个整数的最大值，又能求三个整数的最大值。

Public static int max（int a,int b）{

If（a>b）

Return a;

Else return b;

7

}

Public static int max（int a,int b,int c）{

If（a>b）

Temp=a;

Else temp=b;

If（c>temp）

Temp=c;

Return temp;

}

4.在父类中定义了printA（）方法，输出“A”，子类中覆盖printA（）方法输出“A”。

Class Father{

Int a;

Public void printA（）{

n（“A”）；

}

Class Child extends Father{

public void printA（）{

n（“AA”）；

}

5.父类中定义了process（int n）方法，将参数的值加2，子类覆盖父类中该方法将参数的值乘以2.

Class Father1{

Public int process（int n）{

Return n+2;

}

}

Class Child extends Father1{

public int process（int n）{

Return n*2;

}

抽象类：

6.定义一个抽象类，包括能求面积的抽象方法。

Public abstract class Test6{

Public abstract double area（）；

}

7.定义一个抽象类，包括表示奔跑的抽象方法。

Public abstract class Test7{

Public abstract void run（）；

}

8.定义一个抽象类，包括表示eat的抽象方法。

Public abstract class Test8{

Public abstract void eat（）；

}

9.定义一个抽象类，包括表示start的抽象方法。

Public abstract class Test9{

8

Public abstract void start（）；

}

10.定义一个抽象类，包括表示travel的抽象方法。

Public abstract class Test10{

Public abstract void travel（）；

}

接口：

11.下面是定义一个接口ITF的程序，完成程序填空。

Public interface ITF{

Public static final double P1=Math.P1;

Public static double area（double a,double b）;

}

12.下面是定义一个接口A的程序，完成程序填空。

Public interface ITF{

Public static final double P1=3.1415926;

Public abstract double area（double a,double b）;

}

13.定义一个接口A，类B实现接口A，完成程序填空。

Public interface A{

Void a（）；

}

Class B implements A{

Public void a（）{

}

14.定义一个接口Test，类T实现接口Test,完成程序填空。

Public interface Test{

Void test（）；

}

Class T implements A{

Public void Test（）{

}

15.定义一个接口CanSwim,类Swimmer实现接口CanSwim,完成程序填空。

Public interface CanSwim{

Void swim（）；

}

Public Swimmer implements CanSwim{

Public void swim（）{

}

20.编写程序在main方法中，将两个字符串s1和s2转换成对应的数值然后完成加法运算。Public static void main(String[] args){

String s1 = “2”;

String s2 = “2.5”;

Int n1 = nt（s1）;

9

Double n2 = ouble（s2）;

Double sum = n1+n2;

n（sum）;

}

第三章：类的定义和对象的创建

1.创建一个Circle类，此类中包括一个半径属性radius和一个计算面积的方法findArea，在main方法中创建Circle类的对象c,并计算半径为5的圆的面积。

Public class Circle{

Double radius;

Double findArea（）{

Return 3.14*radius*radius;

}

Public static void main（String[] args）{

Circle c = new Circle（）；

= 5.0;

n（ea()）；

}

2.创建一个Circle类，此类中包括一个半径属性radius和一个计算周长的方法findLong，在main方法中创建Circle类的对象c,并计算半径为10的圆的周长。

Public class Circle{

Double radius;

Double findLong（）{

Return 2*3.14*radius;

}

Public static void main（String[] args）{

Circle c = new Circle（）；

=10.0;

n（ng()）；

}

3.创建一个矩形Rectangle类，此类中包括2个属性，长度L和宽度D。一个计算面积的方法findArea。在main方法中创建Rectangle类的对象r,并计算长度为3，宽度为5的矩形面积。

Public class Rectangle{

Int L,D;

Int findArea（）{

Return L*D;

}

Public static void main （String[] args）{

Rectangle r = new Rectangle();

r.L = 3;

r.D = 5;

n（ea()）;

}

4.创建一个Dog类，此类中包括1个姓名属性name。在main方法中创建Dog类的对象d,并设置其姓名为“XiaoBai”.

10

Public class Dog{

String name;

Public static void main（String[] args）{

Dog d = new Dog();

= “XiaoBai”;

}

5.创建一个Dog类，此类中包括1个大小属性size,在main方法中创建Dog类的对象d,并设置其为值为8.

Public class Dog{

Int size;

Public static void main（String[] args）{

Dog d = new Dog();

=8;

第四章：构建方法和this的使用。

1.创建一个Telephone类，属性有电话号码number,还有2个构造方法。其中一个没有参数，一个带参数。

Public class Telephone {

String number;

Telephone（）{

Number = “1234567890”；

}

Telephone（String number）{

= number;

}

2.创建一个Telephone类，属性有电话费用charge,还有2个构造方法。其中一个没有参数，一个带参数。

Public class Telephone {

Double charge;

Telephone（）{

charge = “56.50”；

}

Telephone（double charge）{

= charge;

}

3.创建一个Telephone类，属性有电话品牌brand,还有2个构造方法。其中一个没有参数，一个带参数。

Public class Telephone {

String brand;

Telephone（）{

brand = “iphone6”；

}

Telephone（String brand）{

= brand;

}

4.创建一个Employee类，属性有员工姓名name,还有2个构造方法。其中一个没有参数，一个带参数。

Public class Employee{

String name;

11

employee（）{

name = “LiuYang”；

}

employee（String name）{

= name;

}

5.创建一个Employee类，属性有员工工资salary,还有2个构造方法。其中一个没有参数，一个带参数。

Public class Employee{

Double salary;

Employee（）{

salary = “5850.0”；

}

Employee（double salary）{

= salary;

}

三、改错：

1.编写程序，用循环语句实现打印到1到100之间的自然数，请修改以下程序的错误。public class Test{

Public static void main（String[] args）{

Int i =1;

While（i<=10）;(去掉分号)

{

n(“”+i);

i--;(i++)

}

2.输出100以内既能被3整除又能被7整除的所有数。

Public class Test{

Public static void main（String [] args）{

For(int i=1,i<=100,i++)（括号里面的逗号改成分号）

{

If (i%7==0||i%3==0)（||改成&&）

{

(“ ”+i);

}

}

3.写一个方法逆序输出任意一个整数。

Public void printReverse(int a)

{

Int b;

while(a==0)（括号里改成a!=0）

{

b=a%10;

a=a%10;（将%改成/）

（“%d”,b）;

12

}

}

4.假设某个大学今年的学费是1000美金，而且以每年7%的速度增加，多少年后学费会翻倍。

Public class FutureTution{

Public static void main（String[] args）{

Double tution = 1000;

Int year = 1;

while（tution <2000）;（去掉分号）

{

tution = tution *1.07;

year--;（year++）

5.蒙特卡罗模拟使用随机数和概率来解决问题，这个方法在数学、物理、化学和财经方面有很广的的应用。使用蒙特卡罗的模拟来估算pai值。为了使用蒙特卡罗方法来估算pai值，画一个圆的外接正方形，假设这个圆的半径为1.那么圆面积就是pai而外接正方形的面积是4，随机产生正方形内的一个点。该店落入圆内的概率为circleArea/squareArea（圆面积/正方形面积）=pai/4.编写程序，在正方形内随机产生1000000个点，用numberOfHits表示落在圆内的点。由此求出pai的近似值。

Public class MonteSimulation{

Public static void main(String[] args){

Final int NUMBER_OF_TRIALS=10000000;

int numberOfHits=0;

For(int i=0;i

{

Double x=()*2.0-1;

Double y= ()*2.0-1;

If(x*x+y*y<=1)

numberOfHits++;

}

Double pi=4.0*NUMBER_OF_TRIALS/numberOfHits;（NUMBER_OF_TRIALS和numberOfHits交换位置）

}

}

6.下面是一个类Myclass的定义，请改正程序中的错误

Public class My（My改为Myclass）

{

Int x,y;

Myclass(int i,double j);（double改为int）

{

X=i; y=j;

}

}

7.定义一个学生类，其中属性有字符串类型姓名，方法有对属性name进行访问的访问器方法，请改正程序的错误

Public class Student{

Private String name;

13

Public void setName(char name)（括号里改成String name）

{

=name;

}

Public void getName()（将void改成String）

{

Return ;

}

}

8.定义一个学生类，其中属性字符串类型的有姓名和专业，方法有对属性进行访问的访问量方法，请改正程序的错误。

Public class Student

{

Private int number;（int改成String）

Private String major;

Public String getMajor(){

return number;（number改成major）

}

Public void setMajor(String major){

= major;

}

Public void setNumber(String number){

= number;

}

Public string getNumber(){

Return number;

}

9.

Public class Student{

Private String number;

Private int age;

Public int getAge(){

Return age;

}

Public void setAge(double age)（double改成int）

{

= age;

}

Public void toString()（void改成String）

{

Return”number=”+number+”age=”+age;

}

10.定义一个电话机类，属性有字符串类型的电话机型号，方法有对属性进行访问的访问器方法，请改正程序的错误。

14

Public class Telephone{

Private String type;

public void setType(char type)（char改成String）

{

=type;

}

public void getType()（void改成String）

{

Return ;

}

11.定义一个汽车类，属性有汽车品牌，颜色和速度。一个为3个属性进行初始化的构造方法，定义一个测试类，创建一个品牌为大众、颜色为红色、速度为60的汽车。

Private class Car{（private改成public）

Private String brand;

Private String color;

Private double speed;

Public Car(String brand,String color,double speed)

{ = speed;

= brand;

= color;

}

}

Public class Test{

Public static void main(String[] args){

Car obj = new Car(“大众”,‘红色’,60);（将红色的‘’改成” ”）

}

12.定义一个汽车类，属性有汽车品牌和速度。一个为2个属性进行初始化的构造方法，定义一个测试类，创建一个品牌为Nissan,颜色为黑色的汽车。

Public class Car{

Private String brand;

Private String color;

Private double speed;

Public Car(String brand,double color)（将double改成String）

{

= brand;

= color;

}

}

Public class Test{

Public static void main(String[] args){

Car obj = new Car(“Nissan”);（括号里改成”Nissan”,”黑色”）

}

13.定义一个汽车类，成员变量有载客人数、重量和颜色。方法有输出所有成员变量的方法。定义一个测试类，创建一个汽车类，输出该汽车的所有信息。

15

Public class Vehicle{

Int passengers;

Double weight;

String color;

Public outpuInfo()（在public 和 outpuInfo之间加上void）

{

n(“passengers = “+passengers);

n(“weight = “+weight);

n(“color =”+color);

}

Public static void main(String[] args){

Vehicle v1 = new Vehicle();

outputInfo()（在括号后面加分后）

}

}

14.下面是一个类的定义，请修改程序中的错误。

Class Student

{

String name;

Int age;

student( String s,int i)（将student里的s改成大写的）

{

Name = s;

age = this.i;（将this.去掉）

}

}

Test{

Public static void main(String args[]){

MyClass a = new Class();（将class的前面加上My） }

}

Class MyClass{

private MyClass()（将private去掉）

{

n(“constructor”);

}

}

Student extend Teacher（extend后面加s）

{

Private String school;

Student(String name,String school){

This(name,18,school);

}

Student(String name,int age,String school){

16

this();（age改成school）

= school;

}

17.假设类A与类B在不同包中，现有类说明如下，请改正程序的错误。

Public class A{

Int b;

Protected static int c = 3;

Publc static int d;

}

Import father A;

Public class B extends A{

Public void dd()（void前面加上static）

{

n(super.d);（将super改成A）

}

Public static void main(String[] args)

{

B b = new B();

dd();

}

class A{

Private int a;

Public A(int a)

Super.a = a;（将super改成this）

}

}

Class B extends A{

Public B(int a){

this(a);（将this改成super）

}

Public static void main(String[] args){

B b = new B(5);

}

}

19.设计类A和A的派生类B，要求：（1）A类与B类不在同一包内，A有一个数据成员a（为int型）；B中继承了A中的a，又定义了自己的数据成员b（int型）。（2）A中的成员a要求只能被不在一个包中的自己的子类看见，不能被不在一个包中的其它类看见。请根据要求修改程序中的错误。

Public class A

{

int a;（在int前加上protected）

}

Class B extend A（extend加s）

{

Int b;

17

}

20.设计类A和A的派生类B，要求：（1）A类与B类在同一包内，A有两个数据成员a和b（都为int型）；（2）B中只能继承A中的b,不能继承A中的b，不能继承A中的a，请根据要求修改程序中的错误。

Public class A

{

Int a;（在int前加private）

Int b;

}

Class A extend B（extend加s）

{

Int b;

}

21.定义一个电话机类，属性有字符串类型的电话机型号，方法有对属性进行访问的访问器方法，请改正程序的错误。

Public class Telephone{

Private String type;

public void setType(char type)（char改成String）

{

=type;

}

22.定义一个汽车类，成员变量有载客人数、重量和颜色。方法有输出所有成员变量的方法。定义一个测试类，创建一个汽车类，输出该汽车的所有信息。

Public class Vehicle{

Int passengers;

Double weight;

String color;

Public outpuInfo()（在public 和 outpuInfo之间加上void）

{

n(“passengers = “+passengers);

n(“weight = “+weight);

n(“color =”+color);

}

Public static void main(String[] args){

Vehicle v1 = new Vehicle();

outputInfo()（在括号后面加分后）

}

}

【程序设计】

---------------------------------------------------------

题目：Prog1类与对象

1) 属性：两个double成员变量，width和height；

2) 不带参数的构造方法：width和height的初始值分别是6和8；

3) 方法：计算并输出矩形的周长方法名为findPremeter ()；

18

4) 在main方法中，创建一个Prog1类的对象，对象名为r，调用findPremeter方法。

-------------------------------------------------------*/

public class Prog1 {

double width, height;

public Prog1() {

width = 6;

height = 8;

}

public void findPremeter(){

n("周长为"+(width*2+height*2));

}

public static void main(String[] args) {

Prog1 r= new Prog1();

emeter();

}

}

/********** End **********/

}

/*------------------------------------------------------

【程序设计】

---------------------------------------------------------

题目：现有父类Good，在此基础上派生出子类Milk，子类定义了自己的属性double类型的会员价格（vipPrice），

有带参数的构造方法，覆盖了父类的show方法，调用父类被覆盖的show方法，增加打印自己的属性的语句，

请实现Milk类的编写

-------------------------------------------------------*/

class Goods {

double unitPrice;//单价

double account;//数量

Goods(double unitPrice, double account) {

ice=unitPrice ;

t=account ;

}

double totalPrice() {//计算总价格

return unitPrice * account;

}

void show() {

n("单价是" + unitPrice);

19

n("购买数量为" + account);

n("购买商品的总金额是" + rice());

}

}

class Milk extends Goods {

/**********Program**********/

/********** End **********/

}

public class Prog1{

public static void main(String[] args){

}

/*-----------------------------------------------

【程序设计】

---------------------------------------------------------

题目：使用循环语句输出1-100间能被3整除的数，循环变量名为i。

-------------------------------------------------------*/

public class Prog1{

public static void main(String[] args) {

for(int i=1;i<=100;i++){

if(i%3==0)

n(i);

}

}

}

20