山东建筑大学java模拟考试选择总结

选择题

1.类Circle的包名为my.shape，源程序文件保存在d:\myjava\ch1\Circle.java，假设运行cmd命令后当前目录为：d:\users，而编译后的Circle.class需要放在d:\install\my\shape文件夹下。下则此时输入的编译命令为：AC

A． javac -d d:\install ..\myjava\ch1\Circle.java

B． javac -d ..\myjava\ch1\Circle.java d:\install

C． javac -d d:\install d: \myjava\ch1\Circle.java

D． javac -d d:\install\my\shape d:\myjava\ch1\Circle.java

知识点1：javac命令常用的语法格式：：

javac命令常用的语法格式：
- javac -d 编译后class文件的位置 java文件的路径
  
  注意点：
  - 编译后class文件的位置：不包括所在的包、会自动创建包的目录层次结构
  - 文件的路径包括相对路径和绝对路径
- javac命令的-d参数用于指定编译后的java类的class文件的位置，如果java类带有包（package），将会在指定位置创建包
- ..表示上一级目录
本题分析
- 当前路径为d:\users
- java文件的相对路径为..\myjava\ch1\Circle.java（..表示跳到D盘），绝对路径为d: \myjava\ch1\Circle.java
- 编译后class文件的位置：d:\install
综上分析，套入语法，得到的写法为
- 相对路径写法：javac -d d:\install ..\myjava\ch1\Circle.java
- 绝对路径写法：javac -d d:\install d: \myjava\ch1\Circle.java
故选AC

package choice.two;

public class ChoiceTwo {
public static void main(String[] args) {A a = new B(10, 20);}

}
class A {int a;static {System.out.print("aaa   ");}public A(int a) {this.a = a;System.out.print("a=" + a + " ");}
}


