weixin_42431912

对网上一些Java笔试题的总结,答案与自我理解(400道)

对网上一些Java笔试题的总结,答案与自我理解

1… https://www.nowcoder.com/questionTerminal/48db39d722894c08907a8f613858672e
在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放。（ b ）

正确
错误
GC垃圾回收器会自动识别无用的内存

2… https://www.nowcoder.com/questionTerminal/9d4c6e25554a42e68ce6fbe40ef79afd
下列有关JAVA异常处理的叙述中正确的是（a）
finally是为确保一段代码不管是否捕获异常都会被执行的一段代码
throws是用来声明一个成员方法可能抛出的各种非运行异常情况
final用于可以声明属性和方法，分别表示属性的不可变及方法的不可继承
throw是用来明确地抛出一个异常情况

try块必须和catch块或和finally同在,不能单独存在,二者必须出现一个.
finally块总会执行,不论是否有错误出现.但是若try语句块或会执行的catch语句块使用了JVM系统退出语句,finally块就不会被执行了. 一般我们把关闭资源的代码放在finally里面保证资源总是能关闭
B选项是因为抛出的是异常情况而不是非异常
C根本就跟异常处理没有关系，所以不选。就算有关系也错了
final用于声明属性、方法、类。分别表示属性不可更改、方法不能被覆盖、类不能被继承。
所以C选项说方法不能被继承错误，是不能覆盖
throw是用来明确地抛出一个异常情况。错误，throw不仅仅可以抛出异常，还可以抛出Error以及Throwable.

3… https://www.nowcoder.com/questionTerminal/2732166fc5aa4335ae0a4b2085da041c
下列说法错误的有（ a,c,d）
在类方法中可用this来调用本类的类方法
在类方法中调用本类的类方法时可直接调用
在类方法中只能调用本类中的类方法
在类方法中绝对不能调用实例方法

首先：
成员方法又称为实例方法
静态方法又称为类方法
其次：
a，静态方法中没有this指针
c，类方法是可以调用其他类的static方法的。
d，太绝对化了，在类中申请一个类对象或者参数传递一个对象或者指针都可以调用;

4… https://www.nowcoder.com/questionTerminal/fd323dab24dc4989b9322680bf43b9ce
以下哪些继承自 Collection 接口（a,b）
List
Set
Map
Array
5… https://www.nowcoder.com/questionTerminal/9b1fef54196f4d1e881804bb235fcd2c
DBMS
中实现事务持久性的子系统是(d)
安全性管理子系统
完整性管理子系统
并发控制子系统
恢复管理子系统

要想事物具有持久性，就得在事物出错时及时恢复。

6… https://www.nowcoder.com/questionTerminal/51123ddacab84a158e121bc5fe3917eb
下列Java代码中的变量a、b、c分别在内存的_c___存储区存放。
class A {
private String a = “aa”;
public boolean methodB() {
String b = “bb”;
final String c = “cc”;
}
}
堆区、堆区、堆区
堆区、栈区、堆区
堆区、栈区、栈区
堆区、堆区、栈区
静态区、栈区、堆区
静态区、栈区、栈区

堆区：只存放类对象，线程共享；
方法区：又叫静态存储区，存放class文件和静态数据，线程共享;
栈区：存放方法局部变量，基本类型变量区、执行环境上下文、操作指令区，线程不共享;

常量池：未经 new 的常量
堆区：成员变量的引用，new 出来的变量
栈区：局部变量的引用

成员变量的引用在堆区，是因为成员变量的所属对象在堆区，所以它也在堆区。见 https://blog.csdn.net/leunging/article/details/80599282。
局部变量的引用在栈区，是因为局部变量不属于某一个对象，在被调用时才被加载，所以在栈区。

7… https://www.nowcoder.com/questionTerminal/25deb8d21e7d442e86c90302d6e03133
public class NameList
{
private List names = new ArrayList();
public synchronized void add(String name)
{
names.add(name);
}
public synchronized void printAll() {
for (int i = 0; i < names.size(); i++)
{
System.out.print(names.get(i) + ””);
}
}
public static void main(String[]args)
{
final NameList sl = new NameList();
for (int i = 0; i < 2; i++)
{
new Thread()
{
public void run()
{
sl.add(“A”);
sl.add(“B”);
sl.add(“C”);
sl.printAll();
}
} .start();
}
}
}
Which two statements are true if this class is compiled and run? e,g
An exception may be thrown at runtime.
The code may run with no output, without exiting.
The code may run with no output, exiting normally(正常地).
The code may rum with output “A B A B C C “, then exit.
The code may rum with output “A B C A B C A B C “, then exit.
The code may ruin with output “A A A B C A B C C “, then exit.
The code may ruin with output “A B C A A B C A B C “, then exit.

8… https://www.nowcoder.com/questionTerminal/970cdaaa4a114cbf9fef82213a7dabca
对于JVM内存配置参数：
-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3 初始堆大小
,其最小内存值和Survivor区总大小分别是（d）
5120m，1024m
5120m，2048m
10240m，1024m
10240m，2048m
D
-Xmx：最大堆大小
-Xms：初始堆大小
-Xmn:年轻代大小
-XXSurvivorRatio：年轻代中Eden区与Survivor区的大小比值
年轻代5120m， Eden：Survivor=3，Survivor区大小=1024m（Survivor区有两个，即将年轻代分为5份，每个Survivor区占一份），总大小为2048m。
-Xms初始堆大小即最小内存值为10240m

9… https://www.nowcoder.com/questionTerminal/2aa69f9816ac4cc4be8872861dca6d6e java单继承,构造方法不能继承
java中关于继承的描述正确的是（a,c,d）
一个子类只能继承一个父类
子类可以继承父类的构造方法
继承具有传递性
父类一般具有通用性，子类更具体

10… https://www.nowcoder.com/questionTerminal/97b40275377b478b87e3e1f35dc098b8
“==“和”!=“比较的是地址指第一个new()c出来的地址
以下程序段的输出结果为： b
public class EqualsMethod
{
public static void main(String[] args)
{
Integer n1 = new Integer(47);
Integer n2 = new Integer(47);
System.out.print(n1 == n2);
System.out.print(”,”);
System.out.println(n1 != n2);
}
}
false，false
false，true
true，false
true，true
俩都是new出来的,肯定地址不是同一个

11… https://www.nowcoder.com/questionTerminal/593cc3972afe4b32a49cd9c518571221
Given the following code: b
public class Test {
private static int j = 0;
private static Boolean methodB(int k) {
j += k;
return true;
}
public static void methodA(int i) {
boolean b;
b = i < 10 | methodB(4);//中间为与计算符，执行完methodB(4)后，j = 4
b = i < 10 || methodB(8);//中间为或计算符，因为i < 10 已成立，不需要后续计算所以最后结果输出为4
}
public static void main(String args[]) {
methodA(0);
System.out.println(j);
}
}
What is the result?
The program prints”0”
The program prints”4”
The program prints”8”
The program prints”12”
The code does not complete.

12… https://www.nowcoder.com/questionTerminal/7d7814b41ded4364aeee6c671233ddb8
类Parent和Child定义如下：

    1) class  Parent{
      
    2) public    float  aFun(float a, float b) {   }

    3) }
    
    4)  class  Child    extends  Parent{
    
	5)
	
    6)  }

将以下哪种方法插入行5是不合法的。（ a ）
float aFun(float a, float b){ }
public int aFun(int a, int b) { }
public float aFun(float p, float q){ }
private int aFun(int a, int b){ }

A选项是重写，但是默认访问修饰符比父类小，插入第五行编辑器会报错。
B、D不是重写。因为形参列表和返回值类型不同，不满足“三同”。所以写在第五行以普通方法对待，插入第五行没有错误。
C选项满足重写的各项条件，是正确的重写，所以插入第五行没有错误。

13… https://www.nowcoder.com/questionTerminal/b730e61f1fc646a7a33b8700a20bb1c7
阅读以下 foo 函数，请问它的时间复杂度是：c int foo(intarray[], int n, int key) { int n1=0,n2=n-1,m; while(n1<=n2) { m=(n1+n2)/2; if(array[m]==key) return m; if(array[m]>key) n2=m-1; else n1=m+1; } return -1; }
O(n2)
O(n3)
O(log(n))
O(n)

二分查找时间复杂度为O（logn）

14… https://www.nowcoder.com/questionTerminal/2be86af464c04b9c9d7895d62dd46732
假设 a 是一个由线程 1 和线程 2 共享的初始值为 0 的全局变量，则线程 1 和线程 2 同时执行下面的代码，最终 a 的结果不可能是（d）

 boolean isOdd = false;  
for(int i=1;i<=2;++i)
 {
 if（i%2==1）isOdd = true； 
else isOdd = false； 
 a+=i*(isOdd?1:-1)；
  }

-1
-2
0
1

假设两线程为A、B，设有3种情况：
1.AB不并发：此时相当于两个方法顺序执行。A执行完后a=-1，B使用-1作为a的初值，B执行完后a=-2
2.AB完全并发：此时读写冲突，相当于只有一个线程对a的读写最终生效。相同于方法只执行了一次。此时a=-1
3.AB部分并发：假设A先进行第一次读写，得到a=1;之后A的读写被B覆盖了。B使用用1作为a的初值，B执行完后a=0

15… https://www.nowcoder.com/questionTerminal/48524c47dd924887be6684b17175fa40
往OuterClass类的代码段中插入内部类声明, 哪一个是错误的:a,b,c,d
public class OuterClass{
private float f=1.0f;
//插入代码到这里
}
class InnerClass{
public static float func(){return f;}
}
abstract class InnerClass{
public abstract float func(){}
}
static class InnerClass{
protected static float func(){return f;}
}
public class InnerClass{
static float func(){return f;}
}

主要考核了这几个知识点：
1.静态内部类才可以声明静态方法
2.静态方法不可以使用非静态变量
3.抽象方法不可以有函数体
静态方法不能访问非静态变量，A和C错；
抽象类中的抽象方法不能有方法体，B错；
一个类中有多个类声明时，只能有一个public类，D错

16… https://www.nowcoder.com/questionTerminal/fb463f20d1cc44e3b4476e5d5319e7e9
下列选项中是正确的方法声明的是？（a,b,c,d）
protected abstract void f1();
public final void f1() {}
static final void fq(){}
private void f1() {}

A：抽象方法只可以被public 和 protected修饰；
B：final可以修饰类、方法、变量，分别表示：该类不可继承、该方法不能重写、该变量是常量
C：static final 可以表达在一起来修饰方法，表示是该方法是静态的不可重写的方法
D：private 修饰方法（这太常见的）表示私有方法，本类可以访问，外界不能访问

17… https://www.nowcoder.com/questionTerminal/3175bb91e5974b97abb6317c247f1bfe
关于类的静态成员的不正确描述是（d）
静态成员不属于对象，是类的共享成员
静态成员要在类外定义和初始化
静态成员函数不拥有this指针，需要通过类参数访问对象成员
只有静态成员函数可以操作静态数据成员

A----------静态成员不属于对象，是类的共享成员。
B----------静态成员要在类外定义和初始化。
B显然是有问题的。静态成员变量存储在方法区，也是在类内定义和初始化的。
C----------静态成员函数不含有this指针，需要通过类参数访问对象成员。
因为静态成员函数被调用的时候，该静态成员函数所属的类很有可能还没有被初始化，所以静态成员函数是不含有this指针的。
D----------只有静态成员函数可以操作静态数据成员。
D显然也是有问题的，非静态成员函数也可以操作静态数据成员。

18… https://www.nowcoder.com/questionTerminal/1bbb41f39dff48d399ef31c5b000e33e
以下哪项陈述是正确的？e
垃圾回收线程的优先级很高，以保证不再使用的内存将被及时回收
垃圾收集允许程序开发者明确指定释放哪一个对象
垃圾回收机制保证了JAVA程序不会出现内存溢出
进入”Dead”状态的线程将被垃圾回收器回收
以上都不对

答案：E
A: 垃圾回收在jvm中优先级相当相当低。
B：垃圾收集器（GC）程序开发者只能推荐JVM进行回收，但何时回收，回收哪些，程序员不能控制。
C：垃圾回收机制只是回收不再使用的JVM内存，如果程序有严重BUG，照样内存溢出。
D：进入DEAD的线程，它还可以恢复，GC不会回收

19.https://www.nowcoder.com/questionTerminal/e75ac035e2d64fbf9989fea31abe0f4e
java8中，下面哪个类用到了解决哈希冲突的开放定址法 c
LinkedHashSet
HashMap
ThreadLocal
TreeMap

ThreadLocalMap中使用开放地址法来处理散列冲突，而HashMap中使用的是分离链表法。
之所以采用不同的方式主要是因为：在ThreadLocalMap中的散列值分散得十分均匀，很少会出现冲突。并且ThreadLocalMap经常需要清除无用的对象，使用纯数组更加方便。

20… https://www.nowcoder.com/questionTerminal/779a8f85397b46dcb98e3ccf299f331f
下列说法正确的有（a,c,d ）
环境变量可在编译source code时指定
在编译程序时，所能指定的环境变量不包括class path
javac一次可同时编译数个Java源文件
javac.exe能指定编译结果要置于哪个目录（directory）

1.环境变量可在编译source code时指定，java -d <目录> 指定放置生成的类文件的位置，A对B错；
2.javac *.java. 即可编译当前目录下的所有java文件，C对；
3.java -s <目录> 指定放置生成的源文件的位置,D对；

21.https://www.nowcoder.com/questionTerminal/bf65d2fb658642a5a959c11f6ce2d77a
public interface IService {String NAME=“default”;}
默认类型等价表示是哪一项: c
public String NAME=“default”;
public static String NAME=“default”;
public static final String NAME=“default”;
private String NAME=“default”;

接口中的成员包括：全局常量和抽象方法。接口中的成员都有固定的修饰符，成员变量：public static final 成员方法：public abstract
接口中的成员的访问权限都是公共的，接口中可以隐藏不写这些固定的修饰符。
接口不可以实例化，只有子类重写了接口中的所有方法后，子类才可以实例化，否则子类还是一个抽象类。
子类重写方法的访问权限都是public的。

22… https://www.nowcoder.com/questionTerminal/d0b72fbaf82c4c92a96b190908e2fbe6
在Struts框架中如果要使用Validation作验证的话，需要使用以下哪个Form？d
ActionForm
ValidatorActionForm
ValidatorForm
DynaValidatorActionForm

DynaValidatorActionForm 动态验证表单
Validation 确认的意思

23… https://www.nowcoder.com/questionTerminal/3dfd72f89070415185f09aebecd0e3f7
Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（a,c,d）。
加载Servlet类及.class对应的数据
创建servletRequest和servletResponse对象
创建ServletConfig对象
创建Servlet对象

Servlet的生命周期一般可以用三个方法来表示：
init()：仅执行一次，负责在装载Servlet时初始化Servlet对象
service() ：核心方法，一般HttpServlet中会有get,post两种处理方式。在调用doGet和doPost方法时会构造servletRequest和servletResponse请求和响应对象作为参数。
destroy()：在停止并且卸载Servlet时执行，负责释放资源
初始化阶段：Servlet启动，会读取配置文件中的信息，构造指定的Servlet对象，创建ServletConfig对象，将ServletConfig作为参数来调用init()方法。所以选ACD。B是在调用service方法时才构造的

24… https://www.nowcoder.com/questionTerminal/15b1429e6c364c3bbe6e8134a519f2a3
byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2); /语句1/
b6=b4+b5; /语句2/
b8=(b1+b4); /语句3/
b7=(b2+b5); /语句4/
System.out.println(b3+b6); 下列代码片段中，存在编译错误的语句是(a,c,d)
语句2
语句1
语句3
语句4

Java表达式转型规则由低到高转换：
1、所有的byte,short,char型的值将被提升为int型；
2、如果有一个操作数是long型，计算结果是long型；
3、如果有一个操作数是float型，计算结果是float型；
4、如果有一个操作数是double型，计算结果是double型；
5、被fianl修饰的变量不会自动改变类型，当2个final修饰相操作时，结果会根据左边变量的类型而转化。
--------------解析--------------
语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int；
语句2正确：b6=b4+b5;b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型；
语句3错误：b8=(b1+b4);虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4);
语句4错误：b7=(b2+b5); 同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变

25… https://www.nowcoder.com/questionTerminal/9dfb7470f3014166947cba07a69133c3
当您尝试编译并运行以下代码时会发生什么
What will happen when you attempt to compile and run the following code? d
public class Test{
static{
int x=5;
}
static int x,y;
public static void main(String args[]){
x–;
myMethod( );
System.out.println(x+y+ ++x);
}
public static void myMethod( ){
y=x++ + ++x;
}
}
compiletime error
prints:1
prints:2
prints:3
prints:7
prints:8

1.JVM加载class文件时，就会执行静态代码块，静态代码块中初始化了一个变量x并初始化为5，由于该变量是个局部变量，静态代码快执行完后变被释放。
2.申明了两个静态成员变量x，y，并没有赋初值，会有默认出值，int类型为0，
3.执行x–操作，变量单独进行自增或自减操作x–和--x的效果一样，此时x变为了-1
4.调用MyMethod()方法，在该方法中对x和y进行计算，由于x和y都是静态成员变量，所以在整个类的生命周期内的x和y都是同一个
5.y=x++ + ++x可以看成是y=(x++)+(++x)，当++或者–和其它变量进行运算时，x++表示先运算，再自增，++x表示先自增再参与运算
所以就时x为-1参与运算，然后自增，x此时为0，++x后x为1，然后参与运算，那么y=-1+1就为0，此时x为1
6.执行并打印x+y + ++x运算方式和第5步相同，最后计算结果就为3.

26…https://www.nowcoder.com/questionTerminal/ec83945fe29f44abbdd6d156fbeccdb1
（这个题不严谨，可以先不做，后面改正后再做）设有下面的两个类定义：
class Father{
public Father(){
System.out.println(“我是父类”);
}
}
class Child extends Father {
public Child(){
System.out.println(“我是子类”);
}
}
则顺序执行如下语句后输出结果为：（） Father a; Child b;
我是父类我是子类
我是子类我是父类
我是父类我是父类
我是子类我是子类

27… https://www.nowcoder.com/questionTerminal/146b3d53c337437fbf780114f18da3c7
要求匹配以下16进制颜色值，正则表达式可以为：b #ffbbad #Fc01DF #FFF #ffE
/#([0-9a-f]{6}|[0-9a-fA-F]{3})/g
/#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})/g
/#([0-9a-fA-F]{3}|[0-9a-f]{6})/g
/#([0-9A-F]{3}|[0-9a-fA-F]{6})/g

28… https://www.nowcoder.com/questionTerminal/27abe0380cbb41a0a612e30e65024e14
下列关于JavaBean的说法正确的是：a
Java文件与Bean所定义的类名可以不同，但一定要注意区分字母的大小写
在JSP文件中引用Bean，其实就是用语句
被引用的Bean文件的文件名后缀为.java
Bean文件放在任何目录下都可以被引用

（1）懂得将 Bean 放在哪个目录下：在 Resin 中 JavaBean 放在 doc\web-inf\classes 目录中。
（2）懂得如何使用 JBuilder 定义一个 Bean；其中的语法规范不一定要记住，但要理解
其中的结构。
（3）Java 文件和 Bean所定义的类名一定要相同，并且是大小写敏感。
（4）Bean中要声明公共方法，与 Bean的名字相同。
（5）懂得如何在JSP 文件中引用JavaBean，其实就是jsp:useBean的语句。
（6）一定要紧记Java 是区分大小写的。

29…https://www.nowcoder.com/questionTerminal/8b992ee9de5e40bb84f6fd29e69d842d
存根（Stub）与以下哪种技术有关 b
交换
动态链接
动态加载
磁盘调度

stub 充当远程对象的客户端代理，有着和远程对象相同的远程接口，远程对象的调用实际是通过调用该对象的客户端代理对象stub来完成的。
这种方式符合等到程序要运行时将目标文件动态进行链接的思想
理解为适配器模式，继承该类则不需要实现一个接口全部方法

30… https://www.nowcoder.com/questionTerminal/47399c2d404c4808bc7914a0596bbdc2
下列各项说法中错误的是？b,
共享数据的所有访问都必须使用synchronized加锁
共享数据的访问不一定全部使用synchronized加锁
所有的对共享数据的访问都是临界区
临界区必须使用synchronized加锁

共享数据的所有访问一定要作为临界区，用synchronized标识，这样保证了所有的对共享数据的操作都通过对象锁的机制进行控制。

https://www.nowcoder.com/questionTerminal/049f3c3b41024630887a7f596e7b450f
设有下面两个赋值语句：
a = Integer.parseInt(“1024”);
b = Integer.valueOf(“1024”).intValue();
下述说法正确的是（d）
a是整数类型变量，b是整数类对象。
a是整数类对象，b是整数类型变量。
a和b都是整数类对象并且它们的值相等。
a和b都是整数类型变量并且它们的值相等。

intValue()是把Integer对象类型变成int的基础数据类型；
parseInt()是把String 变成int的基础数据类型；
Valueof()是把String 转化成Integer对象类型；（现在JDK版本支持自动装箱拆箱了。）
本题：parseInt得到的是基础数据类型int，valueof得到的是装箱数据类型Integer，然后再通过valueInt转换成int，所以选择D

https://www.nowcoder.com/questionTerminal/92620388e2754b72950ca939d6493300
变量a是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF;变量b是一个64位有符号的整数，初始值用16进制表示为：0x8000000000000000。则a+b的结果用10进制表示为多少？b
1
-1
2⁶³⁺²62+…+2²⁺²1+2^0
–(2⁶³⁺²62+…+2²⁺²1+2^0)

a+b=0xFFFFFFFFFFFFFFFF，十六进制的F对应十进制的15，再转换成二进制则为1111。
所以a+b得1111 1111 1111 1111，二进制的首尾为符号位，1位负数，0则为正数，这里为1所以a+b的结果是负数。
负数在内存中存储以补码的形式，所以求原码的步骤为：
1.补码-1得反码（变为1111 1111 1111 1110）
2.反码按位取反得原码（1000 0000 0000 0001）
3.转换成二进制结果为-1

https://www.nowcoder.com/questionTerminal/711badc732d84bd98e4ac684e09791b8
package Wangyi;
class Base
{
public void method()
{
System.out.println(“Base”);
}
}
class Son extends Base
{
public void method()
{
System.out.println(“Son”);
}

public void methodB()
{
System.out.println(“SonB”);
}
}
public class Test01
{
public static void main(String[] args)
{
Base base = new Son();
base.method();
base.methodB();
}
}
问这个程序的输出结果。d
Base SonB
Son SonB
Base Son SonB
编译不通过

Base base = new Son();
这句new 了一个派生类，赋值给基类，所以下面的操作编译器认为base对象就是Base类型的
Base类中不存在methodB()方法，所以编译不通过

https://www.nowcoder.com/questionTerminal/9438324d0fb4407ba96d20df09e90125
在Java中，以下关于方法重载和方法重写描述正确的是？d
方法重载和方法的重写实现的功能相同
方法重载出现在父子关系中，方法重写是在同一类中
方法重载的返回值类型必须一致，参数项必须不同
方法重写的返回值类型必须相同或相容。

重载（overload）：只要方法名一致，其他（参数列表、返回值）怎么折腾随便。重载是发生在同一类中
重写（overriding）：只有实现的功能代码不一致，其他的（函数名、参数列表、返回值类型）必须都一致。重写发生在子类与父类之间

https://www.nowcoder.com/questionTerminal/4cefb62973b149478bedc0ebcdbfb160
下列哪行会产生错误？
Which lines of the following will produce an error? a
byte a1 = 2, a2 = 4, a3;
short s = 16;
a2 = s;
a3 = a1 * a2;
Line 3 and Line 4
Line 1 only
Line 3 only
Line 4 only

short类型转为byte类型出错,short不能自动转成byte和char，必须强转

a1*a2结果为int类型，转为byte类型出错,
java中如果碰到char、byte和short参与运算时，会自动将这些值转换为int类型然后再进行运算。这里a1和a2就自动转为int类型了，结果也为Int类型。把一个int类型赋值给byte需要转型
byte+byte=int，低级向高级是隐式类型转换，高级向低级必须强制类型转换，byte

https://www.nowcoder.com/questionTerminal/f32600cdc2ad413082ea503f9496cadd
下列关于容器集合类的说法正确的是？c
LinkedList继承自List
AbstractSet继承自Set
HashSet继承自AbstractSet
WeakMap继承自HashMap

A.LinkedList是继承自AbstractSequentialList（抽象类，实现了List接口）的，并且实现了List接口。所以A错误。
B.AbstractSet是实现了Set接口的，本身是一个抽象类。继承自AbstractCollection（抽象类，实现了Collection接口）。所以B错误。
C.HashSet是继承自AbstractSet，实现了Set接口。所以C正确。
D.WeakMap不存在于java集合框架的。只有一个叫做WeakHashMap（继承自AbstractMap）。

https://www.nowcoder.com/questionTerminal/5ce602538d784f51a531bf9760592773
以下代码执行的结果显示是多少（0）？

505000
0
运行时错误
5050

for循环外面count=0,循环里面的count=count++;(count的值都等于count值，而后面count自加不影响count结果，因此这个式子无意义);循环count都为0（因count++是先返回count的本身值再自加1的）！
若是改为count=++count;（先自加，再返回自加后的值），结果就是5050101=510050了！
改为count++;结果就是5050101=510050了！

https://www.nowcoder.com/questionTerminal/695903546ba84d388fd80b1461a6141c
以下哪些方法可以取到http请求中的cookie值（a,d）?
request.getAttribute
request.getHeader
request.getParameter
request.getCookies
链接：https://www.nowcoder.com/questionTerminal/695903546ba84d388fd80b1461a6141c
来源：牛客网

