Java错题集(一)

最新推荐文章于 2023-07-04 15:38:13 发布

皮皮杨233

最新推荐文章于 2023-07-04 15:38:13 发布

阅读量821

点赞数

分类专栏：牛客网错题集文章标签：错题集牛客笔记

本文链接：https://blog.csdn.net/qq_45839708/article/details/109890695

版权

牛客网错题集专栏收录该内容

18 篇文章 3 订阅

订阅专栏

java用（）机制实现了线程程之间的同步执行

下列哪种异常是检查型异常，需要在编写程序时声明？

下列外部类定义中，不正确的是：（）

下列不属于算法结构的是（）

以下关于java封装的描述中，正确的是：

what is the result of the following code?

关于下面一段代码，以下说法正确的是： ()

java用（）机制实现了线程程之间的同步执行

正确答案: A 你的答案: D (错误)

监视器

虚拟机

多个CPU

异步调用

链接：https://www.nowcoder.com/questionTerminal/8312c75bc0b04f5a88511da1cc70972d

The code segments within a program that access the same object from separate, concurrent threads are called “critical sections”。
翻译：在一个程序当中代码段访问了同一个对象从单独的并发的线程当中，那么这个代码段叫”临界区”
怎么解决呢：使用同步的机制对临界区进行保护

同步的两种方式：同步块和同步方法
对于同步来说都是使用synchronized方法
每一个对象都有一个监视器，或者叫做锁。
package ticket; 
class Tickets { 
    public static void main(String[] args){
        sellTickets st = new sellTickets(); //四个线程同时卖这100张票，注意是同一个对象创建四个线程，他们共享同一个变量ticket 
        new Thread(st).start(); 
        new Thread(st).start(); 
        new Thread(st).start(); 
        new Thread(st).start();
    }
} 

class sellTickets implements Runnable { int ticket = 100;
    Object o = new Object();
    @Override public void run()  { 
        while(true) { //每一个对象都有一个监视器，或者叫做锁。同步块示例 
            synchronized (o) { 
                if(ticket > 0){ //存在的隐藏的问题当ticket=1，它的时间片到期了进入到if语句中，第二个线程进入到if语句然后时间片到期 
                    try { //线程睡眠,该方法需要写异常 
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();                   
                    } //第几个线程卖出了第多少张票 System.out.println(Thread.currentThread().getName() + "sell tickets" + ticket);
                    ticket--;
                }
            }
        }
    }
}

下列哪种异常是检查型异常，需要在编写程序时声明？

正确答案: C 你的答案: C (正确)

NullPointerException

ClassCastException

FileNotFoundException

IndexOutOfBoundsException

链接：https://www.nowcoder.com/questionTerminal/a4a96e226c7b4dafae8250db4ff88af5

1. 粉红色的是受检查的异常(checked exceptions),其必须被 try{}catch语句块所捕获,或者在方法签名里通过throws子句声明.受检查的异常必须在编译时被捕捉处理,命名为 Checked Exception 是因为Java编译器要进行检查,Java虚拟机也要进行检查,以确保这个规则得到遵守.

2. 蓝色的异常是运行时异常(runtime exceptions),需要程序员自己分析代码决定是否捕获和处理,比如空指针,被0除...

3. 而声明为Error的，则属于严重错误，如系统崩溃、虚拟机错误、动态链接失败等，这些错误无法恢复或者不可能捕捉，将导致应用程序中断，Error不需要捕捉。

下列外部类定义中，不正确的是：（）

正确答案: C 你的答案: C (正确)

class x { .... }

class x extends y { .... }

static class x implements y1,y2 { .... }

public class x extends Applet { .... }

链接：https://www.nowcoder.com/questionTerminal/0d80b3d86aa84ab19694cbb446c80d35

static修饰的为类成员,会随着类的加载而加载,比如静态代码块,静态成员,静态方法(这里只是加载,并没有调用)等等。

假如把一个Class文件中的外部类设为static,目的难道是让这个类随着应用的启动而加载吗？如果在这次使用过程中根本没有使用过这个类,那么是不是就会浪费内存。这样来说设计不合理,总而言之,设计不合理的地方,Java是不会让它存在的。
而为什么内部类可以使用static修饰呢,因为内部类算是类的成员了,如果没有使用静态来修饰,那么在创建内部类的时候就需要先有一个外部类的对象,如果我们一直在使用内部类,那么内存中就会一直存在外部类的引用,而我们有时候只需要使用内部类,不需要外部类,那么还是会浪费内存,甚至会造成内存溢出。使用static修饰内部类之后,内部类在创建对象时就不需要有外部类对象的引用了。

最终结论就是:static可以用来修饰内部类,但是不可以用来修饰外部类

static class 是java内部类的一种，不能声明为外部类

下列不属于算法结构的是（）

正确答案: C 你的答案: C (正确)

输入数据

处理数据

存储数据

输出结果

链接：https://www.nowcoder.com/questionTerminal/fb1dc6d92af2417290dc15c6105ed91c

下面摘录百科关于算法的说明

