Week2

一、选择题(每题2分，共40分)
1.在Java中，以下描述错误的是（ ）
A…class是源文件
B…java是编译前的源文件
C…class是编译后的字节码文件
D.Java程序需编译后方可运行
【正确答案】A
【答案解析】此题目考查的是Java程序的开发过程。Java程序开发需要经过三个步骤：编写（.java）、编译（.class）、运行。编写的源程序为.java后缀的，编译后为.class的字节码文件，因此选项B、C是正确的，A是错误的。Java文件都需要进行编译，编译后的.class文件可以"一次编译、多次运行"，即体现了Java的特点"Write Once,Run more"。因此D是正确的选项。

2.下列的标识符符合Java命名规范的是（）
A.package com.Bi.hr
B.public class xyz
C.int I
D.void setCustomerName()
【正确答案】D
【答案解析】包的名字应该都是由小写单词组成。它们全都是小写字母，即便中间的单词亦是如此，所以A选项错误。 类名的第一个字母一定要大写，所以B选项错误； 变量的第一个字母应该为小写，所以C选项错误； 与属性相对应的get、set方法为：set(get)+属性名，属性名第一个字母为大写，所以D选项正确。

3.下列有关实参和形参说法正确的是（）
A.形参是指在定义方法时参数列表中的参数
实参是指在调用方法时所传入的实际数据
B.形参变量的作用域是在整个类中都可以使用
C.实参只能是字面量值不可以是变量
D.形参不可以用 final 修饰
【正确答案】A
【答案解析】形参是指在定义方法时参数列表中的参数，实参是指在调用方法时所传入的实际数据。 形参是局部变量，作用域在方法体内，出了方法后不可见。 实参可以是字面量常量值也可以是变量，只要是可以在调用方法时传入的数据就是实参。 形参是可以用 final 来修饰的，被 final 修饰的形参被赋初值后值不可以再改变。 所以 A 正确。

4.能够给一个byte型变量赋值的范围是( )。
A. 0～65535
B.(-128)～127
C.（-32, 768)～32, 767
D. (-256)～255
【正确答案】B
【答案解析】Byte的取值范围是(-128)～127。

5.存储一个24X24点阵的汉字（每个点1bit），需要多少字节（ ）
A.24
B.48
C.72
D.144
【正确答案】C
【答案解析】2424/8=72。意思是：2424的结果是二进制位，而八个二进制位等于 一个字节，所以再除以八是所得的字节数。

6.java中char类型的取值范围是（）
A.0 … 32767
B.0 … 65535
C.–256 … 255
D.–32768 … 32767
【正确答案】B
【答案解析】在java中，char是一个无符号16位类型，取值范围为0到65535。
7.找出下列代码哪行有错误
1.public class HelloWorld{
2. public static void main(String[] args) {
3. double avg1=78.5;
4. int rise=5;
5. int avg2=avg1+rise;
6. System.out.println(“考试平均分：”+avg1);
7. System.out.println(“调整后的平均分：”+avg2);
8. }
9.}
A.3
B.4
C.5
D.6
【正确答案】C
【答案解析】在 Java 程序中，不同的基本数据类型的数据之间经常需要进行相互转换, 目标类型大于源类型，如 double 类型长度为 8 字节， int 类型为 4 字节，因此 double 类型的变量里直接可以存放 int 类型的数据，但反过来就不可以了 因此C是正确的选项。

8.在下面程序的第 7 行补充上下列哪个方法,会导致在编译过程中发生
错误（ ）

1. class Super{
2. public float getNum(){

3.  return 3.0f;
   

4. }
5. }
6. public class Sub extends Super{
7. // TODO …
8. }
   A.public float getNum(){retun 4.0f;}
   B.public void getNum(){}
   C.public void getNum(double d){}
   D.public double getNum(float d){retun 4.0f;}
   【正确答案】B
   【答案解析】方法重写、重载的问题。 重写要求方法签名完全相同，返回值类型如果是基本类型或无返回值时必须一致。重载要求方法名相同且参数列表必须不同，与返回值类型无关。

