2018.7.17 牛客网训练

1.以下哪个接口的定义是正确的？（ D ）

A.interface  B
     { public abstract void print()  {  } ;}

B.interface  B
     { static void print() ;}

C.abstract  interface  B  extends  A1, A2  //A1、A2为已定义的接口
     {private abstract  void  print();}

D.interface  B
      {  void  print();}

解释：

A 抽象方法不能有方法体，
B 接口里的方法只能用 public 和 abstract 修饰，如果你不写也没关系，默认的也是 public abstract 修饰.
   B选项是错的，接口中都是抽象方法，如果又定义了静态方法print()，那是没法调用B. print()的，因为它没方法体

2.下列符号中可以在 java 程序里表示单行注释的是（C ）

   --

  /* ……*/

  //

  /** ……*/

解释

1、单行(single-line)--短注释：//……    
注释格式：/* 注释内容 */
2、块(block)--块注释：/*……*/ 
/*
  * 注释内容
  */
3、文档注释：/**……*/
注释若干行，并写入javadoc文档。每个文档注释都会被置于注释定界符
/**......*/之中

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

解释

java1.8实测，抽象类中的抽象方法和非抽象方法在不加修饰符的情况下，都是默认的default

以前抽象类或者抽象方法默认是protected，jdk1.8以后改成默认default了

抽象类的方法可以是public protected的，接口的方法只能是public的

4.Java语言中，如果"xyz"没有被创建过，String s =new String(“xyz”);创建了几个string object？ B

A、1        B、2      C、3       D、4

解释

两个。第一个在堆中，第二个在字符串常量池中！如果在Java字符串常量池中已经存在，就只会创建一个

“xyz”对应一个对象，这个对象存放在字符 串常量缓冲区，不管常量“xyz”出现多少遍，都是缓冲区的那一个，new String每写一遍就创建一个新的对象，如果之前用过“xyz”,那就不会创建，直接从缓冲区拿。所以说可能一个或者两个对象


   jvm 首先在字符串常量池内里面看看找不找到字符串"xyz"；找到，进入第二步；否则，创建新的 String 对象，并“放到”字符串常量池里面。
然后由于遇到了 new，还会在堆创建 String 对象，其实是拷贝的常量池的那个，拷贝比创建大概快吧...最后将其返回给 s1。
将 new String("xyz") 拆分为 new String() 和 "xyz"
如果写在类方法里，请参考前面的类加载，就是相比之下提前驻留了吧。

5.Panel 和 Applet 的默认布局管理器是（ B ）

CardLayout

FlowLayout

BorderLayout

GridLayout

解释

FlowLayout流式布局管理器,是Panel和Applet默认布局管理器，它具有指定的对齐方式以及指定的水平和垂直间隙。
GridLayout布局管理器,GridLayout(int rows,int cols,int hgap,int vgap);建立一个表格的版面对象。rows代表有几行，cols代表有几列；hgap是组件之间的水平距离，vgap是组件之间的竖直距离。

6.下列Java常见事件类中哪个是鼠标事件类？（ MouseEvent ）

7.以下有关构造方法的说法，正确的是：（ A ）

一个类的构造方法可以有多个

构造方法在类定义时被调用

构造方法只能由对象中的其他方法调用

构造方法可以和类同名，也可以和类名不同

解释

A  一个类有多个构造方法便是重载的表现。重载参数列表不同。所以A是正确的。
B  构造方法是在对象创建时就被调用，用于初始化。
C  构造方法是给与之对应的对象进行初始化，初始化的动作只执行一次。
D  构造方法必须与所在类的名称同名。

8.在异常处理中，若try中的代码可能产生多种异常则可以对应多个catch语句，若catch中的参数类型有父类子类关系，此时应该将父类放在后面，子类放在前面。 （ 对 ）

（ 若 catch 中的参数类型有父类子类关系，此时应该将父类放在后面，子类放在前面 ）

9.要使对象具有序列化能力，则其类应该实现如下哪个接口( A )。

java.io.Serializable

java.lang.Cloneable,

java.lang.CharSequence

java.lang.Comparable

解释

java.io.Serializable接口是一个标志性接口，在接口内部没有定义任何属性与方法。只是用于标志此接口的实现类可以被序列化与反序列化。

java.lang.Cloneable接口是一个标志性接口，在接口内部没有定义任何属性与方法。以指示Object.clone()方法可以合法地对该类实例进行按字段复制。

java.lang.CharSequence接口对许多不同种类的char序列提供统一的只读访问接口。CharSequence是char值的一个可读序列。

java.lang.Comparable接口，此接口强制对实现它的每个类的对象进行整体排序，此序列被称为该类的自然排序

