牛客网java基础知识刷题记录-01

最新推荐文章于 2024-03-18 12:35:51 发布

灬繁花落雨灬

最新推荐文章于 2024-03-18 12:35:51 发布

阅读量459

点赞数

分类专栏：笔试题刷题记录文章标签： java 后端

本文链接：https://blog.csdn.net/qq_42426993/article/details/122970737

版权

笔试题刷题记录专栏收录该内容

2 篇文章 0 订阅

订阅专栏

2022.1.27-2022.2.16

假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？

public class Base
{
   public void methodOne()
   {
      System.out.print("A"); // 3. 输出A
      methodTwo();  // 4. 调用的是子类重写的methodTwo方法
   }
 
   public void methodTwo()
   {
      System.out.print("B"); // 6. 输出B
   }
}
 
public class Derived extends Base
{
   public void methodOne() // 1. 第一步
   {
      super.methodOne();  //2. super调用，调用父类的methodOne()方法
      System.out.print("C"); // 8.输出C
   }
 
   public void methodTwo()
   {
      super.methodTwo();  // 5. 调用父类大的methodTwo()方法
      System.out.print("D"); //7. 输出D
   }
}

ABDC
AB
ABCD
ABC

考察内容：
	1. 多态成员方法使用规则： 编译看左边，运行看右边
	2. 多态中，子类重写的方法，当super调用就是调用父类方法【只要是被子类重写的方法，不被super调用都是调用子类方法】

关于下面这段Java程序，哪些描述是正确的：()

public class ThreadTest extends Thread {
    public void run() {
        System.out.println("In run");
        yield();
        System.out.println("Leaving run");
    }
    public static void main(String []argv) {
        (new ThreadTest()).start();
    }
}

程序运行输出只有In run
程序运行输出只有Leaving run
程序运行输出先有In run后有Leaving run
程序运行输出先有Leaving run后有In run
程序没有任何输出就退出了
程序将被挂起，只能强制退出

考察内容：
	1. Thread.yidel()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
	2. 上面代码有两个线程，一个主线程和一个ThreadTest线程，主线程调用ThreadTest后就结束了，所以yield()礼让线程没有作用，因为此时只有一个线程了。

关于final说法正确的是？ ( )

final类的方法肯定不能被同一个包的类访问
final类的方法能否被同一个包的类访问不是由final决定
final方法等同于private方法
final对象本身的引用和值都不能改变

考察内容：
	1. final修饰变量：final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。final 修饰符通常和 static 修饰符一起使用来创建类常量。
	2. final修饰方法：类中的 final 方法可以被子类继承，但是不能被子类修改。声明 final 方法的主要目的是防止该方法的内容被修改。
	3. final修饰类：final 类不能被继承，没有类能够继承 final 类的任何特性。

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

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

考察内容：
	1.  构造函数不能被继承，构造方法只能被显式或隐式的调用。

下面为true的是：

Integer i = 42;
Long l = 42l;
Double d = 42.0;

(i == l)
(i == d)
(l == d)
i.equals(d)
d.equals(l)
i.equals(l)
l.equals(42L)

考察内容：
	1. 基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
	2. 两个Integer类型进行“==”比较， 如果其值在-128至127  ，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
	3. 两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true。
	4. 基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

以下JAVA程序的运行结果是什么( )

public static void main(String[] args) {
    Object o1 = true ? new Integer(1) : new Double(2.0);
    Object o2;
    if (true) {
    o2 = new Integer(1);
    } else {
        o2 = new Double(2.0);
    }
    System.out.print(o1);
    System.out.print(" ");         
    System.out.print(o2);
}

1 1
1.0 1.0
1 1.0
1.0 1

考察内容：
	三元操作符类型的转换规则：
		1.若两个操作数不可转换，则不做转换，返回值为Object类型
		2.若两个操作数是明确类型的表达式（比如变量），则按照正常的二进制数字来转换，int类型转换为long类型，long类型转换为float类型等。
		3.若两个操作数中有一个是数字S,另外一个是表达式，且其类型标示为T，那么，若数字S在T的范围内，则转换为T类型；若S超出了T类型的范围，则T转换为S类型。
		4.若两个操作数都是直接量数字，则返回值类型为范围较大者

关于ThreadLocal类以下说法正确的是

ThreadLocal继承自Thread
ThreadLocal实现了Runnable接口
ThreadLocal重要作用在于多线程间的数据共享
ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏

考察内容：
	1. ThreadLocal的类声明：public class ThreadLocal<T>可以看出ThreadLocal并没有继承自Thread，也没有实现Runnable接口。
	2. ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量。所以ThreadLocal重要作用并不在于多线程间的数据共享，而是数据的独立。
	3. ThreadLocal中定义了一个哈希表用于为每个线程都提供一个变量的副本

抽象类方法的访问权限默认都是public。（）

正确
错误

考察内容：
	1. 关于抽象类
		JDK 1.8以前，抽象类的方法默认访问权限为protected
		JDK 1.8时，抽象类的方法默认访问权限变为default
	2. 关于接口
		JDK 1.8以前，接口中的方法必须是public的
		JDK 1.8时，接口中的方法可以是public的，也可以是default的
		JDK 1.9时，接口中的方法可以是private的
	3. 接口中字段的修饰符为：public static final（默认不写）

关于多线程和多进程，下面描述正确的是（）：

多进程里，子进程可获得父进程的所有堆和栈的数据；而线程会与同进程的其他线程共享数据，拥有自己的栈空间。
线程因为有自己的独立栈空间且共享数据，所有执行的开销相对较大，同时不利于资源管理和保护。
线程的通信速度更快，切换更快，因为他们在同一地址空间内。
一个线程可以属于多个进程。

考察内容：
	1. 一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（通常说的主线程）。
	2. 资源分配给进程，同一进程的所有线程共享该进程的所有资源。
	3. 线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
	4. 处理机分给线程，即真正在处理机上运行的是线程。
	5. 线程是指进程内的一个执行单元，也是进程内的可调度实体。

子类A继承父类B, A a = new A(); 则父类B构造函数、父类B静态代码块、父类B非静态代码块、子类A构造函数、子类A静态代码块、子类A非静态代码块执行的先后顺序是？

父类Ｂ静态代码块->父类Ｂ构造函数->子类Ａ静态代码块->父类Ｂ非静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
父类Ｂ静态代码块->父类Ｂ构造函数->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数
父类Ｂ构造函数->父类Ｂ静态代码块->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块

考察内容：
	1. 当实例化子类对象时，首先要加载父类的class文件进内存，静态代码块是随着类的创建而执行，所以父类静态代码块最先被执行，子类class文件再被加载，同理静态代码块被先执行；实例化子类对象要先调用父类的构造方法，而调用父类构造方法前会先执行父类的非静态代码块
	2. 父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数

在类Tester中定义方法如下，public double max(int x, int y) { // 省略 }则在该类中定义如下哪个方法头是对上述方法的重载(Overload)?

public int max(int a, int b) {}
public int max(double a, double b) {}
public double max(int x, int y) {}
private double max(int a, int b) {}

考察内容：
	Java 重载的规则：
		1、必须具有不同的参数列表；
		2、可以有不同的返回类型，只要参数列表不同就可以；
		3、可以有不同的访问修饰符；	
		4、可以抛出不同的异常；	
		5、方法能够在一个类中或者在一个子类中被重载。

有以下代码片段：

String str1="hello";
String str2="he"+ new String("llo");
System.out.println(str1==str2);

请问输出的结果是：

true
都不对
null
false

考察内容：
	1）String类是final类，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法。
    2）String类底层是char数组来保存字符串的。也被final所修饰

单例模式中，两个基本要点是

构造函数私有
静态工厂方法
以上都不对
唯一实例

考察内容：
	1、单例类只能有一个实例。
	2、单例类必须自己创建自己的唯一实例。
	3、单例类必须给所有其他对象提供这一实例。

以下类型为Final类型的为（）

HashMap
StringBuffer
String
Hashtable

考察内容：
	1. string与stringbuffer都是通过字符数组实现的。
	2. 其中string的字符数组是final修饰的，所以字符数组不可以修改。
	3. stringbuffer的字符数组没有final修饰，所以字符数组可以修改。
	4. string与stringbuffer都是final修饰，只是限制他们所存储的引用地址不可修改。至于地址所指内容能不能修改，则需要看字符数组可不可以修改。

灬繁花落雨灬

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
牛客网java基础知识刷题记录-01

2022.1.27-2022.2.16假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？public class Base{ public void methodOne() { System.out.print("A"); // 3. 输出A methodTwo(); // 4. 调用的是子类重写的methodTwo方法 } public void methodTwo() {
复制链接

扫一扫