9.对记录序列{314，298，508，123，486，145}按从小到大的顺序进行插入排
序，经过两趟排序后的结果为（）
A.{314，298，508，123，145，486}
B.{298，314，508，123，486，145}
C.{298，123，314，508，486，145}
D.{123、298，314，508，486，145}
【正确答案】B
【答案解析】此题为插入排序算法，代码如下：
public static void injectionSort(int[] number) { // 第一个元素作为一部分，对后面的部分进行循环
for (int j = 1; j < number.length; j++) {
int tmp = number[j];
int i = j - 1;
while (tmp < number[i]) {
number[i + 1] = number[i];
i–;
if (i == -1) break;
}
number[i + 1] = tmp; }
}

10.下列数组的初始化正确的是（）
A.int[ ] score = new int[ ];
B.int score[ ] = new int[ ] { 34, 90, 87, 54, 24 };
C.int[ ] score = new int[ 4 ] { 90, 12, 34, 77 };
D.int score = { 78, 23, 44, 78 }；
【正确答案】B
【答案解析】选项 A 需要指定数组的长度；选项 C 在声明数组的同时赋值时不能指定数组长度；选项 D 声明数组的语法错误，应为int[ ] score={ 78, 23, 44, 78 }； 因此选择 B

11.当编译并运行下面程序时会出现什么结果( )
public class MyAr{
public static void main(String argv[]){
int[] i = new int[5];
System.out.println(i[5]);
}
}
A.编译错误
B.运行错误
C.输出0
D.输出“null”
【正确答案】B
【答案解析】这里会发生运行错误，错误原因是访问数组下标越界了

12.选择下面代码的运行结果：（ ）
public class Test{
public void method(){
for(int i = 0; i < 3; i++){
System.out.print(i);
}
System.out.print(i);
}
}
A.0122
B.0123
C.编译错误
D.没有任何输出
【正确答案】C
【答案解析】i变量的作用范围是整个for循环中。

13.以下for循环的执行次数是（ ）。
for（int x=0,y=0;(y!=0)&&(x<4);x++）;
A.无限次
B.一次也不执行
C.执行四次
D.执行三次
【正确答案】B
【答案解析】(y!=0)&&(x<4)中，&&叫做短路与，如果前面的条件表达式已经为假了，整个条件表达式肯定为假，y！=0是假，所以条件不成立，for循环不执行。

14.编译运行以下程序后，关于输出结果的说明正确的是（ ）
publicclass Conditional{
publicstaticvoid main(String args[]){
int x=4;
System.out.println("value is "+ ((x>4) ? 99.9 : 9));
}
}
A.输出结果为：value is 99.99
B.输出结果为：value is 9
C.输出结果为：value is 9.0
D.编译错误
【正确答案】C
【答案解析】三目运算符中：第二个表达式和第三个表达式中如果都为基本数据类型，整个表达式的运算结果由容量高的决定。99.9是double类型而9是int类型， double 容量高。

15.关于以下说法正确的是（ ）
1．class StaticStuff
2．{
3． static int x=10;
4． static {x+=5;}
5． public static void main(String args[])
6． {
7． System.out.println(“x=” + x);
8． }
9． static {x/=3;}
10.}
A.4 行与 9 行不能通过编译，因为缺少方法名和返回类型
B.9 行不能通过编译，因为只能有一个静态初始化器
C.编译通过，执行结果为：x=5
D.编译通过，执行结果为：x=3
【正确答案】C
【答案解析】静态块是类加载的时候就会被执行到的，静态执行顺序是按照在类中出现 的先后顺序执行。
【答案解析】构造方法应与类同名，且没有返回值类型

16.下面关于 import, class 和 package 的声明顺序哪个正确（ ）
A.package, import, class
B.class, import, package
C.import, package, class
D.package, class, import
【正确答案】A
【答案解析】.java文件中先使用package关键字，其次使用import关键字，最后使用class关键字。

17.关于以下程序代码的说明正确的是（ ）
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
【答案解析】静态变量是所有对象所共享的，所以上述代码中的几个对象操作是同一静 态变量x， 静态变量可以通过类名调用。