10.____技术是一种可以使音频，视频和其他多媒体信息在 Internet 及 Intranet 上以实时的，无需下载等待的方式进行播放的技术。 （流媒体 StreamingMedia ）

11.一个以”.java”为后缀的源文件（） 正确答案: C

只能包含一个类，类名必须与文件名相同

只能包含与文件名相同的类以及其中的内部类

只能有一个与文件名相同的类，可以包含其他类

可以包含任意类

解释

在一个.java文件中，只能有一个类用public修饰，且该类的名称与文件名相同。其他类则个数不限。

12.A 派生出子类 B ， B 派生出子类 C ，并且在 java 源代码有如下声明：1. A a0=new A(); 2. A a1=new B(); 3. A a2=new C(); 问以下哪个说法是正确的？（ D ）

只有第一行能通过编译

第1、2行能通过编译，但第3行编译出错

第1、2、3行能通过编译，但第2、3行运行时出错

第1行，第2行和第3行的声明都是正确的

解释

父类（基类）的引用可以指向子类的实例化对象

这道题的考点是Java的继承关系。B继承于A，C继承于B，所以A为B和C共同的父类。
1.   A a0=new A();这种是正常和常见的声明。

2. A a1=new B();类型的向上提升。

3. A a2=new C();类型的向上提升。

13.关于依赖注入，下列选项中说法错误的是（ B ）

依赖注入能够独立开发各组件，然后根据组件间关系进行组装

依赖注入使组件之间相互依赖，相互制约

依赖注入提供使用接口编程

依赖注入指对象在使用时动态注入

解释

依赖注入的动机就是减少组件之间的耦合度，使开发更为简洁

依赖注入和控制反转是同一概念：
        依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源；而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。

14.下面有关jsp中静态include和动态include的区别，说法错误的是？ D

动态INCLUDE:用jsp:include动作实现
 
静态INCLUDE:用include伪码实现，定不会检查所含文件的变化，适用于包含静态页面<%@ include file="included.htm" %>

静态include的结果是把其他jsp引入当前jsp，两者合为一体;动态include的结构是两者独立，直到输出时才合并

静态include和动态include都可以允许变量同名的冲突.页面设置也可以借用主文件的

解释

静态的include不允许变量同名

静态的include：是jsp的指令来实现的，<% @ include file="xx.html"%> 特点是 共享request请求域，先包含再编译，不检查包含页面的变化。
动态的include：是jsp动作来实现的，<jsp:include page="xx.jsp" flush="true"/>  这个是不共享request请求域，先编译在包含，是要检查包含页面的变化的。

15.class Foo {

final int i;
int j;
public void doSomething() {
    System.out.println(++j + i);
}

}

输出的是： 不能执行，因为编译有错

解释

D。final类型的变量一定要初始化，因为final的变量不可更改。

16.关于HashMap与HashTable，以下说法错误的是（ B ）

两者都是用key-value方式获取数据

Hashtable允许null值作为key和value，而HashMap不可以

HashMap不是同步的，而Hashtable是同步的

迭代HashMap采用快速失败机制，而Hashtable不是

解释

A：HashMap和Hashtable两个类都实现了Map接口，二者保存K-V对（key-value对）

B：HashTable不允许null值(key和value都不可以),HashMap允许null值(key和value都可以)。

C：Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。

D：由所有HashMap类的“collection 视图方法”所返回的迭代器都是快速失败的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器本身的 remove 方法，其他任何时间任何方式的修改，迭代器都将抛出ConcurrentModificationException。Hashtable和HashMap的区别主要是前者是同步的，后者是快速失败机制保证
          快速失败（Fail-Fast）机制：对于线程不安全的集合对象的迭代器，如果在使用迭代器的过程中有其他线程修改了集合对象结构或者元素数量，那么将抛出ConcurrentModificationException，这就是所谓fail-fast策略。
迭代 HashMap 采用快速失败机制，而 HashTable 不是，因为 HashTable 是线程安全的。
          java的快速失败机制，即fail-fast，它是Java集合的一种错误检测机制。当多个线程对集合进行结构上的改变的操作时，有可能会产生fail-fast机制。记住是有可能，而不是一定。

17.以下程序的输出结果是？ B

public class Example {
    String str = new String("good");
    char[] ch = { ‘a‘, ‘b‘, ‘c‘ };
 
    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 static void change(String str, char ch[])      
   {
        str = "test ok";
        ch[0] = ‘g‘;
    }
}

good and abc

good and gbc

test ok and abc

test ok and gbc

解释

