第二次测试

最新推荐文章于 2023-11-16 17:35:17 发布

原创最新推荐文章于 2023-11-16 17:35:17 发布 · 1.3k 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java

JAVA练习专栏收录该内容

9 篇文章

订阅专栏

1.关于被私有访问控制符private修饰的成员变量，以下说法正确的是() C
A.可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B.可以被两种类访问和引用：该类本身、该类的所有子类
C.只能被该类自身所访问和修改
D.只能被同一个包中的类访问

序列[15, 67, 26, 43, 61, 25, 84, 80, 34, 70]进行冒泡排序时，第三趟排序的结果是：（）。B
A.[15, 26, 43, 61, 25, 67, 80, 34, 70, 84]
B.[15, 26, 25, 43, 61, 34, 67, 70, 80, 84]
C.[15, 26, 43, 25, 61, 67, 34, 70, 80, 84]
D.[15, 25, 26, 43, 34, 61, 67, 70, 80, 84]
请看下列代码：
class ClassA {}
class ClassB extends ClassA {}
class ClassC extends ClassA {}
public class Test{
public static void main(String[] args) {
ClassA p0 = new ClassA();
ClassB p1 = new ClassB();
ClassC p2 = new ClassC();
ClassA p3 = new ClassB();
ClassA p4 = new ClassC();
<插入代码>
}
}
下列选项中放置在<插入代码>处，使程序编译正确的是：（）。A
A.p0 = p1; B.p1 =p2;
C.p2 = p4; D.p2 = (ClassC)p1;
下列代码的运行结果是：（）。 D
public class Animal {
public String noise() {
return “Animal”;
}
public static void main(String[] args) {
Cat cat = null;
Animal animal = new Dog();
if (animal instanceof Cat) {
cat = (Cat) animal;
System.out.println(cat.noise());
} else {
System.out.println(“animal is not Cat’s instance”);
}
}
}
class Dog extends Animal {
public String noise() {
return “Dog”;
}
}
class Cat extends Animal {
public String noise() {
return “Cat”;
}
}
A.Animal B.Dog
C.Cat D.animal is not Cat’s instance
下列代码编译和运行的结果是：（）。C
class Person {
String name = " ";

public Person(String name) {
this.name = name;
}
}

class Employee extends Person {
String empNO = “0000”;

public Employee(String empNO) {
this.empNO = empNO;
}
}

