精华内容
下载资源
问答
  • 复盘

    2019-08-26 16:12:52
    3、在JAVA中, 下列标识符合法的是() A. 3kyou B. @163 C. name D. while @在java里属于操作符 用于注释 以为name是java里的自带的 7、计算机所能处理的最小的数据项称为() A. 位 B. 字节 C. 字 D. ...

    3、在JAVA中, 下列标识符合法的是()
    A. 3kyou
    B. @163
    C. name
    D. while
    @在java里属于操作符 用于注释
    以为name是java里的自带的


    7、计算机所能处理的最小的数据项称为()
    A. 位
    B. 字节
    C. 字
    D. 双字
    记得混乱 基础知识 字节才是 8位=1字节


    8、创建一个标识有“关闭”标签的语句是 ( ) 。
    A. TextField b = new TextField(“关闭”);
    B. Label b = new Label(“关闭”);
    C. Checkbox b = new Checkbox(“关闭”);
    D. Button b = new Button(“关闭”);
    JLabel是标签组件
    JCheckBox是复选框组件
    JButton是按钮组件
    TextField是输入框组件


    9、下面不属于Object类中方法的是:
    A. hashCode()
    B. finally()
    C. wait()
    D. toString()
    没记过。。。
    Object所有方法

    1. getClass()
    2. hashCode()
    3. equals()
    4. toString()
    5. clone()
    6. wait()…
    7. notify()
    8. notifyAll()
    9. finalize()

    10、下列命令中,用来运行 Java 程序的是()
    A. java
    B. javadoc
    C. jar
    D. javac
    A.java用来运行一个.class文件
    B.javadoc用来生成api文档
    C.jar用来生成jar包
    D.javac用来把.java文件编译为.class文件


    11、以下代码执行的结果显示是多少( )?
    public class Demo { class Super{ int flag=1;
    Super(){
    test();
    } void test(){
    System.out.println(“Super.test() flag=”+flag);
    }
    } class Sub extends Super{
    Sub(int i){ flag=i;
    System.out.println(“Sub.Sub()flag=”+flag);
    } void test(){
    System.out.println(“Sub.test()flag=”+flag);
    }
    } public static void main(String[] args) { new Demo().new Sub(5);
    }
    }

    A. Sub.test() flag=1
    Sub.Sub() flag=5
    B. Sub.Sub() flag=5
    Sub.test() flag=5
    C. Sub.test() flag=0
    Sub.Sub() flag=5
    D. Super.test() flag=1
    Sub.Sub() flag=5
    1.首先调用父类构造方法,即super()
    2.调用test()方法。
    3.由于在子类sub()中重写了test()方法,所以调用子类test()
    4.输出Sub.test() flag=1
    5.调用sub的有参构造方法
    6.输出Sub.Sub() flag=5
    先调用父类 当时记成先子类再父类了


    14、假定x和y为double型,则表达式x=2,y=x+3/2的值是()
    A. 3.500000
    B. 3
    C. 2.00000
    D. 3.00000
    double类型会自动加小数点 以为两个没小数点相加也会没小数点


    16.在Java中,HashMap中是用哪些方法来解决哈希冲突的?
    A. 开放地址法
    B. 二次哈希法
    C. 链地址法
    D. 建立一个公共溢出区
    还没学
    解决方法一般两种:开放定址法和链地址法


    20、在使用super 和this关键字时,以下描述正确的是
    A. 在子类构造方法中使用super()显示调用父类的构造方法,super()必须写在子类构造方法的第一行,否则编译不通过
    B. super()和this()不一定要放在构造方法内第一行
    C. this()和super()可以同时出现在一个构造函数中
    D. this()和super()可以在static环境中使用,包括static方法和static语句块
    this()和super()都是要放在构造函数第一行 并且不能出现在同一个构造函数里
    static可以不用依靠对象 而this和super都是指向对象的所以不能在static环境里使用


    25、假设num已经被创建为一个ArrayList对象,并且最初包含以下整数值:[0,0,4,2,5,0,3,0]。 执行下面的方法numQuest(),最终的输出结果是什么?
    private List nums;
    //precondition: nums.size() > 0
    //nums contains Integer objects
    public void numQuest() {
    int k = 0;
    Integer zero = new Integer(0);
    while (k < nums.size()) {
    if (nums.get(k).equals(zero))
    nums.remove(k);
    k++;
    }
    }
    A. [3, 5, 2, 4, 0, 0, 0, 0]
    B. [0, 0, 0, 0, 4, 2, 5, 3]
    C. [0, 0, 4, 2, 5, 0, 3, 0]
    D. [0, 4, 2, 5, 3]
    这个纯属代码没理解
    第一次循环:k=0 nums[0,0,4,2,5,0,3,0],size=8 nums的第一位为0被移除,此时的k++
    第二次循环:k=1 nums[0,4,2,5,0,3,0] size=7 nums的第一位是0,但是现在K=1不是K=0? ,所以是和4比较不成立。下面同理啦
    第三次循环:k=2 nums[0,4,2,5,0,3,0] size=7 2!=0
    第四次循环:k=3 nums[0,4,2,5,0,3,0] size=7 5!=0
    第五次循环:k=4 nums[0,4,2,5,0,3,0] size=7 0=0
    第六次循环:k=5 nums[0,4,2,5,3,0] size=6 0=0
    第七次循环:k=6 nums[0,4,2,5,3] size=5 k>size 结束循环


    顺序执行下列程序语句后,则b的值是()
    String a=“Hello”;
    String b=a.substring(0,2);
    A. Hello
    B. Hel
    C. He
    D. null
    这个函数是左包右不包?
    substring(a, b)
    从下标为a的字符开始截取(下标从0开始), 截取b-a个


    JAVA语言的下面几种数组复制方法中,哪个效率最高?
    A. for循环逐一复制
    B. System.arraycopy
    C. Arrays.copyOf
    D. 使用clone方法
    这个效率真的没在意过 知识盲区
    A、for循环的话,很灵活,但是代码不够简洁.
    B、System.arraycopy()源码。可以看到是native方法:native关键字说明其修饰的方法是一个原生态方法,方法对应的实现不是在当前文件,而是在用其他语言(如C和C++)实现的文件中。 可以将native方法比作Java程序同C程序的接口。
    C、选项有误,copyOf不是System的方法,而是Arrays的方法,下面是源码,可以看到本质上是调用的arraycopy方法。,那么其效率必然是比不上 arraycopy的
    D。clone的话,返回的是Object【】,需要强制转换。 一般用clone效率是最差的,


    29、(多选)下面哪几个语句正确的声明一个整型的二维数组()
    A. int a[][]=new int[][]
    B. int b[10][10]=new int[][]
    C. int c[][]=new int[10][10]
    D. int []d[]=new int[10][10]
    D这个妖娆的样子真没想到是对的


    30、以下哪个方法用于定义线程的执行体? ()
    A. start()
    B. join()
    C. run()
    D. synchronized()
    start是将线程纳入线程调度,run是才是执行线程体


    下列选项中符合Java命名规则的标识符是()
    A. 2japro
    B. &Class
    C. const
    D. 123_
    const关键字
    &是里面有功能的标识符


    非抽象类实现接口后,必须实现接口中的所有抽象方法,除了abstract外,方法头必须完全一致.
    A. 正确
    B. 错误

    两同两小一大原则:
    方法名相同,参数类型相同
    子类返回类型小于等于父类方法返回类型,
    子类抛出异常小于等于父类方法抛出异常,
    子类访问权限大于等于父类方法访问权限。


    37、下列关于java并发的说法中正确的是:
    A. copyonwritearraylist适用于写多读少的并发场景
    B. readwritelock适用于读多写少的并发场景
    C. concurrenthashmap的写操作不需要加锁,读操作需要加锁
    D. 只要在定义int类型的成员变量i的时候加上volatile关键字,那么多线程并发执行i++这样的操作的时候就是线程安全的了
    对线程了解不深
    A:CopyOnWrite适用于读多写少的并发场景。
    B:正确
    C:ConcurrentHashMap,读操作不需要加锁,写操作需要加锁
    D:对于volatile修饰的变量,jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的


    38、以下代码段执行后的输出结果为
    public class Test {
    public static void main(String[] args) {
    System.out.println(test());

    }
    private static int test() {
    int temp = 1;
    try {
    System.out.println(temp);
    return ++temp;
    } catch (Exception e) {
    System.out.println(temp);
    return ++temp;
    } finally {
    ++temp;
    System.out.println(temp);
    }
    }
    }

    A. 1,2,2
    B. 1,2,3
    C. 1,3,3
    D. 1,3,2
    现在才知道try—catch里面的return是这样用的
    执行顺序为:
    输出try里面的初始temp:1;
    temp=2;
    保存return里面temp的值:2;
    执行finally的语句temp:3,输出temp:3;
    返回try中的return语句,返回存在里面的temp的值:2;
    输出temp:2。


    39、关于Java语言描述正确的是? ( )
    A. java和C++都保留了指针
    B. java和C++都有三个特征:封装、继承和多态
    C. java的垃圾回收机制是指程序结束时系统自动回收内存
    D. 以上说法都不正确
    现在才知道c++也有三特性
    java丢弃了指针。
    java的立即回收不是程序结束后回收垃圾,在程序过程中就会,如对象呗赋值NULL,该对象就成为可回收对象。


    46、下列说法正确的是
    A. java中包的主要作用是实现跨平台功能
    B. package语句只能放在import语句后面
    C. 包(package)由一组类(class)和接口(interface)组成
    D. 可以用#include关键词来标明来自其它包中的类
    package用绝对路径也可以使用
    A: java中"包"的引入的主要原因是java本身跨平台特性的需求。实现跨平台的是JVM。
    B: package语句是Java源文件的第一条语句。(若缺省该语句,则指定为无名包。),如果想在另一个类里面引用包里面的类,要把名字写全。(相当用文件的绝对路径访问)或者用import导入。
    D:java中并无#include关键字, 如果想在另一个类里面引用包里面的类,要把名字写全。(相当用文件的绝对路径访问)或者用import导入。


    47、给定以下JAVA代码,这段代码运行后输出的结果是()
    public class Test
    {
    public static int aMethod(int i)throws Exception
    {
    try{
    return i / 10;
    }
    catch (Exception ex)
    {
    throw new Exception(“exception in a Method”);
    } finally{
    System.out.printf(“finally”);
    }
    }

    public static void main(String [] args)
    {
        try
        {
            aMethod(0);
        }
        catch (Exception ex)
        {
            System.out.printf("exception in main");
        }
        System.out.printf("finished");
    }
    

    }
    A. exception in main finished
    B. finally finished
    C. exception in main finally
    D. finally exception in main finished

    在try中执行到return语句时,不会真正的return,即只是会计算return中的表达式(本题为执行a+b),之后将结果保存在一个临时栈中,接着执行finally中的语句,最后才会从临时栈中取出之前的结果返回。


    48、以下多线程对int型变量x的操作,哪个不需要进行同步()
    A. ++x
    B. x=y
    C. x++
    D. x=1
    直接赋值就是原子操作
    前三个都至少需要先读取,再操作,非原子操作


    57、下列java程序的输出结果为____。
    public class Example{
    String str=new String(“hello”);
    char[]ch={‘a’,‘b’};
    public static void main(String args[]){
    Example ex=new Example();
    ex.change(ex.str,ex.ch);
    System.out.print(ex.str+" and ");
    System.out.print(ex.ch);
    }
    public void change(String str,char ch[]){
    str=“test ok”;
    ch[0]=‘c’;
    }
    }
    A. hello and ab
    B. hello and cb
    C. hello and a
    D. test ok and ab
    E. test ok and cb
    F. test ok and c
    这个并没有改变对象的属性 只是在方法里改了相当于改了一个复制的值


    java8中,下面哪个类用到了解决哈希冲突的开放定址法
    A. LinkedHashSet
    B. HashMap
    C. ThreadLocal
    D. TreeMap
    知识盲区
    ThreadLocalMap中使用开放地址法来处理散列冲突,而HashMap中使用的是分离链表法。之所以采用不同的方式主要是因为:在ThreadLocalMap中的散列值分散得十分均匀,很少会出现冲突。并且ThreadLocalMap经常需要清除无用的对象,使用纯数组更加方便。


    61、下面代码的输出是什么?
    public class Base
    {
    private String baseName = “base”;
    public Base()
    {
    callName();
    }
    public void callName()
    {
    System. out. println(baseName);
    }
    static class Sub extends Base
    {
    private String baseName = “sub”;
    public void callName()
    {
    System. out. println (baseName) ;
    }
    }
    public static void main(String[] args)
    {
    Base b = new Sub();
    }
    }

    A. null
    B. sub
    C. base
    主要就是先执行的父类 当时还没初始化name;
    Base b = new Sub();先初始化父类,顺序如上面的1,2,3,进入callName方法时子类的属性还没有初始化执行代码,所以打印的是null.


    62、在J2EE中,使用Servlet过滤器,需要在web.xml中配置()元素
    A.
    B.
    C.
    D.
    这个。。。。还没看过


    71、从以下哪一个选项中可以获得Servlet的初始化参数?
    A. Servlet
    B. ServletContext
    C. ServletConfig
    D. GenericServlet
    同上 什么过滤器


    72、如果int x=20, y=5,则语句System.out.println(x+y +""+(x+y)+y); 的输出结果是()
    A. 2530
    B. 55
    C. 2052055
    D. 25255
    括号也会被当作字符处理
    因为x和y是int型的,所以x+y就=20+5=25
    x+y +""+(x+y)+y
    就等价于25+“”+(25)+5
    “”是空字符,不是空格。
    因为中间加了个空字符,所以25,25和5就不能再算加法了,要当成字符串拼接


    73、对于下面这段代码,以下说法正确的是:
    public class Test
    {
    public int x;
    public static void main(String []args)
    {
    System. out. println(“Value is” + x);
    }
    }
    A. 程序会打出 “Value is 0”
    B. 程序会抛出 NullPointerException
    C. 非静态变量不能够被静态方法引用
    D. 编译器会抛出 "possible reference before assignment"的错误
    非静态不能被静态方法引用


    74、下列有关Servlet的生命周期,说法不正确的是?
    A. 在创建自己的Servlet时候,应该在初始化方法init()方法中创建Servlet实例
    B. 在Servlet生命周期的服务阶段,执行service()方法,根据用户请求的方法,执行相应的doGet()或是doPost()方法
    C. 在销毁阶段,执行destroy()方法后会释放Servlet 占用的资源
    D. destroy()方法仅执行一次,即在服务器停止且卸载Servlet时执行该方法
    过滤器的直接先跳了 看也看不懂


    75、java8中,下面哪个类用到了解决哈希冲突的开放定址法
    A. LinkedHashSet
    B. HashMap
    C. ThreadLocal
    D. TreeMap
    目前看不懂讲的什么
    ThreadLocalMap中使用开放地址法来处理散列冲突,而HashMap中使用的是分离链表法。之所以采用不同的方式主要是因为:在ThreadLocalMap中的散列值分散得十分均匀,很少会出现冲突。并且ThreadLocalMap经常需要清除无用的对象,使用纯数组更加方便。


    sceond part

    1. 通过HttpServletRequest. getParameter获取的参数.
      A. 总是采用UTF-8编码
      B. 总是采用lS08859-1编码
      C. 由客户端浏览器和Web容器配置共同决定编码
      D. 由服务器所在的操作系统决定编码

    乱码问题之所以一直存在,就是由于编码的灵活性,也就是说,编码与其他工作是解耦的。此外,Web 的编码问题与服务器所在的操作系统无关,Web 容器诸如Tomcat可以配置默认编码方式,例如,Tomcat 的默认编码方式是 iso8859-1。乱码的解决之道就是直接或间接的使客户端与Web 容器编码方式兼容。


    1. 在类设计中,类的成员变量要求仅仅能够被同一package下的类访问,请问应该使用下列哪个修饰词
      A. protected
      B. public
      C. private
      D. 不需要任何修饰词
      protected和默认的弄混了
      protected无论哪个包的子类都可以使用
      默认的只有同一个包的子类才能使用

    1. 下列哪种异常是检查型异常,需要在编写程序时声明?
      A. NullPointerException
      B. ClassCastException
      C. FileNotFoundException
      D. IndexOutOfBoundsException
      A:空指针异常
      B:类转换异常
      C:文件找不到异常
      D :索引超出异常
      A\B\D是运行异常,C检查型异常

    1. 根据以下代码段,执行new Child(“John”, 10); 要使数据域data得到10,则子类空白处应该填写
    2. class Parent {
    3.  private int data;   
      
    4.  public Parent(int d){ data = d; }  
      
    5. }
    6. class Child extends Parent{
    7. String name;   
      
    8. public Child(String s, int d){  
      
    9.     ___________________  
      
    10.     name = s;  
      
    11. }  
      
    12. }
      A. data = d;
      B. super.data = d;
      C. Parent(d);
      D. super(d);
      子类构造方法会的第一行会默认加上一句隐式super(),也就是访问父类的无参构造器,即使不写,编译器也会默认为我们加上。而如果我们想要访问父类有参构造器,必须手动加上,一旦加上super(参数),那么就不会有隐式的super()。

    1. 关于Java中参数传递的说法,哪个是错误的?
      A. 在方法中,修改一个基础类型的参数不会影响原始参数值
      B. 在方法中,改变一个对象参数的引用不会影响到原始引用
      C. 在方法中,修改一个对象的属性会影响原始对象参数
      D. 在方法中,修改集合和Maps的元素不会影响原始集合参数
      在Java里,只有值传递,因为引用本身就是一个地址值,我们说的”传递引用“本质上也是“值传递”,只不过传递的是地址值。
      在方法中,改变一个对象参数的引用不会影响到原始引用。这是很自然的。
      举个例子,假设在函数外有 A a = new A();那么引用a指向堆中的一个对象A()。
      假设有一个函数:
      void f(A a) {
      a = new A();
      }
      显然,这里a指向了堆中的另一个对象A(),而在函数外的那个引用a依然没有改变,指向原来的对象A()。

    1. What will happen when you attempt to compile and run the following code?
    2. public class Test{
    3. static{
    4. int x=5;
    5. }
    6. static int x,y;
    7. public static void main(String args[]){
    8. x–;
    9. myMethod( );
    10. System.out.println(x+y+ ++x);
    11. }
    12. public static void myMethod( ){
    13. y=x++ + ++x;
    14. }
    15. }
      A. compiletime error
      B. prints:1
      C. prints:2
      D. prints:3
      E. prints:7
      F. prints:8
      静态代码块执行过一次后就被释放了
      所以xy是初始默认赋值为0

    1. (多选)对于线程局部存储TLS(thread local storage),以下表述正确的是
      A. 解决多线程中的对同一变量的访问冲突的一种技术
      B. TLS会为每一个线程维护一个和该线程绑定的变量的副本
      C. 每一个线程都拥有自己的变量副本,从而也就没有必要对该变量进行同步了
      D. Java平台的java.lang.ThreadLocal是TLS技术的一种实现
      如果是静态变量是共享的话,那必须同步,否则尽管有副本,还是会出错,故C错

    1. 下列关于容器集合类的说法正确的是?
      A. LinkedList继承自List
      B. AbstractSet继承自Set
      C. HashSet继承自AbstractSet
      D. WeakMap继承自HashMap
      a选项linkedlist类是实现了List接口,而不是继承
      b选项AbstractSet类实现Set接口
      c选项HashSet继承 AbstractSet类,同时也实现set
      d选项WeakMap是HashMap的弱引用

    1. 以下程序执行后,错误的结果是
      public class Test {
      private String name = “abc”;
      public static void main(String[] args) {
      Test test = new Test();
      Test testB = new Test();
      String result = test.equals(testB) + “,”;
      result += test.name.equals(testB.name) + “,”;
      result += test.name == testB.name;
      System.out.println(result);
      }
      }
      A. true,true,true
      B. true,false,false
      C. false,true,false
      D. false,true,true
      看错了 选成正确的了

    1. Hashtable 和 HashMap 的区别是:
      A. Hashtable 是一个哈希表,该类继承了 AbstractMap,实现了 Map 接口
      B. HashMap 是内部基于哈希表实现,该类继承AbstractMap,实现Map接口
      C. Hashtable 线程安全的,而 HashMap 是线程不安全的
      D. Properties 类 继承了 Hashtable 类,而 Hashtable 类则继承Dictionary 类
      E. HashMap允许将 null 作为一个 entry 的 key 或者 value,而 Hashtable 不允许。
      Hashtable:
      (1)Hashtable 是一个散列表,它存储的内容是键值对(key-value)映射。
      (2)Hashtable 的函数都是同步的,这意味着它是线程安全的。它的key、value都不可以为null。
      (3)HashTable直接使用对象的hashCode。
      HashMap:
      (1)由数组+链表组成的,基于哈希表的Map实现,数组是HashMap的主体,链表则是主要为了解决哈希冲突而存在的。
      (2)不是线程安全的,HashMap可以接受为null的键(key)和值(value)。
      (3)HashMap重新计算hash值

    1. 与InputStream流相对应的Java系统的“标准输入对象”是
      A. System.in
      B. System.out
      C. System.err
      D. System.exit()
      输入看成输出了

    1. Which lines of the following will produce an error?
      byte a1 = 2, a2 = 4, a3;
      short s = 16;
      a2 = s;
      a3 = a1 * a2;
      A. Line 3 and Line 4
      B. Line 1 only
      C. Line 3 only
      D. Line 4 only
      byte类型在运算时会自动转换成int类型

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

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


    1. 以下运行结果:
      for(var i = 0; i < 10; i++) {
      setTimeout(function() {
      console.log(i);
      }, 1000);
      . }
      A. 0–9
      B. 10个10
      C. 10个9
      D. 无限循环
      setTimeout中的闭包函数是每1s执行一次,由于for循环的执行速度远小于1s,所以当开始执行闭包函数的时候for循环已经结束了(i=10),之后闭包函数执行十次(因为循环了10次),所以打印了10个10。

    1. 如果希望监听TCP端口9000,服务器端应该怎样创建socket?
      A. new Socket(“localhost”,9000);
      B. new ServerSocket(9000);
      C. new Socket(9000);
      D. new ServerSocket(“localhost”,9000);
      和端口弄混了
      ServerSocket (int port)
      创建一个serversocket 绑定在特定的端口

    Socket(InetAddress address, int port)
    创建一个socket流,连接到特定的端口和ip地址


    1. (多选)关于java集合下列说法不正确的有哪些
      A. HashSet 它是线程安全的,不允许存储相同的对象
      B. ConcurrentHashMap 它是线程安全的,其中存储的键对象可以重复,值对象不能重复
      C. Collection接口是List接口和Set接口的父接口,通常情况下不被直接使用
      D. ArrayList线程安全的,允许存放重复对象
      线程安全(Thread-safe)的集合对象:

    Vector 线程安全:
    HashTable 线程安全:
    StringBuffer 线程安全:

    非线程安全的集合对象:
    ArrayList :
    LinkedList:
    HashMap:
    HashSet:
    TreeMap:
    TreeSet:
    StringBulider:


    1. 下列叙述中,错误的是
      A. File类能够存储文件属性
      B. File类能够读写文件
      C. File类能够建立文件
      D. File类能够获取文件目录信息

    File类能操作文件本身,但不能对文件内容进行修改


    1. 要使对象具有序列化能力,则其类应该实现如下哪个接口
      A. java.io.Serializable
      B. java.lang.Cloneable,
      C. java.lang.CharSequence
      D. java.lang.Comparable
      要使对象具有序列化能力,则其类应该实现如下 java.io.Serializable接口。这是一个标记接口,标记该类的实例可以被序列化。

    1. 以下哪个方法用于定义线程的执行体?
      A. start()
      B. init()
      C. run()
      D. synchronized()
      第一部分有相同题

    public class HasStatic{
    private static int x=100;
    public static void main(String args[]){
    HasStatic hs1=new HasStatic();
    hs1.x++;
    HasStatic hs2=new HasStatic();
    hs2.x++;
    hs1=new HasStatic();
    hs1.x++;
    HasStatic.x–;
    System.out.println(“x=”+x);
    }
    . }
    A. 程序通过编译,输出结果为:x=103
    B. 10行不能通过编译,因为x是私有静态变量
    C. 5行不能通过编译,因为引用了私有静态变量
    D. 程序通过编译,输出结果为:x=102
    static相当于全局变量 每一次都变化了


    1. 下列描述中,错误的是
      A. SQL语言又称为结构化查询语言
      B. java中”static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问
      C. 面向对象开发中,引用传递意味着传递的并不是实际的对象,而是对象的引用,因此,外部对引用对象所做的改变不会反映到所引用的对象上
      D. java是强类型语言,javascript是弱类型语言
      E. 面向对象的三大特性包括:封装,继承,多态

    值传递,传递的是原来值的副本。
    引用传递,除了一些特殊的(String,包装类属于不可变类),一般的引用类型在进行传递的时候,一开始形参和实参都是指向同一个地址的,这个时候形参对对象的改变会影响到实参。


    1. 如果一个接口Cup有个方法use(),有个类SmallCup实现接口Cup,则在类SmallCup中正确的是?
      A. void use() { …}
      B. protected void use() { …}
      C. public void use() { …}
      D. 以上语句都可以用在类SmallCup中
      既然是实现接口,就要实现接口的所以方法,相当于重写方法,方法的重写需要满足:三同一大一小(方法名、返回值类型、形参相同;访问权限>=重写前;抛出异常<=重写前)

    1. 抽象类和接口的区别,一下说法错误的是
      A. 接口是公开的,里面不能有私有的方法或变量,是用于让别人使用的,而抽象类是可以有私有方法或私有变量的。
      B. abstract class 在 Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface,实现多重继承。接口还有标识(里面没有任何方法,如Remote接口)和数据共享(里面的变量全是常量)的作用。
      C. 在abstract class 中可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface中,只能够有静态的不能被修改的数据成员(也就是必须是 static final的,不过在 interface中一般不定义数据成员),所有的成员方法默认都是 public abstract 类型的。
      D. abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"has-a"关系,interface表示的是"is-a"关系。
      D项: abstract class表示的是"is-a"关系,interface表示的是"like-a"关系。

    1. 以下代码运行输出的是
      . public class Person{
      private String name = “Person”;
      int age=0;
      }
      public class Child extends Person{
      public String grade;
      public static void main(String[] args){
      Person p = new Child();
      System.out.println(p.name);
      }
      }
      A. 输出:Person
      B. 没有输出
      C. 编译出错
      D. 运行出错
      Java中对字段属性是静态绑定,方法成员是动态绑定,这里错在:在子类中试图访问父类的private字段,所以编译不通过,将private去掉就可访问,不是动态绑定的问题,它本来就属于静态绑定。

    多选)java中Hashtable, Vector, TreeSet, LinkedList哪些线程是安全的?
    A. Hashtable
    B. Vector
    C. TreeSet
    D. LinkedList
    和前面一题一样
    Vector 线程安全:
    HashTable 线程安全:
    StringBuffer 线程安全:
    非线程安全的集合对象:
    ArrayList :
    LinkedList:
    HashMap:
    HashSet:
    TreeMap:
    TreeSet:
    StringBulider:


    1. (多选)以下表达式中,正确的是
      A. byte i=128
      B. boolean i=null
      C.long i=0xfffL
      D.double i=0.9239d
      答案A 超出了范围 bye的取值范围是-128-127
      答案B boolean行只有两种取值true和false没有null

    1. 只有实现了()接口的类,其对象才能序列化。
      A. Serializable
      B. Cloneable
      C. Comparable
      D. Writeable
      Serializable要实现序列化对象必须要实现的接口

    1. 已知如下类说明:
      public class Test{
      private float f=1.0f;
      int m=12;
      static int n=1;
      public static void main(String args[]){
      Test t=new Test();
      }
      }
      如下哪些使用是正确的
      A. t.f = 1.0
      B. this.n
      C. Test.m
      D. Test.n
    2. main方法是个static方法,然后static方法中不能直接访问非static的属性。
    3. 静态块或者静态方法中不能有this,super关键字
    4. m不是静态属性,所以不能类名访问。

    1. 对于Java中异常的描述正确的是
      A. 用throws定义了方法可能抛出的异常,那么调用此方法时一定会抛出此异常。
      B. 如果try块中没有抛出异常,finally块中的语句将不会被执行。
      C. 抛出异常意味着程序发生运行时错误,需要调试修改
      D. Java中的可不检测(unchecked)异常可能来自RuntimeException类或其子类。

    A错 在调用此方法的时候 也可以再次申明以将异常交由更高一级处理。
    B错 finally块中的语句一定会被执行。除非catch块中有System.exit(0)。
    C错 抛出异常不一定是运行时异常,也有可能是编译时异常。
    D对 运行时异常的特点是Java编译器不会检查它。


    1. 以下JAVA程序的输出是什么
    2. public class HelloSogou{
    3.   public static synchronized void main(String[] a){  
      
    4.       Thread t=new Thread(){  
      
    5.           public void run(){Sogou();}  
      
    6.   };  
      
    7.   t.run();  
      
    8.   System.out.print("Hello");  
      
    9.   }  
      
    10.   static synchronized void Sogou(){  
      
    11.  System.out.print("Sogou");  
      
    12. }  
      
    13. }
      A. HelloSogou
      B. SogouHello
      C. Hello
      D. 结果不确定

    可能当时脑子糊了 这也错了


    1. Which of the following can be applied to constructors:
      A. final
      B. static
      C. synchronized
      D. native
      E. None of these.

    构造方法不能被子类继承,所以用final修饰没有意义。构造方法用于创建一个新的对象,不能作为类的静态方法,所以用static修饰没有意义。此外,Java语言不支持native或synchronized的构造方法。


    1. 有如下代码:请写出程序的输出结果。
      Vpublic class Test
      {
      public static void main(String[] args)
      {
      int x = 0;
      int y = 0;
      int k = 0;
      for (int z = 0; z < 5; z++) {
      if ((++x > 2) && (++y > 2) && (k++ > 2))
      {
      x++;
      ++y;
      k++;
      }
      }
      System.out.println(x + ”” +y + ”” +k);
      }
      }
      A. 432
      B. 531
      C. 421
      D. 523
      当时已经没什么精力去算了
      就是普通的判断条件计算

    1. 关于sleep()和wait(),以下描述错误的一项是
      A. sleep是线程类(Thread)的方法,wait是Object类的方法;
      B. sleep不释放对象锁,wait放弃对象锁
      C. sleep暂停线程、但监控状态仍然保持,结束后会自动恢复
      D. wait后进入等待锁定池,只有针对此对象发出notify方法后获得对象锁进入运行状态
      D错是因为进入的是就绪状态而不是运行状态

    1. 下面说法正确的是
      A. 构造函数先调用自己的构造函数然后初始化成员变量最后调用基类构造函数
      B. 构造函数先调用基类构造函数然后调用自己的构造函数最后初始化成员变量
      C. 构造函数先调用基类构造函数然后初始化成员变量最后调用自己的构造函数
      D. 构造函数先调用自己的构造函数然后调用基类构造函数最后初始化成员变量

    父类静态变量和静态代码块 ( java虚拟机加载类时,就会执行该块代码,故只执行一次)

    子类静态变量和静态代码块 ( java虚拟机加载类时,就会执行该块代码,故只执行一次)

    父类属性对象初始化

    父类普通代码块(每次new,每次执行 )

    父类构造函数(每次new,每次执行)

    子类属性对象初始化

    子类普通代码块(每次new,每次执行 )

    子 类构造函数(每次new,每次执行)


    1. 关于访问权限说法正确的是 ?
      A. 外部类前面可以修饰public,protected和private
      B. 成员内部类前面可以修饰public,protected和private
      C. 局部内部类前面可以修饰public,protected和private
      D. 以上说法都不正确

    当时已经写吐了脑子没了
    答案a类定义指的是普通类,可以理解为独立存在,没有必要用私有约束修饰符。
    答案b中的类是局部变量,作用域小,没有必要设置权限修饰符。
    答案c中的类是类种类,属于主类的成员变量,有成员属性,所以权限修饰符参考类中的成员变量权限修饰符,所以答案c正确


    1. 下面这条语句一共创建了多少个对象:String s=“welcome”+“to”+360;
      A. 1
      B. 2
      C. 3
      D. 4
      编译器自动搞好了
      全是常量的字符串在编译时会进行优化,也就是说编译器会将你写的语句优化成

    1. (多选) 对Collection和Collections描述正确的是
      A. Collection是java.util下的类,它包含有各种有关集合操作的静态方法
      B. Collection是java.util下的接口,它是各种集合结构的父接口
      C. Collections是java.util下的接口,它是各种集合结构的父接口
      D. Collections是java.util下的类,它包含有各种有关集合操作的静态方法
      单纯不知道
      如题所述

    1. 下列选项中关于Java中super关键字的说法正确的是
      A. super关键字是在子类对象内部指代其父类对象的引用
      B. super关键字不仅可以指代子类的直接父类,还可以直接指代父类的父类
      C. 子类通过super关键字只能调用父类的方法,而不能调用父类的属性
      D. 子类通过super关键字只能调用父类的属性,而不能调用父类的方法

    super是java提供的一个关键字,super用于限定该对象调用它从父类继承得到的Field或方法。super关键字不能出现在static修饰的方法中,因为static修饰的方法是属于类的。如果在构造器中使用super,则super用于限定该构造器初始化的是该对象从父类继承得到的field,而不是该类自己定义的field。需要注意的是,super关键字只能指代直接父类,不能指代父类的父类。


    1. J2EE中,当把来自客户机的HTTP请求委托给servlet时,会调用HttpServlet的()方法
      A. service
      B. doget
      C. dopost
      D. init
      噢 又是过滤器
      Servlet生命周期分为三个阶段:

    1.初始化阶段 调用init()方法

    2.响应客户请求阶段  调用service()方法

    3.终止阶段  调用destroy()方法


    1. (多选)下面有关forward和redirect的描述,正确的是() ?
      A. forward是服务器将控制权转交给另外一个内部服务器对象,由新的对象来全权负责响应用户的请求
      B. 执行forward时,浏览器不知道服务器发送的内容是从何处来,浏览器地址栏中还是原来的地址
      C. 执行redirect时,服务器端告诉浏览器重新去请求地址
      D. forward是内部重定向,redirect是外部重定向
      E. redirect默认将产生301 Permanently moved的HTTP响应
      知识盲区

    request的forward和response的redirect
    1.redirect地址栏变化,forward发生在服务器端内部从而导致浏览器不知道响应资源来自哪里
    2.redirect可以重定向到同一个站点上的其他应用程序中的资源,forward 只能将请求 转发给同一个WEB应用中的组件
    3.redirect默认是302码,包含两次请求和两次响应
    4.redirect效率较低


    1. 定义:String s1 = “uml”; String s2 = “uml”; String s3= new String(“uml”); String s4= new String(“uml”);那么,s1==s2;s3 == s4;s1.equals(s3); 判断正确与否
      A. T,F,T
      B. F,T,F
      应该又是脑子糊了

    1. 建立Statement对象的作用是
      A. 连接数据库
      B. 声明数据库
      C. 执行SQL语句
      D. 保存查询结果
      数据库还没看
      1、Statement对象用于执行不带参数的简单SQL语句。
      2、Prepared Statement 对象用于执行预编译SQL语句。
      3、Callable Statement对象用于执行对存储过程的调用。

    1. ArrayLists和LinkedList的区别,下述说法正确的有?
      A. ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。
      B. 对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。
      C. 对于新增和删除操作add和remove,LinkedList比较占优势,因为ArrayList要移动数据。
      D. ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间,而LinkedList的空间花费则体现在它的每一个元素大

    大佬回答的就是详细

    A. ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。 //正确,这里的所谓动态数组并不是那个“ 有多少元素就申请多少空间 ”的意思,通过查看源码,可以发现,这个动态数组是这样实现的,如果没指定数组大小,则申请默认大小为10的数组,当元素个数增加,数组无法存储时,系统会另个申请一个长度为当前长度1.5倍的数组,然后,把之前的数据拷贝到新建的数组。
    B. 对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。//正确,ArrayList是数组,所以,直接定位到相应位置取元素,LinkedLIst是链表,所以需要从前往后遍历。
    C. 对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据。//正确,ArrayList的新增和删除就是数组的新增和删除,LinkedList与链表一致。
    D. ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间,而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。//正确,因为ArrayList空间的增长率为1.5倍,所以,最后很可能留下一部分空间是没有用到的,因此,会造成浪费的情况。对于LInkedList的话,由于每个节点都需要额外的指针,所以,你懂的。

    展开全文
  • Java30道选择题(四)

    2021-01-27 18:37:23
    1.Java Application 中的主类需包含main方法,...2.在JAVA中, 下列标识符合法的是() 正确答案: C 你的答案: C (正确) A.3kyou B.@163 C.name D.while 解释:合法标识符:三不能 1.不能以数字开头 2.不能是关键字 3.

    1.Java Application 中的主类需包含main方法,以下哪项是main方法的正确形参?( )
    正确答案: B 你的答案: B (正确)
    A.String args
    B.String[] args
    C.Char arg
    D.StringBuffer[] args

    2.在JAVA中, 下列标识符合法的是()
    正确答案: C 你的答案: C (正确)
    A.3kyou
    B.@163
    C.name
    D.while

    解释:合法标识符:三不能
    1.不能以数字开头
    2.不能是关键字
    3.不能包含除了$和_以外的其他字符

    3.设有下面一段代码:

    class  Student  extends  Person {
    long    id;     // 身份证号
    int  score;  // 入学总分
    String  name;   // 姓名
    int  getScore(){
    return  score;
    }
    }
    

    问:类 Person 和类 Student 的关系是( )。
    正确答案: B 你的答案: D (错误)
    A.包含关系
    B.继承关系
    C.关联关系
    D.无关系,上述类定义有语法错误

    4.执行下列程序的输出结果为( )

    public class Test {
     public static void main(String[] args) {
     String s1 = "HelloWorld";
     String s2 = new String("HelloWorld");
     if (s1 == s2)  {
     System.out.println("s1 == s2");
     } else {
     System.out.println("s1 != s2");
     }
     if (s1.equals(s2)) {
     System.out.println("s1 equals s2");
     } else {
     System.out.println("s1 not equals s2");
     }
     }
     }
    

    正确答案: D 你的答案: A (错误)
    A.s1 == s2
    s1 not equals s2
    B.s1 == s2
    s1 equals s2
    C.s1 != s2
    s1 not equals s2
    D.s1 != s2
    s1 equals s2

    解释: s1直接指向常量池中的字符串变量(没有就在常量池创建一个) s2是指向堆里的一个字符串对象,对象里面有常量池中字符串对象的引用

    5.下列关于Java中类的构造方法的描述,正确的是()
    正确答案: B 你的答案: C (错误)
    A.构造方法的返回类型为void
    B.可以定义一个类而在代码中不写构造方法。
    C.在同一个类中定义的重载构造方法不可以相互调用。
    D.子类不允许调用父类的构造方法。

    解释:
    A、构造器没有返回值,这个没有返回值和返回值为void可部一样。
    B、每个类在没有自己显式声明构造器的时候,都会有一个默认的无参构造。
    C、构造器可以重载,而且可以使用super()、this()相互调用
    D、每个构造器的默认第一行都是super(),但是一旦父类中没有无参构造,必须在子类的第一行显式的声明调用哪一个构造。

    6.在java中,无论在何处调用,使用静态属性必须以类名做前缀。
    正确答案: B 你的答案: A (错误)
    A.正确
    B.错误

    解释:
    1如果是本类使用,可以直接就用静态变量名。2如果是其他类使用,可以使用类名来调用,也可以创建一个实例对象来调用。3如果静态变量所在的类是静态类,那么不管在本类里或者在其他外部类,都可以直接使用静态变量名。

    7如下语句通过算术运算和逻辑运算之后i和 j的结果是( )

    int i=0;
    int j=0;
    if((++i>0)||(++j>0))
    {
    //打印出i和j的值。
    }
    

    正确答案: D 你的答案: D (正确)
    i=0;j=0
    i=1;j=1
    i=0;j=1
    i=1;j=0

    解释: && 和 || 为短路与 短路或
    &&若前面的表达式为false,整个逻辑表达式为false,所以后面的表达式无论true和false都无法影响整个表达式的逻辑结果,所以为了提高代码执行速率,这里后面的表达式就不会执行。
    同理,若前面表达式为true,则后面的表达式无需计算。

    & 和 | 为不短路与 不短路或 无论什么情况,前面的和后面的都要执行。

    8.以下J2EE中常用的名词解释错误的是?
    正确答案: B 你的答案: C (错误)
    A.EJB容器:Enterprise java bean 容器
    B.JNDI:JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
    C.JMS:JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
    D.JAF:JAVA安全认证框架。提供一些安全控制方面的框架。

    解释:
    (1) web容器:给处于其中的应用程序组件(JSP,SERVLET)提供一个环境,使JSP,SERVLET直接更容器中的环境变量接**互,不必关注其它系统问题。主要有WEB服务器来实现。例如:TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵守J2EE规范中的WEB APPLICATION 标准。我们把遵守以上标准的WEB服务器就叫做J2EE中的WEB容器。

    (2) EJB容器:Enterprise java bean容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器,马上就会被容器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件服务、事务管理。

    (3)JNDI:(Java Naming & Directory
    Interface)JAVA命名目录服务。主要提供的功能是:提供一个目录系,让其它各地的应用程序在其上面留下自己的索引,从而满足快速查找和定位分布式应用程序的功能。

    (4)JMS:(Java Message Service)JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。

    (5)JTA:(Java Transaction API)JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。

    (6)JAF:(Java ActionFrameWork)JAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。

    (7)RMI/IIOP:(Remote Method Invocation/internet对象请求中介协议)他们主要用于通过远程调用服务。例如,远程有一台计算机上运行一个程序,它提供股票分析服务,我们可以在本地计算机上实现对其直接调用。当然这是要通过一定的规范才能在异构的系统之间进行通信。RMI是JAVA特有的。

    9.以下哪一项正则能正确的匹配网址: http://www.bilibili.com/video/av21061574 ()
    正确答案: B 你的答案: D (错误)
    A./^(https:)?)?([a-zA-Z\d]+).bilibili.com/?video/av(\D{1,8})/?$/

    B./^(http:)?(\w+).bilibili.com/?video/av(\d{1,8})/?$/

    C./^(http:)?:?(\w+).bilibili.com/?\w*$/

    D./^(http:)?([a-zA-Z\d]+).bilibili.com/?video/av\w*/+$/

    10.下面哪种情况会导致持久区jvm堆内存溢出?
    正确答案: C 你的答案: D (错误)
    A.循环上万次的字符串处理
    B.在一段代码内申请上百M甚至上G的内存
    C.使用CGLib技术直接操作字节码运行,生成大量的动态类
    D.不断创建对象、

    解释:
    一个对象的一生:我是一个普通的Java对象,我出生在Eden区,在Eden区我还看到和我长的很像的小兄弟,我们在Eden区中玩了挺长时间。有一天Eden区中的人实在是太多了,我就被迫去了Survivor区的“From”区,自从去了Survivor区,我就开始漂了,有时候在Survivor的“From”区,有时候在Survivor的“To”区,居无定所。直到我18岁的时候,爸爸说我成人了,该去社会上闯闯了。于是我就去了年老代那边,年老代里,人很多,并且年龄都挺大的,我在这里也认识了很多人。在年老代里,我生活了20年(每次GC加一岁),然后被回收。

    1. 关于下面的程序Test.java说法正确的是( )。
    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);
        }
    }
    

    正确答案: D 你的答案: D (正确)
    A.3
    B.112
    C.13
    D.程序有编译错误

    12.在开发中使用泛型取代非泛型的数据类型(比如用ArrayList取代ArrayList),程序的运行时性能会变得更好。()
    正确答案: B 你的答案: A (错误)
    A.正确
    B.错误

    解释:

    使用泛型的好处:
    1,类型安全。 泛型的主要目标是提高 Java
    程序的类型安全。通过知道使用泛型定义的变量的类型限制,编译器可以在一个高得多的程度上验证类型假设。没有泛型,这些假设就只存在于程序员的头脑中(或者如果幸运的话,还存在于代码注释中)。

    2,消除强制类型转换。 泛型的一个附带好处是,消除源代码中的许多强制类型转换。这使得代码更加可读,并且减少了出错机会。

    3,潜在的性能收益。
    泛型为较大的优化带来可能。在泛型的初始实现中,编译器将强制类型转换(没有泛型的话,程序员会指定这些强制类型转换)插入生成的字节码中。但是更多类型信息可用于编译器这一事实,为未来版本的
    JVM 的优化带来可能。由于泛型的实现方式,支持泛型(几乎)不需要 JVM
    或类文件更改。所有工作都在编译器中完成,编译器生成类似于没有泛型(和强制类型转换)时所写的代码,只是更能确保类型安全而已。

    所以泛型只是提高了数据传输安全性,并没有改变程序运行的性能

    13.@SuppressWarnings(“deprecation”)的功能是什么?
    正确答案: A 你的答案: D (错误)
    A.屏蔽不赞同使用的类和方法的警告
    B.屏蔽在强制类型转换的时候编译器给出的警告
    C.关闭所有警告信息
    D.当在可序列化的类上缺少serialVersionUID定义的警告

    解释:
    1.Java三大注解分别是@Override @Deprecated @Suppresswarnings
    2.@Override 注解表名子类中覆盖了超类中的某个方法,如果写错了覆盖形式,编译器会报错
    3.@Deprecated 表明不希望别人在以后使用这个类,方法,变量等等
    4.@Suppresswarnings 达到抑制编译器产生警告的目的,但是不建议使用,因为后期编码人员看不懂编译器提示的警告,不能更好的选择更好的类去完成任务

    14.jdk1.8中,下面有关java 抽象类和接口的区别,说法错误的是?

    正确答案: B D 你的答案: D (错误)
    A.抽象类可以有构造方法,接口中不能有构造方法
    B.抽象类中可以包含非抽象的普通方法,接口中的方法必须是抽象的,不能有非抽象的普通方法
    C.一个类可以实现多个接口,但只能继承一个抽象类
    D.接口中可以有普通成员变量,抽象类中没有普通成员变量

    解释:
    抽象类
    特点:
    1.抽象类中可以构造方法
    2.抽象类中可以存在普通属性,方法,静态属性和方法。
    3.抽象类中可以存在抽象方法。
    4.如果一个类中有一个抽象方法,那么当前类一定是抽象类;抽象类中不一定有抽象方法。
    5.抽象类中的抽象方法,需要有子类实现,如果子类不实现,则子类也需要定义为抽象的。
    接口
    1.在接口中只有方法的声明,没有方法体。
    2.在接口中只有常量,因为定义的变量,在编译的时候都会默认加上
    public static final
    3.在接口中的方法,永远都被public来修饰。
    4.接口中没有构造方法,也不能实例化接口的对象。
    5.接口可以实现多继承
    6.接口中定义的方法都需要有实现类来实现,如果实现类不能实现接口中的所有方法
    7.则实现类定义为抽象类。

    15

    void waitForSignal()
    {
        Object obj = new Object();
        synchronized(Thread.currentThread())
        {
            obj.wait();
            obj.notify();
        }
    }
    

    Which statement is true?

    正确答案: A 你的答案: A (正确)
    A.This code may throw an InterruptedException
    B.This code may throw an IllegalStateException
    C.This code may throw a TimeOutException after ten minutes
    D.This code will not compile unless”obj.wait()”is replaced with”(Thread)obj).wait()”
    E.Reversing the order of obj.wait()and obj.notify()may cause this method to complete normally

    16.关于HashMap和Hashtable正确的说法有()
    正确答案: A C 你的答案: B C (错误)
    A.都实现了Map接口
    B.Hashtable类不是同步的,而HashMap类是同步的
    C.Hashtable不允许null键或值
    D.HashMap不允许null或值

    解释: 1、继承不同。public class Hashtable extends Dictionary implements Map

    public class HashMap extends AbstractMap implements Map

    2、Hashtable中的方法是同步的,而HashMap中的方法在缺省情况下是非同步的。在多线程并发的环境下,可以直接使用Hashtable,但是要使用HashMap的话就要自己增加同步处理了。

    3、Hashtable中,key和value都不允许出现null值。

    在HashMap中,null可以作为键,这样的键只有一个;可以有一个或多个键所对应的值为null。当get()方法返回null值时,即可以表示 HashMap中没有该键,也可以表示该键所对应的值为null。因此,在HashMap中不能由get()方法来判断HashMap中是否存在某个键, 而应该用containsKey()方法来判断。

    4、两个遍历方式的内部实现上不同。Hashtable、HashMap都使用了 Iterator。而由于历史原因,Hashtable还使用了Enumeration的方式 。

    5、哈希值的使用不同,HashTable直接使用对象的hashCode。而HashMap重新计算hash值。

    6、Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11,增加的方式是old*2+1。HashMap中hash数组的默认大小是16,而且一定是2的指数

    17.有以下程序段, 则下面正确的选项是()

    public class MyThead extends Thread{
        public static void main(String[] args) {
            MyThead t=new MyThead();
            MyThead s=new MyThead();
            t.start();
            System.out.println("one.");
            s.start();
            System.out.println("two.");
        }
        public void run() {
            System.out.println("Thread");
        }
    }
    

    正确答案: B C D 你的答案: B (错误)
    A.编译失败
    B.程序运行可能结果为:
    one.
    Thread
    two.
    Thread
    C.程序运行可能结果是:
    one.
    two.
    Thread
    Thread
    D.程序运行结果不稳定

    解释:
    start()是开启线程,等待获得时间片,一到获得时间片就执行。所以可能一开启就获得了时间片执行,也有可能等到two输出后才获得了时间片。所以BC都可能,所以D也正确。

    18.CMS垃圾回收器在那些阶段是没用用户线程参与的
    正确答案: A C 你的答案: A (错误)
    A.初始标记
    B.并发标记
    C.重新标记
    D.并发清理

    解释:
    用户线程(user-levelthreads)指不需要内核支持而在用户程序中实现的线程,其不依赖于操作系统核心,应用进程利用线程库提供创建、同步、调度和管理线程的函数来控制用户线程。
    CMS的GC过程有6个阶段(4个并发,2个暂停其它应用程序)

    1. 初次标记(STW initial mark)
    2. 并发标记(Concurrent marking)
    3. 并发可中断预清理(Concurrent precleaning)
    4. 最终重新标记(STW remark)
    5. 并发清理(Concurrent sweeping)
    6. 并发重置(Concurrent reset) 在初次标记,重新标志的时候,要求我们暂停其它应用程序,那么这两个阶段用户线程是不会参与的

    19.往OuterClass类的代码段中插入内部类声明, 哪一个是错误的:

    > public class OuterClass{
    >     private float f=1.0f;
    >     //插入代码到这里
    }
    

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

    class InnerClass{
    public static float func(){return f;}
    }
    

    B.

    abstract class InnerClass{
    public abstract float func(){}
    }
    

    C.

    static class InnerClass{
    protected static float func(){return f;}
    }
    

    D.

    public class InnerClass{
     static float func(){return f;}
    }
    

    解释:
    主要考核了这几个知识点:
    1.静态内部类才可以声明静态方法
    2.静态方法不可以使用非静态变量
    3.抽象方法不可以有函数体

    20.有关finally语句块说法正确的是( )
    正确答案: A B C 你的答案: B (错误)
    A.不管catch是否捕获异常,finally语句块都是要被执行的
    B.在try语句块或catch语句块中执行到System.exit(0)直接退出程序
    C.finally块中的return语句会覆盖try块中的return返回
    D.finally 语句块在 catch语句块中的return语句之前执行

    解释:
    D.不是return之前,是return执行完成之前,return表达式的结果会暂时保存起来,不会被改变

    21.HashSet子类依靠()方法区分重复元素。
    正确答案: C 你的答案: A (错误)
    A.toString(),equals()
    B.clone(),equals()
    C.hashCode(),equals()
    D.getClass(),clone()

    解释:
    HashSet的底层还是用HashMap来实现的。将Entry<K,V>的V都变成了同一个Object对象,public static final PRESENT = new Object()。 而HashMap的数据结构是数组+链表+红黑树。

    调用K的hashCode方法,然后高低16位进行&运算。得到的hash值,与数组tab[](桶)的长度-1进行&运算,确定插入对象在哪一个桶上。然后调用对象的equals方法,形成链表。当链表长度大于8时,链表转红黑树。

    22.程序文件名必须与公共外部类的名称完全一致(包括大小写).
    正确答案: A 你的答案: A (正确)
    A.正确
    B.错误

    23.当你编译和运行下面的代码时,会出现下面选项中的哪种情况?

    public class Pvf{
        static boolean Paddy;
        public static void main(String args[]){
            System.out.println(Paddy);
        }
    }
    

    正确答案: B 你的答案: C (错误)
    A.编译时错误
    B.编译通过并输出结果false
    C.编译通过并输出结果true
    D.编译通过并输出结果null

    解释: 类中声明的变量有默认初始值;方法中声明的变量没有默认初始值,必须在定义时初始化,否则在访问该变量时会出错。
    boolean类型默认值是false

    24.关于Java语言中的final关键字的使用,下列说法正确的是()

    正确答案: C 你的答案: B (错误)
    A.在使用final关键字定义的方法里面使用final关键字定义变量。
    B.使用final关键字定义变量,必须在变量定义的同时给定变量的具体数值,完成变量初始化。
    C.final关键字可以用来修饰方法,表明此方法不可以被子类重写。
    D.使用final关键字定义变量,必须同时使用static关键字。

    解释:
    A 选项在 final 定义的方法里,不是必须要用 final 定义变量。
    B final定义的变量,可以在不是必须要在定义的同时完成初始化,也可以在构造方法中完成初始化。
    C正确,final修饰方法,不能被子类重写,但是可以被重载。
    D final 定义变量,可以用 static 也可以不用。

    25.以下java程序代码,执行后的结果是()

    java.util.HashMap map=new java.util.HashMap(); 
    map.put("name",null);      
    map.put("name","Jack");
    System.out.println(map.size());
    

    正确答案: C 你的答案: B (错误)
    A.0
    B.null
    C.1
    D.2

    解释:ashMap可以插入null的key或value,插入的时候,检查是否已经存在相同的key,如果不存在,则直接插入,如果存在,则用新的value替换旧的value,
    第一条put语句,会将key/value对插入HashMap,
    第二条put语句,要替换为(name,jack)。所以,size为1.

    26.下列叙述错误的是( )

    正确答案: D 你的答案: D (正确)
    A.在接口中定义的方法除了default和static关键字修饰的方法拥有方法体,其他方法都应是没有方法体的抽象方法(JDK1.8以后)
    B.一个java类只能有一个父类,但可以实现多个接口
    C.在类声明中,用implements关键字声明该类实现的接口
    D.定义接口时使用implements关键字。

    解释:
    A、JDK8开始,接口中可以定义有方法体的方法,方法必须被default和static修饰。除此之外,其他方法都是抽象方法。
    B、Java的语法是单继承,但是继承可以传递。其实B更准确一点是只能有一个直接父类。
    C、继承用extends,实现用implements。先继承后实现。
    D、类是class,接口是interface。

    27.正则表达式中,表示匹配非数字字符的字符是()?
    正确答案: D 你的答案: D (正确)
    A.\b
    B.\d
    C.\B
    D.\D

    28.有如下一段代码,请选择其运行结果()

    public class StringDemo{
      private static final String MESSAGE="taobao";
      public static void main(String [] args) {
        String a ="tao"+"bao";
        String b="tao";
        String c="bao";
        System.out.println(a==MESSAGE);
        System.out.println((b+c)==MESSAGE);
      }
    }
    

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

    解释: hotspot中编译时"tao"+“bao"将直接变成"taobao”,b+c则不会优化,因为不知道在之前的步骤中bc会不会发生改变,而针对b+c则是用语法糖,新建一个StringBuilder来处理

    29.下面哪些具体实现类可以用于存储键,值对,并且方法调用提供了基本的多线程安全支持:()
    正确答案: A E 你的答案: D (错误)
    A.java.util.ConcurrentHashMap
    B.java.util.Map
    C.java.util.TreeMap
    D.java.util.SortMap
    E.java.util.Hashtable
    F.java.util.HashMap

    解释:
    Hashtable的方法都是synchrnized修饰的线程安全,
    ConcurrentHashMap并发容器,JDK7采用分段锁,JDK8采用CAS算法,线程安全,建议使用,Connections工具类提供了一个方法synchrnizedMap可以把Map同步,本质就是给每一个方法加上synchrnized关键字进行同步

    30.针对以下代码,哪些选项执行后是true的:()

    class CompareReference{
       public static void main(String [] args){
       float f=42.0f;
       float f1[]=new float[2];
       float f2[]=new float[2];
       float[] f3=f1;
       long x=42;
       f1[0]=42.0f;
      }
    }
    

    正确答案: B C 你的答案: C (错误)
    A.f1== f2
    B.x== f1[0]
    C.f1== f3
    D.f2==f1[1]

    解释:

    public static void main(String[] args){
    int i=42;
    double d=42.0000;
    long l=42;
    float f=42.0f;
    float f2=42.00f;
    System.out.println(d== i);
    System.out.println(f== i);
    System.out.println(f== f2);
    System.out.println(l== i);
    System.out.println(d== f);
    } /*out: true true true true true
    */

    展开全文
  • Java选择题30道(七)

    2021-03-16 23:18:09
    1.在JAVA中, 下列标识符合法的是() 正确答案: C 你的答案: C (正确) A.3kyou B.@163 C.name D.while 解释: JAVA中,标识符, 指用于给变量.类.方法名 等命名的名称. 1,标识以数字,字符,下划线,以及美元$符组成....

    1.在JAVA中, 下列标识符合法的是()

    正确答案: C 你的答案: C (正确)
    A.3kyou
    B.@163
    C.name
    D.while

    解释:
    JAVA中,标识符, 指用于给变量.类.方法名 等命名的名称. 1,标识以数字,字符,下划线,以及美元$符组成.(不能包括@、%、空格等),不能以数字开头. 2,不能与JAVA关键字重复 3,严格区分的大小写,(Flag和flag是两个变量) abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for goto if implements import instanceof int interface long native new package private protected public return strictfp short static super switch synchronized this throw throws transient try void volatile while 等

    2.如果类的方法没有返回值,该方法的返回值类型应当是abstract。()

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

    解释:
    没有返回值就是不返回任何东西
    abstract肯定是错的了
    void返回值为空
    所以说的是构造函数吧

    3.设有定义 int a=3 ,b=4,c=5; 则以下的表达式中 , 值为 false 的是 ()

    正确答案: D 你的答案: D (正确)
    A.a < b && b < c
    B.a <= b
    C.a < ( b + c )
    D.! ( a < b )

    解释:
    a < b && b < c true && true true
    a <= b true
    a < ( b + c ) true
    ! ( a < b ) !true false

    4.编译 Java 源程序文件产生的字节码文件的扩展名为()

    正确答案: B 你的答案: B (正确)
    A.java
    B.class
    C.html
    D.exe

    解释:
    java源文件的后缀名是.java。源文件通过jvm虚拟机编译后会生成二进制字节码文件,后缀是.class

    5.Which of the following statements are valid array declaration?
    (A) int number();
    (B) float average[];
    © double[] marks;
    (D) counter int[];

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

    解释:
    nvalid 无效的 valid 有效的
    可能大家错误都犯在这里

    6.以下定义一维数组的语句中,正确的是:()

    正确答案: D 你的答案: D (正确)
    A.int a [10]
    B.int a []=new [10]
    C.int a[]
    int a []=new int [10]
    D.int a []={1,2,3,4,5}

    解释:
    (1)静态初始化(声明并初始化,此时不能指定容量):
    1)int[] arr = new int[]{1, 2, 3}

    2)int[] arr = {1, 2, 3}
    (2)动态初始化(先声明再初始化,此时必须指定容量):
    int[] arr = new int[3];
    arr[0] = 1;
    arr[1] = 2;
    arr[2] = 3;

    7.下面有关java实例变量,局部变量,类变量和final变量的说法,错误的是?

    正确答案: B 你的答案: A (错误)
    A.实例变量指的是类中定义的变量,即成员变量,如果没有初始化,会有默认值。
    B.局部变量指的是在方法中定义的变量,如果没有初始化,会有默认值
    C.类变量指的是用static修饰的属性
    D.final变量指的是用final 修饰的变量

    解释:
    定义在类中的变量是类的成员变量,可以不进行初始化,Java会自动进行初始化,如果是引用类型默认初始化为null,如果是基本类型例如int则会默认初始化为0
    局部变量是定义在方法中的变量,必须要进行初始化,否则不同通过编译
    被static关键字修饰的变量是静态的,静态变量随着类的加载而加载,所以也被称为类变量
    被final修饰发变量是常量

    8.下面关于垃圾收集的说法正确的是

    正确答案: D 你的答案: D (正确)
    一旦一个对象成为垃圾,就立刻被收集掉。
    对象空间被收集掉之后,会执行该对象的finalize方法
    finalize方法和C++的析构函数是完全一回事情
    一个对象成为垃圾是因为不再有引用指着它,但是线程并非如此

    解释:
    1、在java中,对象的内存在哪个时刻回收,取决于垃圾回收器何时运行。
    2、一旦垃圾回收器准备好释放对象占用的存储空间,将首先调用其finalize()方法, 并且在下一次垃圾回收动作发生时,才会真正的回收对象占用的内存(《java 编程思想》)
    3、在C++中,对象的内存在哪个时刻被回收,是可以确定的,在C++中,析构函数和资源的释放息息相关,能不能正确处理析构函数,关乎能否正确回收对象内存资源。
    在java中,对象的内存在哪个时刻回收,取决于垃圾回收器何时运行,在java中,所有的对象,包括对象中包含的其他对象,它们所占的内存的回收都依靠垃圾回收器,因此不需要一个函数如C++析构函数那样来做必要的垃圾回收工作。当然存在本地方法时需要finalize()方法来清理本地对象。在《java编程思想》中提及,finalize()方法的一个作用是用来回收“本地方法”中的本地对象

    9.下面关于Java package的描述,哪个是正确的:()
    I. 包不提供将所有类名分区为更易管理的块的机制.
    II. 包提供可见性控制机制.
    III. 包的一个重要属性是包内定义的所有类都可以通过该包外的代码访问.
    IV. 声明为包的一部分的类的.class文件可以存储在多个目录中.

    正确答案: B 你的答案: D (错误)
    A.只有I
    B.只有II
    C.只有III
    D.只有IV

    解释:
    为了更好地组织类,Java 提供了包机制,用于区别类名的命名空间。
    包的作用
    1、把功能相似或相关的类或接口组织在同一个包中,方便类的查找和使用。
    2、如同文件夹一样,包也采用了树形目录的存储方式。同一个包中的类名字是不同的,不同的包中的类的名字是可以相同的,当同时调用两个不同包中相同类名的类时,应该加上包名加以区别。因此,包可以避免名字冲突。
    3、包也限定了访问权限,拥有包访问权限的类才能访问某个包中的类。
    Java 使用包(package)这种机制是为了防止命名冲突,访问控制,提供搜索和定位类(class)、接口、枚举(enumerations)和注释(annotation)等。

    10.下列关于修饰符混用的说法,错误的是( )

    正确答案: D 你的答案: C (错误)
    A.abstract不能与final并列修饰同一个类
    B.abstract类中不应该有private的成员
    C.abstract方法必须在abstract类或接口中
    D.static方法中能直接调用类里的非static的属性

    解释:
    1、abstract不能与final并列修饰同一个类 对的。
    2、abstract类中不应该有private的成员 对的 :abstract类中可以有private 但是不应该有。
    3、abstract方法必须在abstract类或接口中 对的 : 若类中方法有abstract修饰的,该类必须abstract修改。接口方法默认public abstract。
    4、static方法中能处理非static的属性 错误 :在JVM中static方法在静态区,静态区无法调用非静态区属性。

    11.当点击鼠标或者拖动鼠标时,触发的事件是下列的哪一个?()

    正确答案: D 你的答案: D (正确)
    A.KeyEvent
    B.AxtionEvent
    C.ItemEvent
    D.MouseEvent

    解释:
    触发ActionEvent这个事件的动作有:
    1.点击按钮。
    2.双击列表中选项。
    3.选择菜单项。
    4.在文本框中输入回车

    12.下面程序的运行结果是

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

    正确答案: B 你的答案: B (正确)
    A.true
    B.false
    C.exception
    D.无输出

    解释:
    String str1 = “hello”;这里的str1指的是方法区的字符串常量池中的“hello”,编译时期就知道的; String str2 = “he” + new String(“llo”);这里的str2必须在运行时才知道str2是什么,所以它是指向的是堆里定义的字符串“hello”,所以这两个引用是不一样的。
    如果用str1.equal(str2),那么返回的是True;因为两个字符串的内容一样。

    13.以下哪个接口的定义是正确的?( )

    正确答案: D 你的答案: B (错误)
    A.interface B
    { void print() { } ;}
    B.interface B
    { static void print() ;}
    C.abstract interface B extends A1, A2 //A1、A2为已定义的接口
    { abstract void print(){ };}
    D.interface B
    { void print();}

    解释:
    A,接口中方法的默认修饰符时public abstract,抽象方法可是没有方法体的,没有大括号{}
    B,JDK8中,接口中的方法可以被default和static修饰,但是!!!被修饰的方法必须有方法体。
    C,注意一下,接口是可以多继承的。整个没毛病,和A选项一样,抽象方法不能有方法体

    14.ArrayList和LinkList的描述,下面说法错误的是?

    正确答案: D 你的答案: B (错误)
    A.LinkedeList和ArrayList都实现了List接口
    B.ArrayList是可改变大小的数组,而LinkedList是双向链接串列
    C.LinkedList不支持高效的随机元素访问
    D.在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动;而在ArrayList的中间插入或删除一个元素的开销是固定的

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

    15.在Web应用程序的文件与目录结构中,web.xml是放置在( )中。

    正确答案: A 你的答案: A (正确)
    A.WEB-INF目录
    B.conf目录
    C.lib目录
    classes目录

    解释:
    (1)/WEB-INF/web.xml 是部署描述文件
    (2)/WEB-INF/classes 用来放置应用程序用到的自定义类(.class),必须包括包(package)结构。
    (3)/WEB-INF/lib 用来放置应用程序用到的JAR文件。

    16.Java中基本的编程单元为:

    正确答案: A 你的答案: A (正确)
    A.类
    B.函数
    C.变量
    D.数据

    解释:
    java的基本编程单元是类,基本存储单元是变量。

    17.在 applet 的方法中 , 可关闭小应用程序并释放其占用资源的是( )

    正确答案: D 你的答案: B (错误)
    A.stop()
    B.paint()
    C.init()
    D.destroy()

    解释:
    Applet 类是浏览器类库中最为重要的类,同时也是所有 JAVA 小应用程序的基本类。 一个 Applet 应用程序从开始运行到结束时所经历的过程被称为 Applet 的生命周期。 Applet 的生命周期涉及 init() 、 start() 、 stop() 和 destroy() 四种方法,这 4 种方法都是 Applet 类的成员,可以继承这些方法,也可以重写这些方法,覆盖原来定义的这些方法。除此之外,为了在 Applet 程序中实现输出功能,每个 Applet 程序中还需要重载 paint() 方法:
    1、 public void init()
    init()方法是 Applet 运行的起点。当启动 Applet 程序时,系统首先调用此方法,以执行初始化任务。
    2、 public void start()
    start()方法是表明 Applet 程序开始执行的方法。当含有此 Applet 程序的 Web 页被再次访问时调用此方法。因此,如果每次访问 Web 页都需要执行一些操作的话,就需要在 Applet 程序中重载该方法。在 Applet 程序中,系统总是先调用 init() 方法,后调用 start() 方法。
    3、 public void stop()
    stop()方法使 Applet 停止执行,当含有该 Applet 的 Web 页被其他页代替时也要调用该方法。
    4、 public void destroy()
    destroy()方法收回 Applet 程序的所有资源,即释放已分配给它的所有资源。在 Applet 程序中,系统总是先调用 stop() 方法,后调用 destroy() 方法。
    5、 paint(Graphics g)
    paint(Graphics g)方法可以使 Applet 程序在屏幕上显示某些信息,如文字、色彩、背景或图像等。参数 g 是 Graphics 类的一个对象实例,实际上可以把 g 理解为一个画笔。对象 g 中包含了许多绘制方法,如 drawstring() 方法就是输出字符串。

    18.下面有个hibernate延迟加载,说法错误的是?

    正确答案: C 你的答案: A (错误)
    A.Hibernate2延迟加载实现:a)实体对象 b)集合(Collection)
    B.Hibernate3 提供了属性的延迟加载功能
    C.get支持延迟加载,load不支持延迟加
    D.hibernate使用Java反射机制,而不是字节码增强程序来实现透明性

    解释:
    Hibernate 中 get()和load() 的区别:
    1.get()采用立即加载方式,而load()采用 延迟加载 ; get()方法执行的时候,会立即向数据库发出查询语句, 而load()方法返回的是一个***(此***中只有一个id属性),只有等真正使用该对象属性的时候,才会发出 sql语句 2.如果数据库中没有对应的记录,get()方法返回的是null.而load()方法出现异常ObjectNotFoundException

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

    正确答案: D 你的答案: C (错误)
    A.调用方法sleep()
    B.调用方法wait()
    C.start()方法的执行结束
    D.run()方法的执行结束

    解释:
    A. 调用sleep()方***让线程进入睡眠状态—睡眠指定的时间后再次执行;
    B. 调用wait()方***让线程进入等待状态 ----等待别的线程执行notify()或notifyAll()唤醒后继续执行;
    C.调用start()方***让线程进入就绪状态—得到CPU时间就执行线程;
    D.run()方法是线程的具体逻辑方法,执行完,线程就结束。

    以下代码段执行后的输出结果为

    public class Test {
    public static void main(String args[]) {
    int x = -5;
    int y = -12;
    System.out.println(y % x);
    }
    }
    

    正确答案: D 你的答案: D (正确)A
    A.-1
    B.2
    C.1
    D.-2

    解释:
    Y(被除数) % X(除数) 当除数与被除数的符号相同时,取余和取模的结果是完全相同的; 当除数与被除数的符号不相同时,结果不同。   具体说,取余结果的符号与被除数相同;取模结果的符号与除数相同。 通常取模运算也叫取余运算,他们都遵循处罚法则,返回结果都是余数; 1.取余    rem(3,2)=1    rem(-3,-2)=-1    rem(3,-2)=1    rem(-3,2)=-1    2.取模    mod(3,2)=1    mod(-3,-2)=-1    mod(3,-2)=-1    mod(-3,2)=1

    21.以下代码结果是什么?
    下面展示一些 内联代码片

    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;
    }
    }
    

    正确答案: C 你的答案: C (正确)
    代码可以编译运行,输出“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。

    22.下面程序的输出结果是什么。

    public class A2{ 
    public static void main(String[] args){
        int[] a={2,4,6,8,3,6,9,12};
        doSomething(a,0,a.length-1);
        for(int i=0;i<=a.length-1;i++)
        System.out.print(a[i]+" ");
    } 
    private static void doSomething(int[] a,int start,int end){
        if(start<end){
            int p=core(a,start,end);
            doSomething(a,start,p-1);
            doSomething(a,p+1,end);
        }
    }
    private static int core(int[] a,int start,int end)
    {
        int x=a[end];
        int i=start;
        for(int j=start;j<=end-1;j++){
            if(a[j]>=x){
                swap(a,i,j);
                i++;//交换了几次 
            }
        }//把最大的放到最后
        swap(a,i,end);//把最大的放到i的位置 
        return i;
    } 
      
    private static void swap(int[] a,int i,int j) 
    {
        int tmp=a[i];
        a[i]=a[j];
        a[j]=tmp;
    }
    } 
    ;
    

    正确答案: C 你的答案: C (正确)
    A.找到最大值
    B.找到最小值
    C.从大到小的排序
    D.从小到大的排序

    解释:
    这道题目的核心思想是:根据交换的次数,决定存储的位置,交换0次,存在第一位,代表最大,交换1次,存在第二位,代表次大,以此类推…结果可以拿一个有序的递增序列进行验证,这样比较直观,而且简单粗暴

    23.以下哪项陈述是正确的?

    正确答案: E A 你的答案: C (错误)
    A.垃圾回收线程的优先级很高,以保证不再 使用的内存将被及时回收
    B.垃圾收集允许程序开发者明确指定释放 哪一个对象
    C.垃圾回收机制保证了JAVA程序不会出现 内存溢出
    D.进入”Dead”状态的线程将被垃圾回收器回收
    E.以上都不对

    解释;深入理解Java虚拟机 书籍中p66,真正宣布一个对象死亡,至少需要经历2次标记过程。当第一次标记时会同时进行一次筛选(判断此对象是否有必要执行finalize方法)。如果对象没有覆盖该方法,就面临死亡,所以说这个方法是对象逃脱死亡命运的最后一次机会。 大家顶我上去,让更多的人看到。看前面没人讲的很详细,如果想深究,去看书。

    24.检查程序,是否存在问题,如果存在指出问题所在,如果不存在,说明输出结果。

    package algorithms.com.guan.javajicu; 
    public class Inc { 
        public static void main(String[] args) { 
           Inc inc = new Inc(); 
           int i = 0; 
           inc.fermin(i); 
           i= i ++; 
           System.out.println(i);
        
        } 
        void fermin(int i){ 
           i++; 
        } 
    }
    

    正确答案: A 你的答案: A (正确)
    A.0
    B.1
    C.2
    D.3

    解释:
    i++ 先赋值在计算结果;
    ++i 先计算结果再赋值。
    int i = 0;
    i = i ++; // 左边这个i其实是障眼法,就是一个中间变量,可以和下行的i合并;
    System.out.println(i); 这里等价于:
    int i = 0;
    System.out.println(i++); 这下再看,先赋值(先将i传给println函数打印出来,在计算表达式结果)
    所以打印出来的是0,实际上整个表达式的结果已经是1了,只是没有打印出整个表达式的结果。
    所以我们知道如下结论:
    1、无论怎么变,i++和++i的整个表达式的结果都是1.
    2、有时我们打印的是表达式的结果(System.out.println(++i)),
    有时我们打印的只是一个中间变量(System.out.println(i++))。

    25.在java中,下列对继承的说法,正确的是( )

    正确答案: A 你的答案: A (正确)
    A.子类能继承父类的所有成员
    B.子类继承父类的非私有方法和状态
    C.子类只能继承父类的public方法和状态
    D.子类只能继承父类的方法

    解释:
    在一个子类被创建的时候,首先会在内存中创建一个父类对象,然后在父类对象外部放上子类独有的属性,两者合起来形成一个子类的对象。所以所谓的继承使子类拥有父类所有的属性和方法其实可以这样理解,子类对象确实拥有父类对象中所有的属性和方法,但是父类对象中的私有属性和方法,子类是无法访问到的,只是拥有,但不能使用。就像有些东西你可能拥有,但是你并不能使用。所以子类对象是绝对大于父类对象的,所谓的子类对象只能继承父类非私有的属性及方法的说法是错误的。可以继承,只是无法访问到而已。

    26.下列代码输出结果为( )

    class Animal{
        public void move(){
            System.out.println("动物可以移动");
        }
    }
    class Dog extends Animal{
        public void move(){
            System.out.println("狗可以跑和走");
        }
        public void bark(){
            System.out.println("狗可以吠叫");
        }
    }
    public class TestDog{
        public static void main(String args[]){
            Animal a = new Animal();
            Animal b = new Dog(); 
            a.move();
            b.move();
            b.bark();
        }
    }
    

    正确答案: D 你的答案: C (错误)
    A.动物可以移动
    狗可以跑和走
    狗可以吠叫
    B.动物可以移动
    动物可以移动
    狗可以吠叫
    C.运行错误
    D.编译错误

    解释:
    编译错误:The method bark() is undefined for the type Animal。Animal中没有定义bark()方法。
    Dog继承自Animal。
    当用Dog对象初始化Animal类对象时,完成了对Animal对象中方法与变量的覆盖与隐藏,也就是b.move()调用的是Dog中move()方法。而Animal中本身并没有bark()方法,不存在被覆盖的情况,亦无法访问,也就是b.bark()会报错。

    27.面向对象的三个基本元素是什么?

    正确答案: A B D 你的答案: A B D (正确)
    A.封装
    B.继承
    C.重载
    D.多态

    解释:
    三个基本元素:封装,继承,多态。
    五个基本原则:单一职责原则,开放封闭原则,里氏替换原则,依赖倒置原则,接口隔离原则

    28.以下哪几种是java的基本数据类型。

    正确答案: B C 你的答案: A B C D (错误)
    A.String
    B.int
    C.boolean
    D.Double

    解释:
    以下哪几种是java的基本数据类型。
    正确答案: B C 你的答案: A B C D (错误)
    String
    int
    boolean
    Double

    29.下面的Java赋值语句哪些是有错误的 ()

    正确答案: B F 你的答案: B (错误)
    A.int i =1000;
    B.float f = 45.0;
    C.char s = ‘\u0639’
    D.Object o = ‘f’;
    E.String s = “hello,world\0”;
    F.Double d = 100;

    解释:
    选项F是自动装箱, 装箱过程中调用的是Double类的valueOf( double d )方法, 而这里是100为int型, 所以编译会“cannot convert from int to Double”。

    30.下面哪项技术可以用在WEB开发中实现会话跟踪实现?

    正确答案: A B C D 你的答案: C D (错误)
    A.session
    B.Cookie
    C.地址重写
    D.隐藏域

    解释:
    HTTP是“无状态”协议:客户程序每次读取 Web 页面,都打开到 Web 服务器的单独的连接,并且,服务器也不自动维护客户的上下文信息。即使那些支持持续性 HTTP 连接的服务器,尽管多个客户请求连续发生且间隔很短时它们会保持 socket 打开,但是,它们也没有提供维护上下文信息的内建支持。上下文的缺失引起许多困难。例如,在线商店的客户向他们的购物车中加入商品时,服务器如何知道购物车中己有何种物品呢?类似地,在客户决定结账时,服务器如何能确定之前创建的购物车中哪个属于此客户呢?这些问题虽然看起来十分简单,但是由于 HTTP 的不足,解答它们却异常复杂困难。对于这个问题,存在 3 种典型的解决方案:
    Cookie(结合session使用)
    可以使用 cookie 存储购物会话的 ID;在后续连接中,取出当前的会话 ID,并使用这个 ID 从服务器上的查找表(lookup table)中提取出会话的相关信息。 以这种方式使用 cookie 是一种绝佳的解决方案,也是在处理会话时最常使用的方式。但是,sevlet 中最好有一种高级的 API 来处理所有这些任务,以及下面这些冗长乏味的任务:从众多的其他cookie中(毕竟可能会存在许多cookie)提取出存储会话标识符的 cookie;确定空闲会话什么时候过期,并回收它们;将散列表与每个请求关联起来;生成惟一的会话标识符。
    URL 重写
    采用这种方式时,客户程序在每个URL的尾部添加一些额外数据。这些数据标识当前的会话,服务器将这个标识符与它存储的用户相关数据关联起来。 URL重写是比较不错的会话跟踪解决方案,即使浏览器不支持 cookie 或在用户禁用 cookie 的情况下,这种方案也能够工作。URL 重写具有 cookie 所具有的同样缺点,也就是说,服务器端程序要做许多简单但是冗长乏味的处理任务。即使有高层的 API 可以处理大部分的细节,仍须十分小心每个引用你的站点的 URL ,以及那些返回给用户的 URL。即使通过间接手段,比如服务器重定向中的 Location 字段,都要添加额外的信息。这种限制意味着,在你的站点上不能有任何静态 HTML 页面(至少静态页面中不能有任何链接到站点动态页面的链接)。因此,每个页面都必须使用 servlet 或 JSP 动态生成。即使所有的页面都动态生成,如果用户离开了会话并通过书签或链接再次回来,会话的信息也会丢失,因为存储下来的链接含有错误的标识信息。
    隐藏的表单域
    HTML 表单中可以含有如下的条目:
    这个条目的意思是:在提交表单时,要将指定的名称和值自动包括在 GET 或 POST 数据中。这个隐藏域可以用来存储有关会话的信息,但它的主要缺点是:仅当每个页面都是由表单提交而动态生成时,才能使用这种方法。单击常规的超文本链接并不产生表单提交,因此隐藏的表单域不能支持通常的会话跟踪,只能用于一系列特定的操作中,比如在线商店的结账过程。

    展开全文
  • 牛客网第四天

    2018-10-18 22:57:50
    在JAVA中, 下列标识符合法的是() A.3kyou B.@163 C.name D.while 正确答案: C 你的答案: C (正确) 解析:JAVA中,标识符, 指用于给变量.类.方法名 等命名的名称. 1,标识以数字,字符,下划线,以及美元$符组成.(不...

    1 . 在JAVA中, 下列标识符合法的是()
    A.3kyou
    B.@163
    C.name
    D.while
    正确答案: C 你的答案: C (正确)
    解析:JAVA中,标识符, 指用于给变量.类.方法名 等命名的名称. 1,标识以数字,字符,下划线,以及美元$符组成.(不能包括@、%、空格等),不能以数字开头. 2,不能与JAVA关键字重复 3,严格区分的大小写,(Flag和flag是两个变量) abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for goto if implements import instanceof int interface long native new package private protected public return strictfp short static super switch synchronized this throw throws transient try void volatile while 等
    2. 有这样一段程序:
    public class Test{
    public static void main(String [] args){
    List list=new ArrayList();
    list.add(“a”);
    list.add(“b”);
    list.add(“a”);
    Set set=new HashSet();
    set.add(“a”);
    set.add(“b”);
    set.add(“a”);
    System.out.println(list.size()+","+set.size());
    }
    }
    请问运行主要的程序会打印出的是什么()
    A.2,2
    B.2,3
    C.3,2
    D.3,3
    解析:HashSet不能添加重复的元素,当调用add(Object)方法时候,
    首先会调用Object的hashCode方法判hashCode是否已经存在,如不存在则直接插入元素;
    如果已存在则调用Object对象的equals方法判断是否返回true, 如果为true则说明元素已经存在,如为false则插入元素
    3.从以下哪一个选项中可以获得Servlet的初始化参数?
    A.Servlet
    B.ServletContext
    C.ServletConfig
    D.GenericServlet
    正确答案: C 你的答案: B (错误)
    解析:
    ServletContext对象:servlet容器在启动时会加载web应用,并为每个web应用创建唯一的servlet context对象,可以把ServletContext看成是一个Web应用的服务器端组件的共享内存,在ServletContext中可以存放共享数据。ServletContext对象是真正的一个全局对象,凡是web容器中的Servlet都可以访问。
    整个web应用只有唯一的一个ServletContext对象
    servletConfig对象:用于封装servlet的配置信息。从一个servlet被实例化后,对任何客户端在任何时候访问有效,但仅对servlet自身有效,一个servlet的ServletConfig对象不能被另一个servlet访问。
    4.关于JAVA堆,下面说法错误的是()?
    A.所有类的实例和数组都是在堆上分配内存的
    B.堆内存由存活和死亡的对象,空闲碎片区组成
    C.数组是分配在栈中的
    D.对象所占的堆内存是由自动内存管理系统回收
    正确答案: C 你的答案: B (错误)
    解析:数组是一种对象,所有的对象类都是在堆内存中,基本数据类型在栈内存中
    5. 有如下代码:请写出程序的输出结果。
    public class Test
    {
    public static void main(String[] args)
    {
    int x = 0;
    int y = 0;
    int k = 0;
    for (int z = 0; z < 5; z++) {
    if ((++x > 2) && (++y > 2) && (k++ > 2))
    {
    x++;
    ++y;
    k++;
    }
    }
    System.out.println(x + ”” +y + ”” +k);
    }
    }
    A.432
    B.531
    C.421
    C.523
    正确答案: B 你的答案: C (错误)
    z=0时候,执行++x > 2,不成立,&&后面就不执行了,此时 x=1,y=0,k=0;
    z=1时候,执行++x > 2,还不成立 ,&&后面就不执行了,此时 x=2,y=0,k=0;
    z=2时候, 执行++x > 2,成立,继续执行 ++y > 2, 不成立 , &&后面就不执行了, 此时 x=3,y=1,k=0;
    z=3时候,执行++x > 2,成立,继续执行++y > 2,不成立 , &&后面就不执行了, 此时 x=4,y=2,k=0;
    z=4 时候,执行++x > 2,成立,继续执行 ++y > 2, 成立 , 继续执行k++>2 ,不成立,此时仍没有进入for循环的语句中, 但此时 x=5,y=3,k=1;
    z=5时候,不满足条件了,整个循环结束,所以最好打印时候: x=5,y=3,k=1;
    6.@SuppressWarnings(“deprecation”)的功能是什么?
    A.屏蔽不赞同使用的类和方法的警告
    B.屏蔽在强制类型转换的时候编译器给出的警告
    C.关闭所有警告信息
    D.当在可序列化的类上缺少serialVersionUID定义的警告
    正确答案: A 你的答案: B (错误)
    解析:本题考查注解编程,对java三大注解是否了解:
    @SuppressWarnings这是java三大注解之一,主要功能是屏蔽相应的警告。
    里面的deprecation修饰符则是对java中已经过时或者废弃方法的警告。
    @SuppressWarnings(“deprecation”)的功能是屏蔽不赞同(就是过时废弃的意思)使用的类和方法的警告
    7.对于非运行时异常,程序中一般可不做处理,由java虚拟机自动进行处理。
    A.正确
    B.错误
    正确答案: B 你的答案: B (正确)
    解析:Java异常都继承自类Throwable,Throwable子类有Error和Exception,其中Exception又分为运行时异常和编译时异常。编译时异常是未雨绸缪性质的异常,是防范,需要显示处理。运行时异常是程序员问题造成,并不强制进行显示处理。
    8. 如果一个接口Glass有个方法setColor(),有个类BlueGlass实现接口Glass,则在类BlueGlass中正确的是? ( )
    A.protected void setColor() { …}
    B.void setColor() { …}
    C.public void setColor() { …}
    D.以上语句都可以用在类BlueGlass中
    正确答案: C 你的答案: D (错误)
    解析:JAVA 子类重写继承的方法时,不可以降低方法的访问权限,子类继承父类的访问修饰符要比父类的更大,也就是更加开放,假如我父类是protected修饰的,其子类只能是protected或者public,绝对不能是friendly(默认的访问范围)或者private,当然使用private就不是继承了。还要注意的是,继承当中子类抛出的异常必须是父类抛出的异常的子异常,或者子类抛出的异常要比父类抛出的异常要少。
    9.下列Java代码中的变量a、b、c分别在内存的____存储区存放。
    class A {
    private String a = “aa”;
    public boolean methodB() {
    String b = “bb”;
    final String c = “cc”;
    }
    }
    A.堆区、堆区、堆区
    B.堆区、栈区、堆区
    C.堆区、栈区、栈区
    D.堆区、堆区、栈区
    E.静态区、栈区、堆区
    F.静态区、栈区、栈区
    正确答案: C 你的答案: E (错误)
    解析:堆区:只存放类对象,线程共享;
    方法区:又叫静态存储区,存放class文件和静态数据,线程共享;
    栈区:存放方法局部变量,基本类型变量区、执行环境上下文、操作指令区,线程不共享;
    10.下面哪个语句是创建数组的正确语句?( )
    A.float f[][] = new float[6][6];
    B.float []f[] = new float[6][6];
    C.float f[][] = new float[][6];
    D.float [][]f = new float[6][6];
    E.float [][]f = new float[6][];
    正确答案: A B D E 你的答案: D E (错误)
    解析:在Eclipse上敲一下就好了。

    展开全文
  • JAVA 选择题练习

    2021-01-15 12:35:53
    1.在JAVA中, 下列标识符合法的是(C) A. 3kyou B. @163 C. name D. while 解析:在JAVA中, 标识符命名规则: 1,标识符不能以数字开头,以数字、字符、下划线、以及美元$符组成(不能包括@、%、空格等)。 2,...
  • 因此,对象名(变量)实际上存放的是一个被实例化之后的对象所占有的内存区域 的指针。 例如: type objectName = new type ( [paramlist] ); 运算符 new 为对象分配内存空间 ,实例化一个对象 。new 调用对象的构造...
  • 1、外观:表面无脏污、破损,电感量标识完整、清晰、型号规格正确,引线脚无氧化、弯曲、变形。 (目测) 2、结构尺寸:电感主体尺寸、引线脚尺寸应符合装配或样品要求。 (试装或用游标卡尺测量。) 3、插件...
  • Java基础 学习笔记 1单词及运算符关键字标识符合法的标识符规则Java中的名称规范Java注释常量与变量常量变量运算符算术运算符赋值运算符比较运算符逻辑运算符三元运算符语句判断语句选择语句生成一个适合你的列表...
  • 标识符合法写法: 1.数字不能开头 2.第一个字符之后,可以包含货币符号、连字符、数字、字母、汉字任意组合 3.字符长度没有限制,一般不要太长 4.Java关键字(保留字)不能作为...
  •  10111100.10111100.000000**.********,一共有530台电脑,IP最后一段1~254可以分给254台计算机,530/254=2.086,采用进1,得整数3,这样,我们确定了IP第三段要分成三个不同数字,也就是说,把...
  • 文章目录创建表语形式细节设置表主键1)、单字段主键修改表语形式 创建表 语法形式 CREATE TABLE 表名( 属性名 数据类型 [完整性约束条件], 属性名 数据类型 [完整性约束条件], . . . 属性名 数据类型 ); ...
  • 这个阶段发展迅速,互联网应用趋于多样化,其中变化最大的是由web 1.0网站创造内容的时代变为由用户创造内容的web 2.0时代。 在web 2.0应用中,博客(Blog)是web 2.0核心应用中最典型、最流行的代表之一,也是web ...
  • 使用BAPI_ACC_DOCUMENT_POST创建会计凭证时,需要在行项目传入反记账标识和记账码,但是找遍了BAPI下面传值结构也没有找到记账码传值,倒是找到了反记账标识的传值,但是实在抬头上,明显不符合要求。...
  • 说明: 与 NLS_TIME_FORMAT 相似, 只不过它设置的是 TIMESTAMP 数据类型的默认值, 该数据类型既存储YEAR, MONTH 和 DAY 这几个日期值, 也存储 HOUR, MINUTE 和 SECOND 这几个时间值。 语法: TIMESTAMP '1997-01-31 ...
  • 您对小米帐号申请、使用等行为应符合小米帐号使用协议及小米不时修订并公布规范。</p> <h4>2.2【用户资格】</h4> <p>在您开始注册程序使用本平台服务前,您应当具备中华人民...
  • flutter Dart DateTime详解

    千次阅读 2019-12-15 09:41:49
      DateTime类用来标识一个瞬时时间节点,可以通过构造函数,从标准格式(符合ISO 8601标准)字符串中构造一个时间对象。DateTIme使用24小时计时。以下是最基础例子: var now = new DateTime.now(); var ...
  • 食品安全管理制度.doc

    2020-12-26 19:44:00
    食品安全管理制度 食品进货查验制度 一、为保障人民群众身体健康和生命安全,加强对食品经营食品质量监督管理,保护消费者合法权益,依据《中华人民共和国食品卫生》、《中华人民共和国产品质量》、《中华...
  • (4) 下面描述中,符合结构化程序设计风格的是(A) A. 使用顺序、选择和重复(循环)三种基本控制结构表示程序的控制逻辑 B. 模块只有一个入口,可以有多个出口 C. 注重提高程序的执行效率 D. 不使用goto语句 (5) 下面...
  • 下列图符名标识的图符不属于数据流图合法图符的是______。(A) A. 控制流 B. 加工 C. 数据存储 D. 源和潭 (17) 软件需求分析阶段的工作,可以分为四个方面:需求获取、需求分析、编写需求规格说明书以及______。(B) A...
  • ● 在Ajax应用程序中使用XML或JSON表示法的细节。 本书遵循已被验证的学习法则,帮助读者逐步理解各种概念,使读者掌握在各种浏览器中创建强大的、快速响应的应用程序的方法。 “无论你是初学者还是有经验的程序员,...
  •  在Ajax应用程序中使用XML或JSON表示法的细节。本书遵循已被验证的学习法则,帮助读者逐步理解各种概念,使读者掌握在各种浏览器中创建强大的、快速响应的应用程序的方法。  “无论你是初学者还是有经验的程序员,...
  • 例如:火车进遂道,最先进遂道的是火车头,最后是火车尾,而火车出遂道的时候也是火车头先出,最后出的是火车尾。若有队列: Q =(q1,q2,…,qn) 那么,q1为队头元素(排头元素),qn为队尾元素。队列中的元素是按照q1...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    第十一章 方 .124 11.1 方法声明.124 11.2 方法中参数.125 11.3 静态和非静态方法.129 11.4 方法重载.130 11.5 操作符重载.134 11.6 小 结.137 第十二章 域 和 属 性 .139 12.1 域 .139 ...
  • C#微软培训资料

    2014-01-22 14:10:17
    第十一章 方 .124 11.1 方法声明.124 11.2 方法中参数.125 11.3 静态和非静态方法.129 11.4 方法重载.130 11.5 操作符重载.134 11.6 小 结.137 第十二章 域 和 属 性 .139 12.1 域 .139 ...
  • 完整性规则是给定数据模型中数据及其联系所具有制约和依存规则,用以限定符合数据模型数据库状态以及状态变化,以保证数据正确、有效、相容。解析数据模型是数据库系统中最重要概念之一。必须通过 《 ...
  • 软件测试规范

    2018-04-23 09:16:12
    软件测试目标 .................................................................................................................................. 2 三.软件测试流程 .......................................

空空如也

空空如也

1 2 3
收藏数 52
精华内容 20
关键字:

标识符合法的是