对于值传递，拷贝的值用完之后就会被释放，对原值没有任何影响，但是对于引用传递，拷贝的是对象的引用，和原值指向的同一块地址，即操作的是同一个对象，所以操作之间会相互影响;
所以对于String str是值传递，操作之间互不影响，原值保持不变。而ch是数组，拷贝的是对象的引用，值发生了改变

18.下列关于Java并发的说法中正确的是（） 正确答案: B

CopyOnWriteArrayList适用于写多读少的并发场景

ReadWriteLock适用于读多写少的并发场景

ConcurrentHashMap的写操作不需要加锁，读操作需要加锁

只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了

A，CopyOnWriteArrayList适用于写少读多的并发场景
B，ReadWriteLock即为读写锁，他要求写与写之间互斥，读与写之间互斥，
   读与读之间可以并发执行。在读多写少的情况下可以提高效率
C，ConcurrentHashMap是同步的HashMap，读写都加锁
D，volatile只保证多线程操作的可见性，不保证原子性

解释

一个线程执行的过程有三个阶段：
     加载（复制）主存数据到操作栈 -->  对操作栈数据进行修改  --> 将操作栈数据写回主存
     volatite关键字，让编译器不去优化代码使用缓存等，以保证线程在“加载数据阶段”加载的数据都是最新的

19.下列命令中，用来运行 Java 程序的是（ java ） 编译的是javac

20.hat is displayed when the following is executed;

double d1=-0.5;
System.out.println("Ceil d1="+Math.ceil(d1));
System.out.println("floor d1="+Math.floor(d1));

Ceil d1=-0.0
floor d1=-1.0

Ceil d1=0.0
floor d1=-1.0

Ceil d1=-0.0
floor d1=-0.0

Ceil d1=0.0
floor d1=0.0

Ceil d1=0
floor d1=-1

解释

ceil：天花板数，向上取整。
floor：地板数，向下取整

ceil：大于等于 x，并且与它最接近的整数。
floor：小于等于 x，且与 x 最接近的整数。

这里有一点比较主要的：
    Math.ceil(d1)     如果参数小于0且大于-1.0，结果为 -0

    Math.floor(d1):如果参数是 NaN、无穷、正 0、负 0，那么结果与参数相同，如果是 -0.0，那么其结果是 -0.0

21.有如下一段代码，请选择其运行结果（ true false ）

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

解释

要注意两个问题：
1，字符串在java中存储在字符串常量区中
2，==判断的是对象引用是否是同一个引用，判断字符串相等要用equals方法
首先判断a==MESSAGE 同一份字符串常量在内存中只有一份，因此是同一地址，返回true
再次比较(b+c)==MESSAGE 这相当于 new String(b+c)==MESSAGE 这里new了一个String对象，所以返回false

Java中的变量和基本类型的值存放于栈内存，而new出来的对象本身存放于堆内存，指向对象的引用还是存放在栈内存；栈内存的一个特点是数据共享，这样设计是为了减小内存消耗，

22. PreparedStatement是CallableStatement的父接口

解释

CallableStatement继承自PreparedSatement，PreparedStatement继承自Statement

PreparedStatement是预编译的，使用PreparedStatement有几个好处

 a. 在执行可变参数的一条SQL时，PreparedStatement比Statement的效率高，因为DBMS预编译一条SQL当然会比多次编译一条SQL的效率要高。

 b. 安全性好，有效防止Sql注入等问题。

 c.  对于多次重复执行的语句，使用PreparedStament效率会更高一点，并且在这种情况下也比较适合使用batch；

 d.  代码的可读性和可维护性。

CallableStatement接口扩展 PreparedStatement，用来调用存储过程,它提供了对输出和输入/输出参数的支持。CallableStatement 接口还具有对 PreparedStatement 接口提供的输入参数的支持。

23.下面有关JAVA swing的描述，说法错误的是？ 正确答案: C

Swing是一个基于Java的跨平台MVC框架。使用单线程模式。
Swing 是为了解决 AWT 存在的问题而新开发的包，它以 AWT 为基础的
Swing优化了AWT，运行速度比AWT快
Swing是一个基于组件的框架，所有的组件都是从javax.swing.JComponent类继承来的

解释

首先swing是单线程的