public class EmployeeTest {
public static void main(String[] args) {
Employee e = new Employee(“1109”);
System.out.println(e.empNO);
}
}
A.输出：0000
B.输出：1109
C.代码public Employee(String empNO) {行，出现编译错误
D.抛出运行时异常

关于下列代码说法正确的是：（）。
public class Cell {
private final int id;
public Cell(int id) {
this.id = id;
}
public void updateId(int id) {
this.id = id;
}
public static void main(String[] args) {
Cell cell = new Cell(1001);
cell.updateId(1002);
System.out.println(cell.id);
}
}
A.编译错误
B.运行时异常抛出
C.运行后，cell对象属性id的值没有改变，仍然是1001
D.运行后，cell对象属性id的值改变成新的值1002

解析：final修饰的变量在被初始化之后就不能再修改，在update（）方法定义时，就已经报错，等不到运行时

关于 abstract，以下选项正确的是：（）
A.A.abstract 类中可以没有 abstract 方法
B.B.abstract 类的子类也可以是 abstract 类
C.C.abstract 类不能创建对象，但可以声明引用
D.D.abstract 方法不能有方法体
SimpleDateFormat类的哪个方法可以将Date转化成String对象？（）。
A.equals B.toString
C.parse D.format
已知下列选项中的方法是在某个类中定义的，现在子类中不可以定义与下列选项中方法签名相同的方法的选项是（）
A.final void methoda() {} B.void methoda() {}
C.static void methoda() {} D.static final void methoda() {}

解析：子类中定义了与父类同名的静态方法，不叫重写，叫覆盖，调用时具体调父类方法还是子类方法，看引用不看对象。

下列选项中，对Object类描述正确的是（）。
**A.Java中所有的类，都默认自动继承了Object类
B.Java中所有的类都从Object类中继承了toString()方法、
hashCode()方法和equals()等方法 **
C.Object类中toString()方法的返回值是一个字符串，
equals方法的返回值为1或0
D.定义类的时候，类中必须重写Object类中的toString(),equals(),hashCode()方法
在Java中，为了区分重载中同名的不同方法，要求（）。
A.返回值类型不同 B.参数名称不同
C.参数列表不同 D.以上三项都不对
下列程序中，出现编译错误的行数是（）。
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

解析：父类定义了有参构造方法，系统不再提供无参构造，子类继承父类，子类构造方法必须显示的写出super(有参传参)，否则编译报错

Java中的继承，如下说法正确的是（）。
A.Java支持接口之间的多继承，也支持类之间的多继承。
B.Java中类只支持单继承，即一个类只能有一个父类.
C.当两个类存在所属关系（is a），才使用继承（is a，是一个。说明该类是某类的一个特殊例子，简单之称为继承。）
D.使用继承，可以使类之间产生关系，提供了多态的特性。
给出以下代码，请问该程序的运行结果是（）。
String s1 =“ab”;
String s2 =“abcd”;
String s3=“cd”;
String s4 =s1+s3;
s1=s4;
System.out.println(“s1”+((s1s2)?"":"!=")+“s2”);
A.s1 == s2 B.s1 != s2
C.s1 D.s1==“abcd”
下列对BufferedOutputStream对象创建正确的是（）。
A.BufferedOutputStream bos =
new BufferedOutputStream(new FileWriter(""));
B.BufferedOutputStream bos =
new BufferedOutputStream(new FileOutputStream(“fileName”));
C.BufferedOutputStream bos =
new BufferedOutputStream(“fileName”);
D.BufferedOutputStream bos =
new BufferedOutputStream(new File(“fileName”));
在JAVA中，下面关于String类和StringBuilder类的描述正确的是（）。
A.StringBuilder类的对象调用tostring（）方法将转换为String类型
B.两个类都有append（）方法
C.可以直接将字符串“test”赋值给声明的Stirng类和StringBuilder类的变量
D.两个类的实例的值都能够被改变
下列对File类的描述正确的是（）。
A.创建File类对象，即在磁盘上创建了一个目录或文件
B.通过File类可以访问文件中的内容
C.File类中的delete()方法，可以删除文件或目录，如果删除目录，只能删除空目录
D.File类中的isDirectory()方法用于判断当前对象表示的是否是一个目录。

解析：StringBuilder 必需通过对象来操作，构造方法：StringBuilder(CharSequence seq)

Java中，下列说法正确的是（）。
A.私有方法不能被重载 B.静态方法能被重载
C.公有方法被重写之后，可以使用private修饰。
D.一个重写的方法不能抛出在父类中不被检查的异常。
如下变量的定义，double d = 1.5;int x=1,y=2,z=3;则正确的switch语句是（）
A.switch((int)d){
case 1:System.out.println(x);break;
case 2:System.out.println(y);break;
}
B.switch(d){
case 1.5:System.out.println(x);break;
case 2.0:System.out.println(y);break;
}
C.switch(x+y){
case 1:System.out.println(x);break;
case 2:System.out.println(y);break;
}
D.switch(x+y){
case 1:System.out.println(x);break;
case z:System.out.println(y);break;
}
关于Java抽象类的说法，错误的是（）。
A.包含抽象方法的类必须是抽象类
B.抽象类不能被实例化
C.继承抽象类时，具体子类必须实现所有的抽象方法
D.如果一个类不包含任何抽象方法，那么该类不能声明为抽象类
下列选项中，对Object类描述正确的是（）。
A.Java中所有的类，都默认自动继承了Object类
B.Java中所有的类都从Object类中继承了toString()方法、
hashCode()方法和equals()等方法
C.Object类中toString()方法的返回值是一个字符串，
equals方法的返回值为1或0
D.定义类的时候，类中必须重写Object类中的toString(),equals(),hashCode()方法
对于以下字符串 str=“wangmengmeng,wangfei,dibiaozuishuaiwangpengli”
通过下列程序获取到三个名字。
程序如下：
String[] names =（）;
for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
空白处应该填写的代码是：（）。
A.split(",",str)
B.str.split(",")
C.str.toArray(",")
D.Arrays.toArray(str,",");
在JAVA中，下面关于String类和StringBuilder类的描述正确的是（）。
A.StringBuilder类的对象调用tostring（）方法将转换为String类型
B.两个类都有append（）方法
C.可以直接将字符串“test”赋值给声明的Stirng类和StringBuilder类的变量
D.两个类的实例的值都能够被改变
下列程序运行后，输出结果是（）。
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

下列程序输出结果是（）。
public class Test {
static int i = 0;
public int aMethod() {
i++;
return i;
}
public static void main(String args[]) {
Test test = new Test();
test.aMethod();
int j = test.aMethod();
System.out.println(j);
Test test1 = new Test();
System.out.println(test1.i);
}
}

A.2 2 B.2 0
C.0 2 D.1 2

下面的程序输出结果是（）。C
public class A implements B {
int k = 20;
public static void main(String args[]) {
int i;
B c1 = new A();//向上造型
i = c1.k;//能点出来什么看引用，重写则看对象，常量不存在重写。
System.out.println(“i=” + i);
}
}
interface B {
int k = 10;
}

A.i=20 B.程序有编译错误
C.i=10 D.i=true

关于以下应用程序的说明，正确的是（）。
1． public class StaticClass
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;}
}
A.4行与9行不能通过编译，因为缺少方法名和返回类型
B.9行不能通过编译，因为只能有一个静态初始化器
C.编译通过，执行结果为：x=5
D.编译通过，执行结果为：x=3
关于Java抽象类的说法，错误的是（）。
A.包含抽象方法的类必须是抽象类
B.抽象类不能被实例化
C.继承抽象类时，具体子类必须实现所有的抽象方法
D.如果一个类不包含任何抽象方法，那么该类不能声明为抽象类
给出以下代码，请问如何声明totalPage使其为一个只读属性（）。
public class Page{
public int totalPage;
}
A.声明totalPage变量为private。
B.声明Page类为private。
**C.声明totalPage变量为private，并且建立一个用于获取totalPage变量值
的getTotalPage() 方法。 **
D.声明totalPage变量为static。
下列程序输出结果是（）。
class Super {
public static void m1() {
System.out.println(“m1 in Super”); }
public void m2() {
System.out.println(“m2 in Super”); }}
class Sub extends Super {
public static void m1() {
System.out.println(“m1 in Sub”); }
public void m2() {
System.out.println(“m2 in Sub”); }}
public class TestMain {
public static void main(String args[]) {
Super sup = new Sub();
sup.m1();
sup.m2();
Sub sub = (Sub) sup;
sub.m1();
sub.m2(); }}