(1) request.getAttribute:getAttribute是在服务器端的操作。
比如说 request.setAttribute(k,v),其行为动作在服务器端。
而在服务端放入cookies是通过response.addCookie(cookie)。因此，A错了
(2）String getHeader(String name)
以字符串形式返回指定的请求头的值。Cookie也是头的一种；

C.request.getParameter()方法获取从客户端中通过get 或者post方式传送到服务器端的参数。行为操作在服务器端。所以cookies明显不是通过url或者form表单提交过来的。C错

D.看方法名字就行了。

https://www.nowcoder.com/questionTerminal/795b066b67c84478aec4dc400b3d0153
以下哪些jvm的垃圾回收方式采用的是复制算法回收? a,d
新生代串行收集器
老年代串行收集器
并行收集器
新生代并行回收收集器
老年代并行回收收集器
cms收集器

两个最基本的java回收算法：复制算法和标记清理算法
复制算法：两个区域A和B，初始对象在A，继续存活的对象被转移到B。此为新生代最常用的算法
标记清理：一块区域，标记可达对象（可达性分析），然后回收不可达对象，会出现碎片，那么引出
标记-整理算法：多了碎片整理，整理出更大的内存放更大的对象
两个概念：新生代和年老代
新生代：初始对象，生命周期短的
永久代：长时间存在的对象
整个java的垃圾回收是新生代和年老代的协作，这种叫做分代回收。
P.S：Serial New收集器是针对新生代的收集器，采用的是复制算法
Parallel New（并行）收集器，新生代采用复制算法，老年代采用标记整理
Parallel Scavenge（并行）收集器，针对新生代，采用复制收集算法
Serial Old（串行）收集器，新生代采用复制，老年代采用标记整理
Parallel Old（并行）收集器，针对老年代，标记整理
CMS收集器，基于标记清理
G1收集器：整体上是基于标记整理，局部采用复制

综上：新生代基本采用复制算法，老年代采用标记整理算法。cms采用标记清理。

https://www.nowcoder.com/questionTerminal/a2230836563b4e26b3b32b108cfcf051
Hashtable 和 HashMap 的区别是： b,c,d,e

Hashtable 是一个哈希表，该类继承了 AbstractMap，实现了 Map 接口
HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口
Hashtable 线程安全的，而 HashMap 是线程不安全的
Properties 类继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类
HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口

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值

https://www.nowcoder.com/questionTerminal/34a92a7e42a84f048491e9339631891a
JVM内存不包含如下哪个部分(d )
Stacks
PC寄存器
Heap
Heap Frame
JVM内存区域分为五个部分，分别是堆(Heap)，方法区(Method Area)，虚拟机栈(VM Stacks)，本地方法栈(Native Method Stack)，程序计数器(PC寄存器(Program Counter Regist)，就是程序计数器)。
https://www.nowcoder.com/questionTerminal/f85fca7cda00483f896b9bf9267412f4
下面不属于HttpServletRequest接口完成功能的是？c
读取cookie
读取HTTP头
设定响应的content类型
读取路径信息

HttpServletRequest类主要处理：
1.读取和写入HTTP头标
2.取得和设置cookies
3.取得路径信息
4.标识HTTP会话
HttpServletResponse类主要处理:

向客户端写入Cookie
设置响应头信息；设定响应的content类型
发送响应的状态码。
设置响应正文；getWriter().print(“fdsfdsa”);
重定向：sendRedirect(“path”);

A: request.getCookies();
B: request.getHeader(String s);
C: response.setContentType(“text/html;charset=utf-8”);
C: request.getContextPath();/request.getServletPath();

https://www.nowcoder.com/questionTerminal/fa0749bc01754235b1607fb04889d705
哪些是Java中的关键字
Which are keywords in Java? d,e
null
true
sizeof
implements
instanceof

java中true ,false , null在java中不是关键字，也不是保留字，它们只是显式常量值，但是你在程序中不能使用它们作为标识符。
sizeof 是 C/C++ 中的方法，Java 中并没有这个方法，也没有该关键字或保留字
implements 和 instanceof 都是 Java 中的关键字

https://www.nowcoder.com/questionTerminal/ecbf77acda8645f3b79e0705a95fc880
给定下面的代码，输出是什么？
given the following code,what will be the output? a
class Value{
public int i=15;
}
public class Test{
public static void main(String argv[]){
Test t=new Test( );
t.first( );
}
public void first( ){
int i=5;
Value v=new Value( );
v.i=25;
second(v,i);
System.out.println(v.i);
}
public void second(Value v,int i){
i = 0;
v.i = 20;
Value val = new Value( );
v = val;
System.out.println(v.i+" "+i);
}
}
15 0 20
15 0 15
20 0 20
0 15 20

这题选A，考察的是值传递与引用传递，Java中原始数据类型都是值传递，传递的是值得副本，形参的改变不会影响实际参数的值，
引用传递传递的是引用类型数据，包括String,数组，列表, map,类对象等类型，形参与实参指向的是同一内存地址，因此形参改变会影响实参的值。

可能有人会选择B，包括我刚开始也是。总以为v不是已经指向了val了吗？？为什么还是20呢？不应该是15吗？
其实，原因很简单。现在我们把second（）换一下
publicvoidsecond(Value tmp,inti){
i = 0;
tmp.i = 20;
Value val = newValue( );
tmp = val;
System.out.println(tmp.i+" "+i);
}
这个tmp其实相当于是一个指向原来first中的V这个对象的指针，也就是对v对象的引用而已。但是引用是会改变所指的地址的值的。
所以在second中当tmp.i= 20的时候，就把原来first中的v的i值改为20了。接下来，又把tmp指向了新建的一个对象，所以在second中的tmp
现在指的是新的对象val，i值为15.
当执行完毕second后，在first中在此输出v.i的时候，应为前面second中已经把该位置的i的值改为了20，所以输出的是20.
至于疑惑v指向了val，其实只是名字的问题，在second中的v实践也是另外的一个变量，名字相同了而已，这个估计也是纠结的重点。

本题考查两个知识点：

局部变量名字会屏蔽点外作用域同名字变量
函数的参数传递问题

下面直接在代码上进行详细分析：

classValue{
publicinti=15;
}
publicclassTest{
publicstaticvoidmain(String argv[]){
Test t=newTest( );
t.first( );
}

publicvoidfirst( ){
inti=5;//注意这个i是局部变量
Value v=newValue( );
v.i=25;//创建了一个Value对象，并把此对象的属性i赋值25(默认值为15)
second(v,i);//v (v中的属性i值为25) 和局部变量i 传进函数second
System.out.println(v.i);//v的属性i在second函数中被改为了20
}

publicvoidsecond(Value v,inti){
i = 0;//second函数中的局部变量，和之前的i没关系
v.i = 20;//将传进的V的属性i改为20
Value val = newValue( );
v = val;//新创建的Value对象val,属性i值为15，并将v指向val对象，v已经和之前传进来的对象没关系了
System.out.println(v.i+" "+i);//此时v的属性i为15，先输出 15(v.i) 0(i)
}
}
所以，输出 15 0 20

https://www.nowcoder.com/questionTerminal/1a16b12b50e346b5aa1f9a681d056daf
下列关于计算机系统和Java编程语言的说法，正确的是（c）
计算机是由硬件、操作系统和软件组成，操作系统是缺一不可的组成部分。
Java语言编写的程序源代码可以不需要编译直接在硬件上运行。
在程序中书写注释不会影响程序的执行，可以在必要的地方多写一些注释。
Java的集成开发环境（IDE），如Eclipse，是开发Java语言必需的软件工具。

计算机是由软件和硬件组成的,操作系统非必须
还有别的开发环境,IDEA

https://www.nowcoder.com/questionTerminal/241062d4dd6e4d9dbff3bb45984af04a
关于struts框架，下面那些说法是正确的？B
Struts中无法完成上传功能
Struts框架基于MVC模式
Struts框架容易引起流程复杂、结构不清晰等问题
Struts可以有效地降低项目的类文件数目

A，structs可以进行文件上传
B，structs基于MVC模式，MVC是模型，视图，控制器，是一种设计模式
C，structs框架让流程结构更清晰
D，structs需要很多 action类，会增加类文件数目

Struts是最早的java开源框架之一，它是MVC设计模式的一个优秀实现。 Struts定义了通用的Controller(控制器)，通过配置文件(通常是 Struts -config.xml)隔离Model(模型)和View(视图)，
以Action的概念以对用户请求进行了封装，使代码更加清晰易读。 Struts还提供了自动将请求的数据填充到对象中以及页面标签等简化编码的工具。 Struts能够开发大型Java Web项目。

https://www.nowcoder.com/questionTerminal/0df1f90997014eb98fcf02dbcc61e0d9
ResultSet中记录行的第一列索引为？C
-1
0
1
以上都不是

ResultSet跟普通的数组不同，索引从1开始而不是从0开始
ResultSet数组是从1开始遍历。ResultSet是jsp，用来接收获取的数据库信息，查询时也是从第1列开始。

https://www.nowcoder.com/questionTerminal/b3b8a1f1a95e453e8fa38ee264191304
在各自最优条件下,对N个数进行排序,哪个算法复杂度最低的是? （a）
插入排序
快速排序
堆排序
归并排序

插入排序：最佳O（N）
快速排序：最佳O（NlogN）
堆排序：最佳O（NlogN）
归并排序：最佳O（NlogN）
因此选择插入排序。

https://www.nowcoder.com/questionTerminal/4c776177d2c04c2494f2555c9fcc1e49
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

import java.util.Stack;
import java.util.Arrays;
public class Solution {
/*借用辅助栈存储min的大小，自定义了栈结构
*/
private int size;
private int min = Integer.MAX_VALUE;
private Stack minStack = new Stack();
private Integer[] elements = new Integer[10];
public void push(int node) {
ensureCapacity(size+1);
elements[size++] = node;
if(node <= min){
minStack.push(node);
min = minStack.peek();
}else{
minStack.push(min);
}
// System.out.println(min+"");
}

private void ensureCapacity(int size) {
    // TODO Auto-generated method stub
    int len = elements.length;
    if(size > len){
        int newLen = (len*3)/2+1; //每次扩容方式
        elements = Arrays.copyOf(elements, newLen);
    }
}
public void pop() {
    Integer top = top();
    if(top != null){
        elements[size-1] = (Integer) null;
    }
    size--;
    minStack.pop();    
    min = minStack.peek();
//    System.out.println(min+"");
}

public int top() {
    if(!empty()){
        if(size-1>=0)
            return elements[size-1];
    }
    return (Integer) null;
}
public boolean empty(){
    return size == 0;
}

public int min() {
    return min;
}

}

https://www.nowcoder.com/questionTerminal/074fc24958e5487e849685fea6a2fb8e
以下哪个类包含方法flush()？（b）
InputStream
OutputStream
A 和B 选项都包含
A 和B 选项都不包含
flush（）函数强制将缓冲区中的字符流、字节流等输出，
目的是如果输出流输出到缓冲区完成后，缓冲区并没有填满，那么缓冲区将会一直等待被填满。所以在关闭输出流之前要调用flush（）。
https://www.nowcoder.com/questionTerminal/eee02717270a4519bf7d4c2a47f3d821
下面的程序将来打印什么?（a）
public class TestIncr {
public static void main(String args[]) {
int i = 0;
i = i++ + i;
System.out.println("I = "a + i);
}
}
I = 1
I = 2
I = 3
编译出错
a就没有被定义，编译肯定不通过呀
https://www.nowcoder.com/questionTerminal/529d3ae5a407492994ad2a246518148a
输入一个链表，输出该链表中倒数第k个结点。

时间复杂度O(n),一次遍历即可
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
ListNode pre=null,p=null;
//两个指针都指向头结点
p=head;
pre=head;
//记录k值
int a=k;
//记录节点的个数
int count=0;
//p指针先跑，并且记录节点数，当p指针跑了k-1个节点后，pre指针开始跑，
//当p指针跑到最后时，pre所指指针就是倒数第k个节点
while(p!=null){
p=p.next;
count++;
if(k<1){
pre=pre.next;
}
k–;
}
//如果节点个数小于所求的倒数第k个节点，则返回空
if(count return pre;

}

https://www.nowcoder.com/questionTerminal/d0267f7f55b3412ba93bd35cfa8e8035
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
链接：https://www.nowcoder.com/questionTerminal/d0267f7f55b3412ba93bd35cfa8e8035
来源：牛客网

方法一：链表从尾到头输出，利用递归实现，不使用库函数直接printf输出的时候用递归比较好

/**

struct ListNode {
```
   int val;
```
```
   struct ListNode *next;
```
```
   ListNode(int x) :
```
```
         val(x), next(NULL) {
```
```
   }
```
};
/
class Solution {
public:
vector printListFromTailToHead(struct ListNode head) {
vector value;
if(head != NULL)
{
value.insert(value.begin(),head->val);
if(head->next != NULL)
{
vector tempVec = printListFromTailToHead(head->next);
if(tempVec.size()>0)
value.insert(value.begin(),tempVec.begin(),tempVec.end());
}
```
 }
 return value;
```
}
};

https://www.nowcoder.com/questionTerminal/deec39e906544bf788593b4a5ede42db
下列哪个选项是错误的。（a,d）
一个文件中只能有一个public class。
一个文件中可以有多个类。
一个类中可以有两个main方法。
若类中只含一个main方法，则必须是public的。

A.一个文件中，可以有多个public class
即，外部类为public，还可以有public的内部类。
B.一个文件中可以有多个类，可以是多个并列的类，也可以是外部类、内部类结合。
C.一个类中，可以有多个main方法，这是重载，但是public static void main(String[] args)的方法只能有一个。
D.类中，可以有main方法，也可以没有main方法，而有一个main()方法的时候，也可以是任意访问权限。因为这个类不一定要执行，可以只是辅助类。

https://www.nowcoder.com/questionTerminal/c6c7742f5ba7442aada113136ddea0c3
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。 n<=39
用循环
public class Solution {
public int Fibonacci(int n) {
int preNum=1;
int prePreNum=0;
int result=0;
if(n0)
return 0;
if(n1)
return 1;
for(int i=2;i<=n;i++){
result=preNum+prePreNum;
prePreNum=preNum;
preNum=result;
}
return result;

}
}
https://www.nowcoder.com/questionTerminal/beb5aa231adc45b2a5dcc5b62c93f593
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

/两个思路吧，第一个思路：类似冒泡算法，前偶后奇数就交换：
class Solution {
public:
void reOrderArray(vector &array) {

    for (int i = 0; i < array.size();i++)
    {
        for (int j = array.size() - 1; j>i;j--)
        {
            if (array[j] % 2 == 1 && array[j - 1]%2 == 0) //前偶后奇交换
            {
                swap(array[j], array[j-1]);
            }
        }
    }
}

};

//第二个思路：再创建一个数组
class Solution{
public:
void reOrderArray(vector &array) {

    vector array_temp;
    vector::iterator ib1, ie1;
    ib1 = array.begin();


    for (; ib1 != array.end();){            //遇见偶数，就保存到新数组，同时从原数组中删除
        if (*ib1 % 2 == 0) {
            array_temp.push_back(*ib1);
            ib1 = array.erase(ib1);
        }
        else{
            ib1++;
        }

    }
    vector::iterator ib2, ie2;
    ib2 = array_temp.begin();
    ie2 = array_temp.end();

    for (; ib2 != ie2; ib2++)             //将新数组的数添加到老数组
    {
        array.push_back(*ib2);
    }
}

};
57. https://www.nowcoder.com/questionTerminal/a1b2b9033b2f4dc5ac79ad2cd24772c1
关于ASCII码和ANSI码，以下说法不正确的是（d）？
标准ASCII只使用7个bit
在简体中文的Windows系统中，ANSI就是GB2312
ASCII码是ANSI码的子集
ASCII码都是可打印字符

A、标准ASCII只使用7个bit，扩展的ASCII使用8个bit。
B、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符。超出此范围的使用0x80~0xFFFF来编码，即扩展的ASCII编码。不同 ANSI 编码之间互不兼容。在简体中文Windows操作系统中，ANSI 编码代表 GBK 编码；在繁体中文Windows操作系统中，ANSI编码代表Big5；在日文Windows操作系统中，ANSI 编码代表 Shift_JIS 编码。
C、ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符，即ASCII码
D、ASCII码包含一些特殊空字符

https://www.nowcoder.com/questionTerminal/9f3231a991af4f55b95579b44b7a01ba
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
链接：https://www.nowcoder.com/questionTerminal/9f3231a991af4f55b95579b44b7a01ba
来源：牛客网

旋转之后的数组实际上可以划分成两个有序的子数组：前面子数组的大小都大于后面子数组中的元素

注意到实际上最小的元素就是两个子数组的分界线。本题目给出的数组一定程度上是排序的，因此我们试着用二分查找法寻找这个最小的元素。

思路：

（1）我们用两个指针left,right分别指向数组的第一个元素和最后一个元素。按照题目的旋转的规则，第一个元素应该是大于最后一个元素的（没有重复的元素）。

但是如果不是旋转，第一个元素肯定小于最后一个元素。

（2）找到数组的中间元素。

中间元素大于第一个元素，则中间元素位于前面的递增子数组，此时最小元素位于中间元素的后面。我们可以让第一个指针left指向中间元素。

移动之后，第一个指针仍然位于前面的递增数组中。

中间元素小于第一个元素，则中间元素位于后面的递增子数组，此时最小元素位于中间元素的前面。我们可以让第二个指针right指向中间元素。

移动之后，第二个指针仍然位于后面的递增数组中。

这样可以缩小寻找的范围。

（3）按照以上思路，第一个指针left总是指向前面递增数组的元素，第二个指针right总是指向后面递增的数组元素。

最终第一个指针将指向前面数组的最后一个元素，第二个指针指向后面数组中的第一个元素。

也就是说他们将指向两个相邻的元素，而第二个指针指向的刚好是最小的元素，这就是循环的结束条件。

到目前为止以上思路很耗的解决了没有重复数字的情况，这一道题目添加上了这一要求，有了重复数字。

因此这一道题目比上一道题目多了些特殊情况：

我们看一组例子：｛1，0，1，1，1｝和｛1，1， 1，0，1｝都可以看成是递增排序数组｛0，1，1，1，1｝的旋转。

这种情况下我们无法继续用上一道题目的解法，去解决这道题目。因为在这两个数组中，第一个数字，最后一个数字，中间数字都是1。

第一种情况下，中间数字位于后面的子数组，第二种情况，中间数字位于前面的子数组。

因此当两个指针指向的数字和中间数字相同的时候，我们无法确定中间数字1是属于前面的子数组（绿色表示）还是属于后面的子数组（紫色表示）。

也就无法移动指针来缩小查找的范围。

代码

#include
#include
#include
#include
#include
using namespace std;

class Solution {
public:
int minNumberInRotateArray(vector rotateArray) {
int size = rotateArray.size();
if(size == 0){
return 0;
}//if
int left = 0,right = size - 1;
int mid = 0;
// rotateArray[left] >= rotateArray[right] 确保旋转
while(rotateArray[left] >= rotateArray[right]){
// 分界点
if(right - left == 1){
mid = right;
break;
}//if
mid = left + (right - left) / 2;
// rotateArray[left] rotateArray[right] rotateArray[mid]三者相等
// 无法确定中间元素是属于前面还是后面的递增子数组
// 只能顺序查找
if(rotateArray[left] == rotateArray[right] && rotateArray[left] == rotateArray[mid]){
return MinOrder(rotateArray,left,right);
}//if
// 中间元素位于前面的递增子数组
// 此时最小元素位于中间元素的后面
if(rotateArray[mid] >= rotateArray[left]){
left = mid;
}//if
// 中间元素位于后面的递增子数组
// 此时最小元素位于中间元素的前面
else{
right = mid;
}//else
}//while
return rotateArray[mid];
}
private:
// 顺序寻找最小值
int MinOrder(vector &num,int left,int right){
int result = num[left];
for(int i = left + 1;i < right;++i){
if(num[i] < result){
result = num[i];
}//if
}//for
return result;
}
};

int main(){
Solution s;
//vector num = {0,1,2,3,4,5};
//vector num = {4,5,6,7,1,2,3};
vector num = {2,2,2,2,1,2};
int result = s.minNumberInRotateArray(num);
// 输出
cout< return 0;
}
59. https://www.nowcoder.com/questionTerminal/abc3fe2ce8e146608e868a70efebf62e
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。
请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

https://www.nowcoder.com/questionTerminal/471706f5ecb249778bf0ddf94c0b7ec6
当使包含
applet
程序的页面从最小化恢复时，以下选项中的哪个方法将被执行？（a）
paint()
start()
destroy()
stop()

applet页面刚打开时，程序调用init（）然后调用start（）再然后paint（）
用户离开applet页面，程序自动调用stop（），用户关闭浏览器，程序触发destroy（）
并且paint（）在每一次浏览器显示页面时被调用。
最小化点开–>页面重新显示，之前进程没丢，只有paint（）。

https://www.nowcoder.com/questionTerminal/47ffaf4670384e34a925e294fcd686c0
final、finally和finalize的区别中，下述说法正确的有？a,b
final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源的回收，例如关闭文件等。
引用变量被final修饰之后，不能再指向其他对象，它指向的对象的内容也是不可变的。

c错，错在最后一句话：例如关闭文件。
finalize 并不是用来关闭文件的，关闭文件的操作由一些 native 本地方法处理，finalize 只负责内存中垃圾对象的回收。
d错,引用内容是可变的

https://www.nowcoder.com/questionTerminal/b4a4fb228d724d8a87b64f3a7311cd27
public interface IService {
String NAME=“default”;
} 与上面等价表示是哪一项（d）？
public String NAME=”default”;
public static String NAME=”default”;
private String NAME=”default”;
public static final String NAME=”default”;

为什么是public：因为接口必然是要被实现的，如果不是public，这个属性就没有意义了；
为什么是static：因为如果不是static，那么由于每个类可以继承多个接口，那就会出现重名的情况；
为什么是final：这是为了体现java的开闭原则，因为接口是一种模板，既然是模板，那就对修改关闭，对扩展开放。
接口是对一类事物的属性和行为更高层次的抽象。对修改关闭，对扩展开放，接口是对开闭原则的一种体现。所以接口的属性用 public static final 修饰。

https://www.nowcoder.com/questionTerminal/6051f858caf441809eaf5cdd6800e537
下面不是面向对象的基本原则的是？ c

单一职责原则（Single-Resposibility Principle）
开放封闭原则（Open-Closed principle）
抽象类原则（Abstract-Class principle）
依赖倒置原则（Dependecy-Inversion Principle）
接口隔离原则（Interface-Segregation Principle）

面向对象的五大基本原则
单一职责原则（SRP）
开放封闭原则（OCP）
里氏替换原则（LSP）
依赖倒置原则（DIP）
接口隔离原则（ISP）
64. https://www.nowcoder.com/questionTerminal/6047ef1f4cd345279a363580e6940547
下面哪些情况可以引发异常：a,b,c
数组越界
指定URL不存在
使用throw语句抛出
使用throws语句

1、throws出现在方法头，throw出现在方法体
2、throws表示出现异常的一种可能性，并不一定会发生异常；
throw则是抛出了异常，执行throw则一定抛出了某种异常。
3、两者都是消极的异常处理方式，只是抛出或者可能抛出异常，是不会由函数处理，真正的处理异常由它的上层调用处理。

https://www.nowcoder.com/questionTerminal/bb13c8d9729a4249b6456510e7f1cd70
以下关于集合类
ArrayList
、
LinkedList
、
HashMap
描述错误的是：c
HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值
ArrayList和LinkedList均实现了List接口
添加和删除元素时，ArrayList的表现更佳
ArrayList的访问速度比LinkedList快

Hashtable不允许 null 值(key 和 value 都不可以)，HashMap允许 null 值(key和value都可以)。 ArrayList和LinkedList均实现了List接口
ArrayList基于数组实现，随机访问更快
LinkedList基于链表实现，添加和删除更快

https://www.nowcoder.com/questionTerminal/cf28c596c6914d358361951d783c1634
以下代码结果是什么？c
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。

https://www.nowcoder.com/questionTerminal/8be1ad1273b944128d04cf9e831cce16
在java7中，下列不能做switch()的参数类型是？d
int型
枚举类型
字符串
浮点型
switch语句后的控制表达式只能是short、char、int、long整数类型和枚举类型，不能是float，double和boolean类型。String类型是java7开始支持
https://www.nowcoder.com/questionTerminal/19b30ddb00d74eb1bf67d04e4a76f251
下列方法中哪个是线程执行的方法？（a）
run（）
start（）
sleep（）
suspend（）

答案是A
run()方法用来执行线程体中具体的内容
start()方法用来启动线程对象，使其进入就绪状态
sleep()方法用来使线程进入睡眠状态
suspend()方法用来使线程挂起，要通过resume()方法使其重新启动

https://www.nowcoder.com/questionTerminal/8d53f414b58b4c3cbc3e20c13facbeca
下面哪个语句是创建数组的正确语句？( a,b,d,e)
float f[][] = new float[6][6];
float []f[] = new float[6][6];
float f[][] = new float[][6];
float [][]f = new float[6][6];
float [][]f = new float[6][];
在Myeclipse中敲了一下，确实ABDE都可以。也就是说数组命名时名称与[]可以随意排列，但声明的二维数组中第一个中括号中必须要有值，它代表的是在该二维数组中有多少个一维数组
https://www.nowcoder.com/questionTerminal/82c0f04139f048f7826660624da84ead
以下叙述正确的是d
实例方法可直接调用超类的实例方法
实例方法可直接调用超类的类方法、
实例方法可直接调用子类的实例方法
实例方法可直接调用本类的实例方法

A错误，类的实例方法是与该类的实例对象相关联的，不能直接调用，只能通过创建超类的一个实例对象，再进行调用
B错误，当父类的类方法定义为private时，对子类是不可见的，所以子类无法调用
C错误，子类具体的实例方法对父类是不可见的，所以无法直接调用，只能通过创建子类的一个实例对象，再进行调用
D正确，实例方法可以调用自己类中的实例方法

https://www.nowcoder.com/questionTerminal/0e99a1000cf44582be284c9dd5b57dc7
下面程序的输出是什么？ b
package algorithms.com.guan.javajicu;
public class TestDemo
{
public static String output = ””;
public static void foo(inti)
{
try
{
if (i == 1)
{
throw new Exception();
}
}
catch (Exception e)
{
output += “2”;
return ;
} finally
{
output += “3”;
}
output += “4”;
}
public static void main(String[] args)
{
foo(0);
foo(1);
System.out.println(output);
}
}
342
3423
34234
323

首先是foo(0),不满足if语句,在try代码块中未抛出异常，不执行catch块,finally是无论是否抛出异常必定执行的语句，
所以 output += “3”;然后是 output += “4”;
执行foo(1)的时候，满足if语句,try代码块抛出异常，进入catch代码块，output += “2”;
前面说过finally是必执行的，即使return也会执行output += “3”
由于catch代码块中有return语句，最后一个output += “4”不会执行。
所以结果是3423

https://www.nowcoder.com/questionTerminal/46999f0286644d6d8c44be91c40e664b
以下各类中哪几个是线程安全的？( b,c ,d )
ArrayList
Vector
Hashtable
Stack

下面是这些线程安全的同步的类：喂,SHE
vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用。在web应用中，特别是前台页面，往往效率（页面响应速度）是优先考虑的。
statck：堆栈类，先进后出
hashtable：就比hashmap多了个线程安全
enumeration：枚举，相当于迭代器
除了这些之外，其他的都是非线程安全的类和接口。

https://www.nowcoder.com/questionTerminal/e252668ee94947bea07edd7300340115
有关下述Java代码描述正确的选项是___f_。
public class TestClass {
private static void testMethod(){
System.out.println(“testMethod”);
}
public static void main(String[] args) {
((TestClass)null).testMethod();
}
}
编译不通过
编译通过，运行异常，报NullPointerException
编译通过，运行异常，报IllegalArgumentException
编译通过，运行异常，报NoSuchMethodException
编译通过，运行异常，报Exception
运行正常，输出testMethod

我来总结下大家的分析。
1）此处是类对方法的调用，不是对象对方法的调用。
2）方法是static静态方法，直接使用"类.方法"即可，因为静态方法使用不依赖对象是否被创建。
null可以被强制类型转换成任意类型（不是任意类型对象），于是可以通过它来执行静态方法。
3）非静态的方法用"对象.方法"的方式，必须依赖对象被创建后才能使用，若将testMethod()方法前的static去掉，则会报空指针异常。此处也验证了2）的观点
当然，不管是否静态方法，都是已经存在的，只是访问方式不同。

https://www.nowcoder.com/questionTerminal/d8f6fcaa49c644e8bce3fa9289305423
关于异常的编程，以下描述错误的是：（ c）

在有除法存在的代码处，抛不抛出异常均可
int i=Integer.parseInt(”123a”);将产生NumberFormatException
int a[]=null; a[0]=1; 将产生ArraylndexOutOfBoundsException
输入输出流编程中，读和写时都必须抛出IOException

A,除法错时运行时错误，不需要抛出异常；
B，对的，会抛出异常; NumberFarmatException数字格式异常
C，会抛出空指针错误，不是ArraylndexOutOfBoundsException数组下标越界异常，因为它没有分配空间NULL；
D，必须抛出，try…catch也是抛出

https://www.nowcoder.com/questionTerminal/0bc5e15365ec44a7bfa976f1a2a40b20
以下代码执行的结果显示是多少（ d）？
true,false,true
false,true,false
true,true,false
false,false,true

Integer i1=128;
Integer i2=128;
i1i2;
Integer i3=“100”;
Integer i4=“1”+new String(“00”);
i3i4;
Integer i5=100;
Integer i6=100;
i5==i6;
可以看出，对于-128到127之间的数，Java会对其进行缓存。而超出这个范围则新建一个对象。
所以现在回到这道问题
i1和i2为128，超出范围，所以都需要新建对象，对象比较为false；
i5和i6为100，在范围之内，在执行Integer i5=100时，就会直接缓存到内存中，但执行执行Integer i6=100时，就直接从缓存里取，而不需要新建对象，所以为true。

https://www.nowcoder.com/questionTerminal/d9862fae22c4443f87e0d52322bda7cb
类的析构函数是一个对象被( b)时自动调用的。
建立
撤消
赋值
引用

析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。
析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

https://www.nowcoder.com/questionTerminal/6ea24d3b200c4a1687e8a66d3d4bdecb
下列关于java并发的说法中正确的是：b
copyonwritearraylist适用于写多读少的并发场景
readwritelock适用于读多写少的并发场景
concurrenthashmap的写操作不需要加锁，读操作需要加锁
只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了

CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。
ReadWriteLock 当写操作时，其他线程无法读取或写入数据，而当读操作时，其它线程无法写入数据，但却可以读取数据。适用于读取远远大于写入的操作。
ConcurrentHashMap是一个线程安全的Hash Table，它的主要功能是提供了一组和HashTable功能相同但是线程安全的方法。
ConcurrentHashMap可以做到读取数据不加锁，并且其内部的结构可以让其在进行写操作的时候能够将锁的粒度保持地尽量地小，不用对整个ConcurrentHashMap加锁。
volatile只能保证变量的安全，不能保证线程的安全

https://www.nowcoder.com/questionTerminal/a10dcc67ea9747448d5e56d063d8d708
下列哪些语句关于
java 内存回收的说明是正确的？c

程序员必须创建一个线程来释放内存
内存回收程序负责释放无用内存
内存回收程序允许程序员直接释放内存
内存回收程序可以在指定的时间释放内存对象

A：垃圾回收程序是一般是在堆上分配空间不够的时候会自己进行一次GC，程序员不需要也不能主动释放内存。
B：Java的内存释放由垃圾回收程序来进行释放
C：在Java里，内存的释放由垃圾回收程序进行管理，程序员不能直接进行释放。
D：程序员可以调用System.gc()运行垃圾回收器，但是不能指定时间。

https://www.nowcoder.com/questionTerminal/e5af023ba8064e98982f0362633535cd
java中 String str = "hello world"下列语句错误的是？a,b,c
str+=’ a’
int strlen = str.length
str=100
str=str+100
A,str += ‘a’ 和 str +="a"都是对的，但是如果a前面加一个空格，那么只能用双引号了。代表字符串
B.String有length()方法,不用定义
C.int 无法直接转成String类型
D.尾部添加字符串”100“
https://www.nowcoder.com/questionTerminal/c5e932bcec3a46cbb9976eea0783e555
有关hashMap跟hashTable的区别，说法正确的是？a,b,c,d
HashMap和Hashtable都实现了Map接口
HashMap是非synchronized，而Hashtable是synchronized
HashTable使用Enumeration，HashMap使用Iterator
HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

HashMap,Hashtable实现的都是map接口,二者是继承类不同
Hashtable是同步的,HashMap不是
C中 Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式。
Hashtable中不允许出现null,HashMap允许key和value为null

https://www.nowcoder.com/questionTerminal/e0e303a6e45140f292ac48f41fbe6ad9
下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换：d

byte[] src,dst;

dst=String.frombytes(src,”GBK”).getbytes(“UTF-8”)
dst=new String (src,”GBK”).getbytes(“UTF-8”)
dst=new String (”GBK”, src,) getbytes()
dst=String.encode(String.decode(src,”GBK”)), “UTF-8”)’

1，使用下面的String构造方法，new一个对象
2，要得到byte[]的结果值，那么需要调用getBytes()方法，传入charsetName即可

String (byte[] bytes, String charsetName) 通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String,
String.getBytes(Charset charset) 使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。
A.String类没有frombytes()这个方法
D.String类没有encode()这个方法。URLEncoder类倒是有这个方法

https://www.nowcoder.com/questionTerminal/97da94abbcab49e7b2d3f215f59f34bf
关于抽象类的叙述正确的是？( a )
抽象类不可以实例化
抽象类就是一种特殊的接口
抽象类的方法都是抽象方法
抽象类的导出类一定不是抽象类

A选项中，抽象类不能实例化，这句是正确的。后面，抽象类不能申明为对象，是错误的。java中，接口和抽象类，都可以声明为对象，只需要在实例化的时候，用一个该接口/抽象类的实现类实例化就行了。即：
interface / abstract class obj = new class();其中，new后面的class是前面接口/抽象类的实现类。
B选项中，接口是一种特殊的抽象类。其中，成员变量都是默认public static final修饰的，方法都是public abstract修饰的，并且除了default和static的以外，只有声明，没有方法体。
C选项中，抽象类的方法，可以是抽象abstract的，也可以是普通的。就算全部是普通方法，也可以用abstract修饰。
D选项中，导出类，及子类，抽象类的子类可以是抽象的，也可以是普通的。

https://www.nowcoder.com/questionTerminal/18f100abfe294eceb6c421d2f6501c1d
下面有关java基本类型的默认值和取值范围，说法错误的是？c
字节型的类型默认值是0，取值范围是-2^7—27-1
boolean类型默认值是false，取值范围是true\false
字符型类型默认是0，取值范围是-2^15 —2^15-1
long类型默认是0，取值范围是-2^63—263-1

默认值取值范围示例

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

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

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

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

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

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

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

boolean: false true\false boolean flag=true;

https://www.nowcoder.com/questionTerminal/1999635c228d49be84eb7623108be35e
下面哪种情况会导致持久区jvm堆内存溢出？c
循环上万次的字符串处理
在一段代码内申请上百M甚至上G的内存
使用CGLib技术直接操作字节码运行，生成大量的动态类
不断创建对象

简单的来说 java的堆内存分为两块:permantspace（持久带）和 heap space。Old + NEW
持久带中主要存放用于存放静态类型数据，如 Java Class, Method 等，与垃圾收集器要收集的Java对象关系不大。
而heapspace分为年轻带和年老带
年轻代的垃圾回收叫 Young GC，年老代的垃圾回收叫 Full GC。
在年轻代中经历了N次（可配置）垃圾回收后仍然存活的对象，就会被复制到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象
年老代溢出原因有循环上万次的字符串处理、创建上千万个对象、在一段代码内申请上百M甚至上G的内存，既A B D选项
持久代溢出原因动态加载了大量Java类而导致溢出

https://www.nowcoder.com/questionTerminal/28141d6c0f344112910717d8599be4eb
下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？b
private
无修饰符
public
protected
public 无限制和private 只同一个类不用解释了
protected可以给同一包中其他类访问，但是也可以给不在同一包的子类访问。
而题目问的是仅可以同一包，所以排除protected
https://www.nowcoder.com/questionTerminal/4e9e5cdc8f37464e828d318cefca4838
在Java中下面Class的声明哪些是错误的？a,b,c
public abstract final class Test {
abstract void method();
}
public abstract class Test {
abstract final void method();
}
public abstract class Test {
abstract void method() {
}
}
public class Test {
final void method() {
}
}

A.被final修饰的类为最终类，不能被继承，而类前面如果有abstract修饰，则为抽象类，抽象类是需要被继承才有意义，因此abstract和final矛盾，选项错误。
B.被final修饰的方法为最终方法，不能被继承，而方法前面如果有abstract修饰，则为抽象方法，抽象方法是需要被继承才有意义，因此abstract和final矛盾，选项错误。
C.抽象类中的抽象方法不能有具体的实现，而选项中的 abstract void method() {}中{}代表有具体的实现，因此此处应该为abstract void method（）；
注意： abstract 不能与private、static、final或native并列修饰同一个方法

https://www.nowcoder.com/questionTerminal/6f126682f29544708bb73a08e4e2bd0a
在创建派生类对象，构造函数的执行顺序（c）
基类构造函数，派生类对象成员构造函数，派生类本身的构造函数
派生类本身的构造函数，基类构造函数，对象成员构造函数
基类构造函数，派生类本身的构造函数，派生类对象成员构造函数
对象成员构造函数，基类构造函数，派生类本身的构造函数

和我背一遍，类的初始化过程也就是方法执行的过程
父类的静态变量-父类的静态代码块子类的静态变量-子类的静态代码块
父类的非静态变量-父类的非静态代码块-父类的构造函数子类的非静态变量-子类的非静态代码块-子类的构造函数
规律就是父类先于子类静态的先于非静态的变量先于代码块
学java的看这边：
父类静态域——》子类静态域——》父类成员初始化——》父类构造块——》1父类构造方法——》2子类成员初始化——》子类构造块——》3子类构造方法；
加黑的123，对应为A

https://www.nowcoder.com/questionTerminal/4e632ee9fb3c45e2bad336236b5ef3a9
以下哪个命令用于查看tar（backup.tar）文件的内容而不提取它?（b）
tar -xvf backup.tar
tar -tvf backup.tar
tar -svf backup.tar
none of these
链接：https://www.nowcoder.com/questionTerminal/4e632ee9fb3c45e2bad336236b5ef3a9
来源：牛客网

tar
-c: 建立压缩档案
-x：解压
-t：查看内容
-r：向压缩归档文件末尾追加文件
-u：更新原压缩包中的文件

这五个是独立的命令，压缩解压都要用到其中一个，可以和别的命令连用但只能用其中一个。下面的参数是根据需要在压缩或解压档案时可选的。

https://www.nowcoder.com/questionTerminal/073fe9f1e5c84a689bcdb9ea899d295e
在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的（a）？
管道
消息队列
高速缓存数据库
套接字

不同服务器不可以用管道
管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
既然是不同的服务器之间进行通信，怎么可能会是具有亲缘关系的进程呢？
90. https://www.nowcoder.com/questionTerminal/bbfa971aa43d4500b16ce57e2226fec6
关于struts项目中的类与MVC模式的对应关系，说法错误的是 c,d
Jsp文件实现视图View的功能
ActionServlet这一个类是整个struts项目的控制器
ActionForm、Action都属于Model部分
一个struts项目只能有一个Servlet

A.视图：主要由JSP生成页面完成视图，
B.核心：Struts的核心是ActionSevlet，ActionSevlet的核心是Struts-config.xml。
C.Model中包含ActionFrom和JavaBean 不包括Action(业务逻辑控制器)
D.肯定可以是多个Servlet啊
91. https://www.nowcoder.com/questionTerminal/3fd7690375a644a0aa0fdbfe43ec7b8d
局部内部类可以用哪些修饰符修饰？c,d
public
private
abstract
final
局部内部类就像是方法里面的一个局部变量一样,是不能有public,protected,private以及static修饰符的

https://www.nowcoder.com/questionTerminal/ba2eca99ecdf466d8a45dcab369e8403
在Java线程状态转换时，下列转换不可能发生的有（）？ a,c
初始态->运行态
就绪态->运行态
阻塞态->运行态
运行态->就绪态
选AC，只有就绪态和运行态可以直接相互转换，其他都是单向的。
https://www.nowcoder.com/questionTerminal/01cd77ba2d1c41ec9ffb4279a9af570c
哪些关键字可以保护包中的类免受包外的类的访问，但不能保护包内的类？
Which keyword can protect a class in a package from accessibility by the
classes outside the package but not package inside ? d

private
protected
final
don’t use any keyword at all (make it default) ？
开始选成了protected，现在明白了如果一个类声明为protected，它的子类是可以访问它的，如果它和子类不在一个包中，子类仍然可以访问该类，所以这里选择default，即什么都不写

https://www.nowcoder.com/questionTerminal/cc37a0fc56cd4c71a3ebff2c4f7e181d
下列方法定义中
，
正确的是（a）

int x( ){ char ch=’a’; return (int)ch; }
void x( ){ …return true; }
int x( ){ …return true; }
int x( int a, b){ return a+b; }

A.Java中涉及到byte、short和char类型都可以强制转化为int，符合返回类型 A正确
B.方法中定义为void 应该没有返回值，但返回值为boolean类型 B错
C. 方法中类型为int，应该返回int类型值，但是返回值为boolean类型 C错
D.方法应该定义为int(int a,int b)，所以D错

https://www.nowcoder.com/questionTerminal/ebe94f2eae814d30b12464487c53649c
有关finally语句块说法正确的是（ a ,b,c ）
不管catch是否捕获异常，finally语句块都是要被执行的
在try语句块或catch语句块中执行到System.exit(0)直接退出程序
finally块中的return语句会覆盖try块中的return返回
finally 语句块在 catch语句块中的return语句之前执行
1、不管有木有出现异常，finally块中代码都会执行；
2.System.exit(0)。表示将整个虚拟机里的内容都释放，JVM停止工作，此时程序正常退出
3.如果try，finally语句里均有return，忽略try的return，而使用finally的return.
4、finally是在return后面的表达式运算后执行的
https://www.nowcoder.com/questionTerminal/473d5173b0174eae8ff586e3568e0915
当你编译和运行下面的代码时，会出现下面选项中的哪种情况？ b

public class Pvf{
static boolean Paddy;
public static void main(String args[]){
System.out.println(Paddy);
}
}
编译时错误
编译通过并输出结果false
编译通过并输出结果true
编译通过并输出结果null
类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。
boolean类型默认值是false

https://www.nowcoder.com/questionTerminal/db216a7d07ae4c9e907e4d95f4ac0181
var one;
var two=null;
console.log(onetwo,one=two);
上面代码的输出结果是： e
true false
true true
false false
false true
错误：one没有定义
链接：https://www.nowcoder.com/questionTerminal/db216a7d07ae4c9e907e4d95f4ac0181
来源：牛客网

在JavaScript中下面的值被当作假 false. undefined. null. 空字符串数字0 数字NAN
== 和 ===的区别是，==会将两边的值进行隐式类型转换，而 ===也不会。
题目中，var one; 只定义未赋值，故one是的值为undefined, undefined和null转换为Boolean类型后都为false，相等
===不会进行转换，，那么undefined和null当然不相等啦，所以是false！

https://www.nowcoder.com/questionTerminal/893358f6d98a45f181a17a8180086283
JSP分页代码中，哪个步骤次序是正确的？a
先取总记录数，得到总页数，最后显示本页的数据。
先取所有的记录，得到总页数，再取总记录数，最后显示本页的数据。
先取总页数，得到总记录数，再取所有的记录，最后显示本页的数据。
先取本页的数据，得到总页数，再取总记录数，最后显示所有的记录。

先取总记录数，得到总页数，再取所有的记录，最后显示本页的数据

https://www.nowcoder.com/questionTerminal/964cf7d6cd29449f91f1dbe21bae8176
关于访问权限说法正确的是？ ( b )
外部类前面可以修饰public,protected和private
成员内部类前面可以修饰public,protected和private
局部内部类前面可以修饰public,protected和private
以上说法都不正确

1.对于外部类而言，它也可以使用访问控制符修饰，但外部类只能有两种访问控制级别： public 和默认。也可以用,abstract,final修饰
因为外部类没有处于任何类的内部，也就没有其所在类的内部、所在类的子类两个范围，因此 private 和 protected 访问控制符对外部类没有意义。
2…内部类指位于类内部但不包括位于块、构造器、方法内，且有名称的类，修饰符有public,private,protected访问控制符，
也可以用static,final关键字修饰
成员内部类定义在类中，可以看成成员变量，可以有public，protected，public，static修饰。
3.可以把局部内部类当做一个局部变量，所以它是不需要加任何修饰符的
局部内部类前不能用修饰符public和private,protected

https://www.nowcoder.com/questionTerminal/df8ba538b6694c3383cd837779804e2b
在
Java
中，属于整数类型变量的是（c）
single
double
byte
char

Java中的四类八种基本数据类型
第一类：整数类型 byte short int long
第二类：浮点型 float double
第三类：逻辑型 boolean(它只有两个值可取true false)
第四类：字符型 char

https://www.nowcoder.com/questionTerminal/27cd26b26df349e8a52e73436f370561
下面哪些类可以被继承？ a,b,e 完美避开正确答案
Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader
Thread
Number
Double
Math
ClassLoader

A，Thread可以被继承，用于创建新的线程
B，Number类可以被继承，Integer，Float，Double等都继承自Number类
C，Double类的声明为
public final class Double extends Number implements Comparable
final生明的类不能被继承
D，Math类的声明为
public final class Mathextends Object
不能被继承
E，ClassLoader可以被继承，用户可以自定义类加载器

https://www.nowcoder.com/questionTerminal/eabef9f274144ec0ac79653404e05433
class Foo {
final int i;
int j;
public void doSomething() {
System.out.println(++j + i);
}
}
的输出是？d
0
1
2
不能执行，因为编译有错

final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化,给初始值。

https://www.nowcoder.com/questionTerminal/e5cdf4caaf66446c866b3557e856de31
下列说法错误的有（b,c,d ）
能被java.exe成功运行的java class文件必须有main()方法
J2SDK就是Java API
Appletviewer.exe可利用jar选项运行.jar文件
能被Appletviewer成功运行的java class文件必须有main()方法

B选项中J2SDK是编程工具，不是API. java api是应用程序接口
C选项中 Appletviewer.exe 就是用来解释执行java applet应用程序的,简单理解就是没有main函数的继承applet类的java类, appletviewer.exe执行选项参数中并没有jar选项。
D选项中能被Appletviewer成功运行的java class文件没有main()方法 c,d是一个知识点

https://www.nowcoder.com/questionTerminal/53d0e1aa9fa047a5be81d87bb741ed43
以下 json 格式数据，错误的是 a,c
{company：4399}
{“company”:{“name”:[4399,4399,4399]}}
{[4399,4399,4399]}
{“company”:[4399,4399,4399]}
{“company”:{“name”:4399}}

A:错误 {company：4399} 首先，其为json对象。但json对象要求属性必须加双引号。
B:正确
C:错误 {[4399,4399,4399]} 。使用 {} 则为json对象。json对象必须由一组有序的键值对组成。
D:正确。答案：

https://www.nowcoder.com/questionTerminal/7457f88577b64e99814772bb9ac9aff2
以下可以正确获取结果集的有
a.Statement sta=con.createStatement();
ResultSet rst=sta.executeQuery(“select * from book”);
b.Statement sta=con.createStatement(“select * from book”); ResultSet rst=sta.executeQuery();
c.PreparedStatement pst=con.prepareStatement();
ResultSet rst=pst.executeQuery(“select * from book”);
d.PreparedStatement pst=con.prepareStatement(“select * from book”);
ResultSet rst=pst.executeQuery();

A,D是正确的；创建Statement是不传参的，PreparedStatement是需要传入sql语句
PreparedStatement 继承于 Statement , 有Statement的所有功能, 执行速度比Statement快,但是比Statement更安全

https://www.nowcoder.com/questionTerminal/7d2af51194e14e708c71c855f5f28a36
mysql数据库，game_order表表结构如下，下面哪些sql能使用到索引（b,c,d,e）？
select * from game_order where plat_game_id=5 and plat_id=134

select * from game_order where plat_id=134 and
plat_game_id=5 and plat_order_id=’100’

select * from game_order where plat_order_id=’100’

select * from game_order where plat_game_id=5 and
plat_order_id=’100’ and plat_id=134

select * from game_order where plat_game_id=5 and plat_order_id=’100’

如果没有plat_order_id那么一个索引也用不到

这道题目想考察的知识点是MySQL组合索引（复合索引）的最左优先原则。最左优先就是说组合索引的第一个字段必须出现在查询组句中，这个索引才会被用到。
只要组合索引最左边第一个字段出现在Where中，那么不管后面的字段出现与否或者出现顺序如何，MySQL引擎都会自动调用索引来优化查询效率。
根据最左匹配原则可以知道B-Tree建立索引的过程，比如假设有一个3列索引(col1,col2,col3),那么MySQL只会会建立三个索引(col1),(col1,col2),(col1,col2,col3)。
所以题目会创建三个索引（plat_order_id）、（plat_order_id与plat_game_id的组合索引）、（plat_order_id、plat_game_id与plat_id的组合索引）。
根据最左匹配原则，where语句必须要有plat_order_id才能调用索引（如果没有plat_order_id字段那么一个索引也调用不到），
如果同时出现plat_order_id与plat_game_id则会调用两者的组合索引，如果同时出现三者则调用三者的组合索引。
题目问有哪些sql能使用到索引，个人认为只要Where后出现了plat_order_id字段的SQL语句都会调用到索引，只不过是所调用的索引不同而已，所以选BCDE。
如果题目说清楚是调用到三个字段的复合索引，那答案才是BD。

https://www.nowcoder.com/questionTerminal/1aac0e529bdf442c9034ee00f9aa0689
以下代码的结果是什么？
what is the result of the following code? c
enum AccountType
{
SAVING, FIXED, CURRENT;
private AccountType()
{
System.out.println(“It is a account type”);
}
}
class EnumOne
{
public static void main(String[]args)
{
System.out.println(AccountType.FIXED);
}
}

Compiles fine and output is prints”It is a account type”once followed by”FIXED”
Compiles fine and output is prints”It is a account type”twice followed by”FIXED”
Compiles fine and output is prints”It is a account type”thrice followed by”FIXED”
Compiles fine and output is prints”It is a account type”four times followed by”FIXED”
Compilation fails
枚举类所有的枚举值都是类静态常量，在初始化时会对所有的枚举值对象进行第一次初始化。
枚举类有三个实例，故调用三次构造方法，打印三次It is a account type

https://www.nowcoder.com/questionTerminal/87dce6ba2996422f8adff752bc51ae28
面向对象程序设计方法的优点包含：a,b,c,
可重用性
可扩展性
易于管理和维护
简单易懂

实际上就是面向对象的三大特性 A.多态 B.继承 C.封装
109. https://www.nowcoder.com/questionTerminal/ec396ab0febf4dd0ad0edef26bd790a7
下列哪个对访问修饰符作用范围由大到小排列是正确的？d
private>default>protected>public
public>default>protected>private
private>protected>default>public
public>protected>default>private

https://www.nowcoder.com/questionTerminal/1f3e85e2f18e4c75aff550760280e03d
访问权限控制从最大权限到最小权限依次为：public、
包访问权限、protected和private
。（错）
正确
错误
应该是：public>protected>默认(包访问权限)>private，因为protected除了可以被同一包访问，还可以被包外的子类所访问
https://www.nowcoder.com/questionTerminal/0fbdf7f12de54a95836524bd11bd2f95
在
applet
的方法中
,
可关闭小应用程序并释放其占用资源的是（d
）
stop()
paint()
init()
destroy()

Applet 类是浏览器类库中最为重要的类，同时也是所有 JAVA 小应用程序的基本类。
一个 Applet 应用程序从开始运行到结束时所经历的过程被称为 Applet 的生命周期。
Applet 的生命周期涉及 init() 、 start() 、 stop() 和 destroy() 四种方法
stop仅关闭不释放
destroy()方法收回 Applet 程序的所有资源，即释放已分配给它的所有资源。在 Applet 程序中，系统总是先调用 stop() 方法，后调用 destroy() 方法。

https://www.nowcoder.com/questionTerminal/9bc2d446173147b3b28b31568a6c4706
class A {}
class B extends A {}
class C extends A {}
class D extends B {}
Which four statements are true ?
哪四种说法是真的？
a,c,d,g
The type Listis assignable to List.
The type Listis assignable to List.
The type Listis assignable to List.
The type Listis assignable to List.
The type Listis assignable to List.
The type Listis assignable to any List reference.
The type Listis assignable to List.
链接：https://www.nowcoder.com/questionTerminal/9bc2d446173147b3b28b31568a6c4706
来源：牛客网

//A对，因为List就是List，代表最大的范围，A只是其中的一个点，肯定被包含在内
//B错，点之间不能相互赋值
//C对，List代表最大的范围，List只是一个点，肯定被包含在内
//D对，List代表小于等于B的范围，List是一个点，在其中
//E错，范围不能赋值给点
//F错，List只是一个点
//G对，小于等于A的范围包含小于等于B的范围，因为B本来就比A小，B时A的子类嘛

https://www.nowcoder.com/questionTerminal/1336fef0204f4aa4bc1df56063428a79
下面关于Applet的说法是正确的是a,b,c,d
Applet可以在带有Java解释器的浏览器中运行
Applet类必须继承java.applet.Applet
Applet可以访问本地文件
Applet是Object类的子类
https://www.nowcoder.com/questionTerminal/572e25122490427c9f33e2b0cdc9c59f
下列关于修饰符混用的说法，错误的是( d)
abstract不能与final并列修饰同一个类
abstract类中不应该有private的成员
abstract方法必须在abstract类或接口中
static方法中能直接调用类里的非static的属性
A选项毋庸置疑是对的，一个类要么能继承要么不能继承，只能选一个
B不管是成员变量，还是非抽象方法都不建议用private修饰，抽象方法是禁止使用private修饰。
原因就是我们创建抽象类的目的就是要实现代码复用，方便子类继承，private修饰的虽然能被继承，但是对子类是不可见的
C选项，一个类若有抽象方法，其本身也必须声明为抽象类
D、static方法中能处理非static的属性错误：在JVM中static方法在静态区，静态区无法调用非静态区属性。
https://www.nowcoder.com/questionTerminal/4e12588431cd40418fd7efa728f75f45
下面哪些写法能在 java8 中编译执行（） b
dir.listFiles((File f)->f.getName().endsWith(“.Java”));
dir.listFiles((File f)=>f.getName().endsWith(“.Java”));
dir.listFiles((_.getName().endsWith(“.Java”)));
dir.listFiles( f->f.getName().endsWith(“.Java”));

Lanbda表达式的主要作用就是代替匿名内部类的繁琐语法，它由三部分组成：
（1）形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的圆括号也可以省略。
（2）箭头（→）。必须通过英文中画线和大于符号组成。
（3）代码块。如果代码块只包含一条语句，Lambda表达式允许省略代码块的花括号，那么那条语句就不要用花括号表示语句结束。Lambda代码块只有一条return语句，甚至可以省略return关键字。Lambda表达式需要返回值，而它的代码块中仅有一套省略了return的语句。Lambda表达式会自动返回这条语句的值。
由此可见，应该是A和D正确。

https://www.nowcoder.com/questionTerminal/fb0bd11569204cbc833a5c8b996636ba
导致当前线程停止或暂停执行的原因 a,b,e
What might cause the current thread to stop or pause executing
An InterruptedException is thrown.
The thread executes a wait() call.
The thread constructs a new Thread.
A thread of higher priority becomes ready.
The thread executes a waitforID()call on a MediaTracker.

A：一个InterruptedException 异常被捕获大家都知道的嘛（一般通过interrupt方法中断线程）如果抓到一个线程都会关紧catch里面然后中断当前操作，A正确。
B：线程执行了wait()方法。线程使用了wait方法，会强行打断当前操作，（暂停状态，不会中断线程）进入阻塞（暂停）状态，然后需要notify方法或notifyAll方法才能进入就绪状态。 B 正确。
C：当前线程创建了一个新的线程。新创建的线程不会抢占时间片，只有等当前线程把时间片用完，其他线程才有资格拿到时间片去执行。
D：一个高优先级别的线程就绪。如C相同，你优先级别再高也待等我现在弄完才会给你。
（就像我们玩游戏，会员虽然有排队优先权，但是还是要等正在登陆的用户进去游戏之后才能抢到他原来那个位置，不能说我在过关卡的过程中你一脚把我踢开，然后霸占我的位置吧，我原来的那些数据咋办！！！）
E：线程在MediaTracker上执行了waitforID（）调用。
然后他的功能是加载图像，直到完成之前，该方法一直等待！这个方法是必须要抛出A选项的InterruptedException 异常的说明这玩意会让其他线程 wait他完成！所以会暂停当前线程~

https://www.nowcoder.com/questionTerminal/b90ae2993e8d4bbbbf9360e7d6f892d3
下面哪些类实现或者继承了Collection接口？B,C
HashMap
ArrayList
Vector
Iterator
https://www.nowcoder.com/questionTerminal/b1b7eaecff064964b6f52c3aa9093e3d
根据以下接口和类的定义，要使代码没有语法错误，则类Hero中应该定义方法( )。d
```
 interface   Action{  


     void fly();  


 }


 class Hero   implements Action{  //……  }
```

private void fly(){}
void fly(){}
protected void fly(){}
public void fly(){}
接口方法默认是public abstract的，且实现该接口的类中对应的方法的可见性不能小于接口方法的可见性，因此也只能是public的。
119. https://www.nowcoder.com/questionTerminal/4b12e28267ad4e0ab8cde2c4a7c93a8d
java接口的方法修饰符可以为？(忽略内部接口)d
private
protected
final
abstract
1、抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。

2、接口是一种特殊的抽象类，接口中的方法全部是抽象方法（但其前的abstract可以省略），所以抽象类中的抽象方法不能用的访问修饰符这里也不能用。
而且protected访问修饰符也不能使用，因为接口可以让所有的类去实现（非继承），不只是其子类，但是要用public去修饰。接口可以去继承一个已有的接口。

链接：https://www.nowcoder.com/questionTerminal/4b12e28267ad4e0ab8cde2c4a7c93a8d
来源：牛客网

考察点：抽象类和接口
相同点：都不能被实例化,位于继承树的顶端，都包含抽象方法
不同点：1、设计目的：接口体现的一种规范，类似与整个系统的总纲，制订了系统各模块应该遵循的标准，因此接口不应该经常改变，一旦改变对整个系统是辐射性的。
抽象类作为多个子类的共同父类，体现的是一种模板式设计，可以当作系统实现过程中的中间产品，已经实现了系统部分功能。
2、使用不同：（1）接口只能包含抽象方法，抽象类可以包含普通方法。
（2）接口里不能定义静态方法，抽象类可以。
（3）接口只能定义静态常量属性不能定义普通属性，抽象类可以。
（4）接口不包含构造器，抽象类可以（不是用于创建对象而是让子类完成初始化）。
（5）接口里不能包含初始化块，抽象类完全可以。
（6）接口多继承，抽象类但继承（只能有一个直接父类）。
总结：接口所有方法全是抽象方法只能 public abstract修饰（默认public abstract修饰），属性默认public static final修饰。
抽象类除了包含抽象方法外与普通类无区别。

https://www.nowcoder.com/questionTerminal/c913505bd7d94a19873b0b377aba2f3d
下面哪个方法与Applet的显示无关？a
draw
paint
repaint
update

这题，应该选draw。
Applet显示相关的方法主要有3个。

paint(Graphicsg)方法，具体执行Applet的绘制。
update(Graphicsg)()方法，主要用于更新Applet的显示。
repaint()方法，主要用于Applet的重新显示，它调用update()方法实现对Applet的更新。
而draw()方法与显示无关，故选A draw
https://www.nowcoder.com/questionTerminal/b310b8bdf2b7485fa8b1c0d39a0a7a6e
下面叙述那个是正确的？（b）
java中的集合类（如Vector）可以用来存储任何类型的对象，且大小可以自动调整。但需要事先知道所存储对象的类型，才能正常使用。
在java中，我们可以用违例（Exception）来抛出一些并非错误的消息，但这样比直接从函数返回一个结果要更大的系统开销。
java接口包含函数声明和变量声明。
java中，子类不可以访问父类的私有成员和受保护的成员。

A.vector是线程安全的ArrayList，在内存中占用连续的空间。初始时有一个初始大小，当数据条数大于这个初始大小后会重写分配一个更大的连续空间。如果Vector定义为保存Object则可以存放任意类型。
B.比如我自定义一个异常，若一个变量大于10就抛出一个异常，这样就对应了B选项说的情况，我用抛出异常说明这个变量大于10，而不是用一个函数体（函数体内判断是否大于10，然后返回true或false）判断，
因为函数调用是入栈出栈，栈是在寄存器之下的速度最快，且占的空间少，而自定义异常是存在堆中，肯定异常的内存开销大！所以B对。
C.接口中只有常量定义，没有变量声明。
D.子类可以访问父类受保护成员

https://www.nowcoder.com/questionTerminal/29c74dd837124f2e895de47fb7c345b6
抽象类方法的访问权限默认都是public。（错误）

正确
错误

关于抽象类
JDK 1.8以前，抽象类的方法默认访问权限为protected
JDK 1.8时，抽象类的方法默认访问权限变为default

关于接口
JDK 1.8以前，接口中的方法必须是public的
JDK 1.8时，接口中的方法可以是public的，也可以是default的
JDK 1.9时，接口中的方法可以是private的

https://www.nowcoder.com/questionTerminal/0e96a198c7cc4d06a00ababae1bbbb0b
设int x=1,float y=2,则表达式x/y的值是：（d）
0
1
2
以上都不是

把int向上自动转型为float类型,不会出现编译错误.
正解：0.5
x/y= （float）1.0/（float）2.0=0.5 （float类型的）

https://www.nowcoder.com/questionTerminal/4fa22ea0888d4bf290ce3603ec8046f4
以下代码定义了一个变量，如何输出这个变量的值？a,c,d

A.<% String myBean = (String)pageContext.getAttribute(“stringBean”,PageContext.PAGE_SCOPE);
%>
<%=myBean%>
B,
C.
D.<%=stringBean%>

A选项：
通过 pageContext（PageContext类的实例，提供对JSP页面所有对象以及命名空间的访问）获取stringBean 的值，赋给 String 类型的变量 myBean，然后通过 Jsp 表达式处理该值。
bean:define
题目中的 Struts 的bean:define 标签定义了一个字符串变量 stringBean ,它的值为 helloworld。
bean:write
bean:write相当于 <%=request.getAttribute(“something”)%> 其中 something 是属性的名字。所以 B 错，C对。
D选项：
通过Jsp 表达式获取变量 stringBean 的值

https://www.nowcoder.com/questionTerminal/41fc5f399f66432ba04d090f57056a66
下列描述中，错误的是 c

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

C.这道题选C，因为引用代表引用的是实际的对象，对引用的修改就是对对象的修改，可以理解为两把钥匙可以打开同一扇门，所以C错；其他几个选项都是对的
值传递，传递的是原来值的副本。
引用传递，除了一些特殊的（String，包装类属于不可变类），一般的引用类型在进行传递的时候，一开始形参和实参都是指向同一个地址的，这个时候形参对对象的改变会影响到实参

D.强类型语言也称为强类型定义语言。是一种总是强制类型定义的语言，要求变量的使用要严格符合定义，所有变量都必须先定义后使用。
java、.NET、C++等都是强制类型定义的。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。

https://www.nowcoder.com/questionTerminal/794be9f841554cff82a50d633126106c
以下集合对象中哪几个是线程安全的（Vector ,HashTable）
LinkedList
ArrayList
Vector
Hashtable
简单记忆线程安全的集合类：喂！SHE！喂是指 vector，S是指 stack， H是指 hashtable，E是指：Eenumeration
https://www.nowcoder.com/questionTerminal/c2bfb1512dfa4a7eab773a5871a52402
下面代码的输出是什么？ A
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();
}
}
null
sub
base

答案：A
new Sub();在创造派生类的过程中首先创建基类对象，然后才能创建派生类。
创建基类即默认调用Base()方法，在方法中调用callName()方法，由于派生类中存在此方法，则被调用的callName（）方法是派生类中的方法，此时派生类还未构造，所以变量baseName的值为null

Base b = new Sub();它为多态的一种表现形式，声明是Base,实现是Sub类，理解为 b 编译时表现为Base类特性，运行时表现为Sub类特性。
当子类覆盖了父类的方法后，意思是父类的方法已经被重写，题中父类初始化调用的方法为子类实现的方法，子类实现的方法中调用的baseName为子类中的私有属性。
由1.可知，此时只执行到步骤4.,子类非静态代码块和初始化步骤还没有到，子类中的baseName还没有被初始化。所以此时 baseName为空。所以为null。

https://www.nowcoder.com/questionTerminal/b51885cd42b5489d94c5d956dd2b7acb
（ a,c,d ）面向对象程序设计语言不同于其他语言的主要特点。
继承性
消息传递
多态性
封装性
https://www.nowcoder.com/questionTerminal/305b2d834f0a4369805f29576e40e8c5
如下代码的输出是
package Test;
public class Test {
private static void test(int[] arr) {
for (int i = 0; i < arr.length; i++) {
try {
if (arr[i] % 2 == 0) {
throw new NullPointerException();
} else {
System.out.print(i);
}
} finally {
System.out.print(“e”);
}
}
}
public static void main(String[]args) {
try {
test(new int[] {0, 1, 2, 3, 4, 5});
} catch (Exception e) {
System.out.print(“E”);
}
}
}
可以得到的结论是（ eE）
编译出错
eE
Ee
eE1eE3eE5
Ee1Ee3Ee5
这题主要是2点:1.finally中的语句一定会执行。 2.是catch捕获到异常后程序结束。

由于arr[0] =0,所以在进入 test()方法里面会在第一个if 上抛出一个 NullPointerException,接着会执行 finally 的语句, (finally语句先于 return 和 throw语句执行)，输出一个’e，
然后回到 main方法中，由于捕捉到异常，所以进入到catch语句中，然后打印一个’E’,所以最终结果为"eE"

https://www.nowcoder.com/questionTerminal/50b657ff1c68456f952e00d15c08d4b2
如果一个接口Cup有个方法use()，有个类SmallCup实现接口Cup，则在类SmallCup中正确的是？ (c
)

void use() { …}
protected void use() { …}
public void use() { …}
以上语句都可以用在类SmallCup中

既然是实现接口，就要实现接口的所有方法，相当于重写方法，方法的重写需要满足：三同一大一小（方法名、返回值类型、形参相同；访问权限>=重写前；抛出异常<=重写前）
实现类权限只能大于等于接口
接口，比抽象类还要抽象的类。
接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract （只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误。）
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
注：
接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
接口中的方法都是公有的。public

https://www.nowcoder.com/questionTerminal/ab6eb06face84c4e81ab5bc6f0f7f258
以下代码的输出结果是？ c
public class B
{
public static B t1 = new B();
public static B t2 = new B();
{
System.out.println(“构造块”);
}
static
{
System.out.println(“静态块”);
}
public static void main(String[] args)
{
B t = new B();
}
}
静态块构造块构造块构造块
构造块静态块构造块构造块
构造块构造块静态块构造块
构造块构造块构造块静态块

开始时JVM加载B.class，对所有的静态成员进行声明，t1 t2被初始化为默认值，为null，
又因为t1 t2需要被显式初始化，所以对t1进行显式初始化，初始化代码块→构造函数（没有就是调用默认的构造函数），咦！静态代码块咋不初始化？
因为在开始时已经对static部分进行了初始化，虽然只对static变量进行了初始化，但在初始化t1时也不会再执行static块了，因为JVM认为这是第二次加载类B了，
所以static会在t1初始化时被忽略掉，所以直接初始化非static部分，也就是构造块部分（输出’‘构造块’’）接着构造函数（无输出）。
接着对t2进行初始化过程同t1相同（输出’构造块’），此时就对所有的static变量都完成了初始化，
接着就执行static块部分（输出’静态块’），
接着执行，main方法，同样也，new了对象，调用构造函数输出（‘构造块’）

https://www.nowcoder.com/questionTerminal/48b14664da4c450dae1316c98a5f47d3
如下代码的输出结果是什么？ d
public class Test {
public int aMethod(){
static int i = 0;
i++;
return i;
}
public static void main(String args[]){
Test test = new Test();
test.aMethod();
int j = test.aMethod();
System.out.println(j);
}
}
0
1
2
编译失败

静态变量只能在类主体中定义，不能在方法中定义, 静态变量属于类所有而不属于方法。

https://www.nowcoder.com/questionTerminal/6453443b28bc49a6b25a81c0e07611ea
选项中哪一行代码可以添加
到题目中而不产生编译错误？d
public abstract class MyClass {
public int constInt = 5;
//add code here
public void method() {
}
}
public abstract void method(int a);
constInt = constInt + 5;
public int method();
public abstract void anotherMethod() {}

A是抽象方法，抽象类可以包含抽象方法，也可以不包含，虽然A 方法名是method，与题目中的方法同名，但是参数不同，是重载方法
B 在类中不能constInt = constInt + 5; 方法中可以
C 的方法名与题目中的方法名相同，返回值(类型)不能作为重载的依据
D 抽象方法没有方法体

https://www.nowcoder.com/questionTerminal/ca4daaaba2a74097b7990018187436b8
有关会话跟踪技术描述正确的是（a,b,c）
Cookie是Web服务器发送给客户端的一小段信息，客户端请求时，可以读取该信息发送到服务器端
关闭浏览器意味着临时会话ID丢失，但所有与原会话关联的会话数据仍保留在服务器上，直至会话过期
在禁用Cookie时可以使用URL重写技术跟踪会话
隐藏表单域将字段添加到HTML表单并在客户端浏览器中显示

A
B.关闭浏览器，只会是浏览器端内存里的session cookie消失，但不会使保存在服务器端的session对象消失，同样也不会使已经保存到硬盘上的持久化cookie消失。
C.在URL中添加用户的信息作为请求的参数,或者让将唯一的会话ID添加到URL结尾以标识一个会话
D:隐藏域在页面中对于用户（浏览器）是不可见的，

https://www.nowcoder.com/questionTerminal/f838b38081b942fba7ab2869f71ad071
下面哪些赋值语句是正确的（a,b,d）
long test=012
float f=-412
int other =(int)true
double d=0x12345678
byte b=128

A和B中long和float，正常定义需要加l和f，但是long和float属于基本类型，会进行转化，所以不会报出异常。AB正确
boolean类型不能和任何类型进行转换，会报出类型异常错误。所以C错。
D选项可以这样定义，D正确。
E选项中，byte的取值范围是-128—127。报出异常： cannot convert from int to byte.所以E选项错误。

https://www.nowcoder.com/questionTerminal/0bc1012214364bc484f8d4757e7ca8b2
不考虑反射，String类型变量所指向内存空间中的内容是不能被改变的
。
（正确）

正确
错误
String类不可变，指的是String对象内容不可变，因为’String对象存在常量池中，而String的引用是可以可变，可以为String引用赋予新的对象字符串。
137. https://www.nowcoder.com/questionTerminal/96042b5ee9194445a7728f43f72244df
常用的servlet包的名称是？b,d
java.servlet
javax.servlet
servlet.http
javax.servlet.http

JEE5.0中的Servlet相关的就下面这几个包:
javax.servlet
javax.servlet.jsp
java.servlet.jsp.el
java.servlet.jsp.tagext
而最用得多的就是
javax.servlet
javax.servlet.http
这两个包了.
138. https://www.nowcoder.com/questionTerminal/9e4e6d1f6bc2456aaaaa2dff4c94f9ab
下面有关 JAVA 异常类的描述,说法正确的有(a,b,c)
异常的继承结构:基类为 Throwable,Error 和 Exception 实现 Throwable,RuntimeException 和 IOException 等继承 Exception
非 RuntimeException 一般是外部错误(不考虑Error的情况下),其必须在当前类被 try{}catch 语句块所捕获
Error 类体系描述了 Java 运行系统中的内部错误以及资源耗尽的情形,Error 不需要捕捉
RuntimeException 体系包括错误的类型转换、数组越界访问和试图访问空指针等等,必须被 try{}catch 语句块所捕获

都是Throwable的子类：
1.Exception（异常） :是程序本身可以处理的异常。
2.Error（错误）: 是程序无法处理的错误。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，一般不需要程序处理。
3.检查异常（编译器要求必须处置的异常）：除了Error，RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。
这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。
4.非检查异常(编译器不要求处置的异常): 包括运行时异常（RuntimeException与其子类）和错误（Error）。

https://www.nowcoder.com/questionTerminal/687a87f9018e4ba4a747ff31ffbcd9c9
关于HashMap和Hashtable正确的说法有（a,c）
都实现了Map接口
Hashtable类不是同步的，而HashMap类是同步的
Hashtable不允许null键或值
HashMap不允许null或值
二者继承的类是不同的,但是都实现map接口
HashTable是同步的线程安全的,HashMap是不同步的线程不安全的
HashTable不允许key或value为null,但HashMap允许键或值为null
https://www.nowcoder.com/questionTerminal/5a9f57aee208466484118b27f3f09c2e
static String str0=“0123456789”;
static String str1=“0123456789”;
String str2=str1.substring(5);
String str3=new String(str2);
String str4=new String(str3.toCharArray());
str0=null;
假定str0,…,str4后序代码都是只读引用。
Java 7中，以上述代码为基础，在发生过一次FullGC后，上述代码在Heap空间（不包括PermGen）保留的字符数为（15）
5
10
15
20

substring实际是new，5字符
str3和4也都是new，每个5字符
分别都会创建新的对象
常量池是PermGen的
因此应该是一共15字符

解析：这是一个关于java的垃圾回收机制的题目。垃圾回收主要针对的是堆区的回收，因为栈区的内存是随着线程而释放的。
堆区分为三个区：年轻代（Young Generation）、年老代（Old Generation）、永久代（Permanent Generation，也就是方法区）。
年轻代：对象被创建时（new）的对象通常被放在Young（除了一些占据内存比较大的对象）,经过一定的Minor GC（针对年轻代的内存回收）还活着的对象会被移动到年老代（一些具体的移动细节省略）。
年老代：就是上述年轻代移动过来的和一些比较大的对象。Minor GC(FullGC)是针对年老代的回收
永久代：存储的是final常量，static变量，常量池。
str3,str4都是直接new的对象，而substring的源代码其实也是new一个string对象返回，如下图：
经过fullgc之后，年老区的内存回收，则年轻区的占了15个，不算PermGen。所以答案选C

https://www.nowcoder.com/questionTerminal/b66b29f7e3294b699ffdc558c54afcb8
下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是？c
实例变量指的是类中定义的变量，即成员变量，如果没有初始化，会有默认值。
局部变量指的是在方法中定义的变量，如果没有初始化，会有默认值
类变量指的是用static修饰的属性
final变量指的是用final 修饰的变量

实例变量：定义在类中的变量是类的成员变量，可以不进行初始化， java 会自动进行初始化。（如果是引用类默认初始化为 null, 如果是基本类型，默认初始化为 0 ）
局部变量：定义在方法中的变量，必须进行初始化，否则不通过编译。
类变量：（也叫作静态变量）是类中独立于方法之外的变量，用 static 修饰。
final 修饰的变量：也称为常量。

https://www.nowcoder.com/questionTerminal/6a3cb7582a7844ef99a04c09c2647e84
下面有关java threadlocal说法正确的有？a,b,c,d

ThreadLocal存放的值是线程封闭，线程间互斥的，主要用于线程内共享一些数据，避免过参数来传递
线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收
在Thread类中有一个Map，用于存储每一个线程的变量的副本。
对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式

ThreadLocal类用于创建一个线程本地变量
在Thread中有一个成员变量ThreadLocals，该变量的类型是ThreadLocalMap,也就是一个Map，它的键是threadLocal，值就是变量的副本，
ThreadLocal为每一个使用该变量的线程都提供了一个变量值的副本，每一个线程都可以独立地改变自己的副本，是线程隔离的。
通过ThreadLocal的get()方法可以获取该线程变量的本地副本，在get方法之前要先set,否则就要重写initialValue()方法。
ThreadLocal不是用来解决对象共享访问问题的，而主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式。
一般情况下，通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象，其他线程是不需要访问的，也访问不到的。各个线程中访问的是不同的对象。
对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。
前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

https://www.nowcoder.com/questionTerminal/03162f63b91545a6ac4cbd9c51cfadee
实现或继承了Collection接口的是（list,set,vector）
Map
List
Vector
Iterator
Set
Vector实现了List接口，即间接实现Collection接口
https://www.nowcoder.com/questionTerminal/a0c59b5a3e71436a86c3cc1f6392e55f
对于线程局部存储TLS(thread local storage)，以下表述正确的是 a,b,d
解决多线程中的对同一变量的访问冲突的一种技术
TLS会为每一个线程维护一个和该线程绑定的变量的副本
每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了
Java平台的java.lang.ThreadLocal是TLS技术的一种实现

该同步还是得同步
如果是静态变量是共享的话，那必须同步，否则尽管有副本，还是会出错，故C错
145. https://www.nowcoder.com/questionTerminal/aad72b8cee5f4f6da06820921e083c03
下列不属于类及类成员的访问控制符是：（static
）

public
private
static
protected

https://www.nowcoder.com/questionTerminal/f7ee16d719cd495b81804ba66effe3f1
下面哪些接口直接继承自Collection接口（list,set,queue）
List
Map
Set
Iterator
https://www.nowcoder.com/questionTerminal/eeff0fdb43034ee7b43838fb9de4519e
关于sleep()和wait()，以下描述错误的一项是（ d）
sleep是线程类（Thread）的方法，wait是Object类的方法；
sleep不释放对象锁，wait放弃对象锁
sleep暂停线程、但监控状态仍然保持，结束后会自动恢复
wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入运行状态

wait方法重新获得对象锁进入就绪态
148. https://www.nowcoder.com/questionTerminal/9deface9f5164fb7a6a2c836ed5a163d
下面哪些类实现或继承了Collection接口？b,c
HashMap
ArrayList
Vector
Iterator

https://www.nowcoder.com/questionTerminal/cafc2c51790e44eda3ae8cc9ed11cb99
在Jdk1.7中，下述说法中抽象类与接口的区别与联系正确的有哪些？ a,b,c,d
抽象类中可以有普通成员变量，接口中没有普通成员变量。
抽象类和接口中都可以包含静态成员常量。
一个类可以实现多个接口，但只能继承一个抽象类
抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法。

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。另外，接口和抽象类在方法上有区别：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
3.抽象类中可以有普通成员变量，接口中没有普通成员变量
4. 抽象类中的抽象方法的访问类型可以是public，protected和默认类型
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型
7. 一个类可以实现多个接口，但只能继承一个抽象类。
二者在应用方面也有一定的区别：接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。
而抽象类在代码实现方面发挥作用，可以实现代码的重用，
例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码
接口中必须全部是抽象方法

https://www.nowcoder.com/questionTerminal/8312c75bc0b04f5a88511da1cc70972d
java用（a）机制实现了进程之间的同步执行
监视器
虚拟机
多个CPU
异步调用

同步的两种方式：同步块和同步方法
对于同步来说都是使用synchronized方法
每一个对象都有一个监视器，或者叫做锁。

https://www.nowcoder.com/questionTerminal/10afeae4a5c24a35898c0771fb5995b1
有如下一段代码，请选择其运行结果（）c
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);
}
}
true true
false false
true false
false true

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

https://www.nowcoder.com/questionTerminal/9cbffe1607ff450580ae665d2625bce9
关于
访问权限说法正确
的是
？
( b )
类定义前面可以修饰public,protected和private
内部类前面可以修饰public,protected和private
局部内部类前面可以修饰public,protected和private
以上说法都不正确

对于外部类来说，只有两种修饰，public和默认（default），因为外部类放在包中，只有两种可能，包可见和包不可见。
在Java中，可以将一个类定义在另一个类里面或者一个方法里边，这样的类称为内部类，广泛意义上的内部类一般包括四种：成员内部类，局部内部类，匿名内部类，静态内部类。
1.成员内部类
（1）该类像是外部类的一个成员，可以无条件的访问外部类的所有成员属性和成员方法（包括private成员和静态成员）；
（2）成员内部类拥有与外部类同名的成员变量时，会发生隐藏现象，即默认情况下访问的是成员内部类中的成员。如果要访问外部类中的成员，需要以下形式访问：【外部类.this.成员变量或外部类.this.成员方法】；
（3）在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问；
（4）成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象；
（5）内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。如果成员内部类用private修饰，则只能在外部类的内部访问；
如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。外部类只能被public和包访问两种权限修饰。
2.局部内部类
（1）局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内；
（2）局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。
3匿名内部类
（1）一般使用匿名内部类的方法来编写事件监听代码；
（2）匿名内部类是不能有访问修饰符和static修饰符的；
（3）匿名内部类是唯一一种没有构造器的类；
（4）匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。
4.内部静态类
（1）静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似；
（2）不能使用外部类的非static成员变量或者方法

https://www.nowcoder.com/questionTerminal/fbe69f6e836d4643983296fc84d64591
以下J2EE中常用的名词解释错误的是？B
EJB容器：Enterprise java bean 容器
JNDI：JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
JMS：JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
JAF：JAVA安全认证框架。提供一些安全控制方面的框架。

EJB容器：Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。
JMS：（Java Message Service）JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
JNDI：（Java Naming & Directory Interface）JAVA命名目录服务。主要提供的功能是：提供一个目录系，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。
JAF：（Java Action FrameWork）JAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。

https://www.nowcoder.com/questionTerminal/a48429bf440f463cb84a01ecdc654cfa
下面有关servlet和cgi的描述，说法错误的是？d
servlet处于服务器进程中，它通过多线程方式运行其service方法
CGI对每个请求都产生新的进程，服务完成后就销毁
servlet在易用性上强于cgi，它提供了大量的实用工具例程，例如自动地解析和解码HTML表单数据、读取和设置HTTP头、处理Cookie、跟踪会话状态等
cgi在移植性上高于servlet，几乎所有的主流服务器都直接或通过插件支持cgi

选择D，servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，
而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。
servlet在易用性上强于cgi，它提供了大量的实用工具例程，例如自动地解析和解码HTML表单数据、读取和设置HTTP头、处理Cookie、跟踪会话状态等
CGI不可移植，为某一特定平台编写的CGI应用只能运行于这一环境中。每一个CGI应用存在于一个由客户端请求激活的进程中，并且在请求被服务后被卸载。
这种模式将引起很高的内存、CPU开销，而且在同一进程中不能服务多个客户。

https://www.nowcoder.com/questionTerminal/2491905752e54af0ad35c58b22e7f257
下列关于JAVA多线程的叙述正确的是（c）
调用start()方法和run()都可以启动一个线程
CyclicBarrier和CountDownLatch都可以让一组线程等待其他线程
Callable类的call()方法可以返回值和抛出异常
新建的线程调用start()方法就能立即进行运行状态

A. start()方法来启动线程，真正实现了多线程运行，调用了run()方法；run()方法当作普通方法的方式调用。run是运行态后执行
B. CyclicBarrier让一组线程等待其他线程；CountDownLatch让一组线程等待某个事件发生。
C. Callable能够抛出checked exception。
D. start()方法让thread进去可运行状态（runnable）进入就绪态，等待获取CPU的使用权。

https://www.nowcoder.com/questionTerminal/dba570e6fed34c24a49fd827e9869e49
下面关于程序编译说法正确的是（c）
java语言是编译型语言，会把java程序编译成二进制机器指令直接运行
java编译出来的目标文件与具体操作系统有关
java在运行时才进行翻译指令
java编译出来的目标文件，可以运行在任意jvm上

Java不同于一般的编译语言和直译语言。它首先将源代码编译成字节码，然后依赖各种不同平台上的虚拟机来解释执行字节码，从而实现了“一次编写，到处运行”的跨平台特性，
所以说java是一种解释型的语言
java源文件生成的是class文件，与系统无关
注意字节码和机器码不是一回事 java程序在运行时字节码才会被jvm翻译成机器码，所以说java是解释性语言
D:注意jvm的版本，好比人穿裤子，一条裤子能被任何人穿上吗

https://www.nowcoder.com/questionTerminal/8787ccb33c7a43e59e6b185971e4ee9b
以下是java concurrent包下的4个类，选出差别最大的一个 c
Semaphore
ReentrantLock
Future
CountDownLatch

A B D是并发编程的锁机制相关，Future是一个线程任务的返回结果的‘欠条’。
A、Semaphore：类，控制某个资源可被同时访问的个数;
B、ReentrantLock：类，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；
C、 Future：接口，表示异步计算的结果；
D、 CountDownLatch：类，可以用来在一个线程中等待多个线程完成任务的类。

https://www.nowcoder.com/questionTerminal/ac5b5d29942a40bfa182a21db3b086a2
已知有下列Test类的说明，在该类的main方法内，则下列哪个语句是正确的？（a）
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(); } }
t.f;
this.n;
Test.m
Test.f
A的答案中变量虽然为private，但因为main函数在该类中，所以即使private也仍可使用，
B的答案static变量不能使用this
3、m 和 f 都是普通成员属性，而 “类名.” 方式只能调用静态成员属性，因此 C 和 D 都错。静态只能调静态
https://www.nowcoder.com/questionTerminal/8852ca9cd5bc4b39bbdaba0a40fd16c1
下列哪一项不属于Swing的顶层容器？（b）
JApplet
JTree
JDialog
JFrame

顶层容器是指可以不能被其他容器包含，是容纳其他容器的容器组件，
顶层容器包含JApplet、JDialog、JFrame和JWindow及其子类.
JFrame中就可以放Jtree（树形组件）
所以B不是

https://www.nowcoder.com/questionTerminal/fe5d2b633bfa4bae9f1dac88ae4d25e1
paint() c
方法使用哪种类型的参数
?（）
Graphics
Graphics2D
String
Color

绘图函数，java.awt中的paint方法
public void paint(Graphics g)
Graphicslei类是所有图形的抽象基类
161. https://www.nowcoder.com/questionTerminal/0f79f4bfa73b4bbe8bfbc05c1e558439

JDK中提供的java、javac、jar等开发工具也是用Java编写的。（对）
正确
错误

就只有JVM的底层实现是用C、C++和汇编写的，其他组件都是用Java写的

https://www.nowcoder.com/questionTerminal/cf9c207b61924fc0876071f86dda76b7
给出以下代码,请给出结果. a
class Two{
Byte x;
}
class PassO{
public static void main(String[] args){
PassO p=new PassO();
p.start();
}
void start(){
Two t=new Two();
System.out.print(t.x+””);
Two t2=fix(t);
System.out.print(t.x+” ” +t2.x);
}
Two fix(Two tt){
tt.x=42;
return tt;
}
}
null null 42
null 42 42
0 0 42
0 42 42
An exception is thrown at runtime
Compilation

基本类型初始化赋值为0,包装类初始化赋值为null
此处为Byte是byte的包装类型，初始化为null而不是0
该题中引用类型t作为形参进行传递，形参的改变会改变实参的值，所以再次打印t.x时已经变为42了。

https://www.nowcoder.com/questionTerminal/36101a70da6b4bfeb4cff82867a8bba2
下列哪种说法是正确的（d ）
实例方法可直接调用超类的实例方法
实例方法可直接调用超类的类方法
实例方法可直接调用其他类的实例方法
实例方法可直接调用本类的类方法

选d，类方法就是静态方法。其它的就是实例方法

实例方法可以对当前对象的实例变量进行操作，也可以对类变量进行操作，但类方法不能访问实例变量。实例方法必须由实例对象来调用，而类方法除了可由实例对象调用外，还可以由类名直接调用。
另外，在类方法中不能使用 this 或 super。关于类方法的使用，有如下一些限制：
1 在类方法中不能引用对象变量。
2 在类方法中不能使用super、this关键字。
3 类方法不能调用类中的对象方法。
与类方法相比，实例方法几乎没有什么限制：
1 实例方法可以引用对象变量（这是显然的），也可以引用类变量。
2 实例方法中可以使用super、this关键字。
3 实例方法中可以调用类方法。

https://www.nowcoder.com/questionTerminal/57350ea7e3864f7f891d4601ba16e655
HashMap和HashTable的描述，错误的是？d
他们都实现了Map接口。
HashMap非线程安全，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供额外同步。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
通过contains方法可以判断一个对象是否存在于HashMap或者Hashtable中。

因为a,b,c 都是对的
HashMap 把 Hashtable 的 contains 方法去掉了，改成 containsvalue 和 containsKey 。因为 contains 方法容易让人引起误解。

https://www.nowcoder.com/questionTerminal/25445967fff84b6b9e884bbbc9184e62
以下代码将打印出 true true
public static void main(String args[]) {
List Listlist1 = new ArrayList();
Listlist1.add(0);
List Listlist2 = Listlist1;
System.out.println(Listlist1.get(0) instanceof Integer);
System.out.println(Listlist2.get(0) instanceof Integer);
}

编译错误
true true
true false
false false

collection类型的集合（ArrayList,LinkedList）只能装入对象类型的数据，该题中装入了0，是一个基本类型，
但是JDK5以后提供了自动装箱与自动拆箱，所以int类型自动装箱变为了Integer类型。编译能够正常通过。
将list1的引用赋值给了list2，那么list1和list2都将指向同一个堆内存空间。
instanceof是Java中关键字，用于判断一个对象是否属于某个特定类的实例，(反射机制) 并且返回boolean类型的返回值。显然，list1.get(0)和list2.get(0)都属于Integer的实例

https://www.nowcoder.com/questionTerminal/34ee71fff1bc48a48494d41593bc2bd5
关于AWT和Swing说法正确的是？ d
Swing是AWT的子类
AWT在不同操作系统中显示相同的风格
AWT不支持事件类型，Swing支持事件模型
Swing在不同的操作系统中显示相同的风格

AWT和Swing都是java中的包。\

AWT(Abstract Window Toolkit)：抽象窗口工具包，早期编写图形界面应用程序的包。

Swing ：为解决 AWT 存在的问题而新开发的图形界面包。Swing是对AWT的改良和扩展。
Swing由纯Java写成，可移植性好，外观在不同平台上相同。所以Swing部件称为轻量级组件
（ Swing是由纯JAVA CODE所写的，因此SWING解决了JAVA因窗口类而无法跨平台的问题，使窗口功能也具有跨平台与延展性的特性，而且SWING不需占有太多系统资源，因此称为轻量级组件！！！）

AWT和Swing之间的区别：
1)AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT的Java程序，其运行速度比较慢。
2)AWT的控件在不同的平台可能表现不同，而Swing在所有平台表现一致(风格一致)。
3)Swing是轻量级组件，AWT是重量级组件，不存在继承关系。
4)awt与swing都支持事件模型。

https://www.nowcoder.com/questionTerminal/82256496e1c94bf3b08a448509b52f17
关于spring说法错误的是（d）
spring是一个轻量级JAVA EE的框架集合
spring是“依赖注入”模式的实现
使用spring可以实现声明事务
spring提供了AOP方式的日志系统

日志系统spring不管,Spring并没有提供日志系统，我们需要使用AOP（面向方面编程）的方式，借助Spring与日志系统log4j实现我们自己的日志系统。

Spring Framework是一个开源的Java/Java EE全功能栈的应用程序框架，Spring的主要特征：
1.基于JavaBeans的采用控制翻转(IOC Inversion of Control)的配置管理，使应用程序组建更加快捷；
2.允许声明式事务管理器，事务划分与底层无关；
3.内建JTA和单个JDBC数据源一般化策略，Spring 的事务只吃不要求Java EE环境
4.JDBC抽象层提供针对性的异常等级
5.以资源容器，DAO实现和事务策略与Hibernate,JDO,iBATiS SQL Maps集成特性支持控制方便特性
6.基于和Spring功能的MVC网页应用程序
7.提供诸如事务管理等服务面向接口编程的框架

https://www.nowcoder.com/questionTerminal/1463d726640b4dbbb9020adec2384de7
一个抽象类并不需要其中所有的方法都是抽象的。（ a ）
正确
错误

1）抽象类可以包括抽象方法和非抽象方法
2）如果类里面有抽象方法的话，那么类一定要声明为抽象的！

169.链接：https://www.nowcoder.com/questionTerminal/2a1cdf3e61d14947bf00dfe10e25a2c0?orderByHotValue=1&mutiTagIds=639_134&page=1&onlyReference=false

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

方法区在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 通过字节码解释器加载运行。

170.链接：https://www.nowcoder.com/questionTerminal/48f183240e8d4ec3aeecc90337a396a0?orderByHotValue=1&mutiTagIds=639_134&page=1&onlyReference=false
来源：牛客网

观察以下代码：

class Car extends Vehicle
{
public static void main (String[] args)
{
new Car(). run();
}
private final void run()
{
System. out. println (“Car”);
}
}
class Vehicle
{
private final void run()
{
System. out. println(“Vehicle”);
}
}

下列哪些针对代码运行结果的描述是正确的？ a
Car
Vehicle
Compiler error at line 3
Compiler error at line 5
Exception thrown at runtime

答案：A
首先final声明的方法是不能被覆盖的，但是这里并不错误，因为方法是private的，也就是子类没有继承父类的run方法，因此子类的run方法跟父类的run方法无关，并不是覆盖。new Car().run()也是调用子类的run方法。

171.链接：https://www.nowcoder.com/questionTerminal/7d0f6ee46013412ba20443f797b41940?orderByHotValue=1&mutiTagIds=639_134&page=1&onlyReference=false
来源：牛客网

下面有关java object默认的基本方法，说法错误的是？b
equals(Object obj) 指示某个其他对象是否与此对象“相等”
copy() 创建并返回此对象的一个副本
wait() 导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法
toString() 返回该对象的字符串表示

java object默认的基本方法中没有copy()，含有如下方法：
getClass(), hashCode(), equals(), clone(), toString(), notify(), notifyAll(), wait(), finalize()

172.链接：https://www.nowcoder.com/questionTerminal/a08eff2849b343d3b636f8a370d10d30?orderByHotValue=1&mutiTagIds=639_134&page=1&onlyReference=false
来源：牛客网

下列不属于Java语言性特点的是 d
A.Java致力于检查程序在编译和运行时的错误
B.Java能运行虚拟机实现跨平台
C.Java自己操纵内存减少了内存出错的可能性
D.Java还实现了真数组，避免了覆盖数据类型的可能

Java致力于检查程序在编译和运行时的错误。
Java虚拟机实现了跨平台接口
类型检查帮助检查出许多开发早期出现的错误。
Java自己操纵内存减少了内存出错的可能性。
Java还实现了真数组，避免了覆盖数据的可能。
注意，是避免数据覆盖的可能，而不是数据覆盖类型

在try的括号里面有return一个值，那在哪里执行finally里的代码？ b
不执行finally代码
return前执行
return后执行

finally 语句块是在 try 或者 catch 中的 return 语句之前执行的。

链接：https://www.nowcoder.com/questionTerminal/41bc0aee367f4377b7a37458d1808eea?orderByHotValue=1&mutiTagIds=639_134&page=1&onlyReference=false
来源：牛客网
经过强制类型转换以后，变量a，b的值分别为多少？b

short a =128；
byte b =(byte) a；

128 127
128 - 128
128 128
编译错误

1.short类型，a的二进制是：0000 0000 1000 0000；
2.强制转换的截后8位，正数用源码表示，负数用补码表示，第一位是符号。
3.因此，a截取后8位的二进制是：1000 0000，第一位是1，表示是一个负数，二进制的值是128，所以结果是 -128。
不知道是否说清楚了，

链接：https://www.nowcoder.com/questionTerminal/12001e799bb94fcdbcac429e50672f51?orderByHotValue=1&mutiTagIds=639_134&page=1&onlyReference=false
来源：牛客网

有以下一段代码，请选择其运行结果。( c)

public class Spike
{
public static void main(String[] args)
{
Counter a = new Counter();
System.out.println(a.increment());
System.out.println(a.anotherIncrement());
Counter b = new Counter();
System.out.println(b.increment());
}
}
class Counter
{
private static int count = 0;
public int increment()
{
return count++;
}
public int anotherIncrement()
{
return ++count;
}
}

1 1 1
1 2 3
0 2 2
0 2 0

count是静态变量，为所有对象所共享，因此不管a.increment()还是b.increment()都会使count持续增加。
increment 使count返回当前值,然后count值+1
anotherIncrement让count值先+1,然后再返回当前值

第一个输出,此时count=0,返回0 ,然后count+1;
第二个输出,此时count=1,先count+1,返回2,
第三个输出,此时count=2,返回2,然后count+1;

176.链接：https://www.nowcoder.com/questionTerminal/8ccaa472525942e9bf68429a9e77a9a8?orderByHotValue=1&mutiTagIds=639_134&page=2&onlyReference=false
来源：牛客网

关于C++/JAVA类中static 成员和对象成员的说法正确的是？c
static 成员变量在对象构造时生成
static 成员函数在对象成员函数中无法调用
虚成员函数不可能是static 成员函数
static 成员函数不能访问static 成员变量

static成员变量是在类加载的时候生成的,不是在对象构造时生成
static成员函数既可以通过类名直接调用，也可以通过对象名进行调用,可以被成员函数调用或访问
在java语言中虚函数指代的就是抽象方法，抽象方法中不能用private，static， synchronized，native等修饰词修饰。
static成员函数可以访问static成员变量
静态可以访问静态，静态不能访问非静态，非静态可以访问静态，非静态可以访问非静态

177.链接：https://www.nowcoder.com/questionTerminal/bbdc91459cf849168b510d8aad90227f?orderByHotValue=1&mutiTagIds=639_134&page=2&onlyReference=false
来源：牛客网

下列程序的输出结果是什么？

public class Test1{
public static void main(String args[]){
String a=“1234”;
String b=“1234”;
String c = new String(“1234”);
System.out.println(ab);
System.out.println(ac);
System.out.println(a.equals©);
}
}

true
false
true

true
true
false

true
false
false

true
true
true

ab ,都指向同一个地址,都在常量池中
ac,c是new出来的,开辟了一个新的地址
a.equals© .equals只比较值,不比较地址

A.第一次String a="1234"时，会在常量池中创建一个常量1234,String b=1234时，常量池中已经有了该常量，所以直接取，a和b的地址一样，所以地址值相等；
String c = newString(“1234”)重新new了对象，在堆内存中开辟了新的空间，所以地址值不想等，而equals方法比较的是值是否相等

178.链接：https://www.nowcoder.com/questionTerminal/c6126fd5ba2d40b0bfca35439a6c3563?orderByHotValue=1&mutiTagIds=639_134&page=2&onlyReference=false
来源：牛客网

以下哪几种方式可用来实现线程间通知和唤醒：( a,c)
Object.wait/notify/notifyAll
ReentrantLock.wait/notify/notifyAll
Condition.await/signal/signalAll
Thread.wait/notify/notifyAll

wait()、notify()和notifyAll()是 Object类中的方法
从这三个方法的文字描述可以知道以下几点信息：

1）wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。
2）调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）
3）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；
4）调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；

Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，
使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。
因此通常来说比较推荐使用Condition，在阻塞队列那一篇博文中就讲述到了，阻塞队列实际上是使用了Condition来模拟线程间协作。
Conditon中的await()对应Object的wait()； Condition中的signal()对应Object的notify()； Condition中的signalAll()对应Object的notifyAll()

179.链接：https://www.nowcoder.com/questionTerminal/943aeab5ab464c5caa7f64ca2638a90a?orderByHotValue=1&mutiTagIds=639_134&page=2&onlyReference=false
来源：牛客网

下列关于java 中的 wait()方法和 sleep()方法的区别描述错误的是？
wait()方法属于Object类，sleep()属于Thread类
调用wait()方法的时候，线程会放弃对象锁
调用sleep()方法的过程中，线程不会释放对象锁
sleep()方法导致了程序暂停执行指定的时间，让出cpu给其他线程

sleep和wait的区别有：
1，这两个方法来自不同的类分别是Thread和Object
2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得敏感词线程可以使用同步控制块或者方法。
3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
任何地方使用
synchronized(x){
x.notify()
//或者wait()
}
4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
sleep方法只是导致线暂停执行指定的事件,而不是暂停程序

180.链接：https://www.nowcoder.com/questionTerminal/0ddad0548cb7404d8aa6ef72912e0c7d?orderByHotValue=1&mutiTagIds=639_134&page=2&onlyReference=false
来源：牛客网

public class Test
{
public int x;
public static void main(String []args)
{
System. out. println(“Value is” + x);
}
}

对于上面这段代码，以下说法正确的是：c
程序会打出 “Value is 0”
程序会抛出 NullPointerException
非静态变量不能够被静态方法引用
编译器会抛出 "possible reference before assignment"的错误

非静态成员只能被类的实例化对象引用，因此这里在静态方法中访问x会造成编译出错
当类加载时，static静态方法随着类加载而初始化，此时实例对象还未被创建，但是非静态成员变量需要等到实例对象创建才会被初始化，故无法被引用。

181.以下哪一个不是赋值符号？ c
+=
<<=
<<<=

=

A.很明显是赋值符号
B.<<=左移赋值
C.不是
D.>>>= 右移赋值，左边空出的位以0填充

182.链接：https://www.nowcoder.com/questionTerminal/15a92560e4634f73a33933f2128c0743?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=2&onlyReference=false
来源：牛客网

关于Spring MVC的核心控制器DispatcherServlet的作用，以下说法错误的是（ c）？

它负责处理HTTP请求
加载配置文件
实现业务操作
初始化上下应用对象ApplicationContext

处理 HTTP 请求，这是 SpringMVC 的功能之一，A 对；
一般在 web.xml 中加载 spring-mvc.xml 的配置文件，B 对；
为什么呢,因为实现业务是在service中
springMVC 加载了配置文件后，就会创建一个上下文运行环境啦，D对。

SpringMVC的原理：
SpringMVC是Spring中的模块，它实现了mvc设计模式的web框架，首先用户发出请求，请求到达SpringMVC的前端控制器（DispatcherServlet）,
前端控制器根据用户的url请求处理器映射器查找匹配该url的handler，并返回一个执行链，
前端控制器再请求处理器适配器调用相应的handler进行处理并返回给前端控制器一个modelAndView，前端控制器再请求视图解析器对返回的逻辑视图进行解析，
最后前端控制器将返回的视图进行渲染并把数据装入到request域，返回给用户。
DispatcherServlet作为springMVC的前端控制器，负责接收用户的请求并根据用户的请求返回相应的视图给用户。

183.链接：https://www.nowcoder.com/questionTerminal/76696627939c46018092e56f7bf38293?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=2&onlyReference=false
来源：牛客网

已知如下类定义：
class Base {
public Base (){
//…
}
public Base ( int m ){
//…
}
public void fun( int n ){
//…
}
}
public class Child extends Base{
// member methods
}
如下哪句可以正确地加入子类中？ d
private void fun( int n ){ //…}
void fun ( int n ){ //… }
protected void fun ( int n ) { //… }
public void fun ( int n ) { //… }

方法的重写（override）两同两小一大原则：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

184.链接：https://www.nowcoder.com/questionTerminal/e426ba1e900c4a7ea000e9a029653aae?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=2&onlyReference=false
来源：牛客网

假设有以下代码String s = “hello”；String t = “hello”；char c [ ] = {‘h’,‘e’,‘l’,‘l’,‘o’}；下列选项中返回false的语句是？b
s.equals (t)；
t.equals ©；
s==t；
t.equals (new String (“hello”))；

equal比较的是值,==比较地址

首先与equals是有明显区别的。
强调栈中的比较，可以理解为地址比较
equals强调对象的内容比较
String s=“hello”；会在栈中生成hello字符串，并存入字符串常量池中。
String t=“hello” ；创建时，会在字符串常量池中寻找，当找到需要的hello时，不进行字符串的创建，引用已有的。
所以，st返回true，s.equals(t)也是true。
char c[]={‘h’,‘e’,‘l’,‘l’,‘o’}; cs这个是不存在的，==两边类型不同
t.equals©这个语句在anObject instanceof String这步判断不会通过，也就是cha[] 压根不能与String相比较，类型不是相同的。返回false

185.链接：https://www.nowcoder.com/questionTerminal/0f0a11f9a158469a9a8bf25bba2ae296?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=2&onlyReference=false
来源：牛客网

java中，StringBuilder和StringBuffer的区别，下面说法错误的是？c
StringBuffer是线程安全的
StringBuilder是非线程安全的
StringBuffer对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象。
效率比较String

效率：StringString(大姐，出生于JDK1.0时代) 不可变字符序列 Java中的String是一个类，而并非基本数据类型。string是值传入，不是引用传入。
StringBuffer和StringBuilder可以算是双胞胎了，这两者的方法没有很大区别。
但在线程安全性方面，StringBuffer允许多线程进行字符操作。这是因为在源代码中StringBuffer的很多方法都被关键字 synchronized 修饰了，而StringBuilder没有。
StringBuilder的效率比StringBuffer稍高，如果不考虑线程安全，StringBuilder应该是首选。
另外，JVM运行程序主要的时间耗费是在创建对象和回收对象上。

对于c选项而言,String对String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，而不是StringBuffer；
StringBuffer每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。

186.链接：https://www.nowcoder.com/questionTerminal/e327bb38e1374b2183dbdd849d7e1b99?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=3&onlyReference=false
来源：牛客网

下列有关Thread的描述，哪个是正确的？
启动一个线程的方法是：thread. run()
结束一个线程的通常做法是：thread. stop()
将一个线程标记成daemon线程，意味着当主线程结束，并且没有其它正在运行的非daemon线程时，该daemon线程也会自动结束。
让一个线程等待另一个线程的通知的方法是：thread. sleep()

1.启动一个线程的方法是 start()
2.结束线程用的是interrupt()方法，而stop()是强制结束线程，并不推荐使用，同时stop()方法已被弃用
3.daemon线程是守护线程，当主线程结束时，守护线程会自动结束
4.一个线程等待另外一个线程的方法是wait()方法

187.Thread. sleep()是否会抛出checked exception? 会
会
不会

Thread.sleep() 和 Object.wait(),都可以抛出 InterruptedException。这个异常是不能忽略的,因为它是一个检查异常(checked exception)编译时异常

188.链接：https://www.nowcoder.com/questionTerminal/97ef5dc3e9e746d2a7d25f3c6b973108?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=3&onlyReference=false
来源：牛客网

下列说法正确的是 c
java中包的主要作用是实现跨平台功能
package语句只能放在import语句后面
包（package）由一组类（class）和接口（interface）组成
可以用#include关键词来标明来自其它包中的类

A： java中"包"的引入的主要原因是java本身跨平台特性的需求。实现跨平台的是JVM。
B： package语句是Java源文件的第一条语句。（若缺省该语句，则指定为无名包。），package必须在import前面
D：java中并无#include关键字，如果想在另一个类里面引用包里面的类，要把名字写全。（相当用文件的绝对路径访问）或者用import导入。

189.链接：https://www.nowcoder.com/questionTerminal/e0ab1d3ccb784b8791c3d9e545793f84?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=3&onlyReference=false
来源：牛客网

看以下代码：
文件名称：forward.jsp
1
2
3
4
5
6

跳转如果运行以上jsp文件，地址栏的内容为 a http://127.0.0.1:8080/myjsp/forward.jsp http://127.0.0.1:8080/myjsp/index.jsp http://127.0.0.1:8080/myjsp/index.htm http://127.0.0.1:8080/myjsp/forward.htm

forward和redirect是最常问的两个问题,它们的区别是
forward 请求转发:服务器行为，地址栏不变(服务器获取跳转页面内容传给用户，用户地址栏不变)
redirect：请求重定向：客户端行为，本质上为2次请求，地址栏改变(是服务器向用户发送转向的地址，redirect后地址栏变成新的地址)

190.链接：https://www.nowcoder.com/questionTerminal/20766232d1eb45c5a37457953438f133?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=3&onlyReference=false
来源：牛客网

在Java语言中，下列关于字符集编码（Character set encoding）和国际化（i18n）的问题，哪些是正确的？c,d
每个中文字符占用2个字节，每个英文字符占用1个字节
假设数据库中的字符是以GBK编码的，那么显示数据库数据的网页也必须是GBK编码的。
Java的char类型，通常以UTF-16 Big Endian的方式保存一个字符。
实现国际化应用常用的手段是利用ResourceBundle类

A 显然是错误的，Java一律采用Unicode编码方式，每个字符无论中文还是英文字符都占用2个字节。
B 也是不正确的，不同的编码之间是可以转换的，通常流程如下：
将字符串S以其自身编码方式分解为字节数组，再将字节数组以你想要输出的编码方式重新编码为字符串。
例：String newUTF8Str = new String(oldGBKStr.getBytes(“GBK”), “UTF8”);
C 是正确的。Java虚拟机中通常使用UTF-16的方式保存一个字符
D 也是正确的。ResourceBundle能够依据Local的不同，选择性的读取与Local对应后缀的properties文件，以达到国际化的目的。

191.链接：https://www.nowcoder.com/questionTerminal/8b92d18f34a743adbdb1f2e76a8d2232?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=3&onlyReference=false
来源：牛客网

java Thread中，run方法和start方法的区别，下面说法错误的是？ b
通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。
他们都可以实现了多线程运行。
run方法是thread的一个普通方法调用。
调用start方法后，一旦得到cpu时间片，就开始执行run()方法。

启动线程是start方法,也有说run方法没有实现多线程
链接：https://www.nowcoder.com/questionTerminal/8b92d18f34a743adbdb1f2e76a8d2232?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=3&onlyReference=false

两种方法的区别:
1.start方法
用 start方法来启动线程，是真正实现了多线程，通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，
一旦得到cpu时间片，就开始执行run()方法。但要注意的是，此时无需等待run()方法执行完毕，即可继续执行下面的代码。所以run()方法并没有实现多线程。
2.run方法
run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，
还是要等待run方法体执行完毕后才可继续执行下面的代码。

192.链接：https://www.nowcoder.com/questionTerminal/7fac094ed550468fa60ea00a9b9a26cd?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=3&onlyReference=false
来源：牛客网

下列整型常量 i 的定义中，正确的是( c )
final i;
static int i;
static final int i=234;
final float i=3.14f;

因为是整型
所以要申明 int
所以A D不对
又因为是常量
所以要用final限制
所以
答案 C

java中final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
int关键字修饰整型类型。
static修饰静态变量，即当利用这个关键字来修饰一个变量的时候，在创建对象之前就会为这个变量在内存中创建一个存储空间。以后创建对对象如果需要用到这个静态变量，那么就会共享这一个变量的存储空间。

193.链接：https://www.nowcoder.com/questionTerminal/956a5387c7344caf9a152cff5c47445f?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=3&onlyReference=false
来源：牛客网

关于Linux系统的负载（Load）,以下表述正确的是__b,c____。
通过就绪和运行的进程数来反映
可以通过TOP命令查看
可以通过uptime查看
Load：2.5，1.3，1.1表示系统的负载压力在逐渐减少

为什么呢,d选项三个数分别表示:距现在一分钟,距现在五分钟,距现在十五分种的压力数,那说明负载压力是在增大注意是距离现在
top用法解析：
实时监控或查看系统资源使用情况的工具，类似于Windows的任务管理器。
uptime的用法解析:显示当前系统时间,系统运时间,用户数,表示系统平均荷载
a选项不对是因为还有许多处于等待、阻塞的进程

194.链接：https://www.nowcoder.com/questionTerminal/ab312e43954145a688d51bac73fee768?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=3&onlyReference=false
来源：牛客网

下面有关jsp中静态include和动态include的区别，说法错误的是？ d
动态INCLUDE:用jsp:include动作实现
静态INCLUDE:用include伪码实现，定不会检查所含文件的变化，适用于包含静态页面<%@ include file=“included.htm” %>
静态include的结果是把其他jsp引入当前jsp，两者合为一体;动态include的结构是两者独立，直到输出时才合并
静态include和动态include都可以允许变量同名的冲突.页面设置也可以借用主文件的

为什么说d不对呢,因为这个允许变量同名的冲突并不二者都适用的,静态的include不允许变量同名

以下是对 include 两种用法的区别，主要有两个方面的不同 ;
一 : 执行时间上 :
<%@ include file=“relativeURI”%> 是在翻译阶段执行
在请求处理阶段执行 .
二 : 引入内容的不同 :

<%@ include file="relativeURI"%>  引入静态文本 (html,jsp), 在 JSP 页面被转化成 servlet 之前和它融和到一起 .
 引入执行页面或 servlet 所生成的应答文本 .

195.链接：https://www.nowcoder.com/questionTerminal/2db655d16fc142599ef79a50092c0eae?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=3&onlyReference=false
来源：牛客网

下面哪一项不是加载驱动程序的方法？ a
通过DriverManager.getConnection方法加载
调用方法 Class.forName
通过添加系统的jdbc.drivers属性
通过registerDriver方法注册

DriverManager.getConnection方法返回一个Connection对象，这是加载驱动之后才能进行的
加载驱动方法有:
1.Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”);
2. DriverManager.registerDriver(new com.mysql.jdbc.Driver());
3.System.setProperty(“jdbc.drivers”, “com.mysql.jdbc.Driver”);

DriverManager.getConnection方法返回一个Connection对象，这是加载驱动之后才能进行的,那不是写了么,获得connection

JDBC流程：
加载驱动 DriverManager. registerDriver(Driver driver)
提供JDBC连接的URL
获取连接 Connection conn = DriverManager.getConnection(url,user,pass);
通过连接创建statement Statement st = conn.createStatement();
解析sql获取结果集 ResultSet rs = st.excuteQuery(sql);
遍历结果集，获得数据 rs.getobject(xx)
释放资源，关闭连接

196.链接：https://www.nowcoder.com/questionTerminal/bd323741339e4bf2b9e9c2c72f1e0d28?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网

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

这几个都是对的,arraylist基于数组,linkedlist基于链表,
访问一个元素ArrayList的时间复杂度是O(1),而LinkedList的时间复杂度是O(n),ArrayList更快
对于添加,修改,删除则是LinkedList更快
LinkedList要为每个元素提供两个指针,而ArrayList空间的增长率为1.5倍，所以，最后很可能留下一部分空间是没有用到的，因此，会造成浪费的情况。

197.链接：https://www.nowcoder.com/questionTerminal/2dfafafc5dca400fb4d1f831213f23a6?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网

下面对JVM叙述不正确的是：b
JVM的全称是Java Virtual Machine
JVM是一种计算机硬件技术，它是Java程序的运行平台
JVM是在计算机硬件系统上用软件实现的一台假想机
Java程序在执行时．JVM把Java字节码解释成机器码

JVM也就是Java Virtual Machine，即java虚拟机，是在现有的平台上，如Windows，Linux等，运行一个软件，虚拟出一台接口统一的计算机，依次实现java语言的跨平台特性。

198.基于Servlet API如何实现转向时不在地址栏中显示转向后的地址？c
redirect ( )
sendRedirect ( )
forward ( )
transform ( )

forward 请求转发,地址不变,服务器行为
redirect 请求重定向,地址改变 ,客户端行为
sendRedirect ( ):重定向，让客户完成工作，即地址栏发生改变，可以转向外部资源。该方法参数为String。使用相对URL作为参数。带/的相对原先的URL建立完整URL。不带/的相对Web应用建立。

199.Java中只有整型才能使用的运算符为？c
*
/
%
+

因为乘啊,除啊,加减,别的基本类型也可以使用
ABD选项的操作符都可用于float和double
只有%取余操作，只适用于整型

200.链接：https://www.nowcoder.com/questionTerminal/7f9f247d29fc49e4aab4760fb04b77b4?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网

下面有个hibernate延迟加载，说法错误的是？ c
Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
Hibernate3 提供了属性的延迟加载功能
get支持延迟加载，load不支持延迟加载
hibernate使用Java反射机制，而不是字节码增强程序来实现透明性

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

链接：https://www.nowcoder.com/questionTerminal/a09bab3e083e4ed9a6b4e6479acde180?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网
下面哪一项不属于优化Hibernate所鼓励的？a
使用单向一对多关联，不使用双向一对多
不用一对一，用多对一取代
配置对象缓存，不使用集合缓存
继承类使用显式多态

选a,又是正好反了,Hibernate鼓励使用双向一对多关联，不使用单向一对多关联。
优化Hibernate所鼓励的7大措施：

1.尽量使用many-to-one，避免使用单项one-to-many
2.灵活使用单向one-to-many
3.不用一对一，使用多对一代替一对一
4.配置对象缓存，不使用集合缓存
5.一对多使用Bag 多对一使用Set
6.继承使用显示多态 HQL:from object polymorphism=“exlicit” 避免查处所有对象
7.消除大表，使用二级缓存

202.使用mvc模式设计的web应用程序具有以下优点,除了？ d
可维护行强
可扩展性强
代码重复少
大大减少代码量

没感觉出来代码量减少了
MVC只是将分管不同功能的逻辑代码进行了隔离，增强了可维护和可扩展性，增强代码复用性，因此可以减少代码重复。但是不保证减少代码量，多层次的调用模式还有可能增加代码量

203.链接：https://www.nowcoder.com/questionTerminal/8993b9539d264a8fb275792a3e92d591?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网

为了将当前目录下的归档文件myftp. tgz解压缩到/tmp目录下，用户可以使用命令 a
tar xvzf myftp. tgz –C /tmp
tar xvzf myftp. tgz –R /tmp
tar vzf myftp. tgz –X /tmp
tar xvzf myftp. tgz /tmp

tar 配合压缩解压缩常用用法

压缩
tar -cvzf 打包文件名打包文件集
解压缩
tar -xvzf 需要解包的文件名

-C 指定解压路径.

，tar命令中
-x：extract files from an archive即从归档文件中释放文件；
-v：verbosely list files processed即详细列出要处理的文件；
-z：filter the archive through gzip即通过gzip解压文件；
-f：use archive file or device ARCHIVE即使用档案文件或设备；
通常情况下解压.tar.gz和.tgz等格式的归档文件就可以直接使用tar xvzf；
因为要解压到指定目录下，所以还应在待解压文件名后加上-C（change to directory）参数，即选项A所示格式。

204.链接：https://www.nowcoder.com/questionTerminal/ca7ad7d9248746b9b0634d9e29d41766?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网

下面关于hibernate核心接口说明错误的是？b
Configuration 接口：配置Hibernate，根据其启动hibernate，创建SessionFactory 对象
SessionFactory 接口：负责保存、更新、删除、加载和查询对象，是线程不安全的，避免多个线程共享同一个session，是轻量级、一级缓存
Query 和Criteria 接口：执行数据库的查询
Transaction 接口：管理事务

其实我是感觉SessionFactory是线程安全的,错在这里
然而
B选项中应该是Session接口而不是SessionFactory接口
1，Configuration接口：配置Hibernate，根据其启动Hibernate，创建SessionFactory对象；
2，SessionFactory接口：初始化Hibernate，充当数据存储源的代理，创建session对象，SessionFactory是
线程安全的，意味着它的同一个实例可以被应用的多个线程共享，是重量级二级缓存；
3，session接口：负责保存、更新、删除、加载和查询对象，是一个非线程安全的，避免多个线程共享一个session，是轻量级，一级缓存。
4，Transaction接口：管理事务。可以对事务进行提交和回滚；
5，Query和Criteria接口：执行数据库的查询。

205.下面哪个不是标准Statement类？d
Statement
PreparedStatement
CallableStatement
BatchedStatement

Statement是sql语句的载体
Statement是标准的Statement类，通过字符串对sql语句进行拼接，但是它存在sql注入的危险
PreparedStatement对sql语句进行了预编译，可以防止SQL注入
CallableStatement用来调用存储过程的
BatchedStatement用于批量操作数据库，BatchedStatement不是标准的Statement类

206.链接：https://www.nowcoder.com/questionTerminal/04cf2ed2d8984424b8e3deb2f562df92?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网

下面有关java的引用类型，说法正确的有？a,b,c,d
对于一个对象来说，只要有强引用的存在，它就会一直存在于内存中
如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存
一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的空间

1、强引用：一个对象赋给一个引用就是强引用，比如new一个对象，一个对象被赋值一个对象,会一直存在于内存。
2、虚引用：不能单独存在，必须和引用队列联合使用。主要作用是跟踪对象被回收的状态。就跟没有引用一样
3、软引用：用SoftReference类实现，一般不会轻易回收，只有内存不够才会回收。
4、弱引用：用WeekReference类实现，一旦垃圾回收已启动，就会回收。

207.链接：https://www.nowcoder.com/questionTerminal/d53108343ca84676a4dbd981d54b1dc3?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网

关于JSP生命周期的叙述，下列哪些为真?
JSP会先解释成Servlet源文件，然后编译成Servlet类文件
每当用户端运行JSP时，jsp init()方法都会运行一次
每当用户端运行JSP时，jsp service()方法都会运行一次
每当用户端运行JSP时，jsp destroy()方法都会运行一次

这个是因为init和destroy在生命周期中只会运行一次

208.若下列所用变量均已经正确定义，一下表达式中不合法的是 b
x>>3
+++j
a=x>y?x:y
x%=4

A ,x右移三位
B，++j是j自增1，+++j是不合法的，编译出错
C，这是一个三目运算符，(exp1)?(exp2):(exp3)
当exp1为true时个表达式结果为exp2
当exp1为false时整个表达式结果为exp3
D，取余运算，等价于x=x%4

209.链接：https://www.nowcoder.com/questionTerminal/4a1ae5c4996d4e82912bb4dacb37fa7c?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网

设 m 和 n 都是 int 类型，那么以下 for 循环语句，a_

for(m=0,n=-1;n=0;m++,n++)
n++;

循环体一次也不执行
循环体执行一次
是无限循环
有限次循环
循环结束判断条件不合法
运行出错

n=0不合法在这里,for循环的条件判断语句中，如果使用赋值语句或常量值，当值为0时，不执行循环体，当值为非0时，无限循环。所以，选A

210.链接：https://www.nowcoder.com/questionTerminal/b8321978323c43c694a561d151e69fd0?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网
int main(){fork()||fork();}共创建几个进程：3
1
2
3
4
5
6

就是有主进程,子进程,子进程
fork()给子进程返回一个零值，而给父进程返回一个非零值；
在main这个主进程中，首先执行 fork() || fork(), 左边的fork()返回一个非零值，根据||的短路原则，前面的表达式为真时，后面的表达式不执行，故包含main的这个主进程创建了一个子进程，
由于子进程会复制父进程，而且子进程会根据其返回值继续执行，就是说，在子进程中， fork() ||fork()这条语句左边表达式的返回值是0, 所以||右边的表达式要执行，这时在子进程中又创建了一个进程，
即main进程->子进程->子进程，一共创建了3个进程。

一个现有进程可以调用fork函数创建一个新进程。由fork创建的新进程被称为子进程（child process）。fork函数被调用一次但返回两次。两次返回的唯一区别是子进程中返回0值而父进程中返回子进程ID。
子进程是父进程的副本，它将获得父进程数据空间、堆、栈等资源的副本。注意，子进程持有的是上述存储空间的“副本”，这意味着父子进程间不共享这些存储空间。

211.链接：https://www.nowcoder.com/questionTerminal/9da4f69abb464d3fb7ea1083064c6774?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网

下面关于Spring的说法中错误的是（d）
Spring是一系列轻量级Java EE框架的集合
Spring中包含一个“依赖注入”模式的实现
使用Spring可以实现声明式事务
Spring提供了AOP方式的日志系统

解释一下答案A
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。
核心容器，Spring上下文，Spring AOP， Spring DAO， Spring ORM， Spring Web， Spring MVC。

说是String的AOP并没有日志系统,Spring并没有为我们提供日志系统，我们需要使用AOP（面向方面编程）的方式，借助Spring与日志系统log4j实现我们自己的日志系统。

212.链接：https://www.nowcoder.com/questionTerminal/784aa1460e704217b18ec5897d3d2a66?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网

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

编码格式由浏览器决定，浏览器根据html中指定的编码格式进行编码，tomcat根据指定的格式进行解码，另外get请求和post请求对编码格式的处理也是不同的

213.链接：https://www.nowcoder.com/questionTerminal/cbec6a41dc75420eb4f909a5fd4652bf?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=4&onlyReference=false
来源：牛客网

有以下一个对象：

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:
1
2
3
DataObject object=new Data0bject ( );
object. setWord(“123”);
object. setI(2);
将此对象序列化为文件，并在另外一个JVM中读取文件，进行反序列化，请问此时读出的Data0bject对象中的word和i的值分别为：d

“”, 0
“”, 2
“123”, 2
“123”, 0

序列化保存的是对象的状态，静态变量属于类的状态，因此，序列化并不保存静态变量。所以i是没有改变的
Java在序列化时不会实例化static变量和transient修饰的变量，因为static代表类的成员，transient代表对象的临时数据，被声明这两种类型的数据成员不能被序列化。

214.链接：https://www.nowcoder.com/questionTerminal/6f4735ac05104e5f8d290414e1b473e8?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=5&onlyReference=false
来源：牛客网
下列哪些语句是有效的数组声明？
Which of the following statements are valid array declaration? a
(A) int number();
(B) float average[];
© double[] marks;
(D) counter int[];

(B) & ©
(A)
(A) & ©
(D)

数据的两种定义方式。 int[] nums; int nums[];
数组类型在前,数组名在后
D项写反了,应该是：
int[] counter;

215.Java的Daemon线程，setDaemon( )设置必须要？a
在start之前
在start之后
前后都可以

setDaemon()方法必须在线程启动之前调用，当线程正在运行时调用会产生异常。

216.链接：https://www.nowcoder.com/questionTerminal/721acd262b2d46d8b9643501c2ef5926?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=5&onlyReference=false
来源：牛客网

将文件file1复制为file2可以用下面哪些命令（）a,b,c,d,e
cp file1 file2
cat file1 >file2
cat < file1 >file2
dd if=file1 of=file2
cat file1 | cat >file2

cp命令：cp指令用于复制文件或目录。
将文件file1复制成文件file2命令如下：cp file1 file2
cat命令：cat命令是linux下的一个文本输出命令，通常是用于观看某个文件的内容的。
一次显示整个文件命令如下： cat filename

: linux中的数据流重导向：输出导向，覆盖导向的文件内容。
< : linux中的数据流重导向：输入导向，理解为原本由键盘输入改为文本输入
dd命令 : 作用是用指定大小的块拷贝一个文件，并在拷贝的同时进行指定的转换。
参数：if 输入文件（或设备名称） of 输出文件（或设备名称）
将文件file1拷贝到文件file2中命令如下： dd if=file1 of=file2
| ：管道命令操作符，处理经由前面一个指令传出的正确输出信息，然后，传递给下一个命令，作为标准的输入

217.J2EE中，当把来自客户机的HTTP请求委托给servlet时，会调用HttpServlet的（ a ）方法

service
doget
dopost
init

额,感觉干活的是service吧
Servlet生命周期分为三个阶段：

1.初始化阶段调用init()方法
2.响应客户请求阶段　　调用service()方法
3.终止阶段　　调用destroy()方法

HttpServlet容器响应Web客户请求流程如下：
1）Web客户向Servlet容器发出Http请求；
2）Servlet容器解析Web客户的Http请求；
3）Servlet容器创建一个HttpRequest对象，在这个对象中封装Http请求信息；
4）Servlet容器创建一个HttpResponse对象；
5）Servlet容器调用HttpServlet的service方法，这个方法中会根据request的Method来判断具体是执行doGet还是doPost，把HttpRequest和HttpResponse对象作为service方法的参数传给HttpServlet对象；
6）HttpServlet调用HttpRequest的有关方法，获取HTTP请求信息；
7）HttpServlet调用HttpResponse的有关方法，生成响应数据；
8）Servlet容器把HttpServlet的响应结果传给Web客户。

doGet() 或 doPost() 是创建HttpServlet时需要覆盖的方法.

218.链接：https://www.nowcoder.com/questionTerminal/21efe6541da84d13af68fcf9d658ea93?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=5&onlyReference=false
来源：牛客网

现有一完全的P2P共享协议，每次两个节点通讯后都能获取对方已经获取的全部信息，现在使得系统中每个节点都知道所有节点的文件信息，
共17个节点，假设只能通过多次两个对等节点之间通讯的方式，则最少需要（）次通讯c
32
31
30
29

2n-4=34-4 ,回头再看下

如上图1所示，假设有5个节点，按连线1、2、3、4通讯之后，节点4和5就掌握了所有节点的信息，之后，1、2、3节点只需跟4或5任一节点通讯一次即连线5、6、7就可保证每个节点都知道所有节点的信息，
总的通讯次数是(n-1)+(n-2)=2n-3次。
如果将所有节点分成两组，如图2所示，两组中的节点分别按连线1-8顺序通讯之后，节点4和5就掌握了1-5所有节点的信息，节点9和0就掌握了6-0所有节点的信息，
再按连线9、10通讯之后，节点4、5、9、0就掌握了1-0所有节点的信息，剩下的节点只需跟4、5、9、0任一节点通讯一次就可保证每个节点知道所有节点信息，
和图1相比，多了9和10两次通讯，总的通讯次数是(2n1-3)+(2n2-3)+2=2n-4次(n1和n2分别表示分组中元素个数)。
分3组的情况是(2n1-3)+(2n2-3)+(2n3-3)+6=2n-3次
分4组的情况是(2n1-3)+(2n2-3)+(2n3-3)+(2n4-3)+8=2n-4次

219.下面哪项技术可以用在WEB开发中实现会话跟踪实现 a,b,c,d
session
Cookie
地址重写
隐藏域

会话跟踪是一种灵活、轻便的机制，它使Web上的状态编程变为可能

有四种方法可以实现会话跟踪技术：URL重写、隐藏表单域、Cookie、Session。
1）.隐藏表单域：，非常适合步需要大量数据存储的会话应用。
2）.URL 重写:URL 可以在后面附加参数，和服务器的请求一起发送，这些参数为名字/值对。
3）.Cookie:一个 Cookie 是一个小的，已命名数据元素。服务器使用 SET-Cookie 头标将它作为 HTTP
响应的一部分传送到客户端，客户端被请求保存 Cookie 值，在对同一服务器的后续请求使用一个
Cookie 头标将之返回到服务器。与其它技术比较，Cookie 的一个优点是在浏览器会话结束后，甚至
在客户端计算机重启后它仍可以保留其值
4）.Session：使用 setAttribute(String str,Object obj)方法将对象捆绑到一个会话

220.通过JDBC访问数据库包含下面哪几步？
载入JDBC驱动程序
建立连接
执行查询或更新
关闭连接

链接：https://www.nowcoder.com/questionTerminal/6068251e0c7e4e51957334029747e0a0?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=5&onlyReference=false
来源：牛客网

1、加载JDBC驱动程序：
2、提供JDBC连接的URL
3、创建数据库的连接
4、创建一个Statement
5、执行SQL语句
6、处理结果
7关闭JDBC对象

221.链接：https://www.nowcoder.com/questionTerminal/b07dfbf3f5d7428aacb7387f48084030?orderByHotValue=1&questionTypes=110000&mutiTagIds=134_570&page=1&onlyReference=false
来源：牛客网

在 myjsp.jsp 中，关于下面的代码说法错误的是： ( a )
<%@ page language=“java” import=“java.util.*” errorPage=“error.jsp” isErrorPage=“false” %>
该页面可以使用 exception 对象
该页面发生异常会转向 error.jsp
存在 errorPage 属性时，isErrorPage 是默认为 false
error.jsp 页面一定要有isErrorPage 属性且值为 true

exception是JSP九大内置对象之一，其实例代表其他页面的异常和错误。只有当页面是错误处理页面时，即isErroePage为 true时，该对象才可以使用。
errorPage 的意思是设置当前页面要引入错误的页面。也就是浮面当前页面如果出现错误就会跳转到errorPage所指定的页面。
isErrorpage 的意思是当前页面为错误页面。
isErrorPage默认值为false，若要当前页面为错误页面就设置isErrorPage=true。

222.链接：https://www.nowcoder.com/questionTerminal/ecfc14246ca84e89a360c7a5c5314f4f?orderByHotValue=1&questionTypes=110000&mutiTagIds=134_570&page=1&onlyReference=false
来源：牛客网
java程序文件中包含的公共类必须与该文件同名，但扩展名除外
public class contained in a Java program file must have the same name as the file, except for the extension “.java”. a
FALSE
TRUE

公共的内部类是不需要和文件的名字相同的。
解题要点：
1、java文件中类型为public的类有两种，一种是外部类，一种是内部类；
2、当外部类的类型为public时，文件名需要与其相同；
3、当内部类的类型为public时，而外部类不是public类型的，则文件名可随意，但需要满足命名规范（以字母或下划线开头）。

223.链接：https://www.nowcoder.com/questionTerminal/13fd0abf5ee944f1babd4849e3b48d94?orderByHotValue=1&questionTypes=110000&mutiTagIds=134_570&page=2&onlyReference=false
来源：牛客网

下面的代码运行的结果是：b

class B extends Object
{
static
{
System.out.println(“Load B”);
}
public B()
{
System.out.println(“Create B”);
}
}
class A extends B
{
static
{
System.out.println(“Load A”);
}
public A()
{
System.out.println(“Create A”);
}
}

public class Testclass
{
public static void main(String[] args)
{
new A();
}
}

Load B ->Create B->Load A -> Create A
Load B -> Load A ->Create B ->Create A
Load B -> Create B-> Create A -> Load A
Create B ->Create A ->Load B ->Load A

因为运行顺序是父类静态块-子类静态块-父类非静态变量-父类构造函数-子类非静态函数-子类构造函数

224.链接：https://www.nowcoder.com/questionTerminal/b6f55c8749764ed2876f76a84c4c46a4?orderByHotValue=1&questionTypes=110000&mutiTagIds=134_570&page=4&onlyReference=false
来源：牛客网

关于Java和C/C++的比较，下列哪个描述是错误的？c
Java不支持指针，C/C++支持
Java程序不需要显式地关心内存释放，而C/C++需要
Java和C++一样，是纯编译型语言，因此它们的class都是在编译时静态联编(static binding)的
Java数组、字符串不可能溢出，C/C++数组、字符串则有可能溢出边界

Java不是编译型语言,是解释性语言,d选项java中也可能发生溢出

C，java不完全算是编译型语言，他编译的字节码文件运行时是解释执行的，其次，java和C++的类也不都完全是静态绑定的，比如C+++的虚函数，java的父类引用子类对象等情况。
D，java也可以数组溢出，溢出是会抛出异常，也就是ArrayIndexOutOfBoundsException

225.链接：https://www.nowcoder.com/questionTerminal/710ca02d57584a62b12de32e4892d832?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_134&page=6&onlyReference=false
来源：牛客网

下面有关文件系统元数据的描述，说法错误的是？d

元数据指用来描述一个文件的特征的系统数据，诸如访问权限、文件拥有者以及文件数据块的分布信息等等
我们可以使用stat命令来查看文件更多的元数据信息
Unix/Linux系统允许，多个文件名指向同一个inode号码
文件A和文件B的inode号码虽然不一样，但是文件A的内容是文件B的路径。读取文件A时，系统会自动将访问者导向文件B，这是文件A就称为文件B的"硬链接"

d中这种情况称为软连接
硬链接 (hard link) 与软链接（又称符号链接，即 soft link 或 symbolic link）。链接为 Linux 系统解决了文件的共享使用，还带来了隐藏文件路径、增加权限安全及节省存储等好处。
若一个 inode 号对应多个文件名，则称这些文件为硬链接。换言之，硬链接就是同一个文件使用了多个别名。
若文件用户数据块中存放的内容是另一文件的路径名的指向，则该文件就是软链接。

226.BufferedReader的父类是以下哪个？ d
FilterReader
InputStreamReader
PipedReader
Reader

这个太好记了吧

227.关于cookie以下描述中不正确的是___d__。
cookie附带于http请求中
cookie有大小限制
用户可以主动禁止cookie
https协议下cookie是明文传递的

注意看题，http协议下cookie是明文传递的，https协议下cookie是密文传递的。https协议下传输的内容都是加密后的，包括cookie也是

228.链接：https://www.nowcoder.com/questionTerminal/ca4daaaba2a74097b7990018187436b8?orderByHotValue=1&questionTypes=110000&mutiTagIds=134_570&page=4&onlyReference=false
来源：牛客网

有关会话跟踪技术描述正确的是（d）
Cookie是Web服务器发送给客户端的一小段信息，客户端请求时，可以读取该信息发送到服务器端
关闭浏览器意味着临时会话ID丢失，但所有与原会话关联的会话数据仍保留在服务器上，直至会话过期
在禁用Cookie时可以使用URL重写技术跟踪会话
隐藏表单域将字段添加到HTML表单并在客户端浏览器中显示

隐藏域在页面中对于用户（浏览器）是不可见的，在表单中插入隐藏域的目的在于收集或发送信息，以利于被处理表单的程序所使用。
浏览者单击发送按钮发送表单的时候，隐藏域的信息也被一起发送到服务器。

1.session用来表示用户会话，session对象在服务端维护，一般tomcat设定session生命周期为30分钟，超时将失效，也可以主动设置无效；
2.cookie存放在客户端，可以分为内存cookie和磁盘cookie。内存cookie在浏览器关闭后消失，磁盘cookie超时后消失。当浏览器发送请求时，将自动发送对应cookie信息，前提是请求url满足cookie路径；
3.可以将sessionId存放在cookie中，也可以通过重写url将sessionId拼接在url。因此可以查看浏览器cookie或地址栏url看到sessionId；
4.请求到服务端时，将根据请求中的sessionId查找session，如果可以获取到则返回，否则返回null或者返回新构建的session，老的session依旧存在，请参考API。以上是个人总结，请多指教。

229.java中，用（a ）关键字定义常量？
final
#define
float
const
final关键字定义常量
final关键字可用于修饰类、变量和方法。final修饰变量时，表示该变量一旦获得了初始值就不可被改变，final既可以修饰成员变量也可以修饰局部变量、形参。

230.链接：https://www.nowcoder.com/questionTerminal/65e572d7c059429fb768fefca9751bb0?orderByHotValue=1&questionTypes=110000&mutiTagIds=134_570&page=5&onlyReference=false
来源：牛客网

什么是Hibernate一级缓存？a,c
Hibernate一级缓存是Session的缓存
Hibernate一级缓存是SessionFactory的缓存
第一级缓存为必需，不允许且事实上也无法被卸除
第一级缓存可以设置

一级缓存是session,二级缓存是sessionFactory

Hibernate缓存分为session一级缓存和sessionFactory二级缓存，session一级缓存是内置的，且不可卸载的就是session的一级缓存，sessionFactory二级缓存分为内置缓存和外置缓存

231.下面有关java的一些细节问题，描述错误的是？b
构造方法不需要同步化
一个子类不可以覆盖掉父类的同步方法
定义在接口中的方法默认是public的
容器保存的是对象的引用

构造方法每次都是构造出新的对象，不存在多个线程同时读写同一对象中的属性的问题，所以不需要同步。
子类应该是可以置换掉父类的同步方法的
接口中控制符都是public
容器保存的是对象的引用对

232.链接：https://www.nowcoder.com/questionTerminal/5360f4061d5440beac2eb20081cffea1
来源：牛客网

在JAVA中，下面关于String类和StringBuffer类的描述正确的是那一个？ a
StringBuffer类的对象调用toString（）方法将返回String类型的结果
两个类都有append（）方法
可以直接将字符串“test”赋值给声明的String类和StringBuffer类的变量
两个类的实例的值都能够被改变

StringBuffer类的对象调用toString（）方法将转换为String类型这个正确反正调用这个方法就能转换,别问为什么
stringBuffer有append()方法,String应该是没有
可以直接将字符串“test”复制给声明的Stirng类和StringBuffer类的变量引用类型只有String可以直接复制，其他的都要new出来
String的实例值不可变,StringBuffer的实例值可变

233.链接：https://www.nowcoder.com/questionTerminal/a1644e2668f94ab78bfefa38808fb006
来源：牛客网

下面有关spring的依赖注入，说法错误的是？c
依赖注入通常有如下两种：设置注入和构造注入：
构造注入可以在构造器中决定依赖关系的注入顺序，优先依赖的优先注入
当设值注入与构造注入同时存在时，先执行设值注入，再执行构造注入
设值注入是指IoC容器使用属性的setter方法来注入被依赖的实例。这种注入方式比较简单、直观

我感觉这c是先构造注入,再设值注入,或者同时注入,感觉的错了,正确的是
在没有设值注入的情况下才会根据配置文件中的构造注入，一旦有设值注入，则构造注入失效
然后a,b,d 都是正确的

234.从以下哪一个选项中可以获得Servlet的初始化参数? c
Servlet
ServletContext
ServletConfig
GenericServlet

链接：https://www.nowcoder.com/questionTerminal/4080cf2493f44837b211a46270bf0175
来源：牛客网

ServletContext对象：servlet容器在启动时会加载web应用，并为每个web应用创建唯一的servlet context对象，可以把ServletContext看成是一个Web应用的服务器端组件的共享内存，
在ServletContext中可以存放共享数据。ServletContext对象是真正的一个全局对象，凡是web容器中的Servlet都可以访问。整个web应用只有唯一的一个ServletContext对象
servletConfig对象：用于封装servlet的配置信息。从一个servlet被实例化后，对任何客户端在任何时候访问有效，但仅对servlet自身有效，
一个servlet的ServletConfig对象不能被另一个servlet访问。通过ServletConfig接口的getInitParameter()方法以获得Servlet的初始化参数.

1）ServletConfig：Servlet的配置对象，容器在初始化Servlet时通过它传递信息给Servlet。
2）ServletContext：上下文对象，提供了一系列方法供Servlet与Web容器交互。

235.链接：https://www.nowcoder.com/questionTerminal/cf803beb7e3346caa636e4eaa3a8c2e9
来源：牛客网

下面关于spring mvc 和struts2的描述，错误的是？ a
spring mvc的入口是filter，而struts2是servlet
spring mvc是基于方法的设计，而struts2是基于类的设计
struts2有以自己的interceptor机制，spring mvc用的是独立的AOP方式
spring mvc的方法之间基本上独立的，独享request response数据，struts2所有Action变量是共享的

这个也是因为是相反的.SpringMvc 的入口是servlet,而Struts2的入口是filter
我们从以下几个维度来区分两者的概念：

机制：spring mvc的入口是servlet，而struts2是filter。所以A是错的
性能：spring会稍微比struts快。 spring mvc是基于方法的设计，而sturts是基于类…所以B是对的
参数传递：struts是在接受参数的时候，可以用属性来接受参数，这就说明参数是让多个方法共享的。所以D是对的。
设计思想上： struts更加符合oop的编程思想， spring就比较谨慎，在servlet上扩展。
intercepter(拦截器)的实现机制：struts有以自己的interceptor机制， spring mvc用的是独立的AOP方式。

236.链接：https://www.nowcoder.com/questionTerminal/6ef619400e424ea6a56d72b4a2a44ccc
来源：牛客网

关于JAVA的垃圾回收机制，下面哪些结论是正确？b
程序可以任意指定释放内存的时间
JAVA程序不能依赖于垃圾回收的时间或者顺序
程序可明确地标识某个局部变量的引用不再被使用
程序可以显式地立即释放对象占有的内存

其实垃圾回收机制我们管不了它那么宽,有些东西不是我们想设定就设定的

当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的。
C项错误的原因：局部变量存放在栈上，栈上的垃圾回收，由finalize()来实现,而GC是用于堆
对于d来说,不能立即释放

237.链接：https://www.nowcoder.com/questionTerminal/94b3a7e3075449649f0ee8e901fe5af6
来源：牛客网

一般用()创建InputStream对象,表示从标准输入中获取数据,用()创建OutputStream对象，表示输出到标准输出设备中。a
System.in System.out
System.out System.in
System.io.in System.io.out
System.io.out System.io.in

我刚开始做错了,选了c.当然可以肯定的是in是输入,out是输出
System.in 和 System.out 是java中的标准输入输出流，一般情况下代表从控制台输入和输出到控制台,不加io!!!
你只要记住system.out.println()是输出语句,就不会选错了

238.下面属于JSP内置对象的是？a,b,c,d

out对象
response对象
application对象
page对象

这个题不该错的,再背一遍
pageContext
page
request
response
application
config
session
out
exception exception

239.下列语句哪一个正确（ b）
Java程序经编译后会产生machine code
Java程序经编译后会产生byte code
Java程序经编译后会产生DLL
以上都不正确

产生字节编码, Java编译后是字节码，电脑只能运行机器码。Java在运行的时候把字节码变成机器码。

240.链接：https://www.nowcoder.com/questionTerminal/7825fa493e22424a9641817a1fac65a8
来源：牛客网

下列说法正确的有（c ） constructor(构造方法)
class中的constructor不可省略
constructor必须与class同名，但方法不能与class同名
constructor可在一个对象被new时执行
一个class只能定义一个constructor

a,类中的构造方法可省略,系统会默认给一个
b,其实普通的类方法是可以和类名同名的，和构造方法唯一的区分就是，构造方法没有返回值
c… 构造方法都在new 对象的时候调用的
d. 一个类可以定义多个构造方法的 ,肯定是啊,可以有多个构造方法

241.默认RMI采用的是什么通信协议？ a
HTTP
UDP/IP
TCP/IP
Multicast

不知道呀,我只认识HTTP协议,不知道了,反正记住RMI使用TCP/IP通信协议
RMI(Remote Method Invocation)远程方法调用是一种计算机之间利用远程对象互相调用实现双方通讯的一种通讯机制。
在过去，TCP/IP套接字通讯是远程通讯的主要手段，但此开发方式没有使用面向对象的方式实现开发，

242.链接：https://www.nowcoder.com/questionTerminal/e6cadfc456db49cb983eeb605f48f51e?orderByHotValue=1&questionTypes=110000&mutiTagIds=134_570&page=5&onlyReference=false
来源：牛客网

要在session对象中保存属性，可以使用以下哪个语句( b )
session.getAttribute(“key”，”value”)
session.setAttribute(“key”，”value”)
session.setAttribute(“key”)
session.getAttribute(“key”)

你要写入,肯定是set 啊,然后有key肯定得有value啊,因为是个键值对
获取属性用getAttribute 保存属性用setAttribute
属性是一个键值对，要把键值对内容都传递进去，所以选B

243.下列不属于java语言鲁棒性特点的是 b
java能检查程序在编译和运行时的错误
java能运行虚拟机实现跨平台
java自己操纵内存减少了内存出错的可能性
java还实现了真数组，避免了覆盖数据的可能

鲁棒性的意思是健壮性
好像是,跨平台不属于鲁棒性,也就是说跨平台证明不了你的健壮

Java在编译和运行程序时，都要对可能出现的问题进行检查，以消除错误的产生。
它提供自动垃圾收集来进行内存管理，防止程序员在管理内存时容易产生的错误。
通过集成的面向对象的例外处理机制，在编译时，Java揭示出可能出现但未被处理的例外，帮助程序员正确地进行选择以防止系统的崩溃。
另外， Java在编译时还可捕获类型声明中的许多常见错误，防止动态运行时不匹配问题的出现。
感觉B选项虽然描述也对，但是，不应该把它归结于鲁棒性，B选项主要是体现Java的由于虚拟机，实现了一次编译，到处运行，跨平台性的特点。因此，我选B。

244.链接：https://www.nowcoder.com/questionTerminal/b507628f3f0b4c85a00a7ed0de830413?orderByHotValue=1&questionTypes=110000&mutiTagIds=570_139&page=1&onlyReference=false
来源：牛客网

这是最热门的一道题

检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。 0
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++; 
}

}
0
1
2
3

还是那一套,先运算再赋值,先赋值再运算
这个说法是fermin()这个方法并没有影响到上面的main,
i++也是一个表达式，是有返回值的，返回值就是i自增前的值。因此执行i = i++后，虽然i自增为1，但是又被i++的返回值给重新赋值了

inc.fermin(i);
基本数据类型是值传递，因此这里不改变i的值
i= i ++;
i++这个表达式的值为0，然后将i+1得到i=1
然后将上面i++这个值为0的表达式赋值给i
所以结果i=0

245.下列方法中哪个是线程执行的方法？（）a
run（）
start（）
sleep（）
suspend（）

run()方法用来执行线程体中具体的内容
start是线程启动,进入就绪态
sleep线程睡眠,暂停
suspend使线程挂起，暂停执行，如果想恢复线程，必须由其他线程调用 resume方法。

246.在Java中,下列说法错误的有（B,c, d）
数组是一种对象
数组属于一种原生类
int number = []{31,23,33,43,35,63};
数组的大小可以任意改变

Java把数组当作一个java类来处理
java是纯面向对象的语言，他的数组也是一个对象。
[]的位置我觉得放的不对
大小定了就不能变,d肯定不对
原生类这个玩意是基本数据类型,而数组是引用数据类型
基本数据类型（或叫做原生类、内置类型）8种：
整数：byte，short，int，long（默认是int类型）
浮点类型： float，double（默认是double类型）
字符类型：char
布尔类型：boolean
引用数据类型3种：数组，类，接口

247.java8中，忽略内部接口的情况，不能用来修饰interface里的方法的有（a,c ）
private
public
protected
static

这个题不用说了,接口的控制符只能是public
订正：Java8新特性：static方法和void方法允许在interface中使用了

248.链接：https://www.nowcoder.com/questionTerminal/9bff6cdfda4344f8a691f6f8de6a8229?orderByHotValue=1&questionTypes=110000&mutiTagIds=570_139_138&page=1&onlyReference=false
来源：牛客网

以下关于JAVA语言异常处理描述正确的有？c,d
throw关键字可以在方法上声明该方法要抛出的异常。
throws用于抛出异常对象。
try是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句。
finally语句块是不管有没有出现异常都要执行的内容。
在try块中不可以抛出异常

分析一波啊,ad反了,然后c不是说了吗,try块可以抛出异常

Java语言中的异常处理包括声明异常、抛出异常、捕获异常和处理异常四个环节。
throw用于抛出异常。
throws关键字可以在方法上声明该方法要抛出的异常，然后在方法内部通过throw抛出异常对象。
try是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句。
cacth用于捕获从try中抛出的异常并作出处理。
finally语句块是不管有没有出现异常都要执行的内容

249.链接：https://www.nowcoder.com/questionTerminal/f7e3d10c71ef4d5ea435a1322d2ccfdf?orderByHotValue=1&questionTypes=110000&mutiTagIds=570_139_138&page=1&onlyReference=false
来源：牛客网

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

package algorithms.com.guan.javajicu;
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 void change(String str, char ch[]){
str= “test ok”;
ch[0]= ‘g’;
}
}
test okandabc
test okandgbc
goodandabc
goodandgbc

就是说str没变,但是ch改变了,输出goodandgbc

java 中String是 immutable的，也就是不可变，一旦初始化，其引用指向的内容是不可变的。
也就是说，String str = “aa”；str=“bb”；第二句不是改变“aa”所存储地址的内容，而是另外开辟了一个空间用来存储“bb”；同时由str指向
原来的“aa”，现在已经不可达，GC时会自动回收。
因此String作为参数传进来时候，str= “test ok”; 实际给副本引用str指向了新分配的地址，该地址存储“test ok”。
因此，原先的str仍然指向“good”

首先要知道两个概念：值传递，和引用传递；
1.对这到题而言，String 属于值传递，数组属于引用传递
2.change(String str, char ch[] ) ，若把第一个参数名给成其他，非“str”,例如： change( String s, char ch[] )；最后的输出将会是： test okandgbc
3.所以题目中的 public void change(String str, char ch[]){
str= “test ok”;
ch[0]= ‘g’;
}
该str 只是参数中的str,而并非原来的str,而参数中的str仅仅是原来的一个副本，所以副本的改变并不会造成原来的也跟着那个改变
4,对于参数中的 ch[] ,这里是把原来的引用传递了进来，而不是副本，所以这里改变就一定会造成原来的内容的改变

250.链接：https://www.nowcoder.com/questionTerminal/35a08d98faba40e6a8946fcb88c6c091?orderByHotValue=1&questionTypes=110000&mutiTagIds=570_139_138&page=1&onlyReference=false
来源：牛客网

说明输出结果。c

package test;
import java.util.Date;
public class SuperTest extends Date{
private static final long serialVersionUID = 1L;
private void test(){
System.out.println(super.getClass().getName());
}

public static void main(String[]args){ 
   new SuperTest().test(); 
}

}

SuperTest
SuperTest.class
test.SuperTest
test.SuperTest.class

忘了忘了,得加上包名,我还心思这test哪来的
TestSuper和Date的getClass都没有重写，他们都是调用Object的getClass，而Object的getClass作用是返回的是运行时的类的名字。这个运行时的类就是当前类，所以
super.getClass().getName()
返回的是test.SuperTest，与Date类无关
要返回Date类的名字需要写super.getClass().getSuperclass()

251.链接：https://www.nowcoder.com/questionTerminal/a251db68bbe2475aba8398f508928376?orderByHotValue=1&questionTypes=110000&mutiTagIds=139_138_570&page=1&onlyReference=false
来源：牛客网

下列正确的有（a,c,d ）
call by value不会改变实际参数的数值
call by reference能改变实际参数的参考地址
call by reference不能改变实际参数的参考地址
call by reference能改变实际参数的内容

call by value 值传递,call by reference 引用传递

引用数据类型是引用传递（call by reference），基本数据类型是值传递（call by value）
值传递不可以改变原变量的内容和地址—》原因是java方法的形参传递都是传递原变量的副本，在方法中改变的是副本的值，而不适合原变量的
引用传递不可以改变原变量的地址，但可以改变原变量的内容—》原因是当副本的引用改变时，原变量的引用并没有发生变化，当副本改变内容时，由于副本引用指向的是原变量的地址空间，所以，原变量的内容发生变化。

结论：1.值传递不可以改变原变量的内容和地址；
2.引用传递不可以改变原变量的地址，但可以改变原变量的内容；

252.链接：https://www.nowcoder.com/questionTerminal/6027723bb7f945339125f20d183138fe?orderByHotValue=1&questionTypes=110000&mutiTagIds=139_138_570&page=1&onlyReference=false
来源：牛客网

下述有关c++的虚类和java接口的描述，说法错误的是？c,d
c++虚类相当与java里面的抽象类
c++中没有接口的概念，与之对应的是纯虚类，对应的是java的接口
纯虚函数和虚函数的区别在于前者只包含定义，而后者还可以包含函数体。
一个抽象类和接口中的方法必须是抽象方法

c我不知道,但是抽象类中的方法不一定必须是抽象方法

1、一个子类只能继承一个抽象类（虚类），但能实现多个接口；
2、一个抽象类可以有构造方法，接口没有构造方法；
3、一个抽象类中的方法不一定是抽象方法，即其中的方法可以有实现（有方法体），接口中的方法都是抽象方法，不能有方法体，只有声明；
4、一个抽象类可以是public、private、protected、default,
接口只有public;
5、一个抽象类中的方法可以是public、private、protected、default，
接口中的方法只能是public和default

纯虚函数可以有函数体 C++ primer 5th p541。但是函数体只能定义在类外,所以c也是错的

253.int i, sum=0;
for(i=0;i<10;++i,sum+=i); i 的最终结果是？a
10
9
11
以上答案都不正确

i=10的时候才能退出循环啊
for(i=0;i<10;++i,sum+=i);
这是一个空的for循环，也等价于for(i=0;i<10;++i){sum+=i；}
中间i<10为判断条件，循环最终退出的时候i=10

254.链接：https://www.nowcoder.com/questionTerminal/f51030a5888d4eb8906d79e95fe601a8?orderByHotValue=1&questionTypes=110000&mutiTagIds=139_138_570&page=1&onlyReference=false
来源：牛客网

下列说法错误的有（a,b,c d）
Java面向对象语言容许单独的过程与函数存在
Java面向对象语言容许单独的方法存在
Java语言中的非静态方法属于类中的成员（member）
Java语言中的方法必定隶属于某一类（对象），调用方法与C语言的过程或C++语言的函数相同

链接：https://www.nowcoder.com/questionTerminal/f51030a5888d4eb8906d79e95fe601a8?orderByHotValue=1&questionTypes=110000&mutiTagIds=139_138_570&page=1&onlyReference=false
来源：牛客网

java不允许单独的方法，过程或函数存在,需要隶属于某一类中。——AB错
java语言中的方法属于对象的成员,而不是类的成员。不过，其中静态方法属于类的成员。——C错
方法不一定是要在类里面。接口也可以。调用方法的方式是（对象或类）.方法名。这个与函数是不一样的。–D错

255.下列哪个选项是Java调试器？如果编译器返回程序代码的错误，可以用它对程序进行调试。c
java.exe
javadoc.exe
jdb.exe
javaprof.exe

我是猜的,猜对了
java,exe是java虚拟机
javadoc.exe用来制作java文档
jdb.exe是java的调试器
javaprof,exe是剖析工具

256.链接：https://www.nowcoder.com/questionTerminal/59f359863b86412b83dcd13a01750820?orderByHotValue=1&questionTypes=110000&mutiTagIds=139_138_570&page=1&onlyReference=false
来源：牛客网

public boolean returnTest()
{
try
{
return true;
}
catch (Exception e)
{

}
finally
{
    return false;
}

}
以上代码返回值是什么？ b
true
false

无论发生什么情况,finally中的语句一定会执行。而且是在try-catch块的return之前执行
一旦在finally块中使用了return或throw语句，将会导致try块，catch块中的return，throw语句失效

257.链接：https://www.nowcoder.com/questionTerminal/9e6dc0f7e2f94873b5b3d26b7be57e79?orderByHotValue=1&questionTypes=110000&mutiTagIds=139_138_570&page=1&onlyReference=false
来源：牛客网

JAVA中，下列语句哪一个正确（c）
class中的constructor(构造函数)不可省略
constructor必须与class同名，但方法不能与class同名
constructor在一个对象被new时执行
一个class只能定义一个constructor

省略构造函数,编译器会自动生成。
方法可以和类同名，和构造器区别在于必须要有返回值类型
一个类可以定义多个参数列表不同的构造器，实现构造器重载

258.基本数据类型均可任意互相转换。错
对
错

链接：https://www.nowcoder.com/questionTerminal/4d8396fc9f07436bb5f60e87f6452805?orderByHotValue=1&questionTypes=110000&mutiTagIds=139_138_570&page=1&onlyReference=false
来源：牛客网

来自百度百科：
原生类是指Java中，数据类型分为基本数据类型（或叫做原生类、内置类型）和引用数据类型。
那么原生类为基本数据类型，有八种，这样转换的时候就有表达范围问题。
1、所占位数少的可以转换为所占位数多的类型，比如byte转char,char转int等；
2、而所占位数多的转为所占位数少的默认情况下不能实现转换，需要强制类型转换，这样可能会丢失一部分原始数据；
3、此外，boolean类型数据和其他七种不能互相转换。

259.Java程序中的类名称必须与存放该类的文件名相同。对
对
错
声明为public类型的类名必须与文件名相同，默认权限()defult的可以不同
并且内部类的类名一般与文件名不同

260.链接：https://www.nowcoder.com/questionTerminal/d6ee5937e0374b13b764ebeedf915eac?orderByHotValue=1&questionTypes=110000&mutiTagIds=570_138_139&page=2&onlyReference=false
来源：牛客网

下列哪个选项是正确计算42度（角度）的余弦值？
double d=Math.cos（42）
double d=Math.cosine（42）
double d=Math.cos（Math.toRadians（42））
double d=Math.cos（Math.toDegrees（42））
Math.cos为计算弧度的余弦值，Math.toRadians函数将角度转换为弧度,toDegrees()是将弧度转换为角度
Math.cos（）里面的参数需要的是弧度，所以我们需要先将42度装换为弧度.toRadians

261.链接：https://www.nowcoder.com/questionTerminal/288fb5d649614bdfa8409080f167c920?orderByHotValue=1&questionTypes=110000&mutiTagIds=570_138_139&page=2&onlyReference=false
来源：牛客网

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

public class HelloB extends HelloA
{
public HelloB()
{
}
{
System.out.println(“I’m B class”);
}
static
{
System.out.println(“static B”);
}
public static void main(String[] args)
{
new HelloB();
}
}
class HelloA
{
public HelloA()
{
}
{
System.out.println(“I’m A class”);
}
static
{
System.out.println(“static A”);
}
}

static A
I’m A class
static B
I’m B class

I’m A class
I’m B class
static A
static B

static A
static B
I’m A class
I’m B class

I’m A class
static A
I’m B class
static B

又是老问题了,这种题出现的频率还是很高,那么再背一遍
父类静态静态块-子类静态块-父类非静态变量-父类构造快-子类非静态变量-子类构造快

262.链接：https://www.nowcoder.com/questionTerminal/911e9ed1a3734cbfa2071a54903c9b58?orderByHotValue=1&questionTypes=110000&mutiTagIds=570_138_139&page=2&onlyReference=false
来源：牛客网
Java程序的种类有（ b,c,d）
类（Class）
Applet
Application
Servlet

没弄明白这个种类的意思

Java程序的种类有：
（a）内嵌于Web文件中，由浏览器来观看的_Applet (不能独立运行)
（b）可独立运行的 Application
（c）服务器端的 Servlets

263.链接：https://www.nowcoder.com/questionTerminal/d8b1a014cf3a4fb1bc2b4f6330eb3578?orderByHotValue=1&questionTypes=110000&mutiTagIds=570_138_139&page=2&onlyReference=false
来源：牛客网

java中提供了哪两种用于多态的机制a,b
通过子类对父类方法的覆盖实现多态
利用重载来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
利用覆盖来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
通过子类对父类方法的重载实现多态

首先啊,多态分为编译时多态和运行时多态,编译时多态由方法重载实现,运行时多态由方法重写实现
那么复习一下重载和重写,重载发生在一个类中,同名的方法有不同的参数;重写发生在子类与父类之间,子类重写更优秀的父类方法

264.在java中，下列标识符不合法的有（a ,c,d）
new
$Usdollars
1234
car.taxi

这个题我也错了好几次啊,说标识符以下划线,字母,数字,$ 组成,但是首字母不能是数字,而且java关键字也不能作标识符
a是关键字,c是数字开头,d是有个点

265.链接：https://www.nowcoder.com/questionTerminal/f2a413d242cf45fcbcef50964ffc6001?orderByHotValue=1&questionTypes=110000&mutiTagIds=570_138_139&page=2&onlyReference=false
来源：牛客网
下列关于一个类的静态成员的描述中，不正确的是 d
该类的对象共享其静态成员变量的值
静态成员变量可被该类的所有方法访问
该类的静态方法能访问该类的静态成员变量
该类的静态数据成员变量的值不可修改

类的静态成员与类直接相关，与对象无关，在一个类的所有实例之间共享同一个静态成员，A正确
静态成员函数中不能调用非静态成员，C正确
非静态成员函数中可以调用静态成员，B正确
静态只能调静态,静态不能调用非静态,非静态可以访问静态，非静态可以访问非静态
常量成员才不能修改，静态成员变量必须初始化，但可以修改（例如我们常利用静态成员变量统计某个函数的调用次数），D错误

266.链接：https://www.nowcoder.com/questionTerminal/89fe14d77c9c4277a37326c5ad26d368?orderByHotValue=1&questionTypes=110000&mutiTagIds=570_138_139&page=2&onlyReference=false
来源：牛客网

下面有关java和c++的描述，错误的是？c
java是一次编写多处运行，c++是一次编写多处编译
c++和java支持多继承
Java不支持操作符重载，操作符重载被认为是c++的突出特征
java没有函数指针机制，c++支持函数指针

A、Java是解释性语言，也就是中一次编译后会形成中间码，中间码再被解释器解释为机器码。对于Java而言，JVM中就有解释器。所以Java得一次编写多处运行，实际上因为不同得OS上需要运行不同得JVM。
C++就是编译性语言了，直接把源码变成了机器码。
B、C++可以多继承，但是Java中对于类而言，只有单继承，接口可以多继承。java是支持多重继承,就是B extends A,C extends B
C、Java不能重载运算符，C++可以。
D、Java中没有指针，只有引用。
JAVA的内存管理比C++方便，而且错误处理也比较好;C++的速度比JAVA快。

267.下列语句正确的是（）
形式参数可被视为local variable 本地变量
形式参数可被所有的字段修饰符修饰
形式参数为方法被调用时，是真正被传递的参数
形式参数不可以是对象

形参就是括号里给的参数 int min(int x,int y,int z) 中 x,y,z 就是形参

A：形式参数可被视为local variable。形参和局部变量一样都不能离开方法。都只有在方法内才会发生作用，也只有在方法中使用，不会在方法外可见。
B：对于形式参数只能用final修饰符，其它任何修饰符都会引起编译器错误。但是用这个修饰符也有一定的限制，就是在方法中不能对参数做任何修改。
不过一般情况下，一个方法的形参不用final修饰。只有在特殊情况下，那就是：方法内部类。一个方法内的内部类如果使用了这个方法的参数或者局部变量的话，这个参数或局部变量应该是final。
C：形参的值在调用时根据调用者更改，实参则用自身的值更改形参的值（指针、引用皆在此列），也就是说真正被传递的是实参。
D：方法的参数列表指定要传递给方法什么样的信息，采用的都是对象的形式。因此，在参数列表中必须指定每个所传递对象的类型及名字。
想JAVA中任何传递对象的场合一样，这里传递的实际上也是引用，并且引用的类型必须正确。\

268.下面有关重载函数的说法中正确的是 c
重载函数必须具有不同的返回值类型
重载函数形参个数必须不同
重载函数必须有不同的形参列表
重载函数名可以不同

重载与返回值类型没有关系.不是说重写要求返回值类型相同,就要求重载是不同的
参数列表包括,参数类型不同或参数个数不同或者二者都不同;不是必须个数相同
关于d啊,名都不一样,叫什么重载啊

269.链接：https://www.nowcoder.com/questionTerminal/e29b73b2fa50462a8ff16c0ddd6fb7f5?orderByHotValue=1&questionTypes=110000&mutiTagIds=570_138_139&page=2&onlyReference=false
来源：牛客网
一个完整的URL地址由(),(),端口和文件四部分组成。b
协议用户名
协议主机名
主机名 ip
以上都不正确

协议肯定有的,HTTP,

URL(Uniform Resource Locator) ，统一资源定位符，能够对因特网的资源进行定位。
URL一般有四部分组成： <协议>://<主机>:<端口>/<路径>
现在最常用的<协议>为http协议。
<主机>是指主机在因特网上的域名。
http协议的默认<端口>为80（可以省略）。
<路径>是指要活的的文件的路径。

270.链接：https://www.nowcoder.com/questionTerminal/f7aa0088f49045dd8a7f1f88b76818f8?orderByHotValue=1&questionTypes=110000&mutiTagIds=570_138_139&page=2&onlyReference=false
来源：牛客网

下面有关java内存模型的描述，说法错误的是？d
JMM通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证
“synchronized” — 保证在块开始时都同步主内存的值到工作内存，而块结束时将变量同步回主内存
“volatile” — 保证修饰后在对变量读写前都会与主内存更新。
如果在一个线程构造了一个不可变对象之后（对象仅包含final字段），就可以保证了这个对象被其他线程正确的查看

synchronized 同步锁
volatile变量读前会将主内存的值拷贝到工作内存，写后会同步回主内存

volatile变量的写-读可以实现线程之间的通信。
从内存语义的角度来说，volatile与监视器锁有相同的效果：volatile写和监视器的释放有相同的内存语义；volatile读与监视器的获取有相同的内存语义。
d.final只是指向不变，但是指向的值有可能便，因此依然不是安全线程。

271.链接：https://www.nowcoder.com/questionTerminal/4b3e099a050445128319e160f2fcccf4?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_570_138_139&page=2&onlyReference=false
来源：牛客网

在jdk1.8之前，下列哪一种叙述是正确的（d ）
abstract修饰符可修饰字段、方法和类
抽象方法的body部分必须用一对大括号{ }包住
声明抽象方法，大括号可有可无
声明抽象方法不可写出大括号

abstract修饰符用来修饰类和成员方法,不可用来修饰字段
1：用abstract修饰的类表示抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化。
2：用abstract修饰的方法表示抽象方法,抽象方法没有方法体。抽象方法用来描述系统具有什么功能，但不提供具体的实现。
抽象方法不能有函数执行体，如果用{}包住，即是没有返回值的空白函数体，不符合抽象方法的语法。
C D同上

272.下列运算符合法的是（ a）
&&
<>
if
:=
运算符啊,我只见过a算运算符
第二个和第三个是数据库中的非和赋值运算符，if那当然是java中的关键字了

273.提供Java存取数据库能力的包是（a ）
java.sql
java.awt
java.lang
java.swing

A，java.sql包提供Java存取数据库能力
B，java.awt包是java图形界面的包
C，java.lang是java语言的核心包，lang是language的简写
D，java.swing是经过java封装的与操作系统无关的图形界面包

274.链接：https://www.nowcoder.com/questionTerminal/0e1fa12fd45642bea3acde2c2e913b3f?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_570_138_139&page=3&onlyReference=false
来源：牛客网

下面有关java类加载器，说法正确的是？a,b,c,d
引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码来实现的
扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。
系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类
tomcat为每个App创建一个Loader，里面保存着此WebApp的ClassLoader。需要加载WebApp下的类时，就取出ClassLoader来使用

Java中的类加载器
Java 中的类加载器大致可以分成两类，一类是系统提供的，另外一类则是由Java 应用开发人员编写的。系统提供的类加载器主要有下面三个：

引导类加载器（bootstrap class loader）：
它用来加载 Java 的核心库，是用原生代码来实现的，并不继承自 java.lang.ClassLoader。主要负责jdk_home/lib目录下的核心api 或 -Xbootclasspath 选项指定的jar包装入工作
扩展类加载器（extensions class loader）：
它用来加载 Java 的扩展库。Java虚拟机的实现会提供一个扩展库目录，扩展类加载器在此目录里面查找并加载 Java 类，主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作。
系统类加载器（system class loader）：
它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的
这个D选项不清楚,反正它们说是对的

275.列关于继承的哪项叙述是正确的？ d
在java中类允许多继承
在java中一个类只能实现一个接口
在java中一个类不能同时继承一个类和实现一个接口
java的单一继承使代码更可靠

额,老生常谈了哈,哈哈哈哈,这个java只支持单继承,一个类只能继承一个父类,多重继承不等于多继承
实现接口和继承没关系,一个类当然可以同时继承一个类又实现一个接口
单继承保证了代码的可靠性,

276.链接：https://www.nowcoder.com/questionTerminal/33c176043ffb4d388b81906cb6591232?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_570_138_139&page=3&onlyReference=false
来源：牛客网

java中用()字指明继承关系.用()关键字指明对接口的实现。b
implements extends
extends implements
extend implement
implement extend
这个题不用说了

277.下列InputStream类中哪个方法可以用于关闭流？b
skip（）
close（）
mark（）
reset（）
这个题也不用说了,主要是来看看其他几个是干啥的
skip用来跳过一些字节
mark用来标记流
reset用来复位流

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

InputEvent
KeyEvent
MouseEvent
WindowEvent
链接：https://www.nowcoder.com/questionTerminal/438432a91d954c8eaccde6e82c4324b8?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_570_138_139&page=3&onlyReference=false
来源：牛客网

一、使用 MouseListener 接口处理鼠标事件

使用 MouseListener 接口可处理 5 类操作发生的鼠标事件：

在事件源上按下鼠标键
在事件源上释放鼠标键
在事件源上单击鼠标键
鼠标进入源
鼠标退出事件源

鼠标事件的类型是 MouseEvent ，该类中有下列主要方法：

getX() ：获取鼠标在事件源坐标系统中的 x 坐标。
getY() ：获取鼠标在事件源坐标系统中的 y 坐标。
getModifiers() ：获取鼠标的左键或右键。鼠标的左键和右键分别使用 InputEvent 类中的常量 BUTTON1_MASK 和 BUTTON3_MASK 来表示。
getClickCount() ：获取鼠标被单击的次数。
getSource() ：获取发生鼠标事件的事件源。

事件源获得监视器的方法是 addMouseListener( 监视器 ) 。

3.MouseListener 接口中有如下方法：

mousePressed(MouseEvent) ：负责处理鼠标按下事件。即当在事件源按下鼠标时，监视器发现这个事件后将自动调用接口中的这个方法对事件作出处理。
mouseReleased(MouseEvent) ：负责处理鼠标释放事件。
mouseEntered(MouseEvent) ：负责处理鼠标进入事件。
mouseExited(MouseEvent) ：负责处理鼠标离开事件。
mouseClicked(MouseEvent) ：负责处理鼠标单击事件。

279.链接：https://www.nowcoder.com/questionTerminal/16bec82b5d2c41eaa65cf794dbf6a858?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_570_138_139&page=3&onlyReference=false
来源：牛客网

一般有两种用于创建线程的方法,一是(),二是()。
从Java.lang.Thread类派生一个新的线程类，重写它的runnable()方法
从Java.lang.Thread类派生一个新的线程类，重写它的run()方法
实现Thread接口，重写Thread接口中的run()方法
实现Runnable接口，重写Runnable接口中的run()方法

我滴妈呀,这个题我还真做错了
首先啊,Thread里面没有runnable 方法
其次啊,Runnable是一个接口

创建线程对象两种方式：
1.继承Thread类，重载run方法；
2.实现Runnable接口，实现run方法

280.链接：https://www.nowcoder.com/questionTerminal/f3e982b8fc4d48f7b95dbadd7f53247f?orderByHotValue=1&questionTypes=110000&mutiTagIds=639_570_138_139&page=3&onlyReference=false
来源：牛客网

下列关于功能性注释不正确的说法是(b)
功能性注释嵌在源程序中，用于说明程序段或语句的功能以及数据的状态
注释用来说明程序段，需要在每一行都要加注释
可使用空行或缩进，以便很容易区分注释和程序
修改程序也应修改注释

如果代码按行算钱，那么需要在每一行都要加注释：) 可以可以

281.链接：https://www.nowcoder.com/questionTerminal/e39bfd29540e4b43b197102282426551?orderByHotValue=1&questionTypes=110000&mutiTagIds=139_138_570&page=3&onlyReference=false
来源：牛客网
this代表了()的对象引用,super表示的是当前对象的()对象?d
当前类当前类
当前类的父类当前类
当前类当前类的父类
以上都不正确

但是很多人都说选d啊,都是杠精,现在不知道选c还是d了,super的确表示子类对父类的调用

我觉得应该是D
《Java核心技术》中说：.super 只是个标识，标识让子类调用父类的方法而已，并不是代表某一个对象
发表于 2016-08-09 10:32:16回复(4)举报

觉得应该选D，如果子类继承父类的方法，子类并没有重写父类的方法，当父类引用指向子类对象时，调用父类方法里的this就是子类对象。

282.链接：https://www.nowcoder.com/questionTerminal/fbe69f6e836d4643983296fc84d64591?orderByHotValue=1&questionTypes=110000&mutiTagIds=139_138_570&page=3&onlyReference=false
来源：牛客网

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

JNDI是java命名和目录接口

EJB容器：Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容器进行高效率的管理。
JNDI：（Java Naming & Directory Interface）JAVA命名目录服务。主要提供的功能是：提供一个目录系，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。
JMS：（Java Message Service）JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
JTA：（Java Transaction API）JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
JAF：（Java Action FrameWork）JAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。

283.在运行时，由java解释器自动引入，而不用import语句引入的包是()。a
java.lang
java.system
java.io
java.util

链接：https://www.nowcoder.com/questionTerminal/487afa3d5b57477c9051ca5e57a6e592?orderByHotValue=1&questionTypes=110000&mutiTagIds=139_138_570&page=3&onlyReference=false
来源：牛客网

java.lang包是java语言包，是自动导入的。是Java的核心包
java.util包是java的工具包，需要手动导入。
java.system包,也是需要手动导入
java.io;各种输入输入流，需要手动导入。

284.在Java中，以下那些数据结构可以以常量的时间复杂度0(1)添加元素(a,d)
HashMap
ArrayList
TreeMap
LinkedList

HashMap是以key和value键值对形式存储信息的，集合元素无序且不用查找再进行添加，直接指定新的key和value就ok，时间复杂度是O(1)
ArrayList是查找数据方便,查数据时间复杂度为O(1),LinkedList是增删改方便,添加元素时间复杂度为O(1)

285.链接：https://www.nowcoder.com/questionTerminal/170c98fb9ade4e01974ef9703ab52575?orderByHotValue=0&questionTypes=110000&mutiTagIds=138_139_639&page=1&onlyReference=false
来源：牛客网

下列关于 clone 和 fork 的区别描述正确的有？c
clone和fork最大不同在于fork不再复制父进程的栈空间，而是自己创建一个新的。
clone和fork最大不同在于clone不再复制父进程的栈空间，而是自己创建一个新的。
clone是fork的升级版本，不仅可以创建进程或者线程，还可以指定创建新的命名空间（namespace）、有选择的继承父进程的内存、甚至可以将创建出来的进程变成父进程的兄弟进程等等
fork是clone的升级版本，不仅可以创建进程或者线程，还可以指定创建新的命名空间（namespace）、有选择的继承父进程的内存、甚至可以将创建出来的进程变成父进程的兄弟进程等等

答案：C
fork是复制进程，创建一个新的进程，不带参数
clone是可选的复制父进程资源，可以通过参数控制复制的内容, clone() 函数则是将部分父进程的资源的数据结构进行复制，复制哪些资源是可选择的,
fork是全复制,clone部分复制

286.链接：https://www.nowcoder.com/questionTerminal/ae9783dc0d234729a4ea313404c9cf01?orderByHotValue=0&questionTypes=110000&mutiTagIds=138_139_639&page=1&onlyReference=false
来源：牛客网

已知：print()函数是一个类的常成员函数，它无返回值，下列表示中，哪一项是正确的?a
void print()const；
const void print()；
void const print()：
void print(const)；

答案解析：使用const关键字修饰的函数为常成员函数，其声明格式：
类型说明符函数名（参数表） const
所以选择A,括号里放的是参数,不能选d

287.链接：https://www.nowcoder.com/questionTerminal/2466d76540d445edb1d85a26bd6fbd36?orderByHotValue=0&questionTypes=110000&mutiTagIds=138_139_639&page=1&onlyReference=false
来源：牛客网

下面有关tcp连接握手，说法错误的是？d
connect() api调用发生在三次握手之后
accept() api调用发生在三次握手之后
“三次握手”的目的是“为了防止已失效的连接请求报文段突然又传送到了服务端，因而产生错误”
因为tcp是全双工模式，接收到FIN时意味将没有数据再发来，但是还是可以继续发送数据，所以断开连接时必须是四次握手

connect发送了一个SYN，收到Server的SYN+ACK后，代表连接完成。发送最后一个ACK是protocol stack,tcp_out完成的。它是在三次握手过程中调用的。
connect 调用发生在三次握手过程中,不是之后
四次握手也是有可能的

288.链接：https://www.nowcoder.com/questionTerminal/5fbc78d89b874ed8b23d29f24f7c3547?orderByHotValue=0&questionTypes=110000&mutiTagIds=138_139_639&page=1&onlyReference=false
来源：牛客网

关于static变量，请选择下面所有说法正确的内容。
若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度
若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度
设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题
静态全局变量过大，可那会导致堆栈溢出

对于D：静态变量放在程序的全局数据区，而不是在堆栈中分配，所以不可能导致堆栈溢出，D是错误的。
答案是A、B、C。
a
289.Internet采用的7层OSI模型主要层次结构有？a,c
应用层，表示层，会话层，传输层
应用层，表示层，会话层，TCP层
网络层，数据链路层，物理层
IP层，数据链路层，物理层

链接：https://www.nowcoder.com/questionTerminal/41e6debfcc364eb385228e9b26d443bd?orderByHotValue=1&questionTypes=110000&mutiTagIds=138_139_639&page=9&onlyReference=false
来源：牛客网

物理层: 将数据转换为可通过物理介质传送的电子信号相当于邮局中的搬运工人
数据链路层: 决定访问网络介质的方式,在此层将数据分帧，并处理流控制。本层指定拓扑结构并提供硬件寻址。相当于邮局中的装拆箱工人
网络层: 使用权数据路由经过大型网络相当于邮局中的排序工人
传输层: 提供终端到终端的可靠连接相当于公司中跑邮局的送信职员
会话层: 允许用户使用简单易记的名称建立连接相当于公司中收寄信、写信封与拆信封的秘书
表示层: 协商数据交换格式相当公司中简报老板、替老板写信的助理
应用层: 用户的应用程序和网络之间的接口老板

290.程序的局部变量存在于1中，全局变量存在于2中，动态申请数据存在于3中。
1栈 2数据区 3堆

一般全局变量存放在数据区，局部变量存放在栈区，
动态变量存放在堆区，函数代码放在代码区。
栈区：由编译器自动分配和释放的内存区域，用于存放函数的参数值，局部变量的值等。随着函数的调用和返回，栈区的数据将动态变化。
堆区：程序员向系统申请或释放（new、malloc等动态申请）。若程序员在程序结束时还没有释放，则可能由操作系统回收。
全局区（静态区）：用来保存全局变量和静态变量。在进入程序时分配区域，程序结束后由系统释放。
文字常量区：用于保存常量字符串的内存区域，程序结束后，由系统释放。
程序代码区：用于保存函数体的二进制代码。

291.1<<3+2的值是（a）。
32
10
16
6

是这样啊,+号优先级大于<<,所以先运行3+2
所以先计算2+3=5；
向左移,空位补0
1<<5等于二进制100000=32（十进制）

在Java中有左移（<<）,有符号的右移（>>）,无符号的右移（>>>）。
左移（<< )能按照操作符右侧所指定的位数将操作数的二进制位向左移动（低位补0）。
有符号的右移（>>）能按照操作符右侧所指定的位数将操作数的二进制位向右移动，其中最高位填充规则为：若原数为负，最高位补1；若原数为正，最高位补0。
无符号的右移（>>>）能按照操作数右侧所指定的位数将操作数的二进制位向右移动，不管其原数正负，最高位统一补0。（这就意味着负数会变成正数）。

292.在顺序表（3,6,8,10,12,15,16,18,21,25,30）中，用二分法查找关键码值11，所需的关键码比较次数为 c
2
3
4
5

二分法,就是永远找中间的数去比较
第一次和15进行比较比十五小
第二次和8进行比较比8大
第三次和10进行比较
第四次和12进行比较

293.链接：https://www.nowcoder.com/questionTerminal/a568949ffbfc4a20977a2dab786032dd?orderByHotValue=1&mutiTagIds=171&page=1&onlyReference=false
来源：牛客网
下面的代码片段会产生什么结果？
What results from the following code fragment? c
int i = 5;
int j = 10;
System.out.println(i + ~j);

Compilation error because”~”doesn’t operate on integers 编译错误，因为"~"不在整数上运算
-5
-6
15
~j =-11
公式-n=_n+1可推出n=-n-1，所以~10=-11再加5结果为-6

294.链接：https://www.nowcoder.com/questionTerminal/005915d777ce40f29b042de47f23974d?orderByHotValue=1&mutiTagIds=171&page=1&onlyReference=false
来源：牛客网

有如下代码：请写出程序的输出结果。b

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

432
531
421
523

&&运算符是如果左边为false,则右边不进行运算,只有左边为true,右边才运算
z,x,y.k 的值分别是
第一遍循环,0,1,0,0
第二遍循环,1,2,0,0
第三遍循环,2,3,1,0
第四遍循环,3,4,2,0
第五遍循环,4,5,3,1

第六遍循环,此时z=5,跳出循环,xyk为531

295.HTTP的会话有四个过程，请选出不是的一个（d）

建立连接
发出响应信息
发出请求信息
传输数据

HTTP会话的四个过程

建立tcp连接
发出请求文档
发出响应文档
释放tcp连接

296.链接：https://www.nowcoder.com/questionTerminal/a8f22c58957d4ade8b73468a7c153ce6?orderByHotValue=1&mutiTagIds=149_570&page=1&onlyReference=false
来源：牛客网

jdk1.8中，下面有关java 抽象类和接口的区别，说法错误的是？b,d
抽象类可以有构造方法，接口中不能有构造方法
抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法
一个类可以实现多个接口，但只能继承一个抽象类
接口中可以有普通成员变量，抽象类中没有普通成员变量

好像是说,1.8中接口可以有default、static方法，所以B是错的。再复习一下

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

297.链接：https://www.nowcoder.com/questionTerminal/856fafc0bf64419798180cd558f55e5c?orderByHotValue=1&mutiTagIds=149_570&page=1&onlyReference=false
来源：牛客网

以下Java程序运行的结果是:a

public class Tester{
public static void main(String[] args){
Integer var1=new Integer(1);
Integer var2=var1;
doSomething(var2);
System.out.print(var1.intValue());
System.out.print(var1==var2);
}
public static void doSomething(Integer integer){
integer=new Integer(2);
}
}
1true
2true
1false
2false

java中引用类型的实参向形参的传递，只是传递的引用，而不是传递的对象本身。
var1指向了 Integer(1)
var2也指向了 Integer(1)

然后var2的引用被赋给了integer,此时三个都指向Integer(1)

然后do方法里把integer指向了新new的Integer(2),但是此时var1和2还是指向同一地址

298.链接：https://www.nowcoder.com/questionTerminal/ac061529b516487b97cd35f61157d369?orderByHotValue=1&mutiTagIds=149_570&page=1&onlyReference=false
来源：牛客网

线程安全的map在JDK 1.5及其更高版本环境有哪几种方法可以实现?
Map map = new HashMap()
Map map = new TreeMap()
Map map = new ConcurrentHashMap();
Map map = Collections.synchronizedMap(new HashMap());

首先我肯定知道HashMap是不安全的,其次TreeMap也是不安全的

HashTable 和 ConcurrentHashMap 都是线程安全的。区别在于他们对加锁的范围不同，HashTable 对整张Hash表进行加锁，而ConcurrentHashMap将Hash表分为16桶(segment)，每次只对需要的桶进行加锁。
Collections 类提供了synchronizedXxx()方法，可以将指定的集合包装成线程同步的集合。比如，
List list = Collections.synchronizedList(new ArrayList());
Set set = Collections.synchronizedSet(new HashSet());

299.链接：https://www.nowcoder.com/questionTerminal/cf49801fc7164f4f88266f6972ec112d?orderByHotValue=1&mutiTagIds=149_570&page=1&onlyReference=false
来源：牛客网

下面有关java classloader说法错误的是?c
Java默认提供的三个ClassLoader是BootStrap ClassLoader，Extension ClassLoader，App ClassLoader
ClassLoader使用的是双亲委托模型来搜索类的
JVM在判定两个class是否相同时，只用判断类名相同即可，和类加载器无关
ClassLoader就是用来动态加载class文件到内存当中用的

c一看就不对,JVM在判定两个class是否相同时，不仅要判断两个类名是否相同，而且要判断是否由同一个类加载器实例加载的。

一个jvm中默认的classloader有Bootstrap ClassLoader、Extension ClassLoader、App ClassLoader，分别各司其职：
Bootstrap ClassLoader 负责加载java基础类，主要是 %JRE_HOME/lib/ 目录下的rt.jar、resources.jar、charsets.jar和class等
Extension ClassLoader 负责加载java扩展类，主要是 %JRE_HOME/lib/ext 目录下的jar和class
App ClassLoader 负责加载当前java应用的classpath中的所有类。

300.链接：https://www.nowcoder.com/questionTerminal/c3c0fc0f0b5d49458b05fc0f25bc1e36?orderByHotValue=1&mutiTagIds=570_140&page=1&onlyReference=false
来源：牛客网

关于以下程序代码的说明正确的是?d

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

程序通过编译，输出结果为：x=103
10行不能通过编译，因为x是私有静态变量
5行不能通过编译，因为引用了私有静态变量
程序通过编译，输出结果为：x=102

我本来想着是x值不能变

首先要了解static的意思。
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

static变量在第一次使用的时候初始化，但只会有一份成员对象。

所以这里不仅可以调用，而且每一次调用都确实修改了x的值，也就是变化情况是这样的：
x=101
x=102
x=103
x=102

301.链接：https://www.nowcoder.com/questionTerminal/d29b742b521743118a741d01fcdc0b96
来源：牛客网

下面有关jdbc statement的说法错误的是？ c
JDBC提供了Statement、PreparedStatement 和 CallableStatement三种方式来执行查询语句，其中 Statement 用于通用查询， PreparedStatement 用于执行参数化查询，而 CallableStatement则是用于存储过程
对于PreparedStatement来说，数据库可以使用已经编译过及定义好的执行计划，由于 PreparedStatement 对象已预编译过，所以其执行速度要快于 Statement 对象”
PreparedStatement中，“?” 叫做占位符，一个占位符可以有一个或者多个值
PreparedStatement可以阻止常见的SQL注入式攻击

一个占位符只能对应一个值

1.Statement、PreparedStatement和CallableStatement都是接口(interface)。
2.Statement继承自Wrapper、PreparedStatement继承自Statement、CallableStatement继承自PreparedStatement。
3.
Statement接口提供了执行语句和获取结果的基本方法；
PreparedStatement接口添加了处理 IN 参数的方法；
CallableStatement接口添加了处理 OUT 参数的方法。
4.
a.Statement:
普通的不带参的查询SQL；支持批量更新,批量删除;
b.PreparedStatement:
可变参数的SQL,编译一次,执行多次,效率高;
安全性好，有效防止Sql注入等问题;
支持批量更新,批量删除;
c.CallableStatement:
继承自PreparedStatement,支持带参数的SQL操作;
支持调用存储过程,提供了对输出和输入/输出参数(INOUT)的支持;

Statement每次执行sql语句，数据库都要执行sql语句的编译，
最好用于仅执行一次查询并返回结果的情形，效率高于PreparedStatement。

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

在执行可变参数的一条SQL时，PreparedStatement比Statement的效率高，因为DBMS预编译一条SQL当然会比多次编译一条SQL的效率要高。
安全性好，有效防止Sql注入等问题。
对于多次重复执行的语句，使用PreparedStament效率会更高一点，并且在这种情况下也比较适合使用batch；
代码的可读性和可维护性。

302.链接：https://www.nowcoder.com/questionTerminal/1c65d30e47fb4f59a5e5af728218cac4
来源：牛客网

下面有关SPRING的事务传播特性，说法错误的是？d
PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行
PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就抛出异常
PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起
PROPAGATION_NESTED：支持当前事务，新增Savepoint点，与当前事务同步提交或回滚

事务属性的种类：传播行为、隔离级别、只读和事务超时

a) 传播行为定义了被调用方法的事务边界。

传播行为

意义

PROPERGATION_MANDATORY
表示方法必须运行在一个事务中，如果当前事务不存在，就抛出异常

PROPAGATION_NESTED
表示如果当前事务存在，则方法应该运行在一个嵌套事务中。否则，它看起来和 PROPAGATION_REQUIRED 看起来没什么俩样

PROPAGATION_NEVER
表示方法不能运行在一个事务中，否则抛出异常

PROPAGATION_NOT_SUPPORTED
表示方法不能运行在一个事务中，如果当前存在一个事务，则该方法将被挂起

PROPAGATION_REQUIRED
表示当前方法必须运行在一个事务中，如果当前存在一个事务，那么该方法运行在这个事务中，否则，将创建一个新的事务

PROPAGATION_REQUIRES_NEW
表示当前方法必须运行在自己的事务中，如果当前存在一个事务，那么这个事务将在该方法运行期间被挂起

PROPAGATION_SUPPORTS
表示当前方法不需要运行在一个是事务中，但如果有一个事务已经存在，该方法也可以运行在这个事务中

303.下面有关servlet service描述错误的是？ b
不管是post还是get方法提交过来的连接，都会在service中处理
doGet/doPost 则是在 javax.servlet.GenericServlet 中实现的
service()是在javax.servlet.Servlet接口中定义的
service判断请求类型，决定是调用doGet还是doPost方法

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

304.下列有关Servlet的生命周期，说法不正确的是？
正确答案: A 你的答案: B (错误)
在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例
在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法
在销毁阶段，执行destroy()方法后会释放Servlet 占用的资源
destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法

创建Servlet的实例是由Servlet容器来完成的，且创建Servlet实例是在初始化方法init()之前

305.下面有关servlet中init,service,destroy方法描述错误的是？
正确答案: D 你的答案: D (正确)
init()方法是servlet生命的起点。一旦加载了某个servlet，服务器将立即调用它的init()方法
service()方法处理客户机发出的所有请求
destroy()方法标志servlet生命周期的结束
servlet在多线程下使用了同步机制，因此，在并发编程下servlet是线程安全的

servlet在多线程下其本身并不是线程安全的。
如果在类中定义成员变量，而在service中根据不同的线程对该成员变量进行更改，那么在并发的时候就会引起错误。
最好是在方法中，定义局部变量，而不是类变量或者对象的成员变量。由于方法中的局部变量是在栈中，彼此各自都拥有独立的运行空间而不会互相干扰，因此才做到线程安全。

306.下面有关struts1和struts2的区别，描述错误的是？
正确答案: B 你的答案: 空 (错误)
Struts1要求Action类继承一个抽象基类。Struts 2 Action类可以实现一个Action接口
Struts1 Action对象为每一个请求产生一个实例。Struts2 Action是单例模式并且必须是线程安全的
Struts1 Action 依赖于Servlet API，Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试
Struts1 整合了JSTL，Struts2可以使用JSTL，但是也支持OGNL

servle是单例的 Struts2是多例的记住这个就OK了

307.根据下面的程序代码，哪些选项的值返回true？

public class Square {
long width;
public Square(long l) {
width = l;
}
public static void main(String arg[]) {
Square a, b, c;
a = new Square(42L);
b = new Square(42L);
c = b;
long s = 42L;
}
}
正确答案: C 你的答案: 空 (错误)
a == b
s == a
b == c
a.equals(s)

c=b,c和b指向了同一个地址,当然b==c

a = new Square(42L);
b = new Square(42L);
这里new了两个对象，所以a,b不是同一个引用a!=b
s的类型跟a,b不同类型，所以s!=a,s!=b
1
c = b;
这里b，c是同一个对象的引用，所以b==c是true

308.jdk1.5的环境下，有如下4条语句：

Integer i01 = 59;
int i02 = 59;
Integer i03 =Integer.valueOf(59);
Integer i04 = new Integer(59);

以下输出结果为false的是：
正确答案: C 你的答案: 空 (错误)
System.out.println(i01 == i02);
System.out.println(i01 == i03);
System.out.println(i03 == i04);
System.out.println(i02 == i04);

i04是一个新new出来的,当然和i03指向的不是同一个地址

309.给定以下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");
}

}

正确答案: B 你的答案: 空 (错误)
exception in main finished
finally finished
exception in main finally
finally exception in main finished

finally中的语句一定会执行。
i / 10;无论i是多少，永远不会抛出异常，所以catch语句不会执行。
而finally语句是必定执行的语句。
所以先指向aMathod()的finally代码块，输出finally
然后执行main()方法的最后一条输出语句，输出finished

310.面哪个不对？
正确答案: C 你的答案: 空 (错误)
RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
A method is not required to declare in its throws clause any subclasses of RuntimeExeption that might be thrown during the execution of the method but not caught
An RuntimeException is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.
NullPointerException is one kind of RuntimeException

运行时异常：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。
非运行时异常（编译异常）：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

311.执行如下代码， c 的值是：（）

int a=0,c=0;
do{
–c;
a=a-1;
}while(a>0);

正确答案: C 你的答案: 空 (错误)
0
1
-1
死循环

do-while 循环至少要执行一次循环语句。
使用while语句应注意以下几点：
1 、 while 语句中的表达式一般是关系表达或逻辑表达式，只要表达式的值为真 ( 非 0) 即可继续循环。
2 、循环体如包括有一个以上的语句，则必须用 {} 括起来，组成复合语句。

程序最开始执行–c,现在c变成了-1，接着执行a=a-1,a也变成了-1，再执行while语句，while（a>0）,判断为假，退出循环，故c= -1

312.Math.round(11.5) 等于：（）
正确答案: C 你的答案: 空 (错误)
11
11.5
12
12.5

复习一下math.round
求四舍五入
例子: Math.round(11.5) ，首先与 11.5最接近的有两个整数 11 和 12，取较大的那结果就是12；
Math.round(-11.5)，首先与 -11.5最接近的有两个整数 -11 和 -12，取较大的那结果就是-11；
Math.round(0.5)，首先与 0.5最接近的有两个整数 0 和 1，取较大的那结果就是1；
Math.round(-0.5)，首先与 -0.5最接近的有两个整数 -1 和 0，取较大的那结果就是0；）

313.java7后关键字 switch 支不支持字符串作为条件：（）
正确答案: A 你的答案: 空 (错误)
支持
不支持

这个之前说过了
在Java7之前，switch只能支持 byte、short、char、int或者其对应的封装类以及Enum类型。在Java7中，呼吁很久的String支持也终于被加上了。

314.有时为了避免某些未识别的异常抛给更高的上层应用，在某些接口实现中我们通常需要捕获编译运行期所有的异常， catch 下述哪个类的实例才能达到目的：（）

正确答案: B 你的答案: 空 (错误)
Error
Exception
RuntimeException
Throwable

正确答案是B，因为error是系统出错，catch是无法处理的，难以修复的，RuntimeException不需要程序员进行捕获处理，
error和exception都是throwable的子类，我们只需要对exception的实例进行捕获即可

315.链接：https://www.nowcoder.com/questionTerminal/733630b017f74bf3bcf54dc8a82dc3cf
来源：牛客网
阅读如下代码。请问，对语句行 test.hello(). 描述正确的有（）

package NowCoder;
class Test {
public static void hello() {
System.out.println(“hello”);
}
}
public class MyApplication {
public static void main(String[] args) {
// TODO Auto-generated method stub
Test test=null;
test.hello();
}
}

正确答案: A 你的答案: 空 (错误)
能编译通过，并正确运行
因为使用了未初始化的变量，所以不能编译通过
以错误的方式访问了静态方法
能编译通过，但因变量为null，不能正常运行

因为Test类的hello方法是静态的，所以是属于类的，当实例化该类的时候，静态会被优先加载而且只加载一次，所以不受实例化new Test();影响，只要是使用到了Test类，都会加载静态hello方法！
另外，在其他类的静态方法中也是可以调用公开的静态方法，此题hello方法是使用public修饰的所以在MyApplication中调用hello也是可以的。
总结：即使Test test=null;这里也会加载静态方法，所以test数据中包含Test类的初始化数据。（静态的，构造的，成员属性）
因此test.hello是会调用到hello方法的。

316.链接：https://www.nowcoder.com/questionTerminal/23e1de26ed9f43868a98ee296891cdaf
来源：牛客网

下面代码将输出什么内容：（b）

public class SystemUtil{
public static boolean isAdmin(String userId){
return userId.toLowerCase()==“admin”;
}
public static void main(String[] args){
System.out.println(isAdmin(“Admin”));
}
}

true
false
1
编译错误

==比较的是指向地址是否相等啊
在源码中 toLowerCase 是重新 new String()

所以为 == 是比较对象是否是同一个对象，所以为 false 。

317.Eclispse 中有很多快捷键，在 windows 系统中格式化代码的是（c）

Ctrl+Alt+F
Ctrl+F
Ctrl+Shift+F
Alt+Shift+F

我只知道ctrl+f全局查找,想起来的,ctrl+shift+f 使代码格式更严谨,什么破题目啊

318.链接：https://www.nowcoder.com/questionTerminal/99a335bd49624e2699da14fc85c5e9b0
来源：牛客网

如下程序代码的执行结果是

class Singleton {
private static Singleton obj = new Singleton();
public static int counter1;
public static int counter2 = 0; private Singleton() {
counter1++;
counter2++;
}
public static Singleton getInstance() {
return obj;
}
}
public class MyMain()
public static void main(String[] args) {
Singleton obj = Singleton.getInstance();
System.out.printIn(“obj.counter1==”+obj.counter1);
System.out.printIn(“obj.counter2==”+obj.counter2);
}
}

obj.counter11
obj.counter20
详解：首先调用类的静态方法（Singleton.getInstance()），会加载这个类（这里指Singleton类）。

执行过程：
1.给所有的静态变量赋予一个默认值（int类型的默认值为0）；【singleton=null,counter1=0,counter2=0(赋值操作未执行)】
2.初始化（从上到下开始执行，把右边的值赋值给左边）；
new Singleton()要生成对象（实例），会自动调用它的构造方法。此时counter1++，所以counter=1；counter2++,counter2=1；
然后继续向下执行，此时counter1没有赋值，故counter1还是等于1， counter2被赋值为0；

319.链接：https://www.nowcoder.com/questionTerminal/3f6c5287a9fa4d0baa162e44970a343d?orderByHotValue=1&mutiTagIds=570_170_178_179&page=1&onlyReference=false
来源：牛客网

关于volatile关键字，下列描述不正确的是？c,d
用volatile修饰的变量，每次更新对其他线程都是立即可见的。
对volatile变量的操作是原子性的。
对volatile变量的操作不会造成阻塞。
不依赖其他锁机制，多线程环境下的计数器可用volatile实现。

volatile 首先保证变量的可见性
能保证该变量的单次读或者单次写都是原子的,而对该变量的修改，volatile并不提供原子性的保证。
它不会造成线程阻塞
多线程下计数器必须使用锁保护。

320.下列哪种排序算法是不稳定算法 c,d
归并排序
插入排序
堆排序
快速排序

稳定的有冒泡排序,插入排序,归并排序
不稳定的有选择排序,希尔排序,堆排序,快速排序

321.以下哪些jvm的垃圾回收方式采用的是标记算法回收 b,e,f
新生代串行收集器
老年代串行收集器
并行收集器
新生代并行回收收集器
老年代并行回收收集器
cms收集器

基本上新生代用的都是复制算法,老年代用的都是标记整理算法,cms用标记清理算法
链接：https://www.nowcoder.com/questionTerminal/795b066b67c84478aec4dc400b3d0153?orderByHotValue=1&mutiTagIds=570_170_178_179&page=1&onlyReference=false
来源：牛客网

：Serial New收集器是针对新生代的收集器，采用的是复制算法
Parallel New（并行）收集器，新生代采用复制算法，老年代采用标记整理
Parallel Scavenge（并行）收集器，针对新生代，采用复制收集算法
Serial Old（串行）收集器，新生代采用复制，老年代采用标记整理
Parallel Old（并行）收集器，针对老年代，标记整理
CMS收集器，基于标记清理
G1收集器：整体上是基于标记整理，局部采用复制

322.JAVA语言的下面几种数组复制方法中，哪个效率最高？
for循环逐一复制
System.arraycopy
Arrays.copyOf
使用clone方法

我觉得这个顺序才是结论：
效率：System.arraycopy > for循环 > Arrays.copyOf >使用clone方法

A、for循环的话，很灵活，但是代码不够简洁.效率还可以
B.一看效率最高的肯定是system最底层的方法嘛,
C.opyOf是Arrays的方法，可以看到本质上是调用的arraycopy方法。，那么其效率必然是比不上 arraycopy的
D。clone的话，返回的是Object【】，需要强制转换。一般用clone效率是最差的，

323.链接：https://www.nowcoder.com/questionTerminal/8feb1f161cd94243b263c523369653cf?orderByHotValue=1&mutiTagIds=570_170_178_179&page=1&onlyReference=false
来源：牛客网

java关于异常处理机制的叙述哪些正确B,c
catch部分捕捉到异常情况时，才会执行finally部分
当try区段的程序发生异常时，才会执行catch区段的程序
在try区段不论程序是否发生异常及捕获到异常，都会执行finally部分
以上都是

又是这个笨蛋问题,就不写注释了

324.已知有30匹马，5个跑道，每个跑道只能容一匹马，没有计时器，至少需要比赛多少次，可以找出最快的前三匹马 b
8
9
12
14

这个题有点意思
1、首先30/5分为6组：组一，组二，…，组六，决出每组的第一名。比了6次。
2、组一第1_{组五第1，决出目前1}4名；再将目前1_{4名与组六第1一起，决出目前1}3名。比了2次。
3、因为有可能某一组的速度比其他组的第一名快，所以继续比较。有5个赛道：目前第一名那组的2,3（因为第一名已经完全确定，不会有谁比他快，而且，我们只需要前3名，所以即使是第一组的全部快，也只需要三个就好了。）
第二名那组的1,2名（因为第二名还是待定的，万一第一名组的2,3名比他快呢），
第三名那组的1（还是有希望的，比比吧o(╯□╰)o）。比了1次。只要这次前两名
所以，9次。
不知道解释清楚了没，好累(～￣▽￣)～

325.以下哪些不是链表的特征？
正确答案: A C D 你的答案: 空 (错误)
数据在内存中一定是连续的
插入或删除时，无需移动其他元素
可以随机访问表内的元素
需要事先估计存储空间

就是之前说的,数组访问快,链表插入或删除快,因为无需移动其他元素,事先预估存储空间也是数组的事,所以可能造成浪费
线性表分为顺序表(数组等)和链表
ACD为顺序表的特征
只有B是链表的特征

326.在OSI参考模型中，物理层的作用是？
正确答案: B 你的答案: 空 (错误)
建立和释放连接
透明地传输比特流
在物理实体之间传送数据帧
发送和接受用户数据

物理层：通过媒介传输比特,确定机械及电气规范（比特Bit）
数据链路层：将比特组装成帧和点到点的传递（帧Frame）
网络层：负责数据包从源到宿的传递和网际互连（包PackeT）
传输层：提供端到端的可靠报文传递和错误恢复（段Segment）
会话层：建立、管理和终止会话（会话协议数据单元SPDU）
表示层：对数据进行翻译、加密和压缩（表示协议数据单元PPDU）
应用层：允许访问OSI环境的手段（应用协议数据单元APDU）

327.以下选项中哪些是SQL的DML语句？
正确答案: B D 你的答案: 空 (错误)
select
insert
alter
delete
create
ANSI SQL语句分成以下六类（
DML（data manipulation language）是数据操纵语言：它们是UPDATE、INSERT、DELETE，就象它的名字一样，这4条命令是用来对数据库里的数据进行操作的语言，增删查改。
DDL（data definition language）是数据定义语言：DDL比DML要多，主要的命令有CREATE、ALTER、DROP等，DDL主要是用在定义或改变表（TABLE）的结构，
数据类型，表之间的链接和约束等初始化工作上，他们大多在建立表时使用。
DCL（DataControlLanguage）是数据库控制语言：是用来设置或更改数据库用户或角色权限的语句，包括（grant,deny,revoke等）语句。

数据查询语言（DQL）：其语句，也称为“数据检索语句”，用以从表中获得数据，确定数据怎样在应用程序给出。保留字SELECT是DQL（也是所有SQL）用得最多的动词，
其他DQL常用的保留字有WHERE，ORDER BY，GROUP BY和HAVING。这些DQL保留字常与其他类型的SQL语句一起使用。
事务处理语言（TPL）：它的语句能确保被DML语句影响的表的所有行及时得以更新。TPL语句包括BEGIN TRANSACTION，COMMIT和ROLLBACK。
指针控制语言（CCL）：它的语句，像DECLARE CURSOR，FETCH INTO和UPDATE WHERE CURRENT用于对一个或多个表单独行的操作。

对n个元素的数组进行（），其平均时间复杂度和最坏情况下的时间复杂度都是O（nlogn）.
正确答案: C 你的答案: 空 (错误)
希尔排序
快速排序
堆排序
选择排序

平均时间复杂度和最坏情况下的时间复杂度都是O(nlogn) 的有堆排序和归并排序

使用堆排序方法排序（45，78，57，25，41，89），初始堆为（？）

78,45,57,25,41,89
89,78,57,25,41,45
89,78,25,45,41,57
89,45,78,41,57,25

堆排序要么是第一层最小然后递增,或者第一层最大开始递减
第一层： 45
第二层： 78 57
第三层：25 41 89
按照选项应该是递减的排序，从89开始上移，完成max heap
则第一次移动之后
第一层： 89
第二层： 78 57
第三层：25 41 45

330.浏览器和服务器在基于https进行请求链接到数据传输过程中，用到了如下哪些技术？
正确答案: A B C D 你的答案: 空 (错误)
非对称加密技术
对称加密技术
散列（哈希）算法
数字证书

非对称加密算法用于在握手过程中加密生成的密码
对称加密算法用于对真正传输的数据进行加密
而HASH算法用于验证数据的完整性。
非对称加密算法会生成公钥和私钥，公钥只能用于加密数据，因此可以随意传输，而网站的私钥用于对数据进行解密，所以网站都会非常小心的保管自己的私钥，防止泄漏。

331.链接：https://www.nowcoder.com/questionTerminal/d1044d9415e34e259859fff894a6d7aa
来源：牛客网

初始序列为1 8 6 2 5 4 7 3一组数采用堆排序，当建堆（小根堆）完毕时，堆所对应的二叉树中序遍历序列为：（a）
8 3 2 5 1 6 4 7
3 2 8 5 1 4 6 7
3 8 2 5 1 6 7 4
8 2 3 5 1 4 7 6

这题就是没画图,画个图就清楚了
1
8 6
2 5 4 7
3
小根堆就是要求结点的值小于其左右孩子结点的值，左右孩子的大小没有关系，从小到大排序
4 和 6 换位置 3和8换位置之后,3再与2换位置
则调整折后为
1
2 4
3 5 6 7
8

然后中序输出就会了

332.S市A，B共有两个区，人口比例为3：5，据历史统计A的犯罪率为0.01%，B区为0.015%，现有一起新案件发生在S市，那么案件发生在A区的可能性有多大？（）
正确答案: C 你的答案: D (错误)
37.5%
32.5%
28.6%
26.1%

这个题口算的没算准, 可以把A区和B区犯罪概率列为2:3
则A区概率为(23)/23+3*5=6/21=0.28 多

333.静态变量通常存储在进程哪个区？（）
正确答案: C 你的答案: B (错误)
栈区
堆区
全局区
代码区

局部变量位于栈区，静态变量位于方法区(全局区)，实例变量位于堆区，对象位于堆区，对象的引用位于栈区。

334.IP地址131.153.12.71是一个（B）类IP地址。
A
B
C
D

直接看前8位即可，A类地址0_{127，B类地址128}191，C类地址192~223.

335.浏览器访问某页面，HTTP协议返回状态码为403时表示：（b）
找不到该页面
禁止访问
内部服务器访问
服务器繁忙

找不到页面时是404
禁止访问：403
内部服务器访问：500
服务器繁忙：503
有表,自己去找

336.如果某系统15*4=112成立，则系统采用的是（）进制。
6
7
8
9

就是这题傻了有点,我还以以为那个154是十进制的,然后112不是十进制,原来154=112两边都是6进制的
假设是X进制则：（x+5）4 = xx +x +2
求解得：x = 6

337.一个栈的入栈序列是A,B,C,D,E，则栈的不可能的输出序列是？（c）
正确答案: C 你的答案: D (错误)
EDCBA
DECBA
DCEAB
ABCDE

栈是先入后出
选项A：压入ABCDE，再依次弹出
选项B：压入ABCD，弹出D，压入E，弹出E，再弹出CBA
选项C：不可能
选项D：压入X，弹出X

338.对于派生类的构造函数，在定义对象时构造函数的执行顺序为？
1：成员对象的构造函数
2：基类的构造函数
3：派生类本身的构造函数
正确答案: D 你的答案: D (正确)
123
231
321
213

派生类中不含对象成员时
· 在创建派生类对象时,构造函数的执行顺序是：基类的构造函数→派生类的构造函数；
· 在撤消派生类对象时,析构函数的执行顺序是：派生类的构造函数→基类的构造函数。

当派生类中含有对象成员时
· 在定义派生类对象时，构造函数的执行顺序：基类的构造函数→对象成员的构造函数→派生类的构造函数；
· 在撤消派生类对象时，析构函数的执行顺序：派生类的构造函数→对象成员的构造函数→基类的构造函数。

339.下列哪两个数据结构，同时具有较高的查找和删除性能？（）
正确答案: C D 你的答案: A B (错误)
有序数组
有序链表
AVL树
Hash表

解析：几种常见的数据结构的操作性能对比如下图所示

由上图可见，平衡二叉树(AVL树)的查找，插入和删除性能都是O(logN)，其中查找和删除性能较好；哈希表的查找、插入和删除性能都是O(1)，都是最好的。
答案：CD

340.设有字母序列{Q,D,F,X,A,P,N,B,Y,M,C,W}，请写出按二路归并方法对该序列进行一趟扫描后的结果为1。
(输出结果请按照以下格式：ABCDEFG，字母之间没有逗号)
你的答案 (错误)
1 ADFPQXBCMNWY
参考答案
(1) DQFXAPBNMYCW

这个走的有点快了,直接走到把两个大的子序列合并了
第一趟扫描应该是最小单位的子序列,也就是相邻的独立的两个比较然后排序

341.链接：https://www.nowcoder.com/questionTerminal/e5d329431f2646f3b733dd346a50ed4a
来源：牛客网

以下程序运行的结果为（a）

public class Example extends Thread{
@Override
public void run(){
try{
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.print(“run”);
}
public static void main(String[] args){
Example example=new Example();
example.run();
System.out.print(“main”);
}
}

run main
main run
main
run
不能确定

答案：A
这个类虽然继承了Thread类，但是并没有真正创建一个线程。
创建一个线程需要覆盖Thread类的run方法，然后调用Thread类的start()方法启动
这里直接调用run()方法并没有创建线程，跟普通方法调用一样，是顺序执行的
也就是这个睡眠1000ms是不运行的

342.链接：https://www.nowcoder.com/questionTerminal/758401c48ddc4deebb955821e175614d
来源：牛客网

Java中用正则表达式截取字符串中第一个出现的英文左括号之前的字符串。比如：北京市（海淀区）（朝阳区）（西城区），截取结果为：北京市。正则表达式为（）
“.?(?=\()"
".?(?=()”
“.(?=\()"
".(?=()”

1.什么是正则表达式的贪婪与非贪婪匹配
如：String str=“abcaxc”;
Patter p=“ab*c”;

贪婪匹配:正则表达式一般趋向于最大长度匹配，也就是所谓的贪婪匹配。如上面使用模式p匹配字符串str，结果就是匹配到：abcaxc(abc)。
非贪婪匹配：就是匹配到结果就好，就少的匹配字符。如上面使用模式p匹配字符串str，结果就是匹配到：abc(abc)。
2.编程中如何区分两种模式
默认是贪婪模式；在量词后面直接加上一个问号？就是非贪婪模式。
量词：{m,n}：m到n个
*：任意多个
+：一个到多个
？：0或一个
以上来自博主的博客，然后这道题目
.表示除\n之外的任意字符
表示匹配0-无穷
+表示匹配1-无穷
(?=Expression) 顺序环视，(?=\()就是匹配正括号
懒惰模式正则：
src=".? (?=\()） "
结果：北京市
因为匹配到第一个"就结束了一次匹配。不会继续向后匹配。因为他懒惰嘛。

343.链接：https://www.nowcoder.com/questionTerminal/3b463ebec8404ad9b1b288859f124543
来源：牛客网

以下JAVA程序的输出是什么（b）

public class HelloSogou{
public static synchronized void main(String[] a){
Thread t=new Thread(){
public void run(){Sogou();}
};
t.run();
System.out.print(“Hello”);
}
static synchronized void Sogou(){
System.out.print(“Sogou”);
}
}
HelloSogou
SogouHello
Hello
结果不确定

这里调用 t.run();
并没有启动一个新的线程，启动一个新线程要用t.start();
所以执行顺序是先执行public void run（），再执行 System.out.print(“HELLO”);

我的理解把就是现在是run()调用Sogou,Sogou()方法体拿着锁,所以先运行run(),等它运行完释放锁,再往下执行

344.链接：https://www.nowcoder.com/questionTerminal/1bab09264a1c4528aa60ee9bca5f0976
来源：牛客网

如下代码，执行test()函数后，屏幕打印结果为（d）

public class Test2
{
public void add(Byte b)
{
b = b++;
}
public void test()
{
Byte a = 127;
Byte b = 127;
add(++a);
System.out.print(a + " ");
add(b);
System.out.print(b + “”);
}
}

127 127
128 127
129 128
以上都不对

也就是说add函数只是个摆设，没有任何作用。
捋了一下,是这样,byte的范围是-128~127,然后++a这里执行了,a到了128然后越界了,就成了-128,然后b那不执行,b还是127,

345.链接：https://www.nowcoder.com/questionTerminal/5a9f57aee208466484118b27f3f09c2e
来源：牛客网

static String str0=“0123456789”;
static String str1=“0123456789”;
String str2=str1.substring(5);
String str3=new String(str2);
String str4=new String(str3.toCharArray());
str0=null;
假定str0,…,str4后序代码都是只读引用。
Java 7中，以上述代码为基础，在发生过一次FullGC后，上述代码在Heap空间（不包括PermGen）保留的字符数为（）
5
10
15
20

解析：这是一个关于java的垃圾回收机制的题目。垃圾回收主要针对的是堆区的回收，因为栈区的内存是随着线程而释放的。堆区分为三个区：年轻代（Young Generation）、年老代（Old Generation）、永久代（Permanent Generation，也就是方法区）。
年轻代：对象被创建时（new）的对象通常被放在Young（除了一些占据内存比较大的对象）,经过一定的Minor GC（针对年轻代的内存回收）还活着的对象会被移动到年老代（一些具体的移动细节省略）。
年老代：就是上述年轻代移动过来的和一些比较大的对象。Minor GC(FullGC)是针对年老代的回收
永久代：存储的是final常量，static变量，常量池。
str3,str4都是直接new的对象，而substring的源代码其实也是new一个string对象返回，如下图：
substring实际是new，5字符
str3和4也都是new，每个5字符
经过fullgc之后，年老区的内存回收，则年轻区的占了15个，不算PermGen。所以答案选C

346.产生死锁的4个必要条件为：互斥条件、请求保持条件、（?）、环路条件
正确答案: D 你的答案: 空 (错误)
永久性条件
相互等待条件
资源均分条件
不可剥夺条件

347.以下的数据库设计就符合第一设计范式的
是：（）。
正确答案: B C D 你的答案: 空 (错误)
CREATE TABLE member(
编号 INT PRIMARY KEY ,
姓名 VARCHAR(20) ,
联系方式 VARCHAR(200)
) ;

CREATE TABLE member(
编号 INT PRIMARY KEY ,
姓名 VARCHAR(20) ,
地址 VARCHAR(200) ,
邮政编码 VARCHAR(6) ,
电话 VARCHAR(20) ,
qq VARCHAR(20)
) ;

CREATE TABLE orders(
编号 INT PRIMARY KEY ,
商品名称 VARCHAR(20) ,
单价 INT ,
数量 INT ,
总价 INT
) ;

CREATE TABLE student(
学生编号 INT PRIARY KEY ,
学生姓名 VARCHAR(20)) ;
CREATE TABLE course(
课程编号 INT PRIMARY KEY ,
课程名称 VARCHAR(50) ,
课程学分 INT) ;
CREATE TABLE studentcourse(
学生编号 INT REFERENCES student(学生编号) ON DELETE CASCADE ,
课程编号 INT REFERENCES course(课程编号) ON DELETE CASCADE ,
成绩 INT) ;

其实吧,有的再细分还能分,不是较真啊.比如成绩,还分哪一科的成绩,或者是总分.
第一设计范式: 所有属性不可以再划分，用于保证列的原子性，上面第一个的联系方式不满足，联系方式有很多(手机、电话、邮编、地址等)，因此A不符合第一设计范式

348.如果在更改一个对象的时候，需要同时连带改变其他的对象，而且不知道究竟应该有多少对象需要被连带改变，应该使用何种设计模式：
正确答案: B 你的答案: 空 (错误)
职责链模式
观察者模式
模板方法模式
策略模式
观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

349.在AVL树中，哪个调整操作可以使根节点的平衡因子由1变为2（）
正确答案: A C 你的答案: 空 (错误)
LL
RR
LR
RL
主要来看人家的解析

有四种种情况可能导致二叉查找树不平衡，分别为：
（1）LL：插入一个新节点到根节点的左子树（Left）的左子树（Left），导致根节点的平衡因子由1变为2
（2）RR：插入一个新节点到根节点的右子树（Right）的右子树（Right），导致根节点的平衡因子由-1变为-2
（3）LR：插入一个新节点到根节点的左子树（Left）的右子树（Right），导致根节点的平衡因子由1变为2
（4）RL：插入一个新节点到根节点的右子树（Right）的左子树（Left），导致根节点的平衡因子由-1变为-2

针对四种种情况可能导致的不平衡，可以通过旋转使之变平衡。有两种基本的旋转：

（1）左旋转：将根节点旋转到（根节点的）右孩子的左孩子位置
（2）右旋转：将根节点旋转到（根节点的）左孩子的右孩子位置

350.以下算法中哪些算法的空间复杂度为O(1)（）
正确答案: A D 你的答案: 空 (错误)
简单选择排序
快速排序
基数排序
堆排序

算法空间复杂度(辅助空间)
O(1) 冒泡排序
O(1) 简单选择
O(1) 直接插入
O(1) 希尔排序
O(1) 堆排序
O(n) 归并排序
O(log n)~O(n) 快速排序

351.链接：https://www.nowcoder.com/questionTerminal/b4f6bb66acf54cd9ac0b5fcc19747ce3
来源：牛客网

甲和乙打算一起去某地参加活动，预先越好在某路口汇合，假定两人最终都会在下午两点到三点之间到达该路口（具体何时到达，服从均匀分布），
且先到的一方会待在路口等待另一方，但最多不超过十五分钟，那么他们最终能一起出发去参加活动的概率最接近下面哪个数值。b
20%
45%
50%
70%

题目可以转化为求阴影面积占正方形面积的百分比，其实是7/16~45% ,画个图就知道了
甲等不到的几率为3/4
乙等不到的几率为3/4
双方都等不到的几率为9/16
则双方都等到的几率为7/16 ≈ 45%

352.链接：https://www.nowcoder.com/questionTerminal/e724000470af4fde977eddce31d0f13a
来源：牛客网

如果A,B,C为布尔型变量，“^”和“v”分别代表布尔类型的“与”和“或”，下面那一项是正确的（）
I.A^(BvC)=(AB)v(A^C)
II.Av(B^C)=(AvB)(AvC)
III.(B^A)vC=Cv(AB)

只有I
只有II
只有I和II
I,II,III；

这个题I II 不好判断,但是III 肯定正确,所以选有III的选项

353.链接：https://www.nowcoder.com/questionTerminal/bc7bdea2f642465e8ff3a95e9ca27eca
来源：牛客网

下面哪个指针表达式可以用来引用数组元素a[i][j][k][l] (b)
(((a+i)+j)+k)+l)
((((a+i)+j)+k)+l)
(((a+i)+j)+k+l)
((a+i)+j+k+l)

a:整个四维数组的地址
*(a+i) = a[i]
*(a+i)+j = a[i] +j
*((a+i)+j) = a[i][j]
*((a+i)+j)+k = a[i][j]+k
*( *((a+i)+j)+k ) = a[i][j][k]
*( *((a+i)+j)+k )+l = a[i][j][k]+l
*( *( ((a+i)+j)+k )+l ) = a[i][j][k][l], 选项B少了和（）
不管多少维，按照这个思路，不会差

1、操作符 * 既可以用来声明一个指针变量，也可以用作指针的取值。
2、除了一维数组，其他高维数组都有a=*a，表示数组的首地址。而在一维数组int a[N]中，a代表数组首地址，*a代表数组第一个元素的值。

354.链接：https://www.nowcoder.com/questionTerminal/f0fa5f7435204ad7b44bae5f1ad6e745
来源：牛客网

根据下面递归函数：调用函数Fun（2），返回值是多少（）d

int Fun(int n)
{
if(n==5)
return 2;
else
return 2*Fun(n+1);
}
2
4
8
16

16 , 这题考函数的递归调用。F(2) = 2F(3) = 22F(4) = 222F(5) = 2222 = 16 [ 看加粗部分, F(3)推理出2F(4) , 后面同理 , 最后 F(5)为2 ]。

355.对于java类型变量char c,short s,float f,double d,表达式c*s+f+d的结果类型为（d）
float
char
short
double

我觉得就是低转高

自动类型转换遵循下面的规则：
1.若参与运算的数据类型不同，则先转换成同一类型，然后进行运算。
2.转换按数据长度增加的方向进行，以保证精度不降低。例如int型和long型运算时，先把int量转成long型后再进行运算。
3.所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。
4.char型和short型参与运算时，必须先转换成int型。
5.在赋值运算中，赋值号两边的数据类型不同时，需要把右边表达式的类型将转换为左边变量的类型。如果右边表达式的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度。

356.链接：https://www.nowcoder.com/questionTerminal/8f4a97a1101148cab4efa69bd67e5ac3
来源：牛客网

java中下面哪个能创建并启动线程（c）

public class MyRunnable implements Runnable {
public void run() {
//some code here
}
}
new Runnable(MyRunnable).start()
new Thread(MyRunnable).run()
new Thread(new MyRunnable()).start()
new MyRunnable().start()

首先创建并启动是start();排除b
一、定义线程： 1、扩展java.lang.Thread类。 2、实现java.lang.Runnable接口。
1、必须新建一个Thread类来启动线程，可排除A，D
2、MyRunnable类必须实例化，也可排除A；

设有一组关键字序列{5,8,14,20,31,55,78,81,93,97,111}，使用二分（折半）法查找关键字93需要进行多少次比较（）
正确答案: A 你的答案: A (正确)
2
3
4
5

这题太简单,但是这个公式需要记一下mid=(left+right)/2
5,8,14,20,31,55,78,81,93,97,111
索引为0-10
第一次 left=0,right=10,mid=(left+right)/2=5; 索引为5的为55
第二次 left=mid+1=6 ,right=10; mid=(left+right)/2=8;索引为8的为93.。到此比较完毕

358.下面哪种排序的平均比较次数最少（d）
插入排序
选择排序
堆排序
快速排序

快排和堆排的平均时间复杂度都是nlong(n)
肯定是D啊！
因为堆排序需要构建堆，所以比较次数是要多于快速排序的！

359.下面哪个协议被用来找到本地设备的硬件地址（b）
RARP
ARP
IP
IMCP

地址解析协议，即 ARP （Address Resolution Protocol）是根据IP地址获取物理地址的一个TCP/IP协议。RARP为逆地址解析协议

360.假设某一虚拟存储系统采用先进先出（FIFO）页面淘汰算法，有一个进程在内存中占3页（开始时内存为空），当访问如下页面序列号后1,2,3,1,2,4,2,3,5,3,4,5会产生几次缺页
正确答案: B 你的答案: B (正确)
4
5
6
7

FIFO是先进先出算法，当CPU需要访问的页不在内存中时产生了缺页中断，缺页中断是一段程序就是把外存中的页调入内存，还需要把内存中原有的页放回到外存。

缺页就是你访问内存中这个数据,该数据不存在,然后就是报缺页,然后把这个数据存放进来,如果内存已满,那么先进先出,先放进来的先移出去腾出空间

第一次访问1,内存里什么没有,访问 1 报缺页,把1放进来
第二次访问2,内存里有1,访问 2 报缺页,把2放进来
第三次访问3,内存里有1,2,访问 3 报缺页,把3放进来
第四次访问1,内存里有1,2,3,不报缺页
第五次访问2,内存里有1,2,3,不报缺页
第六次访问4,内存里没有4,报缺页,把1移出,放进4
第七次访问2.内存里有2,3,4,不报缺页
第八次访问3,内存里有2,3,4,不报缺页
第九次访问5,内存里没5 ,报缺页,把2移出,把5放进来
第十次访问3,内存里有3,4,5,不报缺页
第十次访问4,内存里有3,4,5,不报缺页
第十次访问5,内存里有3,4,5,不报缺页

361.下面哪个SQL命令用来向表中添加列（）
正确答案: D 你的答案: C (错误)
MODIFY TABLE TableName ADD COLUMN ColumnName
MODIFY TABLE TableName ADD ColumnName
ALTER TABLE TableName ADD COLUMN ColumnName
ALTER TABLE TableName ADD ColumnName Type

e.g.,
增加列：alter table tableName add columnName varchar (30)
删除列：alter table tableName drop column columnName
故答案为D。
老容易搞混，特地查了一下modify,alter,update的区别：

modify:修改字段类型和长度的（即修改字段的属性）。
alter:修改表的数据结构（modify是alter的一种用法）。
update：修改数据内容的。

下列哪个不是存储过程的好处（）
正确答案: C 你的答案: A (错误)
更加安全
SQL优化
增加网络流量
重复使用

1、执行速度更快，在数据库中保存的存储过程语句都是编译过的
2、允许模块化程序设计，类似方法的复用
3、提高系统的安全性，防止SQL注入
4、减少网络流通量，只需要传输存储过程的名称

363.下列对于数据库索引的说法一定是错误的（）
正确答案: B 你的答案: B (正确)
索引可以提升查询，分组和排序的性能
索引不会影响表的更新、插入和删除操作的效率
全表扫描不一定比使用索引的执行效率低
对于只有很少数据值的列，不应该创建索引

索引肯定会影响效率的
说白了，索引问题就是一个查找问题。。。
数据库索引，是数据库管理系统中一个排序的数据结构，以协助快速查询、更新数据库表中数据。索引的实现通常使用B树及其变种B+树。
在数据之外，数据库系统还维护着满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据，这样就可以在这些数据结构上实现高级查找算法。这种数据结构，就是索引。
为表设置索引要付出代价的：一是增加了数据库的存储空间，二是在插入和修改数据时要花费较多的时间(因为索引也要随之变动) 。

java中关于继承的描述正确的是（）
正确答案: A C D 你的答案: A B C D (错误)
一个子类只能继承一个父类
子类可以继承父类的构造方法
继承具有传递性
父类一般具有通用性，子类更具体

子类不可以继承父类的构造方法，只可以调用父类的构造方法。子类中所有的构造函数都会默认访问父类中的空参数构造函数，
PS：方法没有继承一说，只有重载和重写

365.java中下面哪些是Object类的方法（）
正确答案: A B D 你的答案: A B C D (错误)
notify()
notifyAll()
sleep()
wait()

Object中没有sleep
在根类Object中包含一下方法：

clone();
equals();
finalize();
getClass();[align=left][/align]
notify(),notifyAll();
hashCode();
toString();
wait();

366.http 请求方式 get 和 post 的区别包括（）
正确答案: A B 你的答案: 空 (错误)
get和post的可传输内容大小不一样，一个有限制一个没有限制
get和post传输的内容存放的位置不一样，一个放在header，一个放在body
get请求Content-type只能是text/html
get请求可以跨域、post请求不能跨域

至于C,D：
C . get请求Content-type只能是text/html
–错误，get的 Content-type不仅可以是 text/html，也可以是其他，如 application/json, text/plain 等等

D. get请求可以跨域、post请求不能跨域
– 错误， post一样可以跨域

367.TCP断开连接的四次挥手中，第四次挥手发送的包会包含的标记，最正确的描述是？（）
正确答案: C 你的答案: 空 (错误)
FIN
FIN,PSH
ACK
FIN,ACK

我们假设由client提出关闭，则：
第一次：FIN（client发给server）
第二次：ACK（server发给client）
第三次：FIN（server发给client ）
第四次：ACK（client发给server）

368.在ISO/OSI参考模型中，网络层的主要功能是（）
正确答案: A 你的答案: 空 (错误)
路由选择，拥塞控制与网络互连
提供可靠的端一端服务，透明地传送报文
数据格式变换，数据加密与解密，数据压缩与恢复
在通信实体之间传送以帧为单位的数据

A选项正确，网络层主要负责分组转发和路由选择,根据路由表把分组逐跳地由源站传送到目的站,并能适应网络的负载及拓扑结构的变化,动态地更新路由表.
B选项错误，传输层传输的PDU称为报文(message),传输层为源结点和目的结点的用户进程之间提供端到端的可靠的传输服务.
C选项错误，表示层的主要功能是完成数据格式变换、数据加密与解密、数据压缩与恢复功能；
D选项错误，数据链路层负责在单个链路上的结点间传送以帧(frame)为PDU的数据,在不太可靠的物理链路上实现可靠的数据传输.

369.在一个分时操作系统中，进程出现由运行状态进入就绪状态，由阻塞状态进入就绪状态的原因分别可能是（）
正确答案: B 你的答案: 空 (错误)
等待资源而阻塞，时间片用完
时间片用完，因获得资源被唤醒
等待资源而阻塞，因获得资源被唤醒
时间片用完，等待资源而阻塞

运行态到就绪态，则肯定没有阻塞。排除AC，正常原因就是时间片用完。
阻塞状态进入就绪状态，就没有运行，所以肯定不是时间片用完，正常原因就是获得所需资源后解除了阻塞。
基本概念，难度0.01颗星。

对数据表进行修改的语句正确的是（）
正确答案: B D 你的答案: 空 (错误)
alter table employee add memo
alter table employee drop column age
alter table employee add column
alter table employee drop age

删除列可以省略column，添加列必须说明数据类型

371.如下图所示，1~9诸数各有一个规定的符号，请据此回答下列问题。
1 2 3 4 5 6 7 8 9
（ = / × \ + - )
9与什么符号相对应？a
÷
+
—
\

哈哈,选一个没有出现过的

372.链接：https://www.nowcoder.com/questionTerminal/0178d88258f64300a326904da5093f1a
来源：牛客网
下面对析构函数的正确描述是：c
系统不能提供默认的析构函数
析构函数必须由用户定义
析构函数没有参数
析构函数可以设置默认参数

析构函数名与类名相同，只是在函数名前面加一个位取反符~，以区别于构造函数。它不能带任何参数，
也没有返回值（包括void类型）。只能有一个析构函数，不能重载。如果用户没有编写析构函数，
编译器自动生成一个缺省的析构函数（即使自定义了析构函数，编译器也总是会为我们合成一个析构函数，
并且如果自定义了析构函数，编译器在执行时会先调用自定义的析构函数再调用合成的析构函数），它也不进行任何操作。所以许多简单的类中没有用显式的析构函数。

373.链接：https://www.nowcoder.com/questionTerminal/91d16d665d5c4eed9ad82bcf87074c53
来源：牛客网

有N个员工排队排成一排，每个员工对应了一个级别K，按照以下规则给员工发奖品。 1.每个员工都至少发一个奖品 2.相邻的两个员工如果级别不同，那么级别高的一定要得到比级别低的员工更多的奖品。
K为整数，1表示级别最低，然后是2,3，以此类推。员工的级别排列如下：1 2 3 4 4 1 2，求最少需要的奖品总数，以满足上述规则？a
15
14
13
12

员工：1 2 3 4 4 1 2
奖品：1 2 3 4 2 1 2 = 15

这个点在于没有规定相邻两个员工如果级别相同则奖品数一定得相同

374.在公有派生的情况下，派生类中定义的成员函数只能访问原基类的()
正确答案: C 你的答案: 空 (错误)
公有成员和私有成员
私有成员和保护成员
公有成员和保护成员
私有成员,保护成员和公有成员

使用 private 继承 , 父类的所有方法在子类中变为 private;
使用 protected 继承 , 父类的 protected 和 public 方法在子类中变为 protected,private 方法不变 ;
使用 public 继承 , 父类中的方法属性不发生改变 ;

375.下面程序输出结果为？

#include
#define SUB(X,Y) (X)*Y
int main(){
int a=3,b=4;
cout< return 0;
}
正确答案: A 你的答案: 空 (错误)
15
16
20
12

a++,先运算再赋值,++b先赋值再运算
SUB（a++,++b) = (a++)++b = （3++）++4 = 3*5 = 15

对网上一些Java笔试题的总结,答案与自我理解(400道)

你可能感兴趣的:(对网上一些Java笔试题的总结,答案与自我理解(400道))