Makasa

打卡刷题Day09

1.下列关于继承的描述正确的是（C）
A. 在Java中允许定义一个子类的引用，指向父类的对象。
B. 在Java中一个子类可以继承多个抽象类，在extends关键字后依次列出，用逗号隔开。
C. 在Java中继承是通过extends关键字来描述的，而且只允许继承自一个直接父类。
D. 在Java中抽象类之间不允许出现继承关系，所有的抽象类都相互独立。

解析：
A、说反了。父类引用指向子类对象
B、类都是单继承。
D、抽象类也可以继承。

2. java是类C语言，从C++改进而来
去掉了指针和多继承，采用自动垃圾回收等

3. 当类加载时，static静态方法随着类加载而初始化，此时实例对象还未被创建，但是非静态成员变量需要等到实例对象创建才会被初始化，故无法被引用。非静态成员只能被类的实例化对象引用

4. 设有下面两个赋值语句：

a = Integer.parseInt("1024");
b = Integer.valueOf("1024").intValue();

下述说法正确的是（D）
A. a是整数类型变量，b是整数类对象。
B. a是整数类对象，b是整数类型变量。
C. a和b都是整数类对象并且它们的值相等。
D. a和b都是整数类型变量并且它们的值相等。

解析：

intValue()是把Integer对象类型变成int的基础数据类型；
parseInt()是把String 变成int的基础数据类型；
Valueof()是把String 转化成Integer对象类型；（现在JDK版本支持自动装箱拆箱了。）
本题：parseInt得到的是基础数据类型int，valueof得到的是装箱数据类型Integer，然后再通过valueInt转换成int，所以选择D

5.

Integer i = 42;
Long l = 42l;
Double d = 42.0;
下面为true的是(G)

A. (i == l)
B. (i == d)
C. (l == d)
D. i.equals(d)
E. d.equals(l)
F. i.equals(l)
G. l.equals(42L)

解析：
同类型的进行比较，如Integer 与int，Long与long进行==比较时，会自动拆箱；不同类型之间进行比较，如果有一方为非包装类，则会自动拆箱。如果两方都为包装类，则不会拆箱，且不能比较，编译会报错

6. 以下代码执行的结果显示是多少（B）？

A. 505000
B. 0
C. 运行时错误
D. 5050
解析:
count = count++ 原理是 temp = count； count = count+1 ； count = temp； 因此count始终是0 这仅限于java 与c是不一样的

7. 给出下面的代码段

public class Base{
int w, x, y ,z;
public Base(int a,int b)
{
x=a; y=b;
}
public Base(int a, int b, int c, int d)
{
// assignment x=a, y=b
w=d;z=c;
}}

在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的？（CD）
A. Base(a,b);
B. x=a, y=b;
C. x=a; y=b;
D. this(a,b);

解析:
A错，调用Base这个构造方法应该这样 new Base(a,b)
B错，和C相比应该是分号不是逗号
C正常赋值操作
D调用本类的构造方法

8. 下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader
A. Thread
B. Number
C. Double
D. Math
E. ClassLoader

解析:
答案：ABE
A，Thread可以被继承，用于创建新的线程
B，Number类可以被继承，Integer，Float，Double等都继承自Number类
C，Double类的声明为
public final class Doubleextends Numberimplements Comparable
final生明的类不能被继承
D，Math类的声明为
public final class Mathextends Object不能被继承
E，ClassLoader可以被继承，用户可以自定义类加载器

9. 下列哪个选项是错误的。（AD）
A.一个文件中只能有一个public class。
B. 一个文件中可以有多个类。
C. 一个类中可以有两个main方法。
D. 若类中只含一个main方法，则必须是public的。

解析:
A.一个文件中，可以有多个public class即，外部类为public，还可以有public的内部类。
B.一个文件中可以有多个类，可以是多个并列的类，也可以是外部类、内部类结合。
C.一个类中，可以有多个main方法，这是重载，但是public static void main(String[] args)的方法只能有一个。
D.类中，可以有main方法，也可以没有main方法，而有一个main()方法的时候，也可以是任意访问权限。因为这个类不一定要执行，可以只是辅助类。

10. GC机制的优点是，系统会自动处理不再被引用的对象，在cpu空闲或者存储空间不足时进行清理，这样编程时就不用弄清内存管理机制，编程者无需管理内存，提高了编程的效率