A.m1 in Sub
m2 in Sub
m1 in Sub
m2 in Sub

B.m1 in Super
m2 in Super
m1 in Sub
m2 in Sub

C.m1 in Sub
m2 in Sub
m1 in Super
m2 in Super

D.m1 in Super
m2 in Sub
m1 in Sub
m2 in Sub

以下关于继承的描述正确的是（）。
A.在java中，一个类只能实现一个接口
B.在java中，类只允许单一继承
C.在java中，一个类不能同时继承一个类和实现一个接口
D.在java中，类通过extends关键字来实现接口
变量定义如下：
int i = 128;
下列赋值语句正确的是：（）。
A.int j = i; B.short s = i;
C.short s = 128; D.long l = i;
给定java代码如下所示，在1处新增下列（）方法，是对show方法的重载
public class Test{
public void show(int x, int y, int z) { }
//1
}
A.public int show(int x,int y,float z){return 0;}
B.public int show(int x,int y,int z){return 0;}
C.public void show(int x,int z){}
D.public viod show(int z,int y,int x){}
Java中，下列说法正确的是（）。
A.私有方法不能被重载
B.静态方法能被重载
C.公有方法被重写之后，可以使用private修饰。
D.一个重写的方法不能抛出在父类中不被检查的异常。
下列程序中不会出现编译错误的是（）
A.short s1 = 3;
short s2 = 5;
s1 += s2;