class B extends A {int b;static {System.out.print("bbb   ");}
public B(int a, int b) {super(a);//此处调用了父类的构造方法this.b = b;System.out.print("b=" + b + " ");}

}

输出结果为: D_

A． aaa a=10 bbb b=20 B． a=10 aaa b=20 bbb

C． a=10 b=20 aaa bbb D． aaa bbb a=10 b=20

知识点2：java初始化顺序、super的用法

java程序的初始化顺序
- 父类静态变量、父类静态代码块、子类静态变量、子类静态代码块、父类非静态变量(实例变量)、父类非静态代码块、父类构造器(构造方法)、子类非静态变量、子类非静态代码块、子类构造器(构造方法)
- 先父后子，先静态后非静态，先量再块后方法
super的用法
- 引用父类的成员变量和成员方法
```
super.getName();
```
- 调用父类的构造方法

3.以下代码的空白处应该填写的代码是：__C

package choice.three;
public class Outer {double d = 100;class Inner {void print() {System.out.println(_);// 输出外部类d的值}}public static void main(String args[]) {Outer o = new Outer();Outer.Inner inner = _________;// 创建内部类Inner的对象inner}
}

A． Outer.d o.new Inner() B． d new Outer.Inner()

C． d o.new Inner() D． Outer.d o.new Inner()

知识点3：外部类与内部类

在内部类里里面使用外部类的成员变量、成员方法十分方便，跟外部类里面使用外部类的成员变量成员方法一样，可以直接引用

测试类里面使用内部类的语法格式

//外部类 外部类对象名=new 外部类构造方法(实参列表);
//外部类.内部类 内部类对象名=外部类对象名.new 内部类构造方法；
Outer outer=new Outer("张三")；
Outer.Inner inner=outer.new Inner();

本题分析：

输出外部类d的值，可直接引用d，排除AD
创建内部类Inner的对象inner：外部类对象名.new 内部类构造方法；

4.关于数组的定义以下正确的是：A__

A． double myDouble[]=new double [5]; B． double myDouble [5]=new double [5];

C． double myDouble =new double [5]; D． double myDouble [5]=new double [] ;

知识点4：一维数组的声明与创建

一维数组声明类型

数据类型[] 数组名；
数据类型  数组名[];

一维数组的创建：

数组名=new 数组元素类型[元素个数];
str=new String[10];

//数组声明创建的格式1；
元素类型[] 数组名=new 元素类型[元素个数];
//数组声明创建的格式2：
元素类型[] 数组名=[new 元素类型[]]{元素1，元素2，元素3...};
int arr[]=new int[]{0,1,2};
int arr[]={0,1,2};
//也可以让数组不指向任何数组对象
int x[]=new int[100];
x=null;

本题分析
- A符合数组声明创建的格式1
- B：double myDouble [5]=new double [5];声明的中括号内不能写元素个数
- C：double myDouble =new double [5]；声明时缺少一个中括号
- D：double myDouble [5]=new double [] ;声明和创建的中括里的内容反了

5.针对第1题的要求，则此时classpath设置的内容为： D

A． d:\myjava\ch1; B． d:\users\my\shape;

C． d:\install\my\shape; D． d:\install;

知识点5：classpath

classpath
- 环境变量classpath里面填写的是字节码文件所在的目录，如果字节码文件表示的类有包的话，则classpath应该填写包所在的目录。
本题分析
- 类Circle的包名为my.shape，所以应该填写包所在目录，即 d:\install，故选D

6.代码如下：

int a=10,b=20;

a++;b=a++;

if(b>=12)
System.out.println("a="+a);

else
System.out.println("b="+b);

程序输出结果为:__B_

A． a=10 B． b=11

C． a=12 D． b=12;

知识点6：

a++：先运算再递增。++a:先递增再运算
本题分析：b = a++; // b的值是a++之前的，即b=11；执行此行后，a=12了。先赋值再进行自增

故选B

7.关于数组以下说法正确的是：__AC__

A． Float f[] ; 只是声明了数组f，并没有分配空间

B． float f={3.2f,2.4f}; f是一个具有2个元素的float数组，其中f[0]=3.2f;f[1]=2.4f;

C． Student s[]=new Student[3]; s是一个Student类型的数组，其中每个元素目前是null

D． char c[]=new char[2]; c[ 2]=’m’;这个语句是正确的。

知识点6：数组的知识

声明数组只是创建了一个引用变量，并不为数组元素分配内存，因此[]中不能指出数组中元素的个数，Java是利用运算符来为数组型变量分配内存空间的，这就是创建数组
如果数组元素是基本数据类型，在完成new操作之后秘书组中的元素会自动初始化为默认值，可以直接使用数据元素

如果数组元素为引用数据类型，在完成new操作之后数组元素默认为null
本题分析：
- A选项说法正确；
- B选项说法错误；原因：没有[]。
- C选项说法正确；Student为引用数据类型，不是基本数据类型
- D选项说法错误； c[ 2]会出现数组下标越界异常。

8.关于文件操作，以下说法正确的是：_ABC

A．要修改文件d:\my.txt的名字为d:\your.txt，使用的代码为：

File f=new File("d:\my.txt"); File fNew=new File("d:\your.txt"); f.renameTo(fNew);

B．要判断文件d:\1.txt是否存在的代码是： File f=new File("d:\1.txt"); f. exists();

C．要删除文件d:\2.txt 的代码为：File f=new File("d:\2.txt"); f.delete();

D．要列出d:\myproject下的子文件的代码为：

File f=new File("d:\myproject");

File[] files=f.listFile();

知识点8：File类的方法

修改文件名的方法renameTo(文件名)
判断文件或目录是否存在的方法：
```
public boolean exists();
```
```
public boolean delete()
```
删除文件或目录。当且仅当成功删除文件或目录时返回true，否则返回false，目录必须为空才能删除
```
public File[] listFiles()
```
以File对象数组的形式返回当前目录下的所有文件和目录
本题分析
- D方法名错误

9.String s="1234567890";

则从s中截取子串"5678"的方法为：__A

A． s.substring(4,8) B． s.substring(4,7)

C． s.substring(5,8) D． s. substring (5,9)

知识点9：String类的常用方法

字符串下标从0开始。String类的常用方法。此处考的是截取子字符串的substring(int beginIndex, int endIndex),结尾指的是开区间

还有substring(int beginIndex)：从beginIndex开始一直到字符串结尾的子串。

10.

类People和Worker的定义如下：

class People{

private String name;

public People(String name){ //应该是

this.name=name;

}

class Worker extends People{

private double wage;

public Worker (String name,double wage){

… …

}

则在Worker的构造方法中给name和wage赋值的语句正确的是：___C___

A． super. People (name); this. wage=wage; B． People (name); this. wage=wage;

C． super(name); this. wage=wage; D． super. name=name; this. wage=wage;

知识点10:super的用法，this

super调用父类构造方法

11.

代码

String s1="Hello World";//0001 常量池中

String s2=new String("hello World");

//Hello World->0001 常量池在堆上Hello World复制并创建 1001

//hello world->0002 常量池在堆上Hello world复制并创建 1001

System.out.print(s1.equals(s2)+ " ");

System.out.println(s1==s2);

的输出结果为：__D

A． true true B． true false

C． false true D．false false

知识点11：String类对象的创建

String类的对象的创建：

（1）String s1="Hello World"

如果"Hello World"在常量池不存在，则在常量池创建对象"hello World"，然后将地址赋给s1。

（2）String s2=new String("hello world")

检测常量池中是否存在对象"hello World"，

不存在，则首先在常量池创建该对象"hello World"，然后将地址赋给s1。

所以本题两个打印结果都为false

12.

类A和类B的定义如下：

package com;

*class* A {

*private* *int* a = 3;

*double* b = 4.5;

*protected* *double* c = 6;

……

}

package com;

class B extends A{

……

}

则在B类中： ___B___

A．可以访问a和b，不能访问c B．不能访问a，可以访问b和c

C．不能访问a，可以访问b D．不能访问a，可以访问c

知识点12：访问控制符

private：private修饰的成员只能被它所属的类内的其他方法访问，不能被该类以外的其他类访问
默认访问权限：不写默认访问控制符的就是默认访问权限，默认访问权限定义的内容可以被同一个包中的类所访问，但不能被别的包中的类访问
protected:修饰的成员可以被同一个包内的其他类访问，不同包如果是它的子类也可以访问，其他包不是它的子类不能访问
public：修饰的成员可以被任何类访问
本题分析：
- 此处，B和A在同一个包中，因此A类对B类是可见的，这样B类有可能访问A类中的默认访问权限的成员（属性和方法）。因此，B类可以访问b属性；
  
