精华内容
下载资源
问答
  • 9、下列有关数据库的描述正确的是()。 A、数据库是一个DBF文件 B、数据库是一个关系 C、数据库是一个结构化的数据集合 D、数据库是一组文件 我的答案:C 10、下列说法中,不属于数据模型所描述的内容的是...
  • 只需要正确的播放地址,即可轻松播放本地和网络音频。 集成和调用API非常简单,音频功能几乎可以集成到一个语句中。 提供丰富的API方法来轻松实现各种功能。 一句话集成自定义通知栏和系统通知栏,支持通知栏自由...
  • 不同编译器给出不同的i值,有的为3,有的为4,哪个是正确的? *3.4 有这样一个巧妙的表达式:a^=b^=a^=b;它不需要临时变量就可以交换a和b的值。 3.5 可否用显式括号来强制执行我所需要的计算顺序并控制相关的副...
  • Java错题集(十三)

    2021-02-08 12:22:01
    下列关于异常处理的描述中,错误的是()。 Java的体系结构包含()。 下面有关 java 类加载器,说法正确的是?() 下列哪些操作会使线程释放锁资源? 下面有关JVM内存,说法错误的是? 以下代码将打印出 关于上面...

    目录

    以下哪个事件会导致线程销毁?()

    下面有关java基本类型的默认值和取值范围,说法错误的是?

    下列关于异常处理的描述中,错误的是()。

    Java的体系结构包含(    )。

    下面有关 java 类加载器,说法正确的是?()

    下列哪些操作会使线程释放锁资源?

    下面有关JVM内存,说法错误的是?

    以下代码将打印出

    关于上面代码片段叙述正确的是()

    假定Base b = new Derived(); 调用执行b.methodOne()后,输出结果是什么?

    关于多线程和多进程,下面描述正确的是():

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

    以下哪个不能用来处理线程安全

    若采用命令行“java Test one two three”调用,则程序输出的结果为:

    This调用语句必须是构造函数中的第一个可执行语句。

    String s = new String("xyz");创建了几个StringObject?

    将此对象序列化为文件,并在另外一个JVM中读取文件,进行反序列化,请问此时读出的Data0bject对象中的word和i的值分别为:


    以下哪个事件会导致线程销毁?()

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

    调用方法sleep()
    调用方法wait()
    start()方法的执行结束
    run()方法的执行结束

    来源:https://www.nowcoder.com/questionTerminal/e108aea70e334abc84f9001734fe3c4c

     

    下面有关java基本类型的默认值和取值范围,说法错误的是?

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

    字节型的类型默认值是0,取值范围是-2^7—2^7-1
    boolean类型默认值是false,取值范围是true\false
    字符型类型默认是0,取值范围是-2^15 —2^15-1
    long类型默认是0,取值范围是-2^63—2^63-1

    来源:https://www.nowcoder.com/questionTerminal/18f100abfe294eceb6c421d2f6501c1d

                     默认值        取值范围                  示例

    字节型 : 0                 -2^7—-2^7-1            byte b=10;

    字符型 : ‘ \u0000′      0—-2^16-1              char c=’c’ ;

    short :      0                  -2^15—-2^15-1       short s=10;

    int :          0                  -2^31—-2^31-1       int i=10;

    long :       0                  -2^63—-2^63-1       long o=10L;

    float :       0.0f              -2^31—-2^31-1       float f=10.0F

    double :   0.0d             -2^63—-2^63-1       double d=10.0;

    boolean:  false             true\false                boolean flag=true

     

    下列关于异常处理的描述中,错误的是()。

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

    程序运行时异常由Java虚拟机自动进行处理
    使用try-catch-finally语句捕获异常
    可使用throw语句抛出异常
    捕获到的异常只能在当前方法中处理,不能在其他方法中处理

    来源:https://www.nowcoder.com/questionTerminal/aa997d8ad0c54da0ae8e0f22c00f1e0d

    编译时异常必须显示处理,运行时异常交给虚拟机。

    运行时异常可以不处理。当出现这样的异常时,总是由虚拟机接管。

    比如我们从来没有人去处理过Null Pointer Exception异常,它就是运行时异常,并且这种异常还是最常见的异常之一。

    出现运行时异常后,系统会把异常一直往上层抛,一直遇到处理代码。

    如果没有处理块,到最上层,如果是多线程就由Thread.run()抛出,如果是单线程就被main()抛出。

    抛出之后,如果是线程,这个线程也就退出了。如果是主程序抛出的异常,整个程序也就退出了。

    运行时异常是Exception的子类,也有一般异常的特点,是可以被Catch块处理的。

    只不过往往不对它处理罢了。也就是说,如果不对运行时异常进行处理,那么出现运行时异常之后,要么是线程中止,要么是主程序终止。

     

    Java的体系结构包含(    )。

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

    Java编程语言
    Java类文件格式
    Java API
    JVM

    来源:https://www.nowcoder.com/questionTerminal/00f7f8eb019945e4876b724338f84f18
    Java体系结构包括四个独立但相关的技术:

    • Java程序设计语言
    • Java.class文件格式
    • Java应用编程接口(API)
    • Java虚拟机

    我们再在看一下它们四者的关系:

        当我们编写并运行一个Java程序时,就同时运用了这四种技术,用Java程序设计语言编写源代码,把它编译成Java.class文件格式,然后再在Java虚拟机中运行class文件。当程序运行的时候,它通过调用class文件实现了Java API的方法来满足程序的Java API调用

     

    下面有关 java 类加载器,说法正确的是?()

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

    引导类加载器(bootstrap class loader):它用来加载 Java 的核心库,是用原生代码来实现的
    扩展类加载器(extensions class loader):它用来加载 Java 的扩展库。
    系统类加载器(system class loader):它根据 Java 应用的类路径(CLASSPATH)来加载 Java 类
    tomcat 为每个 App 创建一个 Loader,里面保存着此 WebApp 的 ClassLoader。需要加载 WebApp 下的类时,就取出 ClassLoader 来使用

    来源:https://www.nowcoder.com/questionTerminal/99bfa10e4c1e429e98856bca6d80586e

    类的加载是由类加载器完成的,类加载器包括:根加载器( BootStrap )扩展加载器( Extension )系统加载器( System )用户自定义类加载器( java.lang.ClassLoader 的子类)

    从 Java 2 ( JDK 1.2 )开始,类加载过程采取了父亲委托机制( PDM )。 PDM 更好的保证了 Java 平台的安全性,在该机制中, JVM 自带的 Bootstrap 是根加载器,其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载,父类加载器无能为力时才由其子类加载器自行加载。 JVM 不会向 Java 程序提供对 Bootstrap 的引用。下面是关于几个类加载器的说明:

    • Bootstrap :一般用本地代码实现,负责加载 JVM 基础核心类库( rt.jar );
    • Extension :从 java.ext.dirs 系统属性所指定的目录中加载类库,它的父加载器是 Bootstrap ;
    • system class loader :又叫应用类加载器,其父类是 Extension 。它是应用最广泛的类加载器。它从环境变量 classpath 或者系统属性 java.class.path 所指定的目录中记载类,是用户自定义加载器的默认父加载器。
    • 用户自定义类加载器: java.lang.ClassLoader 的子类

      父类委托机制是可以修改的,有些服务器就是自定义类加载器优先的。

     

    下列哪些操作会使线程释放锁资源?

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

    sleep()
    wait()
    join()
    yield()

    来源:https://www.nowcoder.com/questionTerminal/3a3f308d61d0453e91ccc23bd6aff468

    1.sleep会使当前线程睡眠指定时间,不释放锁

    2.yield会使当前线程重回到可执行状态,等待cpu的调度,不释放锁

    3.wait会使当前线程回到线程池中等待,释放锁,当被其他线程使用notify,notifyAll唤醒时进入可执行状态

    4.当前线程调用 某线程.join()时会使当前线程等待某线程执行完毕再结束,底层调用了wait,释放锁

     

    下面有关JVM内存,说法错误的是?

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

    程序计数器是一个比较小的内存区域,用于指示当前线程所执行的字节码执行到了第几行,是线程隔离的
    虚拟机栈描述的是Java方法执行的内存模型,用于存储局部变量,操作数栈,动态链接,方法出口等信息,是线程隔离的
    方法区用于存储JVM加载的类信息、常量、静态变量、以及编译器编译后的代码等数据,是线程隔离的
    原则上讲,所有的对象都在堆区上分配内存,是线程之间共享的

    来源:https://www.nowcoder.com/questionTerminal/2a1cdf3e61d14947bf00dfe10e25a2c0

    大多数 JVM 将内存区域划分为 Method Area(Non-Heap)(方法区) ,Heap(堆) , Program Counter Register(程序计数器) ,   VM Stack(虚拟机栈,也有翻译成JAVA 方法栈的),Native Method Stack  ( 本地方法栈 ),其中Method Area 和  Heap 是线程共享的  ,VM Stack,Native Method Stack  和Program Counter Register  是非线程共享的。为什么分为 线程共享和非线程共享的呢?请继续往下看。

    首先我们熟悉一下一个一般性的 Java 程序的工作过程。一个 Java 源程序文件,会被编译为字节码文件(以 class 为扩展名),每个java程序都需要运行在自己的JVM上,然后告知 JVM 程序的运行入口,再被 JVM 通过字节码解释器加载运行。那么程序开始运行后,都是如何涉及到各内存区域的呢?

    概括地说来,JVM初始运行的时候都会分配好 Method Area(方法区) 和Heap(堆) ,而JVM 每遇到一个线程,就为其分配一个 Program Counter Register(程序计数器) ,   VM Stack(虚拟机栈)和Native Method Stack  (本地方法栈), 当线程终止时,三者(虚拟机栈,本地方法栈和程序计数器)所占用的内存空间也会被释放掉。这也是为什么我把内存区域分为线程共享和非线程共享的原因,非线程共享的那三个区域的生命周期与所属线程相同,而线程共享的区域与JAVA程序运行的生命周期相同,所以这也是系统垃圾回收的场所只发生在线程共享的区域(实际上对大部分虚拟机来说知发生在Heap上)的原因。

     

    以下代码将打印出

    1

    2

    3

    4

     public static void main (String[] args) { 

        String classFile = "com.jd.". replaceAll(".""/") + "MyClass.class";

        System.out.println(classFile);

    }

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

    com. jd
    com/jd/MyClass.class
    ///MyClass.class
    com.jd.MyClass

    来源:https://www.nowcoder.com/questionTerminal/53ea61fdee47423fb63a71d9dd0309f4

    由于replaceAll方法的第一个参数是一个正则表达式,而"."在正则表达式中表示任何字符,所以会把前面字符串的所有字符都替换成"/"。

    如果想替换的只是".",那么就要写成"\\.".

    如果想替换的只是“.”的话,正则表达式那里就要写成“\\.”或者是“[.]”。前者将“.”转义为“.”这个具体字符,后者则匹配“[]”中的任意字符,“.”就代表具体字符“.”。

     

    代码片段: 

    1

    2

    3

    4

    5

    byte b1=1,b2=2,b3,b6; 

    final byte b4=4,b5=6

    b6=b4+b5; 

    b3=(b1+b2); 

    System.out.println(b3+b6);

    关于上面代码片段叙述正确的是()

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

    输出结果:13
    语句:b6=b4+b5编译出错
    语句:b3=b1+b2编译出错
    运行期抛出异常

    来源:https://www.nowcoder.com/questionTerminal/344945bc01fd49b5beca0cf5f6edea78

    被final修饰的变量是常量,这里的b6=b4+b5可以看成是b6=10;在编译时就已经变为b6=10了

    b1和b2是byte类型,java中进行计算时候将他们提升为int类型,再进行计算,b1+b2计算后已经是int类型,赋值给b3,b3是byte类型,类型不匹配,编译不会通过,需要进行强制转换。

    Java中的byte,short,char进行计算时都会提升为int类型。

     

    假定Base b = new Derived(); 调用执行b.methodOne()后,输出结果是什么?

    public class Base
    {
       public void methodOne()
       {
          System.out.print("A");
          methodTwo();
       }
    
       public void methodTwo()
       {
          System.out.print("B");
       }
    }
    
    public class Derived extends Base
    {
       public void methodOne()
       {
          super.methodOne();
          System.out.print("C");
       }
    
       public void methodTwo()
       {
          super.methodTwo();
          System.out.print("D");
       }
    }

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

    ABDC
    AB
    ABCD
    ABC

    来源:https://www.nowcoder.com/questionTerminal/b2d79f37c4f444d989d47a392147d65e

    只要是被子类重写的方法,不被super调用都是调用子类方法

     

    关于多线程和多进程,下面描述正确的是():

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

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

    来源:https://www.nowcoder.com/questionTerminal/fbe0cb97dcff4df5bf849d15cbe29e64

    A.子进程得到的是除了代码段是与父进程共享以外,其他所有的都是得到父进程的一个副本,子进程的所有资源都继承父进程,得到父进程资源的副本,子进程可获得父进程的所有堆和栈的数据,但二者并不共享地址空间。两个是单独的进程,继承了以后二者就没有什么关联了,子进程单独运行;进程的线程之间共享由进程获得的资源,但线程拥有属于自己的一小部分资源,就是栈空间,保存其运行状态和局部自动变量的。

    B.线程之间共享进程获得的数据资源,所以开销小,但不利于资源的管理和保护;而进程执行开销大,但是能够很好的进行资源管理和保护。

    C.线程的通信速度更快,切换更快,因为他们共享同一进程的地址空间。

    D.一个进程可以有多个线程,线程是进程的一个实体,是CPU调度的基本单位。

     

    以下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);
    
    }

     

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

    1 1
    1.0 1.0
    1 1.0
    1.0 1

    来源:https://www.nowcoder.com/questionTerminal/701d348fec8f4c1893740e253217a65f

    三元操作符类型的转换规则:三元运算符会对两个结果的数据类型,进行自动的类型提升。
    1.若两个操作数不可转换,则不做转换,返回值为Object类型
    2.若两个操作数是明确类型的表达式(比如变量),则按照正常的二进制数字来转换,int类型转换为long类型,long类型转换为float类型等。
    3.若两个操作数中有一个是数字S,另外一个是表达式,且其类型标示为T,那么,若数字S在T的范围内,则转换为T类型;若S超出了T类型的范围,则T转换为S类型。

    4.若两个操作数都是直接量数字,则返回值类型为范围较大者

    符合4,所以选D.

     

    以下哪个不能用来处理线程安全

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

    synchronized关键字
    volatile关键字
    Lock类
    transient关键字

    来源:https://www.nowcoder.com/questionTerminal/dd1854a663654400ad8c54a49c664011

    synchrozied关键字 称作同步,主要用来给方法、代码块加锁,被加锁的代码段,同一时间内多线程同时访问同一对象的加锁方法/代码块时,只能有一个线程执行能执行方法/代码块中的代码,其余线程必须等待当前线程执行完以后才执行该方法/代码块。

    volatile关键字 1.保证了不同线程对该变量操作的内存可见性.(当一个线程修改了变量,其他使用次变量的线程可以立即知道这一修改)。2.禁止了指令重排序.

    Lock接口 提供了与synchronized关键字类似的同步功能,但需要在使用时手动获取锁和释放锁。

    transient关键字  简单地说,就是让某些被修饰的成员属性变量不被序列化。

     

    如下的Java程序 

    public class Test { 
         public static void main(String[] args) { 
         System.out.println(args[0]); 
         } 
    } 

    若采用命令行“java Test one two three”调用,则程序输出的结果为:

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

    Test
    one
    two
    java

    来源:https://www.nowcoder.com/questionTerminal/fb0b258bc80b4da0bdfea52818389c23

    采用命令行“ java Test one two three ”调用

    其中Test为调用的方法,而one two three则为Test方法里面main函数的参数;

      System.out.println(args[0]);表示输出第一个元素,故为one;

     

    This调用语句必须是构造函数中的第一个可执行语句。

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

    正确
    错误

    来源:https://www.nowcoder.com/questionTerminal/c051336317bd4a2f99eccb0913d0c965

    this()和super()为构造方法,作用是在JVM堆中构建出一个对象。

    因此避免多次创建对象,同一个方法内只能调用一次this()或super()。

    同时为了避免操作对象时对象还未构建成功,需要this()和super()的调用在第一行实现【以此来创建对象】,防止异常。

     

    String s = new String("xyz");创建了几个StringObject?

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

    两个或一个都有可能
    两个
    一个
    三个

    来源:https://www.nowcoder.com/questionTerminal/644933ebcb814fc3a99c8533b8ac6301

    String str2 = new String("aaa") ; 一共会创建两个字符串对象 一个在堆中,一个在常量池中(前提是常量池中还没有 "aaa" 字符串对象)。

     

    public class DataObject implements Serializable{
        private static int i=0;
        private String word=" ";
        public void setWord(String word){
            this.word=word;
        }
        public void setI(int i){
            Data0bject. i=I;
         }
    }

    创建一个如下方式的DataObject:

    DataObject object=new Data0bject ( );
    object. setWord("123");
    object. setI(2); 

    将此对象序列化为文件,并在另外一个JVM中读取文件,进行反序列化,请问此时读出的Data0bject对象中的word和i的值分别为:
     

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

    "", 0
    "", 2
    "123", 2
    "123", 0

    来源:https://www.nowcoder.com/questionTerminal/cbec6a41dc75420eb4f909a5fd4652bf

    序列化的是对象,不是类类变量不会被序列化

     

     

    展开全文
  • 不同编译器给出不同的i值,有的为3,有的为4,哪个是正确的? 34  *3.4 有这样一个巧妙的表达式:a^= b^= a^= b; 它不需要临时变量就可以交换a和b的值。 34 3.5 可否用显式括号来强制执行我所需要的计算顺序并...
  • 《你必须知道495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    不同编译器给出不同的i值,有的为3,有的为4,哪个是正确的? 34  *3.4 有这样一个巧妙的表达式:a^= b^= a^= b; 它不需要临时变量就可以交换a和b的值。 34 3.5 可否用显式括号来强制执行我所需要的计算顺序并...
  • java面试题-try

    2020-01-20 11:41:55
    15.下面关于try块的描述正确的一项是? A. try块后至少应有一个catch块 B. try块后必须有finally块 C. 可能抛出异常的方法应放在try块中 D. 对抛出的异常的处理应放在try块中 正确答案是:C try语句允许...

    15.下面关于try块的描述正确的一项是?

    A. try块后至少应有一个catch块

    B. try块后必须有finally块

    C. 可能抛出异常的方法应放在try块中

    D. 对抛出的异常的处理应放在try块中

     

     

     

    正确答案是:C

    try语句允许我们定义在执行时进行错误测试的代码块。

    catch 语句允许我们定义当 try 代码块发生错误时,所执行的代码块。

    finally 语句在 try 和 catch 之后无论有无异常都会执行。

    try可以和catch一起用。

    也可以单独和finally一起用。

    也可以try-catch-finally一起用。

    就是不能单独使用。

    try

    try-catch

    try-finally

    try-catch-finally

    展开全文
  • 31、关于Java的一些概念,下面哪些描述正确的:( )A 所有的Java异常和错误的基类都是java.lang.Exception, 包括java.lang.RuntimeExceptionB 通过try … catch … finally语句,finally中的语句部分无论发生什么...
    31、关于Java的一些概念,下面哪些描述是正确的:(  )

    A    所有的Java异常和错误的基类都是java.lang.Exception, 包括java.lang.RuntimeException
    B    通过try … catch … finally语句,finally中的语句部分无论发生什么异常都会得到执行
    C    java中所有的数据都是对象
    D    Java通过垃圾回收回收不再引用的变量,垃圾回收时对象的finallize方法一定会得到执行
    E    Java是跨平台的语言,无论通过哪个版本的Java编写的程序都能在所有的Java运行平台中运行
    F    Java通过synchronized进行访问的同步,synchronized作用非静态成员方法和静态成员方法上同步的目标是不同的

    B F

    A、java异常和错误的基类是Throwable,包括Exception和Error
    B、try…catch…finally finally不管什么异常都会执行
    C、java是面向对象的,但是不是所有的都是对象,基本数据类型就不是对象,所以才会有封装类的;
    D、垃圾回收器并不总是工作,只有当内存资源告急时,垃圾回收器才会工作;即使垃圾回收器工作,finalize方法也不一定得到执行,这是由于程序中的其他线程的优先级远远高于执行finalize()函数线程的优先级。
    E、JAVA跨平台性    实现在任意平台(不是任意版本)的java程序都可以在其他平台运行
    F、synchronized实现方式有多种,修饰静态方法和非静态方法是不一样的。

    32、Java1.8之后,Java接口的修饰符可以为()

    A    private
    B    protected
    C    final
    D    abstract

    D

    接口默认是 public abstract修饰

    33、哪些是 setVar方法的重载?
    public class methodover{
        public void setVar(int a, int b, float c) {

        }
    }

    A    private void setVar(int a, float c, int b){}
    B    protected void setVar(int e, int d, float f){}
    C    public int setVar(int a, float c, int b){return a;}
    D    public int setVar(int a, float c){return a;}

    A C D

    重载是在同一个类中,有多个方法名相同,参数列表不同(参数个数不同,参数类型不同),与方法的返回值无关,与权限修饰符无关。

    34、下面这三条语句输出结果是?
    System.out.println("is "100 + 5);
    System.out.println(100 + 5 +" is");
    System.out.println("is "+ (100 + 5));
    is 1005
    105 is
    is 105

    1."is"说明后面的内容都会被强制转换为string,is 100再和 5 拼接。
    2.100+5先得到105,然后与is拼接
    3.先算括号内的

    int 和 String 用 “+” 拼接,自动强制转换为string。

    35、下面叙述那个是正确的?()

    A    java中的集合类(如Vector)可以用来存储任何类型的对象,且大小可以自动调整。但需要事先知道所存储对象的类型,才能正常使用。
    B    在java中,我们可以用违例(Exception)来抛出一些并非错误的消息,但这样比直接从函数返回一个结果要更大的系统开销。
    C    java接口包含函数声明和变量声明。
    D    java中,子类不可以访问父类的私有成员和受保护的成员。

    B

    vector默认就Object类型,不需要事先知道对象类型
    接口的变量是final,准确的说叫常量,不是变量。
    子类可以访问父类受保护(protected)的成员,不能访问的是privated。

    36、Java中,以下输出是?
    byte b = 127;
    int sum = 200;
    b += 1;
    sum += b;
    System.out.println(sum);

    72

    java中byte只有1个字节,9位,所以它的范围是 -128~127

    会发生溢出, 对127加一发生溢出,  0111 1111 --> 1000 0000, 1000 0000为补码-128, 所以结果为200-128=72

    37、最后输出什么?
     public void test() {
            int a = 10;
            System.out.println(a++ + a--);
        }

    A    19
    B    20
    C    21
    D    22

    C

    a++ 先把10赋值给a 再+1 所以左边是10 但此时a=11。

    右边a -- 也是先赋值 此时右边赋值了,这里a=11,再 -1。10+11=2

    最后a的值是10。

    如果:

    int b = 1
    System.out.println(b++ + b); 
    System.out.println(b);

    输出

    3
    2

    b++ + b 左边值是 1 ,b赋值是2;右边 b是2,值也是2 ,所以是3。

    38、关于这段代码的描述:
    byte b1=1,b2=2,b3,b6;  
    final byte b4=4,b5=6;  
    b6=b4+b5;  
    b3=(b1+b2);  
    System.out.println(b3+b6);

    A    输出结果:13
    B    语句:b6=b4+b5编译出错
    C    语句:b3=b1+b2编译出错
    D    运行期抛出异常

    C

    所有的byte,short,char型的值将被提升为int型,b1+b2计算后已经是int类型,赋值给b3,b3是byte类型,类型不匹配,编译不会通过,需要进行强制转换。

    声明为final的变量会被JVM优化,第三行相当于b6=10,第6行相当于 b6 = 10

    39、关于Java中的数组,下面的一些描述,哪些描述是准确的:(    )

    A    数组是一个对象,不同类型的数组具有不同的类
    B    数组长度是可以动态调整的
    C    数组是一个连续的存储结构
    D    一个固定长度的数组可类似这样定义: int array[100]
    E    两个数组用equals方法比较时,会逐个遍历其中的元素,对每个元素进行比较
    F    可以二维数组,且可以有多维数组,都是在Java中合法的

    A C F

    数组的长度是固定的,不能动态调整。

    一个固定长度的数组 初始化 int[] array =new int[100]
    两个数组equals,比较的是是否同一个对象。

    40、表达式(short)10/10.2*2运算后结果是什么类型?

    A    short
    B    int
    C    double
    D    float

    C

    java中,你如果 没有在数字后面声明,浮点数默认为double。

    要注意是(short)10/10.2*2,而不是(short) (10/10.2 *2),前者只是把10强转为short,又由于式子中存在浮点数,所以会对结果值进行一个自动类型的提升,浮点数默认为double,所以答案是double;后者是把计算完之后值强转short。

    --end--

    de2610b13bc8e4b52512c9a7e7f39c55.png

    展开全文
  • 1.关于Java的一些概念,下面哪些描述正确的:( ) 所有的Java异常和错误的基类都是java.lang.Exception, 包括java.lang.RuntimeException 通过try … catch … finally语句,finally中的语句部分无论发生什么异常...

    1.关于Java的一些概念,下面哪些描述是正确的:( )

    所有的Java异常和错误的基类都是java.lang.Exception, 包括java.lang.RuntimeException
    通过try … catch … finally语句,finally中的语句部分无论发生什么异常都会得到执行
    java中所有的数据都是对象
    Java通过垃圾回收回收不再引用的变量,垃圾回收时对象的finallize方法一定会得到执行
    Java是跨平台的语言,无论通过哪个版本的Java编写的程序都能在所有的Java运行平台中运行
    Java通过synchronized进行访问的同步,synchronized作用非静态成员方法和静态成员方法上同步的目标是不同的
    

    解析:

    A、java异常和错误的基类Throwable,包括Exception和Error

    B、try…catch…finally finally不管什么异常都会执行

    C、java是面向对象的,但是不是所有的都是对象,基本数据类型就不是对象,所以才会有封装类的;

    D、如果是等待清理队列中如果又被调用,则不会执行finallize方法

    E、JAVA跨平台性 实现在任意平台的java程序都可以在其他平台运行

    F、synchronized实现方式:三种

    正确答案 BF

    2.在Java中,关于HashMap类的描述,以下正确的是 ()

    HashMap使用键/值得形式保存数据
    HashMap 能够保证其中元素的顺序
    HashMap允许将null用作键
    HashMap允许将null用作值
    

    解析:HashMap允许一个key为null,多个value为null,而Hashtable不允许有null值

    ​ HashMap 不按插入顺序排序,按照哈希值排序,所以无序。

    正确答案 ACD

    3.下面有关servlet service描述错误的是?

    不管是post还是get方法提交过来的连接,都会在service中处理
    doGet/doPost 则是在 javax.servlet.GenericServlet 中实现的
    service()是在javax.servlet.Servlet接口中定义的
    service判断请求类型,决定是调用doGet还是doPost方法
    

    解析:doGet/doPost 则是在 javax.servlet.http.HttpServlet 中实现的

    正确答案 B

    4.下列关于JAVA多线程的叙述正确的是()

    调用start()方法和run()都可以启动一个线程
    CyclicBarrier和CountDownLatch都可以让一组线程等待其他线程
    Callable类的call()方法可以返回值和抛出异常
    新建的线程调用start()方法就能立即进行运行状态
    

    解析:

    A. start()方法来启动线程,真正实现了多线程运行,调用了run()方法;run()方法当作普通方法的方式调用。

    B. CyclicBarrier让一组线程等待其他线程;CountDownLatch让一组线程等待某个事件发生。

    C. Callable能够抛出checked exception。

    D. start()方法让thread进去可运行状态(runnable),等待获取CPU的使用权。

    正确答案:BC

    5.下列容器中,哪些容器按 key 查找的复杂度为 O(log(n)) ()

    std::unordered_set
    std::multimap
    std::map
    std::deque
    

    解析:STL库中,map和multimap底层都是红黑树实现的,两者的不同在于multimap允许重复的可以,而map中不行。红黑树的查找复杂度为O(log(n)),unodered_map/_set底层是哈希表实现的,查找复杂度为O(1)

    正确答案:BC

    6.下面程序段的时间复杂度是()

    i = k = ``0``;`
     `while``( k < n ){``  
        ``i ++ ;
        ``k += i ;
       ``}
    
    O(n)
    O(n^1/2)
    O(n*i)
    O(n+i)
    

    解析:

    写写数字, 观察规律

    i= 1, 2, 3, 4, 5, 6, 7, 8

    k=1, 3, 6, 10, 15, 21, 28, 36

    把k的数字两个两个一起看的话, 也就是(1,3), (6,10), (15, 21), (7,8), 求和后可以发现规律(1+3=4), (6+10=16), (15+21=36), (28+36=64)

    也就是2^2, 4^2, 6^2, 8^2…偶数的平方

    循环在x^2>=n时终止, 可得x等于根号n,也就是n^(1/2)

    循环的次数是x/2, 时间复杂度为O((1/2)n^(1/2)), 一般而言时间复杂度认为常系数为1, 所以答案就是O(n^(1/2))

    正确答案:B

    7.以下代码结果是什么?

    public class foo {
    
    public static void main(String sgf[]) {
    
    StringBuffer a=new StringBuffer(“A”);
    
    StringBuffer b=new StringBuffer(“B”);
    
    operate(a,b);
    
    System.out.println(a+.+b);
    
    }
    
    static void operate(StringBuffer x,StringBuffer y) {
    
    x.append(y);
    
    y=x;
    
    }
    
    }
    
    代码可以编译运行,输出“AB.AB”。
    代码可以编译运行,输出“A.A”。
    代码可以编译运行,输出“AB.B”。
    代码可以编译运行,输出“A.B”。
    

    解析:

    引用a指向对象A

    引用b指向对象B

    引用x指向对象A

    引用y指向对象B

    在operate方法中,引用x指向的对象A被连接了B,对象A也就被改变为AB

    然后又把引用y指向了x所指向的对象地址,也就是此时引用a,x,y指向同一个对象AB

    而引用b没有发生任何变化,依旧指向对象B。

    正确答案 C

    8.实现或继承了Collection接口的是()

    Map
    List
    Vector
    Iterator
    Set
    

    解析:

    在java.util包中提供了一些集合类,常用的有List、Set和Map类,其中List类和Set类继承了Collection接口。这些集合类又称为容器,长度是可变的,数组用来存放基本数据类型的数据,集合用来存放类对象的引用。

    List接口、Set接口、Map接口以及Collection接口的主要特征如下:

    1. Collection接口是List接口和Set接口的父接口,通常情况下不被直接使用。
    2. List接口继承了Collection接口,List接口允许存放重复的对象,排序方式为按照对象的插入顺序。
    3. Set接口继承了Collection接口,Set接口不允许存放重复的对象,排序方式为按照自身内部的排序规则。
    4. Map接口以键值对(key—value)的形式存放对象,其中键(key)对象不可以重复,值(value)对象可以重复,排序方式为按照自身内部的规则。

    C:Vector实现了List接口,即间接实现Collection接口
    D:Iterator是Java迭代器最简单的实现,没有实现Collection接口

    正确答案:BCE

    9.ArrayList list = new ArrayList(20);中的list扩充几次

    0
    1
    2
    3
    

    解析:Arraylist默认数组大小是10,扩容后的大小是扩容前的1.5倍,最大值小于Integer 的最大值减8,如果新创建的集合有带初始值,默认就是传入的大小,也就不会扩容

    正确答案:A

    10.代码片段:

    byte` `b1=``1``,b2=``2``,b3,b6; 
    final` `byte` `b4=``4``,b5=``6``; 
    b6=b4+b5; 
    b3=(b1+b2); 
    System.out.println(b3+b6);
    

    关于上面代码片段叙述正确的是()

    输出结果:13
    语句:b6=b4+b5编译出错
    语句:b3=b1+b2编译出错
    运行期抛出异常
    

    解析:

    被final修饰的变量是常量,这里的b6=b4+b5可以看成是b6=10;在编译时就已经变为b6=10了

    而b1和b2是byte类型,java中进行计算时候将他们提升为int类型,再进行计算,b1+b2计算后已经是int类型,赋值给b3,b3是byte类型,类型不匹配,编译不会通过,需要进行强制转换。

    Java中的byte,short,char进行计算时都会提升为int类型。

    正确答案: C

    11.以下关于final关键字说法错误的是()

    final是java中的修饰符,可以修饰类、接口、抽象类、方法和属性
    final修饰的类肯定不能被继承
    final修饰的方法不能被重载
    final修饰的变量不允许被再次赋值
    

    解析:

    final修饰类、方法、属性!不能修饰抽象类,因为抽象类一般都是需要被继承的,final修饰后就不能继承了。

    final修饰的方法不能被重写而不是重载!

    final修饰属性,此属性就是一个常量,不能被再次赋值!

    正确答案:AC

    12.DBMS 中实现事务持久性的子系统是()

    安全性管理子系统
    完整性管理子系统
    并发控制子系统
    恢复管理子系统
    

    解析:

    原子性:事务是一组不可分割的操作单元,这组单元要么同时成功要么同时失败(由DBMS的事务管理子系统来实现);
    一致性:事务前后的数据完整性要保持一致(由DBMS的完整性子系统执行测试任务);
    隔离性:多个用户的事务之间不要相互影响,要相互隔离(由DBMS的并发控制子系统实现);
    持久性:一个事务一旦提交,那么它对数据库产生的影响就是永久的不可逆的,如果后面再回滚或者出异常,都不会影响已提交的事务(由DBMS的恢复管理子系统实现的)
    

    正确答案:D

    13.关于中间件特点的描述.不正确的是()

    中间件运行于客户机/服务器的操作系统内核中,提高内核运行效率
    中间件应支持标准的协议和接口
    中间件可运行于多种硬件和操作系统平台上
    跨越网络,硬件,操作系统平台的应用或服务可通过中间件透明交互
    

    解析:中间件是一种独立的系统软件或服务程序,分布式应用软件借助这种软件在不同的技术之间共享资源。中间件位于客户机/ 服务器的操作系统之上,管理计算机资源和网络通讯。是连接两个独立应用程序或独立系统的软件。相连接的系统,即使它们具有不同的接口,但通过中间件相互之间仍能交换信息。执行中间件的一个关键途径是信息传递。通过中间件,应用程序可以工作于多平台或OS环境。

    (简单来说,中间件并不能提高内核的效率,一般只是负责网络信息的分发处理)

    正确答案 A

    14.对文件名为Test.java的java代码描述正确的是()

    class` `Person {
      ``String name = ``"No name"``;
      ``public` `Person(String nm) {
        ``name = nm;
      ``}
    }
    class` `Employee extends Person {
      ``String empID = ``"0000"``;
      ``public` `Employee(String id) {
        ``empID = id;
      ``}
    }
    public` `class` `Test {
      ``public` `static` `void` `main(String args[]) {
        ``Employee e = ``new` `Employee(``"123"``);
        ``System.out.println(e.empID);
      ``}
    }
    
    输出:0000
    输出:123
    编译报错
    输出:No name
    

    解析:

    如果子类构造器没有显示地调用超类的构造器,则将自动地调用超类默认(没有参数)的构造器。如果超类没有不带参数的构造器,并且在子类的构造器中有没有显示地调用超类的其他构造器,则Java编译器将报告错误。使用super调用构造器的语句必须是子类构造器的第一条语句。——p153《Java核心技术卷I》

    正确答案 C

    15.给你 n 个非负整数 a1,a2,…,an,每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线,垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线,使得它们与 x 轴共同构成的容器可以容纳最多的水。

    说明:你不能倾斜容器,且 n 的值至少为 2。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n49reANb-1586267078982)(C:\Users\57237\Desktop\question_11.jpg)]

    图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下,容器能够容纳水(表示为蓝色部分)的最大值为 49。

    示例:

    输入:[1,8,6,2,5,4,8,3,7]
    输出:49

    思路一:暴力法,遍历所有可能,取最大值:

    class Solution {
    
      public int maxArea(int[] height) {int max = 0;for(int i=0;i<height.length;i++){for(int j=0;j<height.length;j++){
    
    ​        max = Math.max((i-j)*Math.min(height[i],height[j]),max);}}return max;
    
      }
    
    }
    

    思路二:双指针法:两线段之间形成的区域总是会受到其中较短那条长度的限制。此外,两线段距离越远,得到的面积就越大。

    我们在由线段长度构成的数组中使用两个指针,一个放在开始,一个置于末尾。 此外,我们会使用变量 maxareamaxarea 来持续存储到目前为止所获得的最大面积。 在每一步中,我们会找出指针所指向的两条线段形成的区域,更新 maxareamaxarea,并将指向较短线段的指针向较长线段那端移动一步。

    代码:

    public class Solution {
        public int maxArea(int[] height) {
            int maxarea = 0, l = 0, r = height.length - 1;
            while (l < r) {
                maxarea = Math.max(maxarea, Math.min(height[l], height[r]) * (r - l));
                if (height[l] < height[r])
                    l++;
                else
                    r--;
            }
            return maxarea;
        }
    }
    

    16.罗马数字包含以下七种字符: I, V, X, L,C,D 和 M。

    字符 数值
    I 1
    V 5
    X 10
    L 50
    C 100
    D 500
    M 1000
    例如, 罗马数字 2 写做 II ,即为两个并列的 1。12 写做 XII ,即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

    通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字 5 的左边,所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地,数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况:

    I 可以放在 V (5) 和 X (10) 的左边,来表示 4 和 9。
    X 可以放在 L (50) 和 C (100) 的左边,来表示 40 和 90。
    C 可以放在 D (500) 和 M (1000) 的左边,来表示 400 和 900。
    给定一个整数,将其转为罗马数字。输入确保在 1 到 3999 的范围内。

    示例 1:

    输入: 3
    输出: “III”
    示例 2:

    输入: 4
    输出: “IV”
    示例 3:

    输入: 9
    输出: “IX”
    示例 4:

    输入: 58
    输出: “LVIII”
    解释: L = 50, V = 5, III = 3.
    示例 5:

    输入: 1994
    输出: “MCMXCIV”
    解释: M = 1000, CM = 900, XC = 90, IV = 4.

    思路:贪心算法

    实现:

    public class Solution {
    
        public String intToRoman(int num) {
            // 把阿拉伯数字与罗马数字可能出现的所有情况和对应关系,放在两个数组中
            // 并且按照阿拉伯数字的大小降序排列,这是贪心选择思想
            int[] nums = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
            String[] romans = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
    
            StringBuilder stringBuilder = new StringBuilder();
            int index = 0;
            while (index < 13) {
                while (num >= nums[index]) {
                    stringBuilder.append(romans[index]);
                    num -= nums[index];
                }
                index++;
            }
            return stringBuilder.toString();
        }
    }
    

    给你一个包含 n 个整数的数组 nums,判断 nums 中是否存在三个元素 a,b,c ,使得 a + b + c = 0 ?请你找出所有满足条件且不重复的三元组。

    注意:答案中不可以包含重复的三元组。

    示例:

    给定数组 nums = [-1, 0, 1, 2, -1, -4],

    满足要求的三元组集合为:
    [
    [-1, 0, 1],
    [-1, -1, 2]
    ]

    思路:双指针+排序

    class Solution {
        public List<List<Integer>> threeSum(int[] nums) {
     List<List<Integer>> ans = new ArrayList();
            int len = nums.length;
            if(nums == null || len < 3) return ans;
            Arrays.sort(nums); // 排序
            for (int i = 0; i < len ; i++) {
                if(nums[i] > 0) break; // 如果当前数字大于0,则三数之和一定大于0,所以结束循环
                if(i > 0 && nums[i] == nums[i-1]) continue; // 去重
                int L = i+1;
                int R = len-1;
                while(L < R){
                    int sum = nums[i] + nums[L] + nums[R];
                    if(sum == 0){
                        ans.add(Arrays.asList(nums[i],nums[L],nums[R]));
                        while (L<R && nums[L] == nums[L+1]) L++; // 去重
                        while (L<R && nums[R] == nums[R-1]) R--; // 去重
                        L++;
                        R--;
                    }
                    else if (sum < 0) L++;
                    else if (sum > 0) R--;
                }
            }        
            return ans;
        }
    }
    
    展开全文
  • 对象声明描述的是存 储在对象中的信息以及可对对象执行的操作(类方法)。对象的某些组成部分对于外界来说是可见的(公有部 分),而某些部分却是隐藏的(私有部分)。特殊的类方法(构造函数和析构函数)在对象创建和释放...
  • 对象声明描述的是存 储在对象中的信息以及可对对象执行的操作(类方法)。对象的某些组成部分对于外界来说是可见的(公有部 分),而某些部分却是隐藏的(私有部分)。特殊的类方法(构造函数和析构函数)在对象创建和释放...
  • 对象声明描述的是存 储在对象中的信息以及可对对象执行的操作(类方法)。对象的某些组成部分对于外界来说是可见的(公有部 分),而某些部分却是隐藏的(私有部分)。特殊的类方法(构造函数和析构函数)在对象创建和释放...
  • //下面是一个简单函数实现示例 Matrix sin(const Matrix &A){ switch(A.getDataType()){ case DOUBLE_MATRIX: Matrix B(DOUBLE_MATRIX,A.getNumDims(),A.getSizeDims(),NULL); for(int ii=0;ii<*(double *)...
  • 有关类的描述正确的是:(选择1项) A) 程序在编译时将出错。在Test中的day为私有变量,所以类外无法访问。 B) 程序能通过编译,但是不能正常运行。 C) 程序能通过编译,运行时将打印出0/0,因为在Java中int型变量...
  • 2020-11-22

    2020-11-22 23:51:28
    1.在 Java 语言中,用来编译 Java 源程序的是【 javac.exe 】 2. 在 Java 语言中用来定义常量的关键字是【 Final】 3.try{ }catch(______e){}中,横线处需要填写的是异常类】 ...下面关于调用构造
  • 你必须知道495个C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    3, 有的为4, 哪个是正确的? . . . . . . . . . . . . . . . . . . . . . 14 3.4 这是个巧妙的表达式: a ˆ= b ˆ= a ˆ= b 它不需要临时变量就可 以交换a 和b 的值。. . . . . . . . . . . . . . . . . . . . . . ....
  • 18、关于“解决方案验证”说法正确的是:解决方案验证可以降低风险,避免在大规模投资后才发现解决方案的基础构架部分并不能在生产中很好地运行 / MSF解决方案验证并不完全等同于原型,或单纯的技术验证。...
  • 员工操作页面与主页面3个公共部分相同,不同之处在于中间部分展示的是员工信息的表格显示,而主页面是一个轮播图。 下面就将实现employeePage的页面,详细代码见employeePage.jsp(即将main.jsp中的轮播部分换成...
  • 测试培训教材

    2014-04-01 12:10:48
    本测试集包含用于测试Mercury Tours网站功能正确测试用例。 设置测试集属性中详细信息: In ITG Request Id, add the IT Governance request ID. Note that this is relevant only when integrating ...
  • C#数据结构

    2013-12-10 11:49:54
    输出处理的明确而无歧义的描述。 2、可读性(Readability)。算法主要是为了人阅读和交流,其次才是机器的执行。 所以,一个算法应当思路清晰、层次分明、简单明了、易读易懂。即使算法已转 变成机器可执行的程序,也...
  • 14.6 异常的描述 334 14.6.1 对异常描述的检查 335 14.6.2 未预期的异常 336 14.6.3 异常的映射 336 14.7 未捕捉的异常 338 14.8 异常和效率 339 14.9 处理错误的其他方式 340 14.10 标准异常 342 14.11 ...
  • 14.6 异常的描述 334 14.6.1 对异常描述的检查 335 14.6.2 未预期的异常 336 14.6.3 异常的映射 336 14.7 未捕捉的异常 338 14.8 异常和效率 339 14.9 处理错误的其他方式 340 14.10 标准异常 342 14.11 ...
  • C++程序设计语言(特别版)--源代码

    热门讨论 2012-04-23 07:33:51
    14.6 异常的描述 334 14.6.1 对异常描述的检查 335 14.6.2 未预期的异常 336 14.6.3 异常的映射 336 14.7 未捕捉的异常 338 14.8 异常和效率 339 14.9 处理错误的其他方式 340 14.10 标准异常 342 14.11 ...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    14.4 继承中关于属性一些问题.169 14.5 小 结 .172 第四部分 深入了解 C#.174 第十五章 接 口 .174 15.1 组件编程技术 .174 15.2 接 口 定 义 .177 15.3 接口成员 .178 15.4 接口实现 .182 ...
  • 事务处理原理 第2版

    热门讨论 2012-12-30 10:49:38
     我们关注的是事务处理的工作原理,而不是如何构建事务处理应用程序。我们通过很多产品的范例来演示说明如何应用这些原理以及这些想法是在什么情况下产生的,但不可能详细地叙述每一种产品。本书介绍实用的且在产品...
  • java 面试题 总结

    2009-09-16 08:45:34
    如果该值为false,说明程序已经处于不正确的状态下,系统将给出警告或退出。一般来说,assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能,在软件发布后,assertion...
  • C#微软培训资料

    2014-01-22 14:10:17
    14.4 继承中关于属性一些问题.169 14.5 小 结 .172 第四部分 深入了解 C#.174 第十五章 接 口 .174 15.1 组件编程技术 .174 15.2 接 口 定 义 .177 15.3 接口成员 .178 15.4 接口实现 .182 ...

空空如也

空空如也

1 2 3
收藏数 54
精华内容 21
关键字:

下面关于异常的描述正确的是