11. private方法只可以在类的内部使用，在类外根本访问不到， 而final方法可以在类外访问，但是不可以重写该方法，就是说可以使用该方法的功能但是不可以改变其功能，这就是private方法和final方法的最大区别

12. 下面有关java的一些细节问题，描述错误的是？(B)

A. 构造方法不需要同步化
B. 一个子类不可以覆盖掉父类的同步方法
C. 定义在接口中的方法默认是public的
D. 容器保存的是对象的引用

13. 以下java程序代码，执行后的结果是（）

public class Test {
public static void main(String[] args) {
Object o = new Object() {
public boolean equals(Object obj) {
return true;
}
};
System.out.println(o.equals("Fred"));
}
}

A. Fred
B. true
C. 编译错误
D. 运行时抛出异常
解析:
1、使用了匿名内部类，并重写了Object中的重写了equals()方法
2. o对象调用了equals方法

14. 关于下面的程序Test.java说法正确的是(D)。

public class Test {
static String x="1";
static int y=1;
public static void main(String args[]) {
static int z=2;
System.out.println(x+y+z);
}
}

A. 3
B.112
C.13
D. 程序有编译错误

解析:
被static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效，所以static不能修饰局部变量

15. 以下说法错误的是（D）
A.虚拟机中没有泛型，只有普通类和普通方法
B. 所有泛型类的类型参数在编译时都会被擦除
C. 创建泛型对象时请指明类型，让编译器尽早的做参数检查
D. 泛型的类型擦除机制意味着不能在运行时动态获取List中T的实际类型

解析:
1、创建泛型对象的时候，一定要指出类型变量T的具体类型。争取让编译器检查出错误，而不是留给JVM运行的时候抛出类不匹配的异常。
2、JVM如何理解泛型概念 —— 类型擦除。事实上，JVM并不知道泛型，所有的泛型在编译阶段就已经被处理成了普通类和方法。 处理方法很简单，我们叫做类型变量T的擦除(erased) 。
总结：泛型代码与JVM
1)
虚拟机中没有泛型，只有普通类和方法。
2)
在编译阶段，所有泛型类的类型参数都会被Object或者它们的限定边界来替换。(类型擦除)
3)
在继承泛型类型的时候，桥方法的合成是为了避免类型变量擦除所带来的多态灾难。 无论我们如何定义一个泛型类型，相应的都会有一个原始类型被自动提供。原始类型的名字就是擦除类型参数的泛型类型的名字。

16. 如下代码，执行test()函数后，屏幕打印结果为（D）

public class Test2
{
public void add(Byte b)
{
b = b++;
}
public void test()
{
Byte a = 127;
Byte b = 127;
add(++a);
System.out.print(a + " ");
add(b);
System.out.print(b + "");
}
}

A. 127 127
B. 128 127
C. 129 128
D. 以上都不对

17. 根据下面的代码，
String s = null;
会抛出NullPointerException异常的有（AC）。
A. if( (s!=null) & (s.length()>0) )
B. if( (s!=null) && (s.length()>0) )
C. if( (s==null) | (s.length()0) )
D. if( (snull) || (s.length()==0) )
解析:
String s=null;没有给s开辟任何空间，当执行length()方法时候，
因为没有具体指向的内存空间，所以报出NullPointerException没有指向的错误。
A &是与，位运算，两个都得执行，执行到s.length()自然就报错了。
B S！=null 结果为false 整体就为false ，&& 后面就不会执行。下面的同理

18. ArrayList和LinkList的描述，下面说法错误的是？()
A. LinkedeList和ArrayList都实现了List接口
B. ArrayList是可改变大小的数组，而LinkedList是双向链接串列
C. LinkedList不支持高效的随机元素访问
D. 在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在ArrayList的中间插入或删除一个元素的开销是固定的

解析:
Arraylist的内存结构是数组，当超出数组大小时创建一个新的数组，吧原数组中元素拷贝过去。其本质是顺序存储的线性表，插入和删除操作会引发后续元素移动，效率低，但是随机访问效率高
LinkedList的内存结构是用双向链表存储的，链式存储结构插入和删除效率高，不需要移动。但是随机访问效率低，需要从头开始向后依次访问