18.给出以下代码，请问如何声明totalPage使其为一个只读属性（ ）。
public class Page{
public int totalPage;
}
A.声明totalPage变量为private。
B.声明Page类为private。
C.声明totalPage变量为private，并且建立一个用于获取totalPage变量值
的getTotalPage() 方法。
D.声明totalPage变量为static。
【正确答案】C
【答题时间】2019-11-28 10:19:17
【答案解析】本题考查java类中只读属性的定义
只读属性需要使用private修饰，只能由类中提供的方法访问该属性，
类中需要提供形如public int getTotalPage(){return …}的方法，方法中负责提供算法，返回属性对应的类型的值。
选项C正确

19.下列程序中，出现编译错误的行数是（ ）。
1 class Fu{
2 Fu(int x){
3 System.out.println(“fu …”+x);
4 }
5 }
6 class Zi extends Fu{
7 Zi(){
8 System.out.println(“zi run”);
9 }
10 Zi(int x){
11 this();
12 System.out.println(“zi…”+x);
13 }
14 }

A.11
B.2
C.7
D.10

【正确答案】C
【答题时间】2019-11-28 10:19:17
【答案解析】创建子类时，子类的所有构造函数默认都会调用父类中空参数的构造函数。
因为子类的构造函数第一行有一个句隐式的super();语句
程序中的第7行，空的构造函数中，会自动调用父类没有参数的构造器，
而父类中，定义了有参数的构造器，系统将不会提供无参数的构造器
选项C正确。

20.下列程序运行后，输出结果是（ ）。
public class Point{
private int x,y;
Point(int x,int y){
this.x = x;
this.y = y;
}
public static void main(String[] args) {
Point p1 = new Point(13,14);
Point p2 = new Point(17,16);
System.out.println(p1.x+p2.y);
}
}

A.27 B.31 C.33 D.29

【正确答案】D
【答题时间】2019-11-28 10:19:17
【答案解析】本题考查构造函数初始化对象的成员变量。
this关键字表示调用该方法的当前对象。当使用构造函数创建对象的时候，该构造函数
会被自动调用。
运行Point p1 = new Point(13,14);代码，此时构造函数中this表示对象p1，
运行构造函数的时候，设置p1对象的成员变量x，y值分别为传入的参数13,14
此时p1.x=13；同理p2.y=16,p1.x+p2.y=13+16,结果为29.
选项D正确。

二、多选题(每题3分，共15分)
1.下列说法错误的有( )
A.数组是一种对象
B.数组属于一种原生类 //如果数组类型是基本数据类型，那么数组是原生类，反之不是，存在二义性。
C.int number=[]={31,23,33,43,35,63}
D.数组的大小可以任意改变
【正确答案】B,C,D
【答案解析】数组不是原生类：int double boolean float byte short long char ，初始化多大就是多大

2.关于类、对象、引用以下描述正确的是（ ）。
A.Person person = new Person(“张三”);
person是一个对象，是内存中的一块区域，是Person类的一个实例
B.Person person = new Person(“张三”);
person并不是真正的对象，而是指向所创建的对象的引用
C.Person person;
person = new Person(“张三”);
person = new Person(“李四”);
person是引用类型的变量，指向了“张三”和“李四”两个对象
D.Person person;
person = new Person(“张三”);
person = new Person(“李四”);
person是引用类型的变量，最后指向了“李四”这个对象

3.下面选项中哪两个可以在 A 的子类中使用（ ）
class A {
protected int method1 (int a, int b) {
return 0;
}
}
A.public int method1(int a, int b) { return 0; }
B.private int method1(int a, int b) { return 0; }
C.private int method1(int a, long b) { return 0; } //重载
D.public short method1(int a, int b) { return 0; }
【正确答案】A,C
【答案解析】B子类重写父类的方法，访问权限不能降低;C属于重载;D子类重写父类的方法如果返回值类型是基本类型的话，要求相同。

4.下面哪个函数是public void method(){…}的重载函数（ ）
A.public void method(int m){…}
B.public int method(){…}
C.public void method2(){…}
D.public int method(int m, float f){…}
【正确答案】A,D
【答案解析】重载：方法名相同且参数列表不同，与返回值类型无关。