Swing是一个用于开发Java应用程序用户界面的开发工具包。它以抽象窗口工具包（AWT）为基础使跨平台应用程序可以使用任何可插拔的外观风格。Swing开发人员只用很少的代码就可以利用Swing丰富、灵活的功能和模块化组件来创建优雅的用户界面。 
  工具包中所有的包都是以swing作为名称，例如javax.swing,javax.swing.event
  用Swing创建图形界面步骤：
  （1）导入Swing包
  （2）选择界面风格
  （3）设置顶层容器
  （4）设置按钮和标签
  （5）将组件放到容器上
  （6）为组件增加边框
  （7）处理事件
  （8）辅助技术支持

 1。导入Swing包
  下面语句导入Swing包
  import javax.swing.*;
  大部分Swing程序用到了AWT的基础底层结构和事件模型,因此需要导入两个包：
  import java.awt.*;
  import java.awt.event.*;
  如果图形界面中包括了事件处理，那么还需要导入事件处理包：
  import javax.swing.event.*;
  2.选择界面风格
  Swing允许选择程序的图形界面风格常用的有java风格，windows风格等
  下面的代码用于选择图形界面风格，这里选择的是跨平台的Java界面风格。
  try { UIManager.setLookAndFeel( 
  UIManager.getCrossPlatformLookAndFeelClassName( )); } 
  catch (Exception e) { }
  (3) 设置顶层容器
  图形界面至少要有一个顶级Swing容器
  顶级Swing容器为其它Swing组件在屏幕上的绘制和处理事件提供支持
  常用的顶级容器：
  JFrame（框架）：表示主程序窗口
  JDialog（对话框）：每个JDialog对象表示一个对话框，对话框属于二级窗口
  JApplet（小程序）：在浏览器内显示一个小程序界面
  一个框架包括边界、菜单栏、工具栏、状态栏，以及中间占主要部分的窗格
  窗格也可以看作是一种面板，但它是框架的一个组成部分
  组件不会直接放到框架上，而是放在若干个面板上，这些面板再放到窗格上
  用框架对象的getContentPane()函数来获得窗格，再调用窗格的add()函数放置面板
  public static void main(String[ ]args){JFrame frame=new JFrame("SwingApplication");
  JPanel panel1=new JPanel();
  frame.getContentPane().add(panel1,BorderLayout.CENTER);
  ......//添加其他组件
  frame.pack();frame.setVisible(true);}

Swing 是在AWT的基础上构建的一套新的图形界面系统，它提供了AWT 所能够提供的所有功能，并且用纯粹的Java代码对AWT 的功能进行了大幅度的扩充。AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT 的Java程序，其运行速度比较慢。

AWT和Swing之间的区别：
       1)AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT的Java程序，其运行速度比较慢。
       2)AWT的控件在不同的平台可能表现不同，而Swing在所有平台表现一致。

       在实际应用中，应该使用AWT还是Swing取决于应用程序所部署的平台类型。例如：
       1)对于一个嵌入式应用，目标平台的硬件资源往往非常有限，而应用程序的运行速度又是项目中至关重要的因素。在这种矛盾的情况下，简单而高效的AWT当然成了嵌入式Java的第一选择。

       2)在普通的基于PC或者是工作站的标准Java应用中，硬件资源对应用程序所造成的限制往往不是项目中的关键因素。所以在标准版的Java中则提倡使用Swing， 也就是通过牺牲速度来实现应用程序的功能。

24.下列说法正确的是 B

在类方法中可用this来调用本类的类方法

在类方法中调用本类的类方法时可直接调用

在类方法中只能调用本类中的类方法

在类方法中绝对不能调用实例方法

解释

所谓类的方法就是指类中用static 修饰的方法（非static 为实例方法），比如main 方法，那么可以以main 方法为例，可直接调用其他类方法，必须通过实例调用实例方法，this 关键字不是这么用的。比如main 方法，那么可以以main 方法为例，可直接调用其他类方法，必须通过实例调用实例方法，this 关键字不是这么用的。

在类方法中不能有this关键字，，直接调用类方法即可

25.java中关于继承的描述正确的是（ ACD）

一个子类只能继承一个父类

子类可以继承父类的构造方法

继承具有传递性

父类一般具有通用性，子类更具体

解释

在java中，子类构造器会默认调用super()(无论构造器中是否写有super（）),用于初始化父类成员，同时当父类中存在有参构造器时，必须提供无参构造器，子类构造器中并不会自动继承有参构造器，仍然默认调用super()，使用无参构造器。因此，一个类想要被继承必须提供无参构造器。
方法没有继承一说，只有重载和重写

26.Choose the correct ones from the following statements:

A class can implement more than one interfaces

A class can extend more than one class

An interface has at least one method declared.

An abstract class which has no abstract methods declared is legal

解释

1、一个类可以有多个接口；
2、一个类只能继承一个父类；
3、接口中可以不声明任何方法，和成员变量
interface testinterface{
    
}
4、抽象类可以不包含抽象方法，但有抽象方法的类一定要声明为抽象类
 abstract class abstclass{
    abstract void meth();
}

2018.7.17 牛客网训练

原文：https://www.cnblogs.com/qichunlin/p/9321206.html