B.short s1 = 3;
short s2 = 5;
s1 = s1+s2;

C.short s1 = 3;
short s2 = 5;
s1 = s1 * s2;

*D.short s1 = 3;
short s2 = 5;
s1 = s2 ;

简答题：
1.接口与抽象类的区别？越详细越好（5分）

抽象类和接口的主要区别（笔试简答）

定义抽象类的关键字是abstract ，而定义接口的关键字是interface
继承抽象类的关键字是extends , 而实现接口的关键字是implements
继承抽象类支持单继承，而实现接口支持多实现
抽象类中可以有构造方法，而接口中不可以有构造方法
抽象类中可以有成员方法，成员属性，抽象方法，构造方法，而接口中只能有常量，私有方法，抽象方法。默认方法
java8 以前的版本，抽象类中增加方法时子类可以不用重写，而接口中增加方法时实现类需要重写
从Java8开始增加新特性，接口中允许出现非抽象方法和静态方法，但非抽象方法需要使用default关键字修饰。
从Java 9 开始增加新特性，接口中允许出现私有方法
接口中可以定义变量且没有final修饰（但此时的变量仍然是常量（默认final修饰））

2.静态方法可不可以重写？为什么？（5分）
不可以。因为静态方法是基于类绑定的。子类声明与父类同名同参的静态方法不叫重写，叫隐藏

3.static关键字的用法有哪些？(5分)
static 用来修饰变量，方法，静态内部类，静态代码块，静态导入

4.重写和重载的区别？越详细越好(5分)
方法重载（overload）（重点）
①两同一不同：同一个类同一个名不同参数列表
②同一个类下，方法名相同，参数列表不同的方法称之为方法的重载。注意：参数列表不同是指参数个数，参数顺序，参数类型不同，重载与返回值类型，形参变量名无关。建议把返回值类型设置相同（避免麻烦）
③构造方法可以重载但不能被重写（构造方法是一个类的独有特征，不能被子类重写）
④方法重载的意义：调用者只需要记住一个方法名就可以实现各种不同功能，
//构造方法必须重载，成员方法如果功能相似也可以用
方法重写（Override）：
重写发生在父子类中，或实现的接口与子类中，重写是子类对父类非私有方法的重写。重写遵循两同两小一大原则：
①方法名相同，参数列表相同。
②子类重写父类的方法，若父类方法返回值类型是void，子类必须是void。若父类返回值类型是基本数据类型，子类重写后的方法返回值类型必须保持与父类一致。若父类方法返回值类型是引用类型，子类重写后的方法返回值类型必须小于等于父类。
③子类重写后的方法访问权限大于或等于父类被重写方法。
④子类抛出的异常要小于等于父类。

5.this和super关键字的用法及区别（5分）

1. this 和super关键字可以同时出现在一个方法中
2. super（）和 this（）不能同时出现在一个方法中
3. super（）和 this 能同时出现在同一个方法
4. 父类写了有参构造，子类继承父类后（构造方法不能被继承），在子类的构造方法中必须显示的在第一行写出super（有参传参），不然会出现编译错误

6.说出五种常见异常（5分）
（笔试）简述你熟知的异常（6个）

算术异常ArithmeticException
数组下标越界异常 ArrayInexOutOfBoundsException
空指针异常：NullPointerException
Boy b1=null;编译不会报错，但是如果b1.show ,则编译OK，运行会发生NullPointerException空指针异常
类型转换异常，ClassCastException，当引用类型进行强制类型转换时，转换后的类型不是本应该指向的对象的类型，则会出现编译通过，运行异常
IllegalArgumentException 非法参数异常
NumberFormatException 数子格式异常
一旦程序出现异常，未处理时，程序终止执行