1-1
java语言中不用区分字母的大写小写。
T
F
| 参考答案
答案
F
1分
1-2
用static修饰的变量是类变量。
T
F
| 参考答案
答案
T
1分
1-3
系统自动引入java.lang包中的所有类，因此不需要再显式地使用import语句引入该包的所有类。
T
F
| 参考答案
答案
T
1分
1-4
java.lang包是Java的核心类库，它包含了运行Java程序必不可少的系统类。
T
F
| 参考答案
答案
T
1分
1-5
如果使用import语句引入了整个包中的类，那么可能会增加编译时间。但绝对不会影响程序运行的性能，因为当程序执行时，只是将真正使用的类的字节码文件加载到内存。
T
F
| 参考答案
答案
T
1分
1-6
在Java程序中，可以使用protected来修饰一个类。
T
F
| 参考答案
答案
T
1分
1-7
在Java程序中，可以使用private来修饰一个类。
T
F
| 参考答案
答案
T
1分
1-8
如果一个类的声明中没有使用extends关键字，这个类被系统默认为是继承Object类。
T
F
| 参考答案
答案
T
1分
1-9
如果一个成员变量被修饰为final的，就是常量，常量必须赋给初值，而且不能再发生变化。
T
F
| 参考答案
答案
T
1分
1-10
不允许使用final来修饰abstract方法。
T
F
| 参考答案
答案
T
1分
1-11
对于abstract类，不能创建该类的对象。
T
F
| 参考答案
答案
T
1分
1-12
子类如果想使用父类的构造方法，必须在子类的构造方法中使用，并且必须使用关键字super来表示，而且super必须是子类构造方法中的头一条语句。
T
F
| 参考答案
答案
T
1分
1-13
如果在子类的构造方法中，没有使用关键字super调用父类的某个构造方法，那么默认有super();语句，即调用父类的不带参数的构造方法。
T
F
| 参考答案
答案
T
1分
1-14
为了克服单继承的缺点，Java使用了接口，一个类可以实现多个接口。
T
F
| 参考答案
答案
T
1分
1-15
接口中的方法默认是public abstract方法。
T
F
| 参考答案
答案
T
1分
1-16
类在实现接口方法时必须给出方法体，并且一定要用public来修饰。
T
F
| 参考答案
答案
T
1分
1-17
接口中的常量默认是public static的变量。
T
F
| 参考答案
答案
T
1分
1-18
一个Java源文件就是由类和接口组成的。
T
F
| 参考答案
答案
T
1分
1-19
如果一个类声明实现一个接口，但没有实现接口中的所有方法，那么这个类必须是abstract类。
T
F
| 参考答案
答案
T
1分
1-20
类可以有两种重要的成员：成员变量和方法，类还可以有一种成员：内部类。
T
F
| 参考答案
答案
T
1分
1-21
Java的字符类型采用的是ASCII编码。
T
F
| 参考答案
答案
F
1分
1-22
Java的字符类型采用的是Unicode编码，每个Unicode码占16个比特。
T
F
| 参考答案
答案
T
1分
1-23
Java的各种数据类型占用固定长度，与具体的软硬件平台环境无关。
T
F
| 参考答案
答案
T
1分
1-24
类在实现接口的方法时，必须显式地使用public修饰符。
T
F
| 参考答案
答案
T
1分
1-25
System类不能实例化，即不能创建System类的对象。
T
F
| 参考答案
答案
T
1分
1-26
Java中数组的元素只能是简单数据类型。
T
F
| 参考答案
答案
F
1分
1-27
有的类定义时可以不定义构造函数，所以构造函数不是必需的。
T
F
| 参考答案
答案
F
1分
1-28
类及其属性、方法可以同时有一个以上的修饰符来修饰。
T
F
| 参考答案
答案
T
1分
1-29
一个Java类可以有多个父类。
T
F
| 参考答案
答案
F
1分
1-30
一个类只能有一个父类，但一个接口可以有一个以上的父接口。
T
F
| 参考答案
答案
T
1分
1-31
一个类可以实现多个接口。
T
F
| 参考答案
答案
T
1分
1-32
一个接口可以继承其他接口。
T
F
| 参考答案
答案
T
1分
1-33
接口中的方法默认都是静态的。
T
F
| 参考答案
答案
F
1分
1-34
接口中的属性，都是静态常量。
T
F
| 参考答案
答案
T
1分
1-35
所有异常都必须捕获。
T
F
| 参考答案
答案
F
1分
1-36
一个try语句可以有多个catch语句与之对应。
T
F
| 参考答案
答案
T
1分
1-37
异常也是一个对象。
T
F
| 参考答案
答案
T
1分
1-38
用户可以自定义自己的异常类。
T
F
| 参考答案
答案
T
1分
1-39
可以使用throw语句来抛出异常。
T
F
| 参考答案
答案
T
1分
1-40
可以使用throws语句来指明方法有异常抛出。
T
F
| 参考答案
答案
T
1分
1-41
数组也是对象。
T
F
| 参考答案
答案
T
1分
1-42
Java语言中，变量名可以用汉字表示。
T
F
| 参考答案
答案
T
1分
1-43
使用方法length( )可以获得字符串或数组的长度。
T
F
| 参考答案
答案
F
1分
1-44
一个数组可以存放不同类型的数值。
T
F
| 参考答案
答案
F
1分
1-45
Java中数组的元素可以是简单数据类型的量，也可以是某一类的对象。
T
F
| 参考答案
答案
T
1分
1-46
String字符串在创建后可以被修改。
T
F
| 参考答案
答案
F
1分
1-47
设String对象s="Hello "，运行语句System.out.println(s.concat("world!"));后String对象s的内容为Hello world!，所以语句输出为Hello world!。
T
F
| 参考答案
答案
F
1分
1-48
package语句必须放到java程序的最开始。
T
F
| 参考答案
答案
T
1分
1-49
一个类的非静态方法可以访问静态成员变量。
T
F
| 参考答案
答案
T
1分
1-50
一个类的静态方法不可以访问该类的非静态成员变量。
T
F
| 参考答案
答案
T
1分
1-51
实例变量只能通过对象名访问，类变量既可以通过某个对象名也可以通过类名来访问。
T
F
| 参考答案
答案
T
1分
1-52
抽象类中不能有private的成员，所有的抽象方法必须存在于抽象类中。
T
F
| 参考答案
答案
T
1分
1-53
抽象方法必须在抽象类中，所以抽象类中的方法都必须是抽象方法。。
T
F
| 参考答案
答案
F
1分
1-54
final类中的属性和方法都必须被final修饰符修饰。
T
F
| 参考答案
答案
F
1分
1-55
final类不能派生子类，final方法不能被覆盖。
T
F
| 参考答案
答案
T
1分
1-56
抽象类必须有抽象方法。
T
F
| 参考答案
答案
F
1分
1-57
覆盖只能在不同的类中完成。
T
F
| 参考答案
答案
T
1分
1-58
System.out.println(); 语句的作用是在结尾显示一个换行符。。
T
F
| 参考答案
答案
T
1分
1-59
Java中所有的I/O都是通过流来实现的。
T
F
| 参考答案
答案
T
1分
1-60
程序运行中可以改变数组的大小。
T
F
| 参考答案
答案
F
1分
1-61
Object是Java中所有类的共同父类。
T
F
| 参考答案
答案
T
1分
1-62
字节码文件是与平台无关的二进制码，执行时由解释器解释成本地机器码。
T
F
| 参考答案
答案
T
1分
1-63
一个Java源文件中可以有多个类，但只能有一个类是public的。
T
F
| 参考答案
答案
T
1分
1-64
如果Java源文件中包含了多个类，那么用编译器javac编译完源文件后将生成多个扩展名为.class的文件。
T
F
| 参考答案
答案
T
1分
1-65
语句 System.out.println(4+8+"Hello,world!"); 的输出结果是12Hello,world!。
T
F
| 参考答案
答案
T
1分
1-66
Java允许创建不规则数组，即Java多维数组中各行的列数可以不同。
T
F
| 参考答案
答案
T
1分
1-67
在实例方法或构造器中，this用来引用当前对象，通过使用this可引用当前对象的任何成员。
T
F
| 参考答案
答案
T
1分
1-68
当一个方法在运行过程中产生一个异常，则这个方法会终止，但是整个程序不一定终止运行。
T
F
| 参考答案
答案
T
1分
1-69
Java系统的标准输入对象是System.in，标准输出对象有两个，分别是System.out和System.err。
T
F
| 参考答案
答案
T
1分
1-70
修饰符protected主要是允许其他包中的子类来访问父类的特定属性。
T
F
| 参考答案
答案
T
1分
1-71
abstract类中定义的方法只能是abstract方法。
T
F
| 参考答案
答案
F
1分
1-72
程序运行时所产生的系统定义的异常将自动被抛出。
T
F
| 参考答案
答案
T
1分
1-73
Java中类和方法都不允许嵌套定义。
T
F
| 参考答案
答案
F
1分
1-74
abstract可以与final同时修饰同一个类。
T
F
| 参考答案
答案
F
1分
1-75
构造函数名应与类名相同，返回类型为void。
T
F
| 参考答案
答案
F
1分
1-76
引用一个类的属性或调用其方法，必须以这个类的对象为前缀。
T
F
| 参考答案
答案
F
1分
1-77
把数组中元素按某种顺序排列的过程叫做查找 。
T
F
| 参考答案
答案
F
1分
1-78
一个数组可以存放许多不同类型的数值。
T
F
| 参考答案
答案
F
1分
1-79
数组作为方法的参数时，必须加在数组名后加方括号。
T
F
| 参考答案
答案
T
1分
1-80
数组中有length()这个方法，如array.length()表示数组array中元素的个数
T
F
| 参考答案
答案
F
1分
1-81
制造（new）数组时，要指定数组长度，以便为数组分配内存。
T
F
| 参考答案
答案
T
1分
1-82
Java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。
T
F
| 参考答案
答案
T
1分
1-83
如果线程死亡，它便不能运行。
T
F
| 参考答案
答案
T
1分
1-84
在Java中，高优先级的可运行线程会抢占低优先级线程。
T
F
| 参考答案
答案
F
1分
1-85
当调用一个正在进行线程的stop()方法时，该线程便会进入休眠状态。
T
F
| 参考答案
答案
F
1分
1-86
类也是一种数据类型（type）。
T
F
| 参考答案
答案
T
1分
1-87
对象是类的实例（instance）。
T
F
| 参考答案
答案
T
1分
1-88
静态变量是被同一个类的所有实例所共享的。
T
F
| 参考答案
答案
T
1分
1-89
可以使用protected修饰符来防止方法和数据被不同包的非子类访问。
T
F
| 参考答案
答案
T
1分
1-90
子类不继承父类的构造方法。
T
F
| 参考答案
答案
T
1分
1-91
构造方法可以调用本类中重载的构造方法和它的父类的构造方法。
T
F
| 参考答案
答案
T
1分
1-92
可以覆盖在父类中定义的私有方法。
T
F
| 参考答案
答案
F
1分
1-93
InputStream类和OutputStream类是所有二进制I/O的根类。
T
F
| 参考答案
答案
T
1分
1-94
boolean型数据的值只有true和false。
T
F
| 参考答案
答案
T
1分
1-95
在一个编辑器中编写好的Java应用程序，是扩展名为.class的文件。
T
F
| 参考答案
答案
F
1分
1-96
构造方法不能被重载。
T
F
| 参考答案
答案
F
5分
1-97
抽象类是不能实例化的。
T
F
| 参考答案
答案
T
5分
1-98
String实例一旦创建完毕，就不能再修改其内容。
T
F
| 参考答案
答案
T
5分
1-99
子类和父类必须在一个包中。
T
F
| 参考答案
答案
F
1分
1-100
Java中，boolean基本类型的变量取值为0、1，也可取值true或false。
T
F
| 参考答案
答案
F
1分
单选题
183 分
2-1
下列不可作为java语言标识符的是（）。
A.
a2
B.
$2
C.
_2
D.
22
| 参考答案
答案
D
1分
2-2
有一段java 应用程序，它的主类名是a1，那么保存它的源文件名可以是（ ）.
A.
a1.java
B.
a1.class
C.
a1
D.
都对
| 参考答案
答案
A
1分
2-3
整型数据类型中，需要内存空间最少的是（ ）.
A.
short
B.
long
C.
int
D.
byte
| 参考答案
答案
D
1分
2-4
Java中（ ） 。
A.
一个子类可以有多个父类，一个父类也可以有多个子类
B.
一个子类可以有多个父类，但一个父类只可以有一个子类
C.
一个子类可以有一个父类，但一个父类可以有多个子类
D.
上述说法都不对
| 参考答案
答案
C
1分
2-5
Java语言具有许多优点和特点，哪个反映了Java程序并行机制的特点？( )
A.
安全性
B.
多线性
C.
跨平台
D.
可移植
| 参考答案
答案
B
1分
2-6
关于以下程序代码的说明正确的是（ ） 。
1．class HasStatic{
2． private static int x=100；
3． public static void main(String[ ] args){
4． HasStatic hs1=new HasStatic( );
5． hs1.x++;
6． HasStatic hs2=new HasStatic( );
7． hs2.x++;
8． hs1=new HasStatic( );
9． hs1.x++;
10． HasStatic.x--;
11． System.out.println(“x=”+x);
12． }
13． }
A.
5行不能通过编译，因为引用了私有静态变量
B.
10行不能通过编译，因为x是私有静态变量
C.
程序通过编译，输出结果为：x=103
D.
程序通过编译，输出结果为：x=102
| 参考答案
答案
D
2分
2-7
以下选项中没有语法错误的是（ ） 。
A.
while (int i<7) {
i++;
System.out.println(“i is “+i);
}
B.
int j=3; while(j) {
System.out.println(“ j is “+j);
}
C.
int j=0;
for(int k=0; j + k !=10; j++,k++) {
System.out.println(“ j is “+ j + “k is”+ k);
}
D.
int j=0;
do{
System.out.println( “j is “+j++);
if (j == 3) {
continue loop;
}
}while (j<10);
| 参考答案
答案
C
2分
2-8
将以下哪种方法插入行3是不合法的。
1．public class Test1{
2． public float aMethod（float a，float b）{ }
3．
4．}
A.
public float aMethod（float a， float b，float c）{ }
B.
public float aMethod（float c，float d）{ }
C.
public int aMethod（int a， int b）{ }
D.
private float aMethod（int a，int b，int c）{ }
| 参考答案
答案
B
2分
2-9
将以下哪种方法插入行6是不合法的。（ ） 。
1．public class Test1 {
2． public float aMethod（float a，float b） throws
3． IOException { }
4． }
5．public class Test2 extends Test1{
6．
7．}
A.
float aMethod（float a，float b）{ }
B.
public int aMethod（int a，int b）throws Exception{ }
C.
public float aMethod（float p，float q）{ }
D.
public int aMethod（int a，int b）throws IOException{ }
| 参考答案
答案
A
2分
2-10
以下哪个方法用于定义线程的执行体？ （ ）
A.
start()
B.
init()
C.
run()
D.
ynchronized()
| 参考答案
答案
C
2分
2-11
在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序的特性称为（ ）。
A.
隐藏
B.
覆盖
C.
重载
D.
Java不支持此特性
| 参考答案
答案
C
1分
2-12
以下关于构造函数的描述错误的是（ ）。
A.
构造函数的返回类型只能是void型。
B.
构造函数是类的一种特殊函数，它的方法名必须与类名相同。
C.
构造函数的主要作用是完成对类的对象的初始化工作。
D.
一般在创建新对象时，系统会自动调用构造函数。
| 参考答案
答案
A
1分
2-13
下列哪些语句关于Java内存回收的说明是正确的? （ ）
A.
程序员必须创建一个线程来释放内存
B.
内存回收程序负责释放无用内存
C.
内存回收程序允许程序员直接释放内存
D.
内存回收程序可以在指定的时间释放内存对象
| 参考答案
答案
B
2分
2-14
若需要定义一个类属性或类方法，应使用哪种修饰符？（ ）
A.
static
B.
package
C.
private
D.
public
| 参考答案
答案
A
2分
2-15
有以下方法的定义，请选择该方法的返回类型（ ）。
ReturnType method(byte x, double y) {
return (short)x/y*2;
}
A.
byte
B.
short
C.
int
D.
double
| 参考答案
答案
D
2分
2-16
有以下程序片段，下列哪个选项不能插入到行1。（ ）
1)
2) public class Interesting{
3) //do sth
4) }
A.
import java.awt.*;
B.
package mypackage;
C.
class OtherClass{ }
D.
public class MyClass{ }
| 参考答案
答案
D
2分
2-17
若A1、A2为已定义的接口 ,以下接口定义中没有语法错误的是（ ） 。
A.
interface B { void print() { } }
B.
abstract interface B { void print() }
C.
abstract interface B extends A1,A2 { abstract void print(){ };}
D.
interface B { void print();}
| 参考答案
答案
D
2分
2-18
下面哪个函数是public void aMethod(){...}的重载函数？（ ）
A.
void aMethod( ){...}
B.
public int aMethod(){...}
C.
public void aMethod ( ){...}
D.
public int aMethod ( int m){...}
| 参考答案
答案
D
2分
2-19
A派生出子类B，B派生出子类C，对于如下Java源代码正确的说法是（）。
1. A a0 =new A();
2. A a1 =new B();
3. A a2 =new C();
A.
只有第1行能通过编译
B.
第1、2行能通过编译，但第3行编译出错
C.
第1、2、3行能通过编译，但第2、3行运行时出错
D.
第1行、第2行和第3行的声明都是正确的
| 参考答案
答案
D
2分
2-20
假设类A有如下定义，且a是A类的一个实例，则必定错误的选项是（ ）。
class A {
int i;
static String s;
void method1() { }
static void method2() { }
}
A.
System.out.println(a.i)；
B.
a.method1();
C.
A.method1();
D.
A.method2() ;
| 参考答案
答案
C
2分
2-21
假设方法unsafe() 将抛出IOException, 可以填入如下代码段第1行的选项是（ ）。
1)
2) { if(unsafe()){//do something…}
3) else if(safe()){//do the other…}
4) }
A.
public IOException methodName()
B.
public void methodName()
C.
public void methodName() throw IOException
D.
public void methodName() throws IOException
| 参考答案
答案
D
2分
2-22
以下关于继承的叙述正确的是（ ）。
A.
在Java中类只允许单一继承
B.
在Java中一个类只能实现一个接口
C.
在Java中一个类不能同时继承一个类和实现一个接口
D.
在Java中接口只允许单一继承
| 参考答案
答案
A
2分
2-23
在使用interface声明一个接口时，只可以使用（ ）修饰符修饰该接口。
A.
private
B.
protected
C.
private protected
D.
public
| 参考答案
答案
D
2分
2-24
下列哪个类的声明是正确的？（ ）
A.
abstract final class HI{}
B.
abstract private move(){}
C.
protected private number;
D.
public abstract class Car{}
| 参考答案
答案
D
2分
2-25
关于被私有访问控制符private修饰的成员变量，以下说法正确的是（ ）
A.
可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B.
可以被两种类访问和引用：该类本身、该类的所有子类
C.
只能被该类自身所访问和修改
D.
只能被同一个包中的类访问
| 参考答案
答案
C
2分
2-26
执行完以下代码int [ ] x = new int[10]；后，以下哪项说明是正确的（ ）
A.
x[9]为0
B.
x[9]未定义
C.
x[10]为0
D.
x[0]为空
| 参考答案
答案
A
2分
2-27
下列方法头中哪一个不与其他方法形成重载(overload)关系?（ ）
A.
void mmm()
B.
void mmm(int i)
C.
void mmm(String s)
D.
int mm()
| 参考答案
答案
D
2分
2-28
编译Java源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( )。
A.
.byte
B.
.class
C.
.html
D.
.exe
| 参考答案
答案
B
2分
2-29
在Java中用什么关键字修饰的方法可以直接通过类名来调用？（ ）
A.
static
B.
final
C.
private
D.
void
| 参考答案
答案
A
2分
2-30
若在某一个类定义中定义有如下的方法：abstract void performDial( );该方法属于（ ）。
A.
接口方法
B.
最终方法
C.
抽象方法
D.
空方法
| 参考答案
答案
C
2分
2-31
在Java中，"456"属于（ ）类的对象。
A.
int
B.
String
C.
Integer
D.
Number
| 参考答案
答案
B
2分
2-32
欲构造ArrayList类的一个实例，此类继承了List接口，下列哪个方法是正确的？（ ）
A.
ArrayList myList=new Object（）；
B.
List myList=new ArrayList（）；
C.
ArrayList myList=new List（）；
D.
List myList=new List（）；
| 参考答案
答案
B
2分
2-33
下面说法不正确的是( )
A.
一个子类的对象可以接收父类对象能接收的消息；
B.
当子类对象和父类对象能接收同样的消息时，它们针对消息产生的行为可能不同；
C.
父类比它的子类的方法更多；
D.
子类在构造函数中可以使用super( )来调用父类的构造函数；
| 参考答案
答案
C
2分
2-34
声明成员变量时,如果不使用任何访问控制符(public, protected, private)，则以下哪种类型的类不能对该成员进行直接访问 （ ） .
A.
同一类
B.
同一包中的子类
C.
同一包中的非子类
D.
不同包中的子类
| 参考答案
答案
D
2分
2-35
下列哪种异常是检查型异常，需要在编写程序时声明 （ ）.
A.
NullPointerException
B.
ClassCastException
C.
FileNotFoundException
D.
IndexOutOfBoundsException
| 参考答案
答案
C
2分
2-36
下面哪个流类属于面向字符的输入流( ) 。
A.
BufferedWriter
B.
FileInputStream
C.
ObjectInputStream
D.
InputStreamReader
| 参考答案
答案
D
2分
2-37
下面关于数组声明和初始化的语句那个有语法错误？（ ）
A.
int a1[]={3,4,5};
B.
String a2[]={"string1","string1","string1"};
C.
String a3[]=new String(3);
D.
int[][] a4=new int[3][3];
| 参考答案
答案
C
2分
2-38
下面的方法，当输入为2的时候返回值是多少?（ ）
public int getValue(int i) {
int result = 0;
switch (i) {
case 1:
result = result + i;
case 2:
result = result + i * 2;
case 3:
result = result + i * 3;
}
return result;
}
A.
0
B.
2
C.
4
D.
10
| 参考答案
答案
D
2分
2-39
getCustomerInfo()方法如下，try中可以捕获三种类型的异常，如果在该方法运行中产生了一个IOException，将会输出什么结果（ ）。
public void getCustomerInfo() {
try {
// do something that may cause an Exception
} catch (java.io.FileNotFoundException ex){
System.out.print("FileNotFoundException!");
} catch (java.io.IOException ex){
System.out.print("IOException!");
} catch (java.lang.Exception ex){
System.out.print("Exception!");
}
}
A.
IOException!
B.
IOException!Exception!
C.
FileNotFoundException!IOException!
D.
FileNotFoundException!IOException!Exception!
| 参考答案
答案
A
2分
2-40
下面是People和Child类的定义和构造方法，每个构造方法都输出编号。在执行new Child("mike")的时候都有哪些构造方法被顺序调用？请选择输出结果 ( )
class People {
String name;
public People() {
System.out.print(1);
}
public People(String name) {
System.out.print(2);
this.name = name;
}
}
class Child extends People {
People father;
public Child(String name) {
System.out.print(3);
this.name = name;
father = new People(name + ":F");
}
public Child(){
System.out.print(4);
}
}
A.
312
B.
32
C.
432
D.
132
| 参考答案
答案
D
2分
2-41
list是一个ArrayList的对象，哪个选项的代码填写到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？( )
Iterator it = list.iterator();
int index = 0;
while (it.hasNext()){
Object obj = it.next();
if (needDelete(obj)) { //needDelete返回boolean，决定是否要删除
//todo delete
}
index ++;
}
A.
list.remove(obj);
B.
list.remove(index);
C.
list.remove(it.next());
D.
it.remove();
| 参考答案
答案
D
2分
2-42
在Java中，负责对字节代码解释执行的是（ ）。
A.
应用服务器
B.
虚拟机
C.
垃圾回收器
D.
编译器
| 参考答案
答案
B
1分
2-43
以下代码段将创建几个对象?
String s1="bc";
String s2="bc";
A.
2
B.
3
C.
0
D.
1
| 参考答案
答案
D
2分
2-44
下面哪个对类的声明是错误的？
A.
class MyClass extends MySuperClass1, MySupperClass2 {}
B.
public class MyClass{}
C.
abstract class MyClass implements YourInterface1, Youriterface2 {}
D.
private class MyClass {}
E.
class MyClass extends MySuperClass implements YourInterface {}
| 参考答案
答案
A
2分
2-45
类的实例方法表示的是什么？（ ）
A.
父类对象的行为
B.
类的属性
C.
类对象的行为
D.
类的行为
| 参考答案
答案
C
2分
2-46
下面说法正确的是（ ） 。
A.
JAVA中线程是非抢占式的
B.
JAVA中的线程不可以共享数据
C.
每个JAVA程序都至少有一个线程，即主线程
D.
JAVA中的线程不可以共享代码
| 参考答案
答案
C
2分
2-47
要创建一个新目录，可以用下面( )类实现。
A.
FileInputStream
B.
FileOutputStream
C.
RandomAccessFile
D.
File
| 参考答案
答案
D
2分
2-48
类Teacher和Student是类Person的子类,下面的代码中最后一句语句的运行结果是( ).
Person p;
Teacher t;
Student s;
//p,t and s are all non-null.
if(t instanceof Person) {s=(Student)t;}
A.
编译时正确，但运行时错误
B.
将构造一个Student对象
C.
表达式是错误的
D.
表达式是合法的
| 参考答案
答案
C
2分
2-49
下面哪个Set是根据内容排序的？
A.
LinkedHashSet
B.
HashSet
C.
TreeSet
D.
AbstractSet
| 参考答案
答案
C
2分
2-50
如果你被要求写一段代码读取一个文本文件，那么一般使用哪种Stream？
A.
DataInputStream
B.
ObjectInputStream
C.
FileReader
D.
FileInputStream
| 参考答案
答案
D
2分
2-51
下面关于缺省构造方法的描述中正确的是（ ）。
A.
当类中没有定义任何构造方法时，Java编译器将为这个类创建缺省构造方法
B.
缺省构造方法可以初始化其他方法中定义的变量
C.
Java编译器会为所有的类创建缺省构造方法。
D.
如果在一个类中定义的构造方法都声明了参数，Java编译器将为这个类创建一个缺省构造方法
| 参考答案
答案
A
2分
2-52
对于类与对象的关系，以下说法错误的是（ ）。
A.
类是对象的类型
B.
对象由类来创建
C.
类是同类对象的抽象
D.
对象是创建类的模板
| 参考答案
答案
D
2分
2-53
类中某方法定义如下：
double fun(int a,int b){
return a*1.0/b;
}
同一类内其它方法调用该方法的正确方式是（ ）。
A.
double a = fun(1,2)
B.
double a = fun(1.0,2.0)
C.
int x = fun(1,2)
D.
int x = fun(1.0,2.0)
| 参考答案
答案
A
2分
2-54
下面哪单词是Java语言的关键字（ ）。
A.
Float
B.
this
C.
string
D.
unsigned
| 参考答案
答案
B
2分
2-55
下述哪条关于构造方法的说法，不符合Java语法的规定（ ）。
A.
每个类至少有一个构造方法
B.
构造方法必须与类同名
C.
构造方法无返回值，其返回值类型必须写为void
D.
构造方法可以是private的
| 参考答案
答案
C
2分
2-56
关于类中成员变量的作用范围，下述说法中正确的是（ ）。
A.
只有用public修饰的变量才能在所有方法中使用
B.
用private修饰的成员变量可以在main方法中直接使用
C.
类中所有成员变量在所有成员方法中有效
D.
用static修饰的成员变量只能在用static修饰的方法中使用
| 参考答案
答案
C
2分
2-57
方法体内定义的变量称局部变量，下述关于局部变量的说法中错误的是（ ）。
A.
局部变量仅在所定义的代码块内（花括号对内）有效
B.
局部变量不能加修饰词修饰
C.
局部变量不能与类中的成员变量同名
D.
局部变量未经赋值不能使用
| 参考答案
答案
C
2分
2-58
为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为（ ）。
A.
static void method( )
B.
public void method( )
C.
final void method( )
D.
abstract void method( )
| 参考答案
答案
A
2分
2-59
下面（ ）表达式可以得到x和y中的最大值。
A.
x>y?y:x
B.
x<y?y:x
C.
x>y?(x+y):(x-y)
D.
x==y?y:x
| 参考答案
答案
B
2分
2-60
以下代码的输出结果为（ ）。
public class Pass{
static int j = 20;
public void amethod(int x){
x = x*2;
j = j*2;
}
public static void main(String args[]){
int i = 10;
Pass p = new Pass();
p.amethod(i);
System.out.println(i+" and "+j);
}
}
A.
错误:方法参数与变量不匹配
B.
20 and 40
C.
10 and 40
D.
10 and 20
| 参考答案
答案
C
2分
2-61
定义了一维int型数组a[10]后，下面错误的引用是( ) 。
A.
a[0]=1
B.
a[10]=2
C.
a[0]=5*2
D.
a[1]=a[2]*a[0]
| 参考答案
答案
B
2分
2-62
定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为( )
A.
24
B.
25
C.
18
D.
17
| 参考答案
答案
B
2分
2-63
下面程序的运行结果是（ ）
main() {
int x=30;
int[] numbers=new int[x];
x=60;
System.out.println(numbers.length);
}
A.
60
B.
20
C.
30
D.
50
| 参考答案
答案
C
2分
2-64
当访问无效的数组下标时，会发生（ ）。
A.
中止程序
B.
抛出异常
C.
系统崩溃
D.
直接跳过
| 参考答案
答案
B
2分
2-65
编译和运行下列程序会出现什么样的结果（ ）。
public class Ref {
public static void main(String[] args){
Ref r = new Ref();
r.amethod(r);
}
public void amethod(Ref r){
int i = 99;
multi(r);
System.out.println(i);
}
public void multi(Ref r){
r.i = r.i * 2;
}
}
A.
编译出错
B.
输出：99
C.
输出：198
D.
运行出错
| 参考答案
答案
A
2分
2-66
下列语句会造成数组new int[10]越界是（ ）。
A.
a[0] += 9;
B.
a[9]=10;
C.
a[9]
D.
for(int i=0;i<=10;i++) a[i]++;
| 参考答案
答案
D
2分
2-67
在Java中，能实现多重继承效果的方式是（ ）。
A.
接口
B.
继承
C.
内部类
D.
适配器
| 参考答案
答案
A
2分
2-68
下列选项中，用于定义接口的关键字是（ ）。
A.
interface
B.
implements
C.
abstract
D.
class
| 参考答案
答案
A
2分
2-69
下列选项中，用于实现接口的关键字是 （ ）。
A.
interface
B.
implements
C.
abstract
D.
class
| 参考答案
答案
B
2分
2-70
如果需要从文件中读取数据，则可以在程序中创建哪一个类的对象（）。
A.
FileInputStream
B.
FileOutputStream
C.
DataOutputStream
D.
FileWriter
| 参考答案
答案
A
2分
2-71
对JVM来说，可执行文件的扩展名正确的是（ ）。
A.
java
B.
class
C.
dll
D.
pyc
| 参考答案
答案
B
2分
2-72
有一个类A，以下为其构造方法的声明，其中正确的是（）。
A.
void A(int x){...}
B.
A(int x){...}
C.
a(int x){...}
D.
void a(int x){...}
| 参考答案
答案
B
3分
2-73
以下程序段的输出结果是
class Test {
public static void main(String[] args) {
System.out.println(4 + 5 + "" + 3 + 6);
}
}
A.
99
B.
4536
C.
936
D.
459
| 参考答案
答案
C
2分
2-74
下列关于数组的声明哪一个是错误的。
A.
int[ ] a={1,2};
B.
int a[ ]={1,2};
C.
int[ ] a=new int[2];
D.
int a[2]={1,2};
| 参考答案
答案
D
2分
2-75
下列关于抽象类的说法哪一个是错误的。
A.
含抽象方法的类为抽象类
B.
抽象类能创建(new)实例
C.
子类有未实现父类的抽象方法时仍为抽象类
D.
子类实现所有抽象方法时不再是抽象类
| 参考答案
答案
B
2分
2-76
以下二维数组的定义正确的是（ ）
A.
int a[3][2]={{1,2},{1,3},{2,3}}
B.
int a[][]=new int[3][]
C.
int[][] a=new int[][3]
D.
int[][] a=new int[][]
| 参考答案
答案
B
2分
2-77
关于抽象类，下面叙述错误的是（） 。
A.
包含抽象方法的类必须是抽象类
B.
抽象方法只需要声明，不需要实现
C.
抽象类可以实例化
D.
抽象类中可以没有抽象方法
| 参考答案
答案
C
1分
2-78
关于接口的声明，错误的是( ) 。
A.
接口中所有的成员属性都是public static final修订的常量
B.
接口中的成员属性在声明时可以省略修订关键字
C.
接口中所有的方法都是public abstract final修订的
D.
接口中所有的方法都是public abstract修订的
| 参考答案
答案
C
1分
2-79
关于接口，下面的叙述错误的是（）。
A.
一个接口可以多继承多个接口
B.
一个类可以实现多个接口
C.
抽象类在实现接口时，可以不实现该接口中声明的所有方法
D.
抽象类在实现接口时，必须实现该接口中声明的所有方法
| 参考答案
答案
D
1分
2-80
下面的概念，哪个不是关于对象的多态性的体现。
A.
方法的重载
B.
方法的继承
C.
方法的覆盖
D.
对象的上、下转型
| 参考答案
答案
B
1分
2-81
一个*.java文件中可以包含多少个public类？
A.
最多1个
B.
最少1个
C.
只能是0个
D.
不限制
| 参考答案
答案
A
2分
2-82
在使用super 和this关键字时，以下描述正确的是
A.
在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B.
this（）和super（）可以同时出现在一个构造函数中
C.
super（）和this（）不一定要放在构造方法内第一行
D.
this（）和super（）可以在static环境中使用，包括static方法和static语句块
| 参考答案
答案
A
1分
2-83
以下对抽象类的描述正确的是
A.
抽象类没有构造方法
B.
抽象类必须提供抽象方法
C.
有抽象方法的类一定是抽象类
D.
抽象类可以通过new关键字直接实例化
| 参考答案
答案
C
1分
2-84
以下描述错误的有
A.
abstract 可以修饰类、接口、方法
B.
abstract修饰的类主要用于被继承
C.
abstract 可以修饰变量
D.
abstract修饰的类，其子类也可以是abstract修饰的
| 参考答案
答案
C
1分
2-85
以下程序运行结果是
public class Test extends Father{
private String name="test";
public static void main(String[] args){
Test test = new Test();
System.out.println(test.getName());
}
}
class Father{
private String name="father";
public String getName() {
return name;
}
}
A.
father
B.
编译出错
C.
test
D.
运行出错，无输出
| 参考答案
答案
A
2分
2-86
以下描述不正确的有
A.
try块不可以省略
B.
可以使用多重catch块
C.
finally块可以省略
D.
catch块和finally块可以同时省略
| 参考答案
答案
D
1分
2-87
下列选项中关于java中super关键字的说法错误的是
A.
super关键字是在子类对象内部指代其父类对象的引用
B.
super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C.
子类可以通过super关键字调用父类的方法
D.
子类可以通过super关键字调用父类的属性
| 参考答案
答案
B
1分
2-88
在Java中，以下程序段的输出结果是（ ）。
int n=9;
while(n>6){
n--;
System.out.print(n);
}
A.
987
B.
876
C.
8765
D.
9876
| 参考答案
答案
B
1分
2-89
下面那种类型不属于Java的基本数据类型？
A.
byte
B.
int
C.
boolean
D.
String
| 参考答案
答案
D
2分
2-90
假设有如下程序：
public class Demo {
public static void main(String args[]) {
String str = "" ;
for (int x = 0 ; x < 5 ; x ++) {
str += x ;
}
System.out.println(str) ;
}
}
最终的执行结果是什么？
A.
01234
B.
10.0
C.
14.0
D.
25.0
| 参考答案
答案
A
2分
2-91
对于构造方法，下列叙述不正确的是（ ）。
A.
构造方法是类的一种特殊方法，它的方法名必须与类名相同
B.
构造方法的返回类型只能是void型，即在方法名前加void
C.
构造方法的主要作用是完成对类的对象的初始化工作
D.
一般在创建新对象时，系统会自动调用构造方法
| 参考答案
答案
B
2分
2-92
在JAVA中，给定代码片段如下所示，则编译运行后，输出结果是（）。
for (int i = 0; i < 10; i++) {
if (i == 10 - i) {
break;
}
if (i % 3 != 0) {
continue;
}
System.out.print(i + " ");
}
A.
0
B.
0 3
C.
0 3 6
D.
0 3 6 9
| 参考答案
答案
B
2分
2-93
下面代码运行结果显示（ ）。
double temperature = 50;
if (temperature >= 100)
System.out.println("too hot");
else if (temperature <= 40)
System.out.println("too cold");
else
System.out.println("just right");
A.
too hot
B.
too cold
C.
just right
D.
too hot too cold just right
| 参考答案
答案
C
2分
2-94
下面代码将输出（ ）行 "Welcome to Java"?。
int count = 0;
do {
System.out.println("Welcome to Java");
} while (count++ < 10);
A.
10
B.
11
C.
9
D.
1
| 参考答案
答案
B
2分
2-95
循环执行后，count的值是（ ）
int count = 0;
do {
System.out.println("Welcome to Java");
} while (count++ < 9);
System.out.println(count);
A.
11
B.
10
C.
9
D.
8
| 参考答案
答案
B
2分
2-96
声明一个类是需要（ ）关键字。
A.
public
B.
private
C.
class
D.
以上都是
| 参考答案
答案
C
2分
2-97
下面关于try块的说法正确的是?
A.
try块后至少应有一个catch 块
B.
try块后必须有finally块
C.
可能抛出异常的语句应放在try块中
D.
对抛出的异常的处理应放在try块中
| 参考答案
答案
C
2分
2-98
设类B是类C的父类，下列声明对象x1的语句中不正确的是?
A.
B x1 = new B( );
B.
B x1=new C( );
C.
C x1 = new C( );
D.
C x1=new B( );
| 参考答案
答案
D
2分
2-99
下列哪个叙述是正确的？
A.
一个类最多可以实现两个接口
B.
允许接口中只有一个抽象方法
C.
如果一个抽象类实现某个接口，那么它必须要重写接口中的全部方法
D.
如果一个非抽象类实现某个接口，那么它可以只重写接口中的部分方法
| 参考答案
答案
B
2分
2-100
下列语句序列执行后，k 的值是( )
int x=6, y=10, k=5;
switch( x%y ){
case 0: k=x*y;
case 6: k=x/y;
case 12: k=x-y;
default: k=x*y-x;
}
A.
60
B.
5
C.
0
D.
54
| 参考答案
答案
D
2分
程序填空题
110 分
5-1
题目要求:
1.使用this调用已有的有参构造方法，将width与length分别设置为5和6。
2.在Rectangle类中覆盖toString方法。按照width=实际宽度值,length=实际长度值的格式返回。
public Rectangle(){
this(5,6);
(1分)
}
public Rectangle(int width, int length) {
this.width = width;
this.length = length;
}
public
String toString()
(1分){
return "width="+width+",length="+length;
(1分)
}
| 参考答案
填空#1
this(5,6);
填空#2
String toString()
填空#3
return "width="+width+",length="+length;
3分
5-2
该程序功能是遍历数组，输出一维数组的所有元素，
public class Main {
public static void main(String[] args) {
int[] a={10,3,1,3,53,23,232,90,21,33};
for(
int
(2分)
t
(2分):
a
(2分))
{
System.out.print(
t
(2分)+" ");
}
}
}
###输出样例：
10 3 1 3 53 23 232 90 21 33
| 参考答案
填空#1
int
填空#2
t
填空#3
a
填空#4
t
8分
5-3
阅读程序，补全以下程序：
public class Main {
public static void main(String[] args) {
Test test = new Test(true);
}
}
class Test {
public Test(){
System.out.println("Constructor one invoked!");
}
public Test(int x){
this();
(2分)
System.out.println("Constructor two invoked!");
}
public Test(boolean b){
this(0);
(2分)
System.out.println("Constructor three invoked!");
}
}
使得程序输出结果，如下所示。
Constructor one invoked!
Constructor two invoked!
Constructor three invoked!
| 参考答案
填空#1
this();
填空#2
this(0);
4分
5-4
现有一个Employee类，继承了Person类，其中Employee类有一个年龄age属性，当年龄为负数时会发生异常。根据运行结果，补充以下程序空格处代码：
class Person {
public Person() {
System.out.println("创建一个Person");
(2分)
}
}
class Employee
extends
(2分) Person{
int age;
(2分)
public Employee(int age) {
System.out.println("创建了一个Employee");
(2分)
setAge(age);
System.out.println("年龄为："+age);
(2分)
}
public void setAge(int age)
throws
(2分) IllegalArgumentException {
if (age >= 0)
this.age = age;
else
throw new IllegalArgumentException(
"年龄不能为负数"
(2分));
}
}
public class Main{
public static void main(String[] args){
try {
Employee emp1 = new Employee(10);
Employee emp2 = new Employee(-1);
}
catch (IllegalArgumentException ex)
(2分) {
System.out.println(ex.getMessage());
}
finally {
System.out.println("继续.....");
(2分)
}
System.out.println("任务完成！");
(2分)
}
}
以上程序的运行结果为：
创建一个Person
创建了一个Employee
年龄为：10
创建一个Person
创建了一个Employee
年龄不能为负数
继续.....
任务完成！
| 参考答案
填空#1
System.out.println("创建一个Person");
填空#2
extends
填空#3
int age;
填空#4
System.out.println("创建了一个Employee");
填空#5
System.out.println("年龄为："+age);
填空#6
throws
填空#7
"年龄不能为负数"
填空#8
catch (IllegalArgumentException ex)
填空#9
System.out.println("继续.....");
填空#10
System.out.println("任务完成！");
20分
5-5
class Base {
int x, y, z, w;
public Base(int a, int b) {
x = a;
y = b;
}
public Base(int a, int b, int c, int d) {
this(a, b);
(1分)// 换一种办法实现赋值 x=a, y=b
z = c;
w = d;
}
}
public class Main {
public static void main(String[] args) {
Base base =
new Base
(1分)(1, 1, 1, 1);
System.out.println(base.x + " " + base.y + " " + base.z + " " + base.w);
}
}
| 参考答案
填空#1
this(a, b);
填空#2
new Base
2分
5-6
有如下父类和子类的定义，请根据要求填写代码。
class Father {
int a;
public Father(int a) {
this.a=a;
}
public void print() {
System.out.println(a);
}
}
class Child extends Father {
int a;
public Child(int a) {
super(a);
(1分) // 将形参a的数值赋给父类成员变量a
this.a=super.a*10;
(1分) // 将父类成员变量a的值*10赋给本类的成员变量a
}
public void print() {
System.out.println（
super.a
(1分)); // 输出父类成员变量a的值
System.out.println(
a
(1分) ); // 输出子类成员变量a的值
}
}
public class Main {
public static void main(String[] args) {
Child child=new Child(10);
child.print();
}
}
| 参考答案
填空#1
super(a);
填空#2
this.a=super.a*10;
填空#3
super.a
填空#4
a
4分
5-7
下面程序抛出了一个“异常”并捕捉它。请在横线处填入适当内容完成程序。
class Main {
static void procedure() throws IllegalAccessException {
System.out.println("inside procedure");
throw
(1分)
new
(1分) IllegalAccessException("demo");
}
public static void main(String args[]) {
try {
procedure();
} catch (
IllegalAccessException e
(1分)) {
System.out.println("捕获：" + e);
}
}
}
| 参考答案
填空#1
throw
填空#2
new
填空#3
IllegalAccessException e
3分
5-8
本题目要求使用迭代器遍历学生列表。
import java.util.*;
/* 这里是 Student 类代码，无需关心
*/
public class Main {
public static void main(String args[]) {
List<Student> list = new ArrayList<Student>();
list.add(new Student("2016001","rose",18));
list.add(new Student("2016002","hunifu",19));
list.add(new Student("2016003","britsh",20));
Iterator<Student> it =
list.iterator()
(2分); //创建迭代器
while (
it.hasNext()
(2分) ) { //判断遍历是否结束
Student stu=
(Student) it.next()
(2分);//取列表元素
System.out.println(stu);
}
}
}
| 参考答案
填空#1
list.iterator()
填空#2
it.hasNext()
填空#3
(Student) it.next()
6分
5-9
定义一个Person类，该类包括age，name两个数据成员和eat(),work()两个成员方法，并实现对两个数据成员的Getter方法。然后通过测试程序，实现相应对象的操作。程序输出结果如下：
屏幕截图 2021-12-22 085223.jpg
请按提示完善相应的程序。
class Person
{
public int age; //声明公共字段age
private String name
(2分); //声明私有字段name
public int getAge() {//实现age成员的Getter方法
return age;
}
public String getName() {//实现name成员的Getter方法
return name
(2分);
}
public void eat() //定义无参数的eat方法
{
System.out.println(
"会生活"
(2分));
}
public void work(String s) //定义带参数的work方法
{
System.out.println("努力创造"+s);
}
public Person(int age, String name) //定义一个带参数构造函数
{
this.age = age;
this.name = name;
}
}
public class Main
{
public static void main(String[] args)
{
Person p =
new Person
(2分)(18, "张三");//调用类的有参构造函数
System.out.println("姓名:"+p.getName()+"\n年龄:" + p.getAge());
p.eat()
(2分); //调用对象的eat方法
p.work("美好生活");//
}
}
| 参考答案
填空#1
private String name
填空#2
return name
填空#3
"会生活"
填空#4
new Person
填空#5
p.eat()
10分
5-10
设计一个Circle类，该类有属性radius，表示圆的半径，其默认值为1；getArea()返回该圆的面积。
创建一个名为ComparableCircle的类，它继承自Circle类，并实现Comparable接口，在类中实现compareTo方法，使其根据面积比较两个圆。
编写测试程序求出两个ComparableCircle实例对象的较大者。程序输出如下信息：
Cirlce: radius = 7.0
Area: 153.93804002589985
Cirlce: radius = 5.0
Area: 78.53981633974483
c1较大
class Circle {
private double radius;
public
Circle()
(2分) {
radius = 1;
}
public Circle(double radius) {
this.radius
(2分) = radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public double getArea() {
return radius * radius * Math.PI;
(2分)
}
public String toString() {
return "Cirlce: radius = " + radius;
(2分)
}
}
class ComparableCircle
extends
(2分) Circle
implements
(2分) Comparable<ComparableCircle> {
public ComparableCircle() {
}
public ComparableCircle(double radius) {
super(radius);
(2分)
}
@Override // Implement the compareTo method defined in Comparable
public int compareTo(
ComparableCircle o
(2分)) {
if (getArea() > o.getArea())
return 1;
else if (getArea() < o.getArea())
return -1;
else
return 0;
}
@Override
public String toString() {
return
super.toString()
(2分) + "\nArea: " + getArea();
}
}
public class Main {
public static void main(String[] args) {
ComparableCircle c1 = new ComparableCircle(7);
ComparableCircle c2 = new ComparableCircle(5);
System.out.println(c1);
System.out.println(c2);
System.out.println(
(c1.compareTo(c2)>=0)
(2分)?"c1较大":"c2较大");
}
}
| 参考答案
填空#1
Circle()
填空#2
this.radius
填空#3
return radius * radius * Math.PI;
填空#4
return "Cirlce: radius = " + radius;
填空#5
extends
填空#6
implements
填空#7
super(radius);
填空#8
ComparableCircle o
填空#9
super.toString()
填空#10
(c1.compareTo(c2)>=0)
20分
5-11
设计并实现Box类，它包含盒子的高度、宽带和深度的实例数据：还包含布尔变量full这个实例数据，变量full表示盒子是否满了。所有数据都定义为私有。定义Box构造函数接收并初始化盒子的高度、宽带和深度。每次新创建的Box都为空，构造函数将full初始化为假。该类所有实例都有getter和setter方法；该类还包含了一个计算盒子体积的方法。
该类包含一个toString方法，用来返回一行关于盒子的描述。
例如，输入的长、宽、高分别为4，如果盒子为空，则输出：
Box is empty, The Volumn is 64
若将盒子的宽度修改为5，盒子设置为满，则输出：
Box is full, The Volumn is 80
创建一个测试类BoxTest，其main方法输入盒子的长、宽、高，实例化一个Box对象，并输出盒子的描述。
根据以下的测试类，在空格出填入Box类的设计程序。
import java.util.Scanner;
(2分)
class
Box
(2分) {
private boolean
full
(2分);
private int width;
private int height;
private int lenght;
public Box(
int width, int height, int lenght
(2分)) {
full = false;
this.width = width;
this.height = height;
this.lenght = lenght;
}
public
boolean
(2分) isFull() {
return full;
}
public void setFull(boolean full) {
this.full = full;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getHeight() {
return height;
}
public void setHeight(int h) {
this.height = height;
}
public int getLenght() {
return lenght;
}
public void setLenght(int lenght) {
this.lenght = lenght;
}
public int getVolumn() {
return height * lenght * width;
(2分)
}
@Override
public String
toString()
(2分) {
return "Box is " + (full ? "full" : "empty") + ", The Volumn is " + getVolumn();
}
}
public class Main {
public
static void
(2分) main(String[] args) {
Scanner input = new Scanner(System.in);
int w = input.nextInt();
int h = input.nextInt();
int l = input.nextInt();
Box box1 =
new Box(w,h,l);
(2分)
System.out.println(box1.toString());
box1.setWidth(5);
box1.setFull(
true
(2分));
System.out.println(box1.toString());
}
}
| 参考答案
填空#1
import java.util.Scanner;
填空#2
Box
填空#3
full
填空#4
int width, int height, int lenght
填空#5
boolean
填空#6
return height * lenght * width;
填空#7
toString()
填空#8
static void
填空#9
new Box(w,h,l);
填空#10
true
20分
5-12
有如下父类和子类的定义，请根据要求填写代码。
class Animal{
String name = "牧羊犬"; //名字
void shout(){
System.out.println("动物发出叫声");
}
}
class Dog
extends Animal
(2分){ //Dog是Animal的子类
public void shout(){
super.shout();
(2分) //调用父类Animal的shout()方法
System.out.println("汪汪汪……");
}
public void printName() { //输出名字
System.out.println("名字：" +
super.name
(2分)); //访问父类Animal的name属性
}
}
public class Main {
public static void main(String[] args) {
Dog dog =
new Dog()
(2分); //创建Dog类的实例
dog.shout();
(2分) //调用Dog类的shout()方法
dog.printName(); //调用Dog类的printName()方法
}
}
| 参考答案
填空#1
extends Animal
填空#2
super.shout();
填空#3
super.name
填空#4
new Dog()
填空#5
dog.shout();
编程题：
声明一个图书类，其数据成员为书名、编号（利用静态变量实现自动编号）、书价，并拥有静态数据成员册数，记录图书的总册数；在构造方法中，利用静态变量为对象的编号赋值，在主方法中定义对象数组，并求出总册数。
public class ptatest {
public static void main(String[] args) {
Book[] book = new Book[3];
book[0] = new Book("Java程序设计",34.5);
book[1] = new Book("数据结构",44.8);
book[2] = new Book("C++程序设计",35.0);
for(int i=0;i<3;i++){
book[i].print();
}
System.out.print("图书总册数为："+Book.num);
}
}
class Book{
String name;
int id;
double price;
static int num=0;
public Book(String name,double price){
num++;
this.name=name;
this.price=price;
this.id=num;
}
public void print(){
System.out.println("书名："+this.name+", 书号："+this.id+", 书价："+this.price);
}
}
7-3 jmu-Java-03面向对象基础-03-形状
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int area = 0;
int Perimeter = 0;
Rectangle[] r = new Rectangle[2];
for (int i = 0; i < 2; i++) {
int length = sc.nextInt();
int width = sc.nextInt();
r[i] = new Rectangle(length,width);
//计算面积
area+=r[i].getArea();
//计算周长
Perimeter+=r[i].getPerimeter();
}
Circle[] c = new Circle[2];
for (int i = 0; i < 2; i++) {
int radius = sc.nextInt();
c[i] = new Circle(radius);
//计算面积
area+=c[i].getArea();
//计算周长
Perimeter+=c[i].getPerimeter();
}
System.out.println(Perimeter);
System.out.println(area);
System.out.println(Arrays.deepToString(r));
System.out.println(Arrays.deepToString(c));
}
}
class Rectangle{
private int width;
private int length;
public Rectangle() {
}
public Rectangle(int width, int length) {
this.width = width;
this.length = length;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
//长方形的求周长方法
public int getPerimeter(){
return (this.length+this.width)*2;
}
//长方形的求面积方法
public int getArea(){
return this.length*this.width;
}
public String toString() {
return "Rectangle [width=" + width + ", length=" + length + "]";
}
}
class Circle{
private int radius;
public Circle() {
}
public Circle(int radius) {
this.radius = radius;
}
public int getRadius() {
return radius;
}
public void setRadius(int radius) {
this.radius = radius;
}
//圆形的求面积方法
public int getArea(){
return (int)(this.radius*this.radius*Math.PI);
}
//圆形的求周长方法
public int getPerimeter(){
return (int)(this.radius*2*Math.PI);
}
public String toString() {
return "Circle [radius=" + radius + "]";
}
}
定义一个有关人的Person类，内含属性：
String name、int age、boolean gender、int id，所有的变量必须为私有(private)。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int nextInt = sc.nextInt();
Person[] s = new Person[nextInt];
for (int i = 0; i < nextInt; i++) {
String a = sc.next();
int b = sc.nextInt();
boolean c=sc.nextBoolean();
s[i] = new Person(a,b,c);
}
for (int i = nextInt-1; i >=0; i--) {
System.out.println(s[i].toString());
}
Person person = new Person();
System.out.println(person.toString());
}
}
class Person{
private String name;
private int age;
private boolean gender;
private int id;
@Override
public String toString() {
return "Person [" + "name=" + name +
", age=" + age +
", gender=" + gender +
", id=" + id +
']';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isGender() {
return gender;
}
public void setGender(boolean gender) {
this.gender = gender;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Person() {
System.out.println("This is constructor");
System.out.println(name+","+age+","+gender+","+id);
}
public Person(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
}
7-4 jmu-Java-03面向对象基础-04-形状-继承
import java.awt.*;
import java.util.Arrays;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n= sc.nextInt();
sc.nextLine();
Shape[] shapes=new Shape[n];
for (int i = 0; i < n; i++) {
String s=sc.nextLine();
if (s.equals("rect")){
shapes[i]=new Rectangle(sc.nextInt(), sc.nextInt());
sc.nextLine();
}else if (s.equals("cir")){
shapes[i]=new Circle(sc.nextInt());
sc.nextLine();
}
}
System.out.println(sumAllPerimeter(shapes));
System.out.println(sumAllArea(shapes));
System.out.println(Arrays.toString(shapes));
for (Shape s: shapes) {
System.out.println(s.getClass()+","+s.getClass().getSuperclass());
}
}
public static double sumAllArea(Shape[] ss){
double ret=0;
for (Shape s : ss) {
ret += s.getArea();
}
return ret;
}
public static double sumAllPerimeter(Shape[] ss){
double ret=0;
for (Shape s:ss) {
ret+=s.getPerimeter();
}
return ret;
}
}
abstract class Shape{
static double PI=3.14;
public abstract double getPerimeter();
public abstract double getArea();
}
class Rectangle extends Shape{
private int width;
private int length;
public Rectangle(int width, int length) {
this.width = width;
this.length = length;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public double getPerimeter(){
return 2.0*(this.length+this.width);
}
public double getArea(){
return this.length*this.width;
}
@Override
public String toString() {
return "Rectangle [" +
"width=" + width +
", length=" + length +
']';
}
}
class Circle extends Shape{
private int radius;
public Circle(int radius) {
this.radius = radius;
}
public int getRadius() {
return radius;
}
public void setRadius(int radius) {
this.radius = radius;
}
public double getPerimeter(){
return 2*PI*this.radius;
}
public double getArea(){
return PI*Math.pow(this.radius,2);
}
@Override
public String toString() {
return "Circle [" +
"radius=" + radius +
']';
}
}
7-5 jmu-Java-03面向对象基础-05-覆盖
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Objects;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n1= sc.nextInt();
boolean f=true;
sc.nextLine();
ArrayList<PersonOverride> ap=new ArrayList<PersonOverride>();
for (int i=0;i<n1;i++){
ap.add(new PersonOverride());
}
int n2= sc.nextInt();
sc.nextLine();
for (int i=0;i<n2;i++){
f=true;
PersonOverride a=new PersonOverride(sc.next(),sc.nextInt(), sc.nextBoolean());
sc.nextLine();
for (PersonOverride aa:ap) {
if (aa.equals(a)){
f=false;
break;
}
}
if (f)ap.add(a);
}
for(PersonOverride a:ap){
System.out.println(a.toString().replace("[","").replace("]",""));
}
System.out.println(ap.size()-n1);
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
}
}
class PersonOverride{
private String name;
private int age;
private boolean gender;
public PersonOverride() {
this("default",1,true);
}
public PersonOverride(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
@Override
public String toString() {
return name + "-" + age + "-" + gender;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
PersonOverride that = (PersonOverride) o;
return age == that.age &&
gender == that.gender &&
name.equals(that.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age, gender);
}
}
7-6 jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company
import java.text.DecimalFormat;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//创建集合，存储元素
List<Person> personList = new ArrayList<>();
while(true){
String choice = sc.next();
if("s".equals(choice)){
String name = sc.next();
int age = sc.nextInt();
boolean gender = "true".equals(sc.next());
String stuNo = sc.next();
String clazz = sc.next();
personList.add(new Student(name,age,gender,stuNo,clazz));
}else if("e".equals(choice)){
String name = sc.next();
int age = sc.nextInt();
boolean gender = "true".equals(sc.next());
double salary = sc.nextDouble();
Company company = new Company(sc.next());
personList.add(new Employee(name,age,gender,company,salary));
}else{
break;
}
}
/*
利用Collections工具类里的sort方法，这里我用的是匿名内部类的方式书写的，可以转成lambda表达
式，不过转完之后会让人难以理解，所以我就不转了
*/
Collections.sort(personList, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
int i = o1.name.compareTo(o2.name);
i = i==0 ? o1.age-o2.age : i;
return i;
}
});
//增强for对集合进行遍历打印
for (Person person : personList) {
System.out.println(person.toString());
}
String choice = sc.next();
if("exit".equals(choice)){
//手动安全结束虚拟机工作
System.exit(0);
}
//创建两个集合
ArrayList<Student> stuList = new ArrayList<>();
ArrayList<Employee> empList = new ArrayList<>();
for (Person person : personList) {
//用instanceof判断能否转成Student类
if(person instanceof Student){
if(ExistsStu(stuList,person)){
stuList.add((Student)person);
}
}else{
if(ExistsEmp(empList,person)){
empList.add((Employee)person);
}
}
}
System.out.println("stuList");
for (Student student : stuList) {
System.out.println(student.toString());
}
System.out.println("empList");
for (Employee employee : empList) {
System.out.println(employee.toString());
}
}
//判断empList是否存在该元素
private static boolean ExistsEmp(ArrayList<Employee> empList, Person person) {
for (Employee employee : empList) {
if(employee.equals(person)){
return false;
}
}
return true;
}
//判断stuList是否存在该元素
private static boolean ExistsStu(ArrayList<Student> stuList, Person person) {
for (Student student : stuList) {
if(student.equals(person)){
return false;
}
}
return true;
}
}
//抽象类Person
abstract class Person{
String name;
int age;
boolean gender;
public Person(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public Person() {
}
@Override
public String toString() {
return name+"-"+age+"-"+gender;
}
@Override
public boolean equals(Object obj) {
Person p1 = (Person)obj;
if(p1==null){
return false;
}
if(p1.name==null){
return false;
}
if(!this.name.equals(p1.name)){
return false;
}
if(!(this.age==p1.age)){
return false;
}
return this.gender == p1.gender;
}
}
//学生类
class Student extends Person{
String stuNo;
String clazz;
public Student(String name, int age, boolean gender, String stuNo, String clazz) {
super(name, age, gender);
this.stuNo = stuNo;
this.clazz = clazz;
}
@Override
public String toString() {
return "Student:"+super.toString()+"-"+stuNo+"-"+clazz;
}
@Override
public boolean equals(Object obj) {
if(!super.equals(obj)){
return false;
}
Student s1 = (Student)obj;
if(s1==null){
return false;
}
if(s1.stuNo==null){
return false;
}
if(!this.stuNo.equals(s1.stuNo)){
return false;
}
if(s1.clazz==null){
return false;
}
return this.clazz.equals(s1.clazz);
}
}
class Company{
String name;
public Company(String name) {
this.name = name;
}
@Override
public String toString() {
return name;
}
@Override
public boolean equals(Object obj) {
Company c1 = (Company)obj;
if(c1==null){
return false;
}
if(c1.name==null){
return false;
}
return this.name.equals(c1.name);
}
}
//员工类
class Employee extends Person{
Company company;
double salary;
public Employee(String name, int age, boolean gender, Company company, double salary) {
super(name, age, gender);
this.company = company;
this.salary = salary;
}
@Override
public String toString() {
return "Employee:"+super.toString()+"-"+company.toString()+"-"+salary;
}
@Override
public boolean equals(Object obj) {
if(!super.equals(obj)){
return false;
}
Employee e1 = (Employee)obj;
if(e1.company==null){
return false;
}
if(!this.company.name.equals(e1.company.name)){
return false;
}
//这里不知道什么原因，小数对比总会返回false,所以我就用字符串的方式进行判断
DecimalFormat df = new DecimalFormat("#.#");
String s1 = df.format(this.salary);
String s2 = df.format(e1.salary);
return s1.equals(s2);
}
}
7-7 jmu-Java-06异常-02-使用异常机制处理异常输入
import java.lang.reflect.Array;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String s=sc.nextLine();
int a[]=new int[Integer.valueOf(s)];
for (int i=0;i<a.length;i++){
String str=sc.nextLine();
if (Character.isDigit(str.charAt(0))){
a[i]=Integer.valueOf(str);
}else {
System.out.println("java.lang.NumberFormatException: For input string: \""+str+"\"");
i--;
}
}
System.out.println(Arrays.toString(a));
}
}
7-8 学生类-构造函数
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String s = sc.nextLine();
String[] str=s.split(" ");
Student student=new Student(str[0],str[2],Integer.valueOf(str[1]));
System.out.println(student);
}
}
class Student {
private String name;
private String sex;
private int age;
public void setName(String name){
this.name=name;
}
public void setsex(String sex){
this.sex=sex;
}
public void setage(int age){
this.age=age;
}
public String getName() {
return name;
}
public String getSex() {
return sex;
}
public int getAge() {
return age;
}
@Override
public String toString() {
String str="Student [name='"+name+"', sex='"+sex+"', age="+age+"]";
return str;
}
public Student(){
}
public Student(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
}
7-16 集体评分
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] grade = new int[5];
for(int i=0; i<grade.length; i++){
grade[i] = in.nextInt();
}
RR rr = new RT(grade);
double dd = rr.mark();
System.out.printf("%.2f",dd);
}
}
abstract class RR{
int[] grade;
public RR(int[] grade){
this.grade = grade;
}
public abstract double mark();
}
class RT extends RR{
public RT(int[] grade) {
super(grade);
}
@Override
public double mark() {
double sum=0;
for (int i=1;i<grade.length-1;i++){
sum+=grade[i];
}
return sum/3;
}
}
作品评分
全国中小学生Scratch作品大赛拉开了序幕。每个参赛选手可以通过网络直接上传作品。本次比赛人人可做评委。每个网络评委可以通过网络对每一件作品进行打分。评分系统也是请程序高手设计的，能自动去掉一个最高分和一个最低分，求出平均分。
package test;
import java.util.Arrays;
import java.util.Scanner;
//import java.util.*;//全
public class zuopinpingfen {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
float[] score = new float[n];
float sum = 0;
for(int i = 0;i < n;i++) {
score[i] = sc.nextFloat();
}
Arrays.sort(score);//进行排序（升序）
for(int i = 1;i < score.length-1;i++)//去掉了最大值和最小值之后进行的求和
sum += score[i];
System.out.printf("%.2f",sum/(score.length-2));
sc.close();//防 'sc' leak
}
}
班级里要搞智力竞赛啦!同学们都踊跃参加。进入最后决赛的是10个同学，随着一道道题目的出示，有时是1号选手得分，有时是5号选手得分，每次答对者得10分，最后结果如何呢?
#include <stdio.h>
#define MAXN 12
int main()
{
int score[MAXN], i, n, m;
for (i = 1; i <= 10; i++)
{
scanf("%d", &score[i]);
}
scanf("%d", &n);
for (i = 1; i <= n; i++)
{
scanf("%d", &m);
score[m] += 10;
//第m个自增
}
for (i = 1; i <= 10; i++)
{
printf("%d", score[i]);
if (i != 10)
printf(" ");
}
return 0;
}
利用接口做参数，写个计算器，能完成加减乘除运算。
定义一个接口ICompute含有一个方法int computer(int n, int m)。
定义Add类实现接口ICompute，实现computer方法，求m，n之和
定义Sub类实现接口ICompute，实现computer方法，求n-m之差
定义Main类，在里面输入两个整数a, b，利用Add类和Sub类的computer方法，求第一个数a和第二个数b之和，输出和，第一个数a和第二个数b之差，输出差。
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int m=in.nextInt();
Add l=new Add();
Sub j=new Sub();
System.out.println(l.computer(n, m));
System.out.println(j.computer(n, m));
in.close();
}
}
interface IComputer{
abstract public int computer(int n ,int m);
}
class Add implements IComputer
{
int m,n;
public int computer(int n ,int m) {
return n+m;
}
}
class Sub implements IComputer
{
int m,n;
public int computer(int n ,int m) {
return n-m;
}
}
假定要为某个公司编写雇员工资支付程序，这个公司有各种类型的雇员（Employee），不同类型的雇员按不同的方式支付工资（都是整数）：
（1）经理（Manager）——每月获得一份固定的工资
（2）销售人员（Salesman）——在基本工资的基础上每月还有销售提成
（3）一般工人（Worker）——则按他每月工作的天数计算工资
在Employee中提供函数getSalary()计算每个雇员一个月的工资，并在子类中重写。
在main函数中构造Employee的三个变量，分别指向Manager、Salesman、Worker的对象，调用getSalary函数，输出三个对象的工资
public abstract class Employee{
public abstract double ComputerSalary();
public double basis;
}
public class Manager extends Employee{
public Manager(double m_basis){
basis=m_basis;
}
public double ComputerSalary(){
return basis;
}
public void show(){
System.out.println("工资:"+ComputerSalary());
}
}
public class worker extends Employee{
public int days;
worker(int days,double m_basis){
this.days=days;
basis=m_basis;
}
public double ComputerSalary(){
return days*basis;
}
public void show(){
System.out.println("工资:"+ComputerSalary());
}
}
import java.util.Scanner;
public class shows{
public static void main(String args[]){
double basis;
int days;
double commission;
System.out.print("请输入基本工资：");
Scanner reader=new Scanner(System.in);
basis=reader.nextDouble();
System.out.print("请输入工作天数：");
days=reader.nextInt();
System.out.print("请输入销售提成：");
commission=reader.nextDouble();
Manager a=new Manager(basis);
a.show();
Saleman b=new Saleman(basis,commission);
b.show();
worker c=new worker(days,basis);
c.show();
}
}
定义一个商品类。创建对象并按指定格式输出它。
商品类要求：
（1）成员变量：商品编号（String） 、商品名称(String)、商品单价(double)
（2）成员变量封装，定义为私有属性，并为每个成员变量定义getXXXX，setXXXX方法
（3）定义构造方法，要求带三个参数，参数值用于给成员变量赋值。
（4）重写toString（）方法，将对象转换为字符串，格式：商品编号，商品名称，商品单价
在这里插入代码片
import java.util.Scanner;
class Product{
private String number;
private String name;
private double price;
Product(String number,String name,double price){
this.number=number;
this.name=name;
this.price=price;
}
public String toString(){
return number+","+name+","+price;
}
public String getNumber(){
return number;
}
public void setNumber(String number){
this.number=number;
}
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public double getPrice(){
return price;
}
public void setPrice(double price){
this.price=price;
}
}
public class Main{
public static void main(String []args){
Scanner sc=new Scanner(System.in);
String number=sc.next();
String name=sc.next();
double price=sc.nextDouble();
Product p1=new Product(number,name,price);
System.out.println(p1.toString());
}
}
编写一个完整的Java Application 程序。包含类Circle、Cylinder、Main，具体要求如下。
import java.util.Scanner;
class Circle{
private double radius;
Circle(double radius){
this.radius=radius;
}
Circle(){
double radius=0;
}
void setRadius(double r){
double radius=r;
}
double getRadius(){
return radius;
}
double getArea(){
return Math.PI*radius*radius;
}
double getPerimeter(){
return 2*Math.PI*radius;
}
public String toString(){
return "Circle(r:"+radius+")";
}
}
class Cylinder{
private double height;
private Circle circle;
Cylinder(double height,Circle circle){
this.height=height;
this.circle=circle;
}
Cylinder(){
double height=0;
circle.setRadius(0);
}
void setHeight(double height){
this.height=height;
}
double getHeight(){
return height;
}
void setCircle(Circle circle){
this.circle=circle;
}
Circle getCircle(){
return circle;
}
double getArea(){
return 2*Math.PI*circle.getRadius()*circle.getRadius()+circle.getPerimeter()*height;
}
double getVolume(){
return circle.getArea()*height;
}
public String toString(){
return "Cylinder(h:"+height+","+circle.toString()+")";
}
}
public class Main{
public static void main(String args[]) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
for(int i = 0; i < n; i++) {
String str = input.next();
if(str.equals("Circle")) {
Circle c = new Circle(input.nextDouble());
System.out.println("The area of " + c.toString() + " is " + String.format("%.2f",c.getArea()));
System.out.println("The perimeterof " + c.toString() + " is "+ String.format("%.2f",c.getPerimeter()));
} else if(str.equals("Cylinder")) {
Cylinder r = new Cylinder(input.nextDouble(), new Circle(input.nextDouble()));
System.out.println("The area of " + r.toString() + " is " + String.format("%.2f",r.getArea()));
System.out.println("The volume of " + r.toString() + " is " + String.format("%.2f",r.getVolume()));
}
}
}
}
小明来到了古都西安，想去参观大唐西市！
西安的道路可以看做是与x轴或y轴垂直的直线，小明位于(a,b)，而目的地位于(c,d)，问最少几步可以到达。((((((用c语言))))))))
#include <stdio.h>
#include <math.h>
int main()
{
int a,b,c,d;
int m,n;
scanf("%d %d %d %d",&a,&b,&c,&d);
m=fabs(c-a);
n=fabs(d-b);
printf("%d",m+n);
return 0;
}
扫一扫
1469
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