  B是A的子类。因此，无论A与B是否在同一个包中，B类可以访问其父类A中的protected成员。所以可以访问c属性
  
  private的成员，只有在本类中才可以访问，其他任何类无权访问。因此此处，B类不能访问a属性。
- 所以B不能访问a，可以访问b和c，选B

14.

代码

class Test{

static int m=10;

int n=5;

public Test(){m++;n=n+2;}

public void add(){

m++;n++;//12 8

}

则执行以下代码

Test t1=new Test ();

t1.add();

Test t2=new Test ();

t2.add();

System.out.println("t1.m="+t1.m+" t2.n="+t2.n);

的输出结果为： _A

A． t1.m=14 t2.n=8 B． t1.m=12 t2.n=8

C． t1.m=14 t2.n=11 D．t1.m=12 t2.n=11

知识点：类变量和实例变量
- 此处m是类变量，是所有new出来的对象共有的，n为实例变量，仅为t2拥有

18.

以下说法正确的是：__ACDE

A．抽象类可以有抽象方法，也可以没有抽象方法，接口里都是抽象方法

B．继承抽象类使用implements，实现接口使用extends

C．接口里定义的量都是public static final的。

D．java类的代码编写中只能有1个package语句，但是可以有多个import语句，package语句放在最前面，import语句放在package语句后面，然后才能定义类。

E．一个java源程序文件中只能有一个public的类。

知识点13：抽象类与接口、package（包）与import语句的用法

抽象类与接口：

抽象类和抽象方法的说明
- 抽象方法只有说明，没有实现
- 抽象类可以包含抽象方法，也可以不包含抽象方法。但是包含抽象方法的类必须定义成抽象类
- 抽象类不能被实例化，抽象类可以被继承，所以不允许被定义成final类
- 继承抽象类必须实现抽象类的抽象方法，否则，也必须定义成抽象类
- 一个类实现某个接口，但没有实现该接口的所有方法，则必须定义成抽象类。
抽象类与接口的去区别
- 类可以实现多个接口，但仅能从一个抽象类继承，从抽象类派生的类仍可实现接口，接口可以支持多继承
- 抽象类中可以有普通方法；接口中的方法都是抽象方法，且都是public方法
- 抽象类中的成员变量可以被不同的修饰符来修饰，可以有实例变量，也可以有类变量；接口中的成员默认的都是public、static、final的变量
- 抽象类中有构造方法；接口中不能有构造方法，所以也不能创建对象

package（包）与import语句的用法

java类的代码编写中只能有1个package语句，但是可以有多个import语句，package语句放在最前面，import语句放在package语句后面，然后才能定义类。
一个java源程序文件中只能有一个public的类。

本题分析：

B中继承抽象类使用extends，实现接口使用implements

19.

关于图形界面的以下说法正确的是：A CDE

A．默认从上到下、从左到右排列的布局是FlowLayout

B． JRadioButton是复选框，JCheckBox是单选按钮

C． JTextField是单行文本输入控件，JtextArea是多行文本输入控件

D．在四周放置小控件，在中间区域放置大控件的布局是：BorderLayout;

E．可以按照多行多列布局的是GridLayout

知识点14：图形界面

FlowLayout：称为流式布局，是JPanel的默认布局方式，按照组建的先后顺序，默认从左到右依次将组件添加到容器中，根据容器宽度，放满一行后，自动从下一行开始从左到右派组件。
JRadioButton是单选按钮，JCheckBox是复选框
JTextField是单行文本输入控件，JtextArea是多行文本输入控件
BorderLayout：边框式布局，在四周放置小控件，在中间区域放置大控件的布局
GridLayout：网格式布局，按照多行多列的方式排列组件，每个行列的交叉区域称为一个单元格，每个组件占据一个单元格，根据单元格的大小调整大小。
本题分析：
- B中反了

20.

以下代码正确的是：_A_C_E

A．

public class Test{

public void draw(){System.out.println("hello");}

public int getA(){return 1;}

}

B．

public class Test{

public void draw(){System.out.println("hello");}

public int getA(){System.out.println("hello World");}

}//public int getA(){System.out.println("hello World");}//需要有return语句

C．

public class Test{

public int sum(int a,int b){return a+b;}

public double sum(double a, double b){return a+b;}

}

D．

public class Test{

public int sum(int a,int b){return a+b;}

public int sum(int x,int y){return x+y;}

}//方法名重复了

E．

public class Test{

public int sum(int a,int b){return a+b;}

public int sum(int a,int b,int c){return a+b+c;}

}

知识点15：成员方法的定义：

成员方法的定义格式：
```
[修饰符列表] 返回值类型 方法名([参数列表]){方法体
}
```
- 该方法不需要返回任何结果，需要定义成void
- 如果不是void，方法体最后要有return语句，return值要跟方法头中写的返回值类型一致，方法名可以是任何合法的表示符

考试小技巧：

太复杂的程序可以直接在ecilipse上直接复制粘贴来验证答案（本解析中有几个题没做解析的原因）