特征

一个算法应该具有以下五个重要的特征：

有穷性

（Finiteness）

算法的有穷性是指算法必须能在执行有限个步骤之后终止；

确切性

(Definiteness)

算法的每一步骤必须有确切的定义；

输入项

(Input)

一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件；

输出项

(Output)

一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的；

可行性

(Effectiveness)

算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步，即每个计算步都可以在有限时间内完成（也称之为有效性）。

以下关于java封装的描述中，正确的是：

正确答案: A 你的答案: A (正确)

封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性

封装的意义不大，因此在编码中尽量不要使用

如果子类继承父类，对于父类中进行封装的方法，子类仍然可以直接调用

只能对一个类中的方法进行封装，不能对属性进行封装

链接：https://www.nowcoder.com/questionTerminal/a1271839a54d42b19a55d16354ab0650

封装主要是隐藏内部代码；

继承主要是复用现有代码；

多态主要是改写对象行为。

关于封装：

封住、继承、多态是面向对象的三大特征，其重要性与使用频率不言而喻。------所以B错误。

1 、什么是封装？

封装就是将属性私有化，提供公有的方法访问私有属性。------------------- 所以CD错误。

做法就是：修改属性的可见性来限制对属性的访问，并为每个属性创建一对取值（ getter ）方法和赋值（ setter ）方法，用于对这些属性的访问。

如： private String name;

public String getName(){

                    return;

           }

        public void setName(String name){

                    this.name=name;

           }

2、     为什么需要封装？

通过封装，可以实现对属性的数据访问限制，同时增加了程序的可维护性。

由于取值方法和赋值方法隐了实现的变更，因此并不会影响读取或修改该属性的类，避免了大规模的修改，程序的可维护性增强

what is the result of the following code?

enum AccountType
{
SAVING, FIXED, CURRENT;
private AccountType()
{
System.out.println(“It is a account type”);
}
}
class EnumOne
{
public static void main(String[]args)
{
System.out.println(AccountType.FIXED);
}
}

正确答案: C 你的答案: E (错误)

Compiles fine and output is prints”It is a account type”once followed by”FIXED”

Compiles fine and output is prints”It is a account type”twice followed by”FIXED”

Compiles fine and output is prints”It is a account type”thrice followed by”FIXED”

Compiles fine and output is prints”It is a account type”four times followed by”FIXED”

Compilation fails

链接：https://www.nowcoder.com/questionTerminal/1aac0e529bdf442c9034ee00f9aa0689

枚举类所有的枚举值都是类静态常量，在初始化时会对所有的枚举值对象进行第一次初始化。

枚举类在后台实现时，实际上是转化为一个继承了java.lang.Enum类的实体类，原先的枚举类型变成对应的实体类型，上例中AccountType变成了个class AccountType，并且会生成一个新的构造函数，若原来有构造函数，则在此基础上添加两个参数，生成新的构造函数，如上例子中：

复制代码

1

private AccountType(){ System.out.println(“It is a account type”); }

会变成：

复制代码

1

2

private AccountType(String s, int i){

    super(s,i); System.out.println(“It is a account type”); }

而在这个类中，会添加若干字段来代表具体的枚举类型：

复制代码

1

2

3

public static final AccountType SAVING;

public static final AccountType FIXED;

public static final AccountType CURRENT;

而且还会添加一段static代码段：

复制代码

1

2

3

4

5

6

static{

    SAVING = new AccountType("SAVING", 0);

    ... CURRENT = new AccountType("CURRENT", 0);

   $VALUES = new AccountType[]{

         SAVING, FIXED, CURRENT

    } }

以此来初始化枚举中的每个具体类型。（并将所有具体类型放到一个$VALUE数组中，以便用序号访问具体类型）

在初始化过程中new AccountType构造函数被调用了三次，所以Enum中定义的构造函数中的打印代码被执行了3遍。

关于下面一段代码，以下说法正确的是： ()

public class Test {
private synchronized void a() {
}
private void b() {
synchronized (this) {
}
}
private synchronized static void c() {
}
private void d() {
synchronized (Test.class) {
}
}
}

正确答案: A C D 你的答案: C D (错误)

同一个对象，分别调用方法a和b，锁住的是同一个对象

同一个对象，分别调用方法a和c，锁住的是同一个对象

同一个对象，分别调用方法b和c，锁住的不是同一个对象

同一个对象，分别调用方法a、b、c，锁住的不是同一个对象

链接：https://www.nowcoder.com/questionTerminal/718f28312bf34cbdb00bc80ee42b83e4

修饰非静态方法锁的是this 对象

修饰静态方法锁的是class对象

皮皮杨233

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
Java错题集(一)

目录java用（）机制实现了线程程之间的同步执行java用（）机制实现了线程程之间的同步执行正确答案: A 你的答案: D(错误)监视器虚拟机多个CPU异步调用链接：https://www.nowcoder.com/questionTerminal/8312c75bc0b04f5a88511da1cc70972dThe code segments within a program that access the same object from s...
复制链接

扫一扫