5.byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2); /语句1/
b6=b4+b5; /语句2/ 被final修饰的变量及类型运算时不会自动类型提升，运算时必须保证所有参与运算的变量均为final修饰的才不会转型。
b8=(b1+b4); /语句3/
b7=(b2+b5); /语句4/
System.out.println(b3+b6);
下列代码片段中，存在编辑错误的语句是()
A.语句2
B.语句1
C.语句3
D.语句4
【正确答案】B,C,D
【答案解析】语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int； 语句2正确：b6=b4+b5;b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型； 语句3错误：b8=(b1+b4);虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4); 语句4错误：b7=(b2+b5); 同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变。

三、简答题(每题5分，共25分)
1.重写和重载的区别？
重载：同一个类中，方法名相同，参数列表不同的方法称为方法的重载；
遵从两同一不同的规则：两同： 同一个类，方法名相同。
一不同：参数列表不同；
注意: 参数列表不同指的是：参数个数，形参顺序，形参类型不同
重载与与返回值类型，访问权限，形参变量名，方法体无关。

重写：发生在父子类中，子类对父类已有的非私有方法（除构造方法（不能被继承））重写。
遵从两同两小一大原则：
两同：方法名相同，参数列表相同。
两小：①若父类返回值类型为基本数据类型或void,子类必须与父类保持一致。若父类返回值类型为引用类型，子类可以与父类相同，也可以为该引用类型的子类。② 子类抛出的异常必须小于父类（若父类中没有抛出异常，子类只能使用try-catch捕获解决异常）。
一大：子类访问权限必须大于等于父类。

2.静态变量与实例变量的区别？
静态变量：① 静态变量使用static修饰，属于类的资源，跟类一起加载，可以直接使用类名调用，或使用对象调用（不推荐），全局共享，只有一份；编译期加载进内存。
实例变量：没有static修饰，实例变量属于对象的资源，只有创建完对象才能使用，需要用对象调用。每个对象都有一套特有的实例变量，运行时加载进内存。
二者都有默认值

3.简述final关键字的用法
①final修饰类不可被继承
②final修饰方法不能被重写
③final修饰变量称为常量，初始化之后不可修改。
拓展：
④final 与 static 共同修饰变量称为静态常量。必须声明并赋值。
⑤final不可与abstract一起使用。

4.this和super的区别
this 指代子类对象引用，可以使用super调用父类资源，因为此时可能没有创建父类对象，所以不能说super指向父类对象。
②当本类成员变量名和局部变量名相同时，用this.来区分成员变量和局部变量。当父类成员变量与子类成员变量相同时，用super来区分父类成员变量和子类成员变量。

拓展：
③可以使用super([参数列表])调用父类构造方法初始化父类属性。可以使用this([参数列表])初始化成员变量。this()中显示或隐式调用super()调用父类构造方法初始化成员，所以二者不能同时使用，否则会造成两次初始化父类成员变量。
为什么this()或super()只能放在方法的第一行。因为java不允许调用没有初始化的成员。

5.分别简述什么是JDK、JRE、JVM，以及他们之间的关系。
①JDK ：Java Development Kit ,是针对java开发员的产品，是整个java的核心。包括：JRE 和 Java 工具， java基础类库。
②JRE ：Java Runtime Enverionment.是运行java的运行时环境。包含JVM 和Java核心类库。
③ JVM —Java Virtual Machine,Java 虚拟机的缩写。是整个Java实现跨平台的最核心部分，能运行以java语言写作的软件程序。

四、编程题(每题10分，共20分)

1. 封装一个方法randomArr(int n){}，随机生成长度为n、元素是0–100以内的数组并返回，数组的长度由参数来决定。

2. 封装sortBubble(int[] arr)方法，将传入的数组进行冒泡排序并返回。

           
public int[] sotBulle(int[] arr){
	for(int i = 0; i < arr.length - 1; i++){
		for(int j = 0; j < arr.length - 1-i; j++){
			if(arr[j] > arr[j+1]){
				System.out.println();
			}
		}
	}
}