19. 下列语句哪一个是不正确的（D）
A. Log4j支持按分钟为间隔生成新的日志文件
B. Log4j是一个打印日志用的组件
C. Log4j支持按年为间隔生成新的日志文件
D. Log4j的日志打印级别可以在运行时重新设置

解析:
日志的级别之间的大小关系如右所示：ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF Log4j建议只使用四个级别，优先级从高到低分别是 ERROR > WARN > INFO > DEBUG。 log4j在运行期间是不可以重新设置的

20.

public class IfTest{
public static void main(string[]args){
int x=3;
int y=1;
if(x=y)
System.out.println(“Not equal”);
else
System.out.println(“Equal”);
}
}

What is the result?©
A. The output is “Equal”
B. The output in “Not Equal”
C. An error at line 5 causes compilation to fall.
D. The program executes but does not print a message.
解析:
这个题考查两个知识点。
1、Java中，赋值是有返回值的 ，赋什么值，就返回什么值。比如这题，x=y，返回y的值，所以括号里的值是1。
2、Java跟C的区别，C中赋值后会与0进行比较，如果大于0，就认为是true；而Java不会与0比较，而是直接把赋值后的结果放入括号。

21. 下面代码运行结果是（C）

public class Test{
public int add(int a,int b){
try {
return a+b;
}
catch (Exception e) {
System.out.println("catch语句块");
}
finally{
System.out.println("finally语句块");
}
return 0;
}
public static void main(String argv[]){
Test test =new Test();
System.out.println("和是："+test.add(9, 34));
}
}

A. catch语句块
和是：43
B. 编译异常
C. finally语句块
和是：43
D. 和是：43
finally语句块

解析:
System.out.println(“和是：”+test.add(9, 34)); 这是进行字符串拼接是一个整体，所以首先是进入add方法中，进去之后先把先不运算result，而是输出finally块。注意：此时finally块输出结果是：finally语句块，这句话首先打印到控制台中。打印完后返回来执行try中的return得到43，所以此时再将结果与"和是："进行拼接–>输出：和是 43。所以此时控制台又多了一句话：和是 43。加上之前finally先在控制台上的输出，所以结果为：finally语句块 和是 43.

22. What will be printed when you execute the following code?

class C {
C() {
System.out.print("C");
}
}
class A {
C c = new C();
A() {
this("A");
System.out.print("A");
}
A(String s) {
System.out.print(s);
}
}
class Test extends A {
Test() {
super("B");
System.out.print("B");
}
public static void main(String[] args) {
new Test();
}
}

A. BB
B. CBB
C. BAB
D. None of the above

解析:
首先new了一个子类对象，那么就要调用构造方法来初始化该子类对象，但是该类继承自A，所以要先调用父类的构造方法，这里通过super(“B”)显示的调用了父类的带参构造。执行父类的带参构造前要先对父类中的对象进行初始化，对父类中的c成员进行初始化，调用了C类的无参构造，所以调用顺序为：
先调用C类的无参构造
再调用A类的带参构造
最后调用调用子类的构造

23. 对于子类的构造函数说明，下列叙述中错误的是（D）。

A. 子类不能继承父类的无参构造函数。
B. 子类可以在自己的构造函数中使用super关键字来调用父类的含参数构造函数，但这个调用语句必须是子类构造函数的第一个可执行语句。
C. 在创建子类的对象时，若不含带参构造函数，将先执行父类的无参构造函数，然后再执行自己的无参构造函数。
D. 子类不但可以继承父类的无参构造函数，也可以继承父类的有参构造函数。

解析:
构造函数不能被继承，构造方法只能被显式或隐式的调用。

24. 在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放。（错误）

JVM 内存可简单分为三个区：

1、堆区（heap）：用于存放所有对象，是线程共享的（注：数组也属于对象）
2、栈区（stack）：用于存放基本数据类型的数据和对象的引用，是线程私有的（分为：虚拟机栈和本地方法栈）
3、方法区（method）：用于存放类信息、常量、静态变量、编译后的字节码等，是线程共享的（也被称为非堆，即 None-Heap）
Java 的垃圾回收器（GC）主要针对堆区

最后

以上就是务实钢笔为你收集整理的Java基础题(九)Makasa的全部内容，希望文章能够帮你解决Java基础题(九)Makasa所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。