牛客刷题笔记--(java基础401-478)--完结撒花

401 下面这条语句一共创建了多少个对象：String s=“welcome”+“to”+360; A

1

2

3

4

String test=“javaandpython”;
String str1=“java”;
String str2=“and”;
String str3=“python”;
System. out. println(test==“java”+“and”+“python”):
System. out. println(test ==str1 + str2 + str3);
对于上面这段代码，结果是true false
这是因为字符串字面量拼接操作是在Java编译器编译期间就执行了，也就是说编译器编译时，直接把"java"、“and"和"python"这三个字面量进行”+“操作得到一个"javaandpython” 常量，并且直接将这个常量放入字符串池中，这样做实际上是一种优化，将3个字面量合成一个，避免了创建多余的字符串对象（只有一个对象"javaandpython"，在字符串常量池中）。而字符串引用的"+“运算是在Java运行期间执行的，即str1 + str2 + str3在程序执行期间才会进行计算，它会在堆内存中重新创建一个拼接后的字符串对象。且在字符串常量池中也会有str1,str2与str3，这里创建多少个新的对象与原来字符串常量池中有没有str1\str2\str3有关，如果之前存在就不会创建新的对象。
总结来说就是：字面量”+“拼接是在编译期间进行的，拼接后的字符串存放在字符串池中；而字符串引用的”+"拼接运算实在运行时进行的，新创建的字符串存放在堆中。
那么再来看这题，很明显只在编译期间在字符串常量池中创建了"welcometo360"一个字符串

402 以下程序执行的结果是： C

class X{
	Y y=new Y();
	public X(){
		System.out.print("X");
	}
}
class Y{
	public Y(){
		System.out.print("Y");
	}
}
public class Z extends X{
	Y y=new Y();
	public Z(){
		System.out.print("Z");
	}
	public static void main(String[] args) {
		new Z();
	}
}

ZYXX

ZYXY

YXYZ

XYZX

答案C
初始化过程：

1. 初始化父类中的静态成员变量和静态代码块 ；
2. 初始化子类中的静态成员变量和静态代码块 ；
   3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；
   4.初始化子类的普通成员变量和代码块，再执行子类的构造方法；

（1）初始化父类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y
（2）再执行父类的构造方法；输出X
（3） 初始化子类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y
（4）再执行子类的构造方法；输出Z
所以输出YXYZ

/*
涉及继承：
a.初始化父类中的静态成员变量和静态代码块
b.初始化子类中的静态成员变量和静态代码块
c.初始化父类的普通成员变量和构造代码块(按次序)，再执行父类的构造方法
d.初始化子类的普通成员变量和构造代码块(按次序)，再执行子类的构造方法
*/

403 以下说法错误的是（D）

虚拟机中没有泛型，只有普通类和普通方法

所有泛型类的类型参数在编译时都会被擦除

创建泛型对象时请指明类型，让编译器尽早的做参数检查

泛型的类型擦除机制意味着不能在运行时动态获取List<T>中T的实际类型

// 通过反射得到T的真实类型
ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();
T的真实类型 = (Class) pt.getActualTypeArguments()[0];//取第一个泛型的类型

404 下面代码在main()方法中第八行后可以正常使用的是（AD ）

public class Test
{ 
    private int a=10; 
    int b=20; 
    static int c=1; 
    public static void main(String arg[])
    { 
        Test t = new Test(); 
    } 
 } 

t.a

this.c

Test.b

Test.c

A : 在private 修饰不能在外部类中调用，main 方法属于Test类的方法， 所以 对象 t 可以在他自己的类方法中调用它的private
B ： static 方法中没有this 这么一说
C: b不是static变量
D: 合理

这个要看情况了，类成员变量在实例方法中能用this去调用,但是多此一举，而在静态方法中不能用this去调用，被static修饰的变量或方***随类加载时加载到内存中，在准备阶段赋初值，比如题目中的private int a = 10;其实先是a = 0,在后序的初始化中才是a = 10。

405 java 中哪个关键字可以对对象加互斥锁？B

transient

synchronized

serialize

static

synchronized 关键字 : 用来给对象和方法或者代码块加锁,当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。
volatile：用来确保将变量的跟新操作通知到其他线程，当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。然而，在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比 synchronized关键字更轻量级的同步机制。
serialize：Java 对象序列化为二进制文件。
static关键字： static关键字可以修饰变量，方法，静态代码块。
静态变量:
由static修饰的变量称为静态变量
静态变量属于类，而不属于某个对象
静态变量它的副本只有一个(静态变量在类中只加载一次)
静态方法：
在静态方法中只能调用静态变量和静态方法
在非静态方法中，可以调用静态方法或者变量。
在静态方法中不能使用this和super关键字。
静态代码块
作用:用来给静态成员变量初始化

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

abstract 修饰符，用来创建抽象类和抽象方法。

transient：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
transient，反序列化修饰符，序列化的时候，类中的属性都会被复制，但是被transient和static修饰的属性不会被复制。

406 Java的跨平台特性是指它的源代码可以在多个平台运行。（×）
Java的跨平台特性是因为JVM的存在， 它可以执行.class字节码文件，而不是.java源代码
JAVA的跨平台特性表述为“一次编译，到处运行”，JAVA程序运行在JVM上，而JVM对上屏蔽了底层操作系统差异。
我们编译好的文件是以.java后缀保存的，编译器会自动帮我们生成一个标准的.class字节码文件，JVM运行该文件。JVM也是一个软件，不同的系统平台JVM不同，但都可以实现标准的.class字节码文件。

407 在开发中使用泛型取代非泛型的数据类型（比如用ArrayList取代ArrayList），程序的运行时性能会变得更好。（×）

解释：泛型仅仅是java的语法糖，它不会影响java虚拟机生成的汇编代码，在编译阶段，虚拟机就会把泛型的类型擦除，还原成没有泛型的代码，顶多编译速度稍微慢一些，执行速度是完全没有什么区别的.

泛型只在编译的时候保证数据类型的正确性，和运行期间的性能无关

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

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

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

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

407 Java的体系结构包含（ ABCD ）

Java编程语言

Java类文件格式

Java API

JVM

Java体系结构包括四个独立但相关的技术：

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

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

408 有关会话跟踪技术描述正确的是（ABC）

Cookie是Web服务器发送给客户端的一小段信息，客户端请求时，可以读取该信息发送到服务器端

关闭浏览器意味着临时会话ID丢失，但所有与原会话关联的会话数据仍保留在服务器上，直至会话过期

在禁用Cookie时可以使用URL重写技术跟踪会话

隐藏表单域将字段添加到HTML表单并在客户端浏览器中显示

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

410 在程序代码中写的注释太多，会使编译后的程序尺寸变大。（×）
注释是给人看的，不是给机器看的
编译后的程序尺寸即class文件大小
过多注释影响编译效率，影响合作开发效率
注释不会影响class文件的执行效率
编译不会编译注释中的内容。javac编译后的字节码文件中也不会出现自己手打的注释。

411 输出结果为：B

String str = "";
System.out.print(str.split(",").length);

0

1

出现异常

注意2点： 1：String获取长度用的是length（）方法，而数组类型我们直接用属性length获取长度，所以String[]数组类型我们应该用length获取长度；2：总结来说，因为原字符串不包含分隔符，所以直接返回原字符串，分割出来只有一个空的字符串数组，所以结果是1.（注意，虽然原字符串为空，存到字符串数组为空，但是这个空也会算一个元素。）

412 以下代码运行输出的是 C

public class Person{
	private String name = "Person";
	int age=0;
}
public class Child extends Person{
	public String grade;
	public static void main(String[] args){
		Person p = new Child();
		System.out.println(p.name);
	}
}

输出：Person

没有输出

编译出错

运行出错

Java中对字段属性是静态绑定，方法成员是动态绑定，这里错在：在子类中试图访问父类的private字段，所以编译不通过，应该把private去掉
1.一个java文件里，public 的类只能出现一个，只能出现一个，只能出现一个，否则，不管你用哪一个类名命名文件名编译器都会报错
2.关于多态。子类继承了父类的所有成员，包括private权限的成员变量，但是继承的子类具有私有变量的拥有权但是没有使用权。
3.private的成员变量，根据权限修饰符的访问控制范围，只有在类内部才能被访问，就算是他的子类，也不能访问。

貌似其他类也不能用权限修饰符
default private protected都不行

public class Person{
    public String name = "Person";
    int age=0;
}
 class Child extends Person{
    public String grade;
    public static void main(String[] args){
        Person p = new Child();
        System.out.println(p.name);
    }
}

Person

413 关于Java中的ClassLoader下面的哪些描述是错误的：( BDF )

默认情况下，Java应用启动过程涉及三个ClassLoader: Boostrap, Extension, System

一般的情况不同ClassLoader装载的类是不相同的，但接口类例外，对于同一接口所有类装载器装载所获得的类是相同的

类装载器需要保证类装载过程的线程安全

ClassLoader的loadClass在装载一个类时，如果该类不存在它将返回null

ClassLoader的父子结构中，默认装载采用了父优先

所有ClassLoader装载的类都来自CLASSPATH环境指定的路径

A、java中类的加载有5个过程，加载、验证、准备、解析、初始化；这便是类加载的5个过程，而类加载器的任务是根据一个类的全限定名来读取此类的二进制字节流到JVM中，然后转换为一个与目标类对应的java.lang.Class对象实例，在虚拟机提供了3种类加载器，引导（Bootstrap）类加载器、扩展（Extension）类加载器、系统（System）类加载器（也称应用类加载器）。A正确
B、一个类，由不同的类加载器实例加载的话，会在方法区产生两个不同的类，彼此不可见，并且在堆中生成不同Class实例。所以B前面部分是正确的，后面接口的部分真的没有尝试过，等一个大佬的讲解吧；
C、类加载器是肯定要保证线程安全的；C正确
D、装载一个不存在的类的时候，因为采用的双亲加载模式，所以强制加载会直接报错，D错误
java.lang.SecurityException: Prohibited package name: java.lang
E、双亲委派模式是在Java 1.2后引入的，其工作原理的是，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，即每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子自己想办法去完成，所以默认是父装载，E正确
F、自定义类加载器实现 继承ClassLoader后重写了findClass方法加载指定路径上的class，F错误

414 java有8种基本类型，请问byte、int、long、char、float、double、boolean各占多少个字节？

1 4 8 2 4 8 1

byte：8位 一个字节 int：32位 四个字节 long：64位 八个字节 char：16位 两个字节 float:32位 四个字节 double：64位 八个字节 boolean：8位 一个字节

boolean数据类型只有两个可能的值：true和false。将此数据类型用于跟踪真/假条件的简单标志。此数据类型表示一小部分信息，但其“大小”不是精确定义的。
官方文档：https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

415 在基本JAVA类型中，如果不明确指定，整数型的默认是什么类型？带小数的默认是什么类型？

int double

如果要指定长整型加L；如果要指定为单精度加F

比如表达式
byte a=2;
a=a-10；
由于10是整型int，因此表达式a-10；将自动转换成int类型，int类型在赋值给byte，会编译错误
byte a=2;
a-=10;
不会发生编译错误，因为复合运算符是一个带有隐式转换的运算符，将右侧表达式类型自动转换成左侧表达式类型

416 以下表达式的类型和值是什么？（注意整数除法）（D）

-5 + 1/4 + 2*-3 + 5.0

int -3

int -4

double -5.5

double -6.0

在进行运算的时候会自动向较高级别转换
short s1= 1; s1 = s1 + 1;
这句话编译会报错，因为s1+1会自动转换成int类型进行计算，需要类型强制转换

在Java中5.0是double类型,所以结果的数据类型为double。因为1/4结果为0，所以结果为-6.0

-5+0-6+5.0=-6.0

417 下面程序的运行结果是B

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

true

false

exception

无输出

String str1 = “hello”;这里的str1指的是方法区的字符串常量池中的“hello”，编译时期就知道的； String str2 = “he” + new String(“llo”);这里的str2必须在运行时才知道str2是什么，所以它是指向的是堆里定义的字符串“hello”，所以这两个引用是不一样的。

如果用str1.equal(str2)，那么返回的是True；因为两个字符串的内容一样。

String str1= "hello", String str2="he"+"llo";之所以str1==str2返回true是因为两者都是在字符串常
量池中（由于初始化就会在此区域分布内存）而常量池中的有个与栈区类似的特性，就是当str2指向的常量在常量区
已存在时，他不会创建新的内存空间来存此常量，而是指向已有常量的内存（应该是以此节约空间），此时str1与
str2这两个引用变量的值都是存"hello"的内存空间地址，但是String str3= "he"+a;String a="llo";时
str1==str3返回的为false，是因为：str1指向的hello在编译期一如既往的还是分配在常量区内，a指向的llo也
在常量区，虽然str3也是初始化但是编译器无法判断a这货到底是什么个情况，进而不会将str3的等号右侧声明在常
量区内，而是在通过构造时在堆区中的非常量池外的内存中声明，至此str3与str1不止是分配内存的时期不同（一个
在编译期，一个在运行期）而且在内存空间的区域也不同，上面最高票答案只区分了时间没区分空间。 

418 以下哪一个不是赋值符号？C

+=

<<=

<<<=

>>>=

 C.混合赋值运算符的使用
<<表示左移位
>>表示带符号右移位
>>>表示无符号右移
但是没有<<<运算符 

>>为带符号右移，右移后左边的空位被填充为符号位
>>>为不带符号右移，右移后左边的空位被填充为0
没有<<< 因为<<后右边总是补0

419 Which statement declares a variable a which is suitable for referring to an array of 50 string objects?（Java） BCF

char a[][];

String a[];

String[] a;

Object a[50];

String a[50];

Object a[];

BCF
在java 中，声明一个数组时，不能直接限定数组长度，只有在创建实例化对象时，才能对给定数组长度.。
如下，1，2,3可以通过编译，4，5不行。而String是Object的子类，所以上述BCF均可定义一个存放50个String类型对象的数组。

1. String a[]=new String[50];
2. String b[];
3. char c[];
4. String d[50];
5. char e[50];

A：char[][] 定义了二位字符数组。在Java中，使用字符串对char数组赋值，必须使用toCharArray()方法进行转换。所以A错误。

B、C：在Java中定义String数组，有两种定义方式：String a[]和String[] a。所以B、C正确。

D、E：数组是一个引用类型变量 ，因此使用它定义一个变量时，仅仅定义了一个变量 ，这个引用变量还未指向任何有效的内存 ，因此定义数组不能指定数组的长度。所以D、E错误。

F：Object类是所有类的父类。子类其实是一种特殊的父类，因此子类对象可以直接赋值给父类引用变量，无须强制转换，这也被称为向上转型。这体现了多态的思想。所以F正确。

420 在 Java 中，属于整数类型变量的是（C）

single

double

byte

char

Java中的四类八种基本数据类型
第一类：整数类型 byte short int long
第二类：浮点型 float double

第三类：逻辑型 boolean(它只有两个值可取true false)

第四类：字符型 char

421 一般情况下，以下哪个选项不是关系数据模型与对象模型之间匹配关系？D

表对应类

记录对应对象

表的字段对应类的属性

表之间的参考关系对应类之间的依赖关系

一般关系数据模型和对象数据模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性

类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many

目前ORMapping只是规定了数据结构和数据集的映射关系，还没到规定赖关系的阶段

422 对下面Spring声明式事务的配置含义的说明错误的是（C）

<bean id="txProxyTemplate" abstract="true"
class=
"org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager" ref="myTransactionManager" />
<property name="transactionAttributes">      
 <props>
        <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
         <prop key="*">PROPAGATION_REQUIRED</prop>
     </props>
</property> 
</bean>

定义了声明式事务的配置模板

对get方法采用只读事务

缺少sessionFactory属性的注入

配置需要事务管理的bean的代理时，通过parent引用这个配置模板，代码如下：

<bean id="petBiz" parent="txProxyTemplate">
         <property name="target" ref="petTarget"/>
</bean>

皇上作为对象，太监作为IOC容器，当皇上要挑选妃子晚上睡觉的时候，不用管，只要到床上即可。太监则根据皇上喜好(找到对应依赖或其他对象)，找到对应的妃子送到皇上榻上。

sessionFactory只有使用Hibernate才需要注入，并且是注入到事务管理器的，所以c错误
1.Spring本身并不直接管理事务，而是提供了事务管理器接口，对于不同的框架或者数据源则用不同的事务管理器；而对于事务，它把相关的属性都封装到一个实体里边去，有以下的属性:

    int propagationBehavior;    /*事务的传播行为*/
    int isolationLevel;                /*事务隔离级别*/
    int timeout;                            /*事务完成的最短时间*/
    boolean readOnly;                /*是否只读*/

Spring提供了对编程式事务和声明式事务的支持，编程式事务是嵌在业务代码中的，而声明式事务是基于xml文件配置。
2. readOnly – 事务隔离级别，表示只读数据，不更新数据

3.PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 
PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。 
PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。 
PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。 
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 
PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。 

423 下面有关servlet和cgi的描述，说法错误的是？D

servlet处于服务器进程中，它通过多线程方式运行其service方法

CGI对每个请求都产生新的进程，服务完成后就销毁

servlet在易用性上强于cgi，它提供了大量的实用工具例程，例如自动地解析和解码HTML表单数据、读取和设置HTTP头、处理Cookie、跟踪会话状态等

cgi在移植性上高于servlet，几乎所有的主流服务器都直接或通过插件支持cgi

选择D，servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。

选D：CGI不可移植，为某一特定平台编写的CGI应用只能运行于这一环境中。每一个CGI应用存在于一个由客户端请求激活的进程中，并且在请求被服务后被卸载。这种模式将引起很高的内存、CPU开销，而且在同一进程中不能服务多个客户。

Servlet 与 CGI 的比较

和CGI程序一样，Servlet可以响应用户的指令(提交一个FORM等等)，也可以象CGI程序一样，收集用户表单的信息并给予动态反馈(简单的注册信息录入和检查错误)。
然而，Servlet的机制并不仅仅是这样简单的与用户表单进行交互。传统技术中，动态的网页建立和显示都是通过CGI来实现的，但是，有了Servlet,您可以大胆的放弃所有CGI(perl?php?甚至asp!)，利用Servlet代替CGI,进行程序编写。
对比一：当用户浏览器发出一个Http/CGI的请求，或者说 调用一个CGI程序的时候，服务器端就要新启用一个进程 (而且是每次都要调用)，调用CGI程序越多(特别是访问量高的时候)，就要消耗系统越多的处理时间，只剩下越来越少的系统资源，对于用户来说，只能是漫长的等待服务器端的返回页面了，这对于电子商务激烈发展的今天来说，不能不说是一种技术上的遗憾。
而Servlet充分发挥了服务器端的资源并高效的利用。每次调用Servlet时并不是新启用一个进程 ，而是在一个Web服务器的进程敏感词享和分离线程，而线程最大的好处在于可以共享一个数据源，使系统资源被有效利用。
对比二：传统的CGI程序，不具备平台无关性特征，系统环境发生变化，CGI程序就要瘫痪，而Servlet具备Java的平台无关性，在系统开发过程中保持了系统的可扩展性、高效性。
对比三：传统技术中，一般大都为二层的系统架构，即Web服务器+数据库服务器，导致网站访问量大的时候，无法克服CGI程序与数据库建立连接时速度慢的瓶颈，从而死机、数据库死锁现象频繁发生。而我们的Servlet有连接池的概念，它可以利用多线程的优点，在系统缓存中事先建立好若干与数据库的连接，到时候若想和数据库打交道可以随时跟系统"要"一个连接即可，反应速度可想而知。

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

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

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

继承具有传递性

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

子类不可以继承父类的构造方法，只可以调用父类的构造方法。子类中所有的构造函数都会默认访问父类中的空参数构造函数，这是因为子类的构造函数内第一行都有默认的super（）语句。super（）表示子类在初始化时调用父类的空参数的构造函数来完成初始化。一个类都会有默认的空参数的构造函数，若指定了带参构造函数，那么默认的空参数的构造函数，就不存在了。这时如果子类的构造函数有默认的super（）语句，那么就会出现错误，因为父类中没有空参数的构造函数。因此，在子类中默认super（）语句，在父类中无对应的构造函数，必须在子类的构造函数中super（参数）指定要访问的父类中的构造函数。

this如果能调用父类构造函数，就与构造函数不能被继承相悖。事实父类构造函数不能被继承，故this（当前类对象）并不能访问父类构造函数

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

425 以下关于Histroy对象的属性或方法描述正确的是（AD）

bcak回到浏览器载入历史URL地址列表的当前URL的前一个URL

go表示刷新当前页面

length保存历史URL地址列表的长度信息

forward转到浏览器载入历史URL地址列表的当前URL的下一个URL。

选A、D。考察的是浏览器的内置对象管理模型，简称BOM(Browser Object Model)中的Histroy属性和方法。

length 返回浏览器历史列表中的URL数量。所以C中表述的长度信息是错误的。
back() 加载 history列表中的前一个URL。
forward() 加载  history  列表中的下一个URL。
go()  加载history列表中的某个具体页面。所以B的表述刷新当前页面是错误的。

426 以下关于Object类的说法正确的是（A）

Java中所有的类都直接或间接继承自Object，无论是否明确的指明，无论其是否是抽象类。

Java中的接口(interface)也继承了Object类

利用“==”比较两个对象时，Java调用继承自Object的equals方法，判断是否相等。

如果类的定义中没有重新定义toString()方法，则该类创建的对象无法使用toStrig()方法。

A，Object是所有类的直接或者间接父类。
B，接口没有继承Object类。（一旦继承，Object中可以有实例方法的）
C，Object的equals方法，只有一句话，return this==object。这句话说反了。
D，和A一样，都是Object的子类了，肯定有Object的方法：hashCode、equals、toString、clone、notify、notifyall、wait、finalize、getClass

Object 是基类 Java中的所有的类都直接或间接的继承；所以A对
从一个class派生的必然是另一个class。Object是一个class，如果interface继承自Object，那么interface必然是一个class，所以B错
利用equals()方法进行比较时 会调用== 可以看equals()方法的源码，可以这样说， == 比equal更加强大，所以C错
toString()方法是Object类中 即使不重写也能使用 所以D错

如果一个接口也继承了Object 类，那么接口会继承Object类中的很多方法，显然会错，因为那些方法都是实方法，不是抽象方法。比如toString() 方法，被继承过来，不满足接口中方法都是抽象方法这一限定。

427 socket编程中，以下哪个socket的操作是不属于服务端操作的（C）？

accept

listen

connect

close

TCP客户端：
1.建立连接套接字，设置Ip和端口监听，socket()
2.建立连接 connect
3.write() 获取网络流对象 发送数据
4.read()获取网络流对象 接收数据
5.关闭套接字

TCP服务器端
1.建立端口监听 socket()
2.绑定指定端口 bind()
3.listen 进行端口监听
4.accept() 阻塞式 直到有客户端访问
5.read()获取客户端发送数据
6.write()发送返回数据
7.close关闭端口监听

428 以下JAVA程序代码的输出是 (13)

public static void main(String args[]) {
System.out.println(14^3);
}

按位或|
按位且&
按位取反~
按位异或^
----------------------------------
逻辑与&&
逻辑或||
非!
----------------------------------
左移<<:补0，相当于乘以2
右移>>：补符号位，相当于除以2
无符号右移>>>：补0

^表示异或 就是相同是0 不同是1
14是1110
3是0011
所以14^3=1101，即13

429 在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的（A）？

管道

消息队列

高速缓存数据库

套接字

对于管道，有下面这几种类型：
①普通管道（PIPE）：通常有两种限制，一是单工，即只能单向传输；二是血缘，即常用于父子进程间（或有血缘关系的进程间）。

②流管道（s_pipe）：去除了上述的第一种限制，实现了双向传输。
③命名管道（name_pipe）：去除了上述的第二种限制，实现了无血缘关系的不同进程间通信。
显然，要求是对于不同的服务器之间的通信，是要要求全双工形式的，而管道只能是半双工，虽然可以双向，但是同一时间只能有一个方向传输，全双工和半双工的区别可以如下图示理解

管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
既然是不同的服务器之间进行通信，怎么可能会是具有亲缘关系的进程呢？
管道通信类似于通信中半双工信道的进程通信机制，一个管道可以实现双向的数据传输，而同一个时刻只能最多有一个方向的传输，不能两个方向同时进行

430 判断对错。在java的多态调用中，new的是哪一个类就是调用的哪个类的方法。(×)
java多态有两种情况：重载和覆写
在覆写中，运用的是动态单分配，是根据new的类型确定对象，从而确定调用的方法；
在重载中，运用的是静态多分派，即根据静态类型确定对象，因此不是根据new的类型确定调用的方法

引用毕向东教程的一段话：
1.成员变量：编译和运行都参考左边。
2.成员函数（非静态）：编译看左边，运行看右边
3.静态函数：编译和运行都看左边

== 总结一句话，只有非静态方法运行才看右边==

例：

public class Father {
    int a =10;
    static int b=10;
    public void say(){
        System.out.println("father");
    }
    public static void action(){
        System.out.println("爸爸打儿子！");
    }
}
 class Son extends Father{
    int a=9;
     static int b=9;
    public void say() {
        System.out.println("son");
    }
    public static void action(){
        System.out.println("打打！");
    }
    public static void main(String[] args) {
        Father f=new Son();
        f.say();
        f.action();
        System.out.println(f.a);
        System.out.println(f.b);
    }
}

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

输入数据

处理数据

存储数据

输出结果

算法包括0个或多个输入，1个或多个输出，中间有穷个处理过程。
存储结构不属于算法结构
算法=输入（0/n）+过程+输出（1/n）

432 Which statement is true? A

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

This code may throw an InterruptedException

This code may throw an IllegalStateException

This code may throw a TimeOutException after ten minutes

This code will not compile unless”obj.wait()”is replaced with”(Thread)obj).wait()”

Reversing the order of obj.wait()and obj.notify()may cause this method to complete normally

第一，记住wait必须要进行异常捕获
第二，记住调用wait或者notify方法必须采用当前锁调用，即必须采用synchronized中的对象
解析：

这题有两个错误的地方，第一个错误是 wait() 方法要以 try/catch 包覆，或是掷出 InterruptedException 才行
因此答案就是因为缺少例外捕捉的 InterruptedException

第二个错误的地方是， synchronized 的目标与 wait() 方法的物件不相同，会有 IllegalMonitorStateException ，不过 InterruptedException 会先出现，所以这不是答案

最后正确的程式码应该是这样：

 void waitForSignal() {

Object obj = new Object();

         synchronized (obj) {

             try {

obj.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

obj.notify();

}

} 

433 下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：(AE)

java.util.ConcurrentHashMap

java.util.Map

java.util.TreeMap

java.util.SortMap

java.util.Hashtable

java.util.HashMap

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

434 下面有关java的一些细节问题，描述错误的是？B

构造方法不需要同步化

一个子类不可以覆盖掉父类的同步方法

定义在接口中的方法默认是public的

容器保存的是对象的引用

构造方法每次都是构造出新的对象，不存在多个线程同时读写同一对象中的属性的问题，所以不需要同步 。
如果父类中的某个方法使用了 synchronized关键字，而子类中也覆盖了这个方法，默认情况下子类中的这个方法并不是同步的，必须显示的在子类的这个方法中加上 synchronized关键字才可。当然，也可以在子类中调用父类中相应的方法，这样虽然子类中的方法并不是同步的，但子类调用了父类中的同步方法，也就相当子类方法也同步了。详见：http://blog.csdn.net/welcome000yy/article/details/8941644
接口里面的变量为常量，其实际是 public static final ；接口里面的方法为抽象方法，其实际是public abstract。

435 有一个源代码，只包含import java.util. ; 这一个import语句，下面叙述正确的是？ (C )*

只能写在源代码的第一句

可以访问java/util目录下及其子目录下的所有类

能访问java/util目录下的所有类，不能访问java/util子目录下的所有类

编译错误

导入java.util.*不能读取其子目录的类，因为如果java.util里面有个a类，java.util.regex里面也有个a类，我们若是要调用a类的方法或属性时，应该使用哪个a类呢。所以也应该选C

java.util.*，只能读取其目录下的类，不能读取其子目录下的类。
因为其根目录和子目录下可能有同名类，若都能读取，则会混淆。

在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，package语句必须放在第一行
436 变量a是一个64位有符号的整数，初始值用16进制表示为：0Xf000000000000000； 变量b是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF。 则a-b的结果用10进制表示为多少？（C）

1

-(2^62+2^61+2^60+1)

2^62+2^61+2^60+1

2^59+(2^55+2^54+…+2^2+2^1+2^0)

0x7FFFFFFFFFFFFFFF+1=0X8000000000000000，那么
a-b=0Xf000000000000000-0X8000000000000000+1
=0X7000000000000001
=16^15*7+16^0*1
=2^60*7+1
=2^60*(2^2+2^1+2^0)+1
=2^62+2^61+2^60+1

（1）原码是符号位加上真值的绝对值，即用第一位表示符号位，其余位表示值。

（2）正数的反码是其本身。负数的反码是在原码的基础上，符号位不变，其余按位取反。

（3）正数的补码是其本身。负数的补码是在原码的基础上，符号位不变，其余按位取反，最后加1。

（4）计算机进行符号运算时，会以补码表示，符号位和数字位会一起参与运算。

a-b实际转换为[a-b]补=[a]补+[-b]补

a为1111（后面60个0），1开头，所以为一个负数；补码为1001（后面60个0）

b为0111（后面60个1），0开头，所以为一个正数；补码为其本身。

-b为1111（后面60个1），补码为1000（后面59个0，最后有个1）

所以1001（后面60个0） + 1000（后面59个0.最后有个1） = 0001（后面59个0，最后有个1），发生了溢出，比
如采用双高位判别法处理溢出，则补码1001（后面59个0，最后有个1）转换为原码为1110（后面60个1），即-（7 
*2的60次方+1）=-（2的62次方+2的61次方+2的60次方 +  1）

答案：-(2^62+2^61+2^60+1)

437 下面属于java引用类型的有？AD

String

byte

char

Array

java语言是强类型语言，支持的类型分为两类：基本类型和引用类型。
基本类型包括boolean类型和数值类型，数值类型有整数类型和浮点类型。整数类型包括：byte、short、int、long和char；浮点类型包括：float和double
引用类型包括类、接口和数组类型以及特殊的null类型。

438 以下哪些继承自 Collection 接口（AB）

List

Set

Map

Array

Collection

├List

│├LinkedList

│├ArrayList

│└Vector

│　└Stack

└Set

Map

├Hashtable

├HashMap
└WeakHashMap
Collection中存放的是一组各自独立的对象，Map中存放的是“键-值”对象。
List和Set都是Collection的子接口，List是一个有序可重复列表，Set是一个无序重复集。
而Array是数组，并不继承Collection接口。

439 下面有关java的instanceof、?、&、&&说法正确的有？ABCD

instanceof 可用来判断某个实例变量是否属于某种类的类型。

"?："  三目运算符

&在逻辑运算中是非短路逻辑与，在位运算中是按位与

&& 逻辑运算：逻辑与

1、三目运算是右结合的。
2、&不短路，&&短路。

&&是逻辑与 即判断&&两侧的表达式是否都为真，都为真则此&&表达式值为真；& 是按位与 即将&两侧的数用二进制展开，每一位都求与运算，最后得到的二进制数即为结果；逻辑与结果只讲真和假，而按位与得出的却是实实在在的一个数

440 设int x=1,float y=2,则表达式x/y的值是：（D）

0

1

2

以上都不是

正解：0.5
x/y= （float）1.0/（float）2.0=0.5 （float类型的）
不同基本数据类型转化与运算byte-short-int-long-float-double，float=1转化为float=1.0,int/float相比先转化为同一类型即float(1.0)/float(2.0)=0.5

441 java程序内存泄露的最直接表现是（C ）

频繁FullGc

jvm崩溃

程序抛内存控制的Exception

java进程异常消失

java是自动管理内存的，通常情况下程序运行到稳定状态，内存大小也达到一个 基本稳定的值
但是内存泄露导致Gc不能回收泄露的垃圾，内存不断变大.
最终超出内存界限，抛出OutOfMemoryExpection

首先理解一下内存泄漏的概念，内存泄漏就是对象引用消失了，对象内存却没有被回收。
A答案：FullGC 是老年代内存空间不足的时候，才会触发的，老年代一般是生命周期较长的对象或者大对象，频繁的 FullGC 不会可能会影响程序性能（因为内存回收需要消耗CPU等资源），但是并不会直接导致内存泄漏。
B 答案：JVM奔溃的可能是内存溢出引起的，也可能是其他导致 JVM崩溃的操作，例如设置了错误的JVM参数等。
C 答案：内存异常，最常见的 就是 StackOverFlow 了把，内存溢出，其实内存泄漏的最终结果就是内存溢出。所以，基本上C是对的答案。
D 答案：Java 进程异常消失，这个明显不对的。

442 下面代码的输出是什么？ 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

1.首先，需要明白类的加载顺序。
(1) 父类静态代码块(包括静态初始化块，静态属性，但不包括静态方法)
(2) 子类静态代码块(包括静态初始化块，静态属性，但不包括静态方法 )
(3) 父类非静态代码块( 包括非静态初始化块，非静态属性 )
(4) 父类构造函数
(5) 子类非静态代码块 ( 包括非静态初始化块，非静态属性 )
(6) 子类构造函数
其中：类中静态块按照声明顺序执行，并且(1)和(2)不需要调用new类实例的时候就执行了(意思就是在类加载到方法区的时候执行的)
2.其次，需要理解子类覆盖父类方法的问题，也就是方法重写实现多态问题。
Base b = new Sub();它为多态的一种表现形式，声明是Base,实现是Sub类， 理解为 b 编译时表现为Base类特性，运行时表现为Sub类特性。
当子类覆盖了父类的方法后，意思是父类的方法已经被重写，题中 父类初始化调用的方法为子类实现的方法，子类实现的方法中调用的baseName为子类中的私有属性。
由1.可知，此时只执行到步骤4.,子类非静态代码块和初始化步骤还没有到，子类中的baseName还没有被初始化。所以此时 baseName为空。 所以为null。

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

443 下面有关forward和redirect的描述，正确的是(BCD) ？

forward是服务器将控制权转交给另外一个内部服务器对象，由新的对象来全权负责响应用户的请求

执行forward时，浏览器不知道服务器发送的内容是从何处来，浏览器地址栏中还是原来的地址

执行redirect时，服务器端告诉浏览器重新去请求地址

forward是内部重定向，redirect是外部重定向

redirect默认将产生301 Permanently moved的HTTP响应

A选项 服务器会直接访问目标地址的URL，不会把控制权转交，因此错误！

1.从地址栏显示来说
forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.
redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.

2.从数据共享来说
forward:转发页面和转发到的页面可以共享request里面的数据.
redirect:不能共享数据.

3.从运用地方来说
forward:一般用于用户登陆的时候,根据角色转发到相应的模块.
redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.

4.从效率来说
forward:高.
redirect:低.

444 以下描述正确的是B

CallableStatement是PreparedStatement的父接口

PreparedStatement是CallableStatement的父接口

CallableStatement是Statement的父接口

PreparedStatement是Statement的父接口

public interface CallableStatement extends PreparedStatement
public interface PreparedStatement extends Statement
所以答案是B
445 下面哪个不属于HttpServletResponse接口完成的功能？C

设置HTTP头标

设置cookie

读取路径信息

输出返回数据

HttpServletResponse完成：设置http头标，设置cookie，设置返回数据类型，输出返回数据；读取路径信息是HttpServletRequest做的

A：设置HTTP头标

response.setHeader("Refresh","3"); //三秒刷新页面一次

B：设置cookie

Cookie c1 = new Cookie("username","only");
response.addCookie(c1);

C（错误）：读取路径信息,request读取路径信息

从request获取各种路径总结
request.getRealPath("url"); // 虚拟目录映射为实际目录
request.getRealPath("./");    // 网页所在的目录
request.getRealPath("../"); // 网页所在目录的上一层目录
request.getContextPath();    // 应用的web目录的名称

D：输出返回数据

	HttpServleteResponse.getOutputStream().write();

446 将以下哪种方法插入行5是不合法的。（ A ）

1 ．class  Parent{

2.         public  float  aFun(float a, float b) { }

3 ．}

4 ．class  Child  extends  Parent{

5 ．

6 ．}

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 默认修饰符是default，方法重写，子类方法的权限修饰符应该不低于父类方法的权限修饰符

方法重写应遵循“三同一小一大”原则：

“三同”：即方法名相同，形参列表相同，返回值类型相同；
“一小”：子类方法声明抛出的异常比父类方法声明抛出的异常更小或者相等；
“一大”:子类方法的访问修饰符应比父类方法更大或相等。 

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

447 下面选项中,哪些是interface中合法方法定义?(ACD)

public void main(String [] args);

private int getSum();

boolean setFlag(Boolean [] test);

public float get(int x);

interface中的方法默认为public abstract 的 ，变量默认为public static final

java程序的入口必须是static类型的，接口中不允许有static类型的方法。A项没有static修饰符，可以作为普通的方法。而且接口中的方法必须是public的。想想接口就是为了让别人实现的，相当于标准，标准不允许别人使用是不合理的，所以接口中的方法必须是public。C项中，接口中的方法默认是public的。D项属于正常的方法。所以答案是：ACD

448 选项中哪一行代码可以替换 //add code here 而不产生编译错误 A

public abstract class MyClass {
     public int constInt = 5;
     //add code here
     public void method() {
     } 

public abstract void method(int a);

consInt=constInt+5;

public int method();

public abstract void anotherMethod(){}

A是抽象方法，抽象类可以包含抽象方法，也可以不包含，实现重载。（√）
B 在类中不能constInt = constInt + 5（×）
C 返回值不能作为重载的依据（×）
D 有方法体的不能作为抽象函数（×）

注意两段代码输出的区别

A：抽象类可以包含抽象方法
B：类中定义成员和方法，不能直接进行运算，可以写在代码块{}或者静态代码块中static{}中
C: 与第四行想要构成重载，二者区别是返回类型，但是返回类型不能作为重载的依据
D: 该方法使用abstract修饰，是抽象方法，但是他有方法体(带有{}的就是方法体，即使里面是空的)，就不能作为抽象方法

public abstract class Parent {
    public static int constInt = 3;
    static{
        constInt=constInt+5;
    }
    public void method() {
    }
    public static void main(String[] args) {
        System.out.println(constInt);
    }
}

public abstract class Parent {
    public static int constInt = 3;
    {
        constInt=constInt+5;
    }
    public void method() {
    }
    public static void main(String[] args) {
        System.out.println(constInt);
    }
}

449 对于以下代码段，4个输出语句中输出true的个数是( C )

 class A{}

class B extends A{}

class C extends A{}

class D extends B{}

A obj = new D();

System.out.println(obj instanceof B);

System.out.println(obj instanceof C);

System.out.println(obj instanceof D);

System.out.println(obj instanceof A); 

1

2

3

4

A

| |
B C
|
D
D属于B,D属于A,D属于D,D不属于C
所以选C

450 根据以下代码段,执行new Child(“John”, 10); 要使数据域data得到10，则子类空白处应该填写( D )。

 class Parent {

    private int data;

    public Parent(int d){ data = d; }

}

class Child extends Parent{

    String name;

    public Child(String s, int d){

        ___________________

        name = s;

    }

} 

data = d;

super.data = d;

Parent(d);

super(d);

如果父类中只有有参构造函数，则子类构造函数必须调用。
创建子类对象时，会默认调用父类的无参构造函数。如果父类没有无参构造函数，需显示调用。
1.子父类存在同名成员时，子类中默认访问子类的成员，可通过super指定访问父类的成员，格式：super.xx (注：xx是成员名)；
2.创建子类对象时，默认会调用父类的无参构造方法，可通过super指定调用父类其他构造方法，格式：super(yy) (注：yy是父类构造方法需要传递的参数)

451 关于java编译和运行命令叙述不正确的是？ ( A)

运行“java Scut.class”

运行“java Scut”

运行“javac Scut.java”的输出文件是Scut.class

java这个命令的运行对象是Scut.class

A 错误 运行命令是 java + 你的 Java 程序的名字但是不加后缀 所以这道题错在多了 .class这个后缀
B 正确
C javac 是编译命令，后跟 你的 Java 程序名字加后缀，也就是 YourClassName.java 所以答案正确
D JVM （Java 虚拟机）运行的是编译后的字节码文件（以.class为后缀的文件），也就是 YourClassName.class 所以答案正确

==先编译：javac scut.java.产生字节码文件(scut.class). 再运行字节码文件:java scut.此时不需要加后缀 ==
C:如果java文件里面有多个类，将生成对应数量的class文件

452 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

公式-n=~n+1可推出~n=-n-1，所以~10=-11再加5结果为-6 

答案：C
10原码：0000000000000000,0000000000001010；
~10： 1111111111111111,1111111111110101 变为负数，计算机用补码存储
~10反码：10000000000000000,0000000000001010
~10补码：10000000000000000,0000000000001011，等于 -11
故程序结果-6

453 若所用变量都已正确定义，以下选项中，非法的表达式是（C）

a!= 4||b==1

’a’ % 3

’a’ = 1/3

’A’ + 32

'a’是个常数，不能赋值
当字符型与整型运算时会自动转换成整型。a的ASCII码为97

开始我也这样觉得C少一个强制转换的（char），都是后面一想，'a’就是一个常数，不能赋值

454 关于Java语言中的final关键字的使用，下列说法正确的是（C）

在使用final关键字定义的方法里面使用final关键字定义变量。

使用final关键字定义变量，必须在变量定义的同时给定变量的具体数值，完成变量初始化。

final关键字可以用来修饰方法，表明此方法不可以被子类重写。

使用final关键字定义变量，必须同时使用static关键字。

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

final定义的成员变量可以在代码块(类变量则静态代码块，实例变量普通代码块)里初始化，也可以在构造器中初始化，也可以在声明变量时初始化。final的局部变量声明时不必马上初始化，但使用时必须初始化，而且只能一次赋值

B如图，可以定义时不初始化，在构造器里面初始化

也可以在代码块里面初始化

455 在jdk 1.7中，以下说法正确的是（ A ）

Java中所有的非抽象方法都必须在类内定义

Java中主方法可以不在类内定义，其他方法都必须定义在类内

Java中主方法必须定义在类内，其他方法可以不必定义在类内

Java中所有方法都不必在类内定义

Java是纯粹的面向对象语言，所有的方法都必须存在于类中。类才有封装，继承，多态的特性。 在一些非纯粹的面向对象语言中，如PHP，定义的方法是可以脱离类而单独存在的。

这个问题可能会有不同的理解。。在Java中无论是普通类还是接口最后都会编译成Class文件，而在Class文件中普通类和接口的区别体现在标志字段access_flags上，如果是接口的话则将access_flags字段里的ACC_INTERFACE标志位标志为true（同理也可以标志是否为注解、枚举等），如果这些标志为都为false则为普通类，而且这个标志位和标记一个普通类是不是public类型（将ACC_PUBLIC标志为true）是一个层次上的，这个层面可以也认为接口是某种加了标记的类。这题应该还是考察Java和c/c++这类非纯面向对象语言的区别，在Java中，万物皆对象，你的一切动作必须依赖于某种“类型”实体来实现，面向对象编程实际上就是不断创造新的数据类型，而不可以像过程式编程那样单独调用某个方法（函数），所以这里的类可以理解为“类型”，方法必须包含于某种“类型”里，这个观点在《Think in Java》一书中也有提及。

题目关键在于1.8中 接口也可以声明方法 而不仅仅是抽象方法.接口在JDK8加入了默认方法，在JDK9加入了私有方法

jdk1.8之后，接口才允许default、static的方法实现，1.8之前接口中的方法只能是抽象方法。题目明确说明了是jdk1.7，此时非抽象方法只能定义在类中。

456 Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 (C ).

11 ,-11

11 ,-12

12 ,-11

12 ,-12

Math类中提供了三个与取整有关的方法：ceil,floor,round,这些方法的作用于它们的英文名称的含义相对应，例如：ceil的英文意义是天花板，该方法就表示向上取整，Math.ceil（11.3）的结果为12，Math.ceil(-11.6)的结果为-11；floor的英文是地板，该方法就表示向下取整，Math.floor(11.6)的结果是11，Math.floor(-11.4)的结果-12；最难掌握的是round方法，他表示“四舍五入”，算法为Math.floor(x+0.5),即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果是12，Math.round(-11.5)的结果为-11.

round函数是取最接近整数，如果遇到一样近，则取最大值。

457 给出以下代码,请给出结果. B

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

byte初始化赋值为0，包装类型Byte初始化赋值为null(所有包装类初始化值都是null)

解题思路：
1.注意第二行代码，Byte x；Byte是包装类，不是byte（基本数据类型），因此Byte的默认是null，不是0
2.t是一个引用地址类型，在调用fit（Two tt）函数时，是一个实参到形参的传值，也就是把t的地址赋值给了tt，但是都是指向堆内存中新建的对象，因此当对tt.x和t.x指向是相同的。因此t.x也是42
3.Two t2=fit（t）；fit函数返回的还是一个引用地址，这句代码相当于把t（函数里面返回的是tt）的地址赋值给了t2，因此t2.x也是42

458 下面程序段执行完成后，则变量sum的值是( B )

 int  b[][]={{1}, {2,2}, {2,2,2}};

int sum=0;

for(int i=0;i<b.length;i++) {

    for(int j=0;j<b[i].length;j++) {

        sum+=b[i][j];

    }

} 

32

11

2

3

需要注意的是，每一行的长度都不同，不会默认0的，访问会数组越界

459 下面有关java object默认的基本方法，说法错误的是？B

equals(Object obj) 指示某个其他对象是否与此对象“相等”

copy() 创建并返回此对象的一个副本

wait() 导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法

toString() 返回该对象的字符串表示

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

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

s.equals (t)；

t.equals (c)；

s==t；

t.equals (new String ("hello"))；

public class Base
{
    public static void main(String[] args)
    {
        String s = "hello";
        String t = "hello";
        char c [ ] = {'h','e','l','l','o'};
        System.out.println( s.equals (t));
        System.out.println(t.equals (c));
        System.out.println( s==t);
        System.out.println( t.equals (new String ("hello")));
    }
}

 1. java数据类型分为:
        *  基本数据类型
        *  引用数据类型

2.对于"=="
        *用于基本数据类型相互比较. 比较二者的值是否相等.
        *用于引用数据类型相互比较. 比较二者地址是否相等.
        *不能用于基本数据类型与引用型比较.

3.对于"equals":
        * 不能用于基本数据类型比较(因为这是一个方法, 继承自object).
        *用于进行对象的比较, 比较二者的引用地址是否相同.

 4.特殊情况:
        1)数值型基本类型和数值型类会存在自动装箱和自动拆箱.
        2)字符串会以常量形式存在, 如果多个字符串变量值相同, 则他们指向同一个地址.
        3)数值类型会存在类型自动转换.

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

461 Java程序中的类名称必须与存放该类的文件名相同（错）

声明为public类型的类名必须与文件名相同，默认权限的可以不同，并且内部类的类名一般与文件名不同

一个文件中可以有多个类，如果没有public类，则可以与任意类名相同，如果有public类则文件名必须与此类名相同，因为一个文件中只能有一个public类。如果文件中只有一个类，则文件名必须与类名相同

一个类文件中可以同时包含多个平行的类，但最多只能有一个类用public修饰，文件名需与该类名相同。
外部类中还可以包含内部类，匿名类。

462 代码行float t=5.1; int i=t; ,不正确的是B

代码不能编译

代码编译, i被设置为5

第二行若改为 int i=(byte)t ，并结合D选项，则可编译

第一行若改为 float t=5.1f ，并结合C选项，则可编译

  float t=5.1f;
          int i=(byte)t;
        System.out.println((byte)t);

463 下列关于包（package）的描述，正确的是（D）

包（package）是Java中描述操作系统对多个源代码文件组织的一种方式。

import语句将所对应的Java源文件拷贝到此处执行。

包（package）是Eclipse组织Java项目特有的一种方式。

定义在同一个包（package）内的类可以不经过import而直接相互使用。

1、为了更好地组织类，Java提供了包机制。包是类的容器，用于分隔类名空间。如果没有指定包名，所有的示例都属于一个默认的无名包。Java中的包一般均包含相关的类，java是跨平台的，所以java中的包和操作系统没有任何关系，java的包是用来组织文件的一种虚拟文件系统。A错
2、import语句并没有将对应的java源文件拷贝到此处仅仅是引入，告诉编译器有使用外部文件，编译的时候要去读取这个外部文件。B错
3、Java提供的包机制与IDE没有关系。C错
4、定义在同一个包（package）内的类可以不经过import而直接相互使用。

外部类只能被public、abstract、final、（default）修饰
private修饰类的话只能修饰内部类
内部类可以被public、abstract、final、（default）、private修饰
内部类是外部类的一个成员，所以可以访问外部类的私有属性
同包无需导入即可使用，因为外部类不会是private的

464 在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的？（CD）

public class Base{
int w, x, y ,z;
public Base(int a,int b)
{
x=a; y=b;
}
public Base(int a, int b, int c, int d)
{
// assignment x=a, y=b
w=d;z=c;
}}

Base(a,b);

x=a, y=b;

x=a; y=b;

this(a,b);

B选项，可以使用逗号的是变量初始化的语句，比如
int i=1,b=2;
如果是赋值语句，不能用逗号分隔。

A错，调用Base这个构造方法应该这样 new Base(a,b)
B错，和C相比应该是分号不是逗号，帅的一塌糊涂
C正常赋值操作
D调用本类的构造方法

465 在使用super和this关键字时，以下描述错误的是（BCD）

在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过

super()和this()不一定要放在构造方法内第一行

this()和super()可以同时出现在一个构造函数中

this()和super()可以在static环境中使用，包括static方法和static语句块

==super和this都只能位于构造器的第一行，而且不能同时使用，这是因为会造成初始化两次，this用于调用重载的构造器，super用于调用父类被子类重写的方法 ==

1、super()表示调用父类构造函数、this()调用自己的构造函数，而自己的构造函数第一行要使用super()调用父类的构造函数，所以这俩不能在一个构造函数中会出现重复引用的情况
2、super()和this()必须在构造函数第一行，所以这一点也表明他俩不能在一个构造函数中
3、this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块(里面不能使用非static类型的)。

*466 int，String，point，union哪些不是 Java 的数据类型？CD

int

String

*point

union

题目是说数据类型，并没有说基本数据类型，所有包括了引用数据类型，String为字符串类，属于引用数据类型

string是C++中定义字符串的类型，java中是String类

*point是指针，java中没有这种类型

union是C系的类型，java中没有

467 instanceof运算符能够用来判断一个对象是否为:C

一个类的实例

一个实现指定接口的类的实例

全部正确

一个子类的实例

468 关于Java中参数传递的说法，哪个是错误的？D

在方法中，修改一个基础类型的参数不会影响原始参数值

在方法中，改变一个对象参数的引用不会影响到原始引用

在方法中，修改一个对象的属性会影响原始对象参数

在方法中，修改集合和Maps的元素不会影响原始集合参数

https://blog.csdn.net/scholar_man/article/details/80900212

469 以下说法中正确的有？AD

StringBuilder是 线程不安全的

Java类可以同时用 abstract和final声明

HashMap中，使用 get(key)==null可以 判断这个Hasmap是否包含这个key

volatile关键字不保证对变量操作的原子性

因为HashMap可以使用null作为value，所以map.get(key)得到的null，有可能是value值为null，也有可能是key不存在
选项C 如果 HashMap 换成 HashTable 就是对的，因为 HashTable 中无论是 key 还是 value 都不允许是 null 。通过查看源码中的 put 方法可以知道。

StringBuilder是 线程安全的
abstract修饰的类不能被实例化，final修饰的类不能被继承，冲突了

470 如果Child extends Parent，那么正确的有（BCD）？

如果Child是class，且只有一个有参数的构造函数，那么必然会调用Parent中相同参数的构造函数

如果Child是interface，那么Parent必然是interface

如果Child是interface，那么Child可以同时extends Parent1，Parent2等多个interface

如果Child是class，并且没有显示声明任何构造函数，那么此时仍然会调用Parent的构造函数

A 可以调用父类无参的构造函数，子类的有参构造函数和是否调用父类的有参数的构造函数无必然联系。
B接口继承的时候只能继承接口不能继承类，因为如果类可以存在非抽象的成员，如果接口继承了该类，那么接口必定从类中也继承了这些非抽象成员，这就和接口的定义相互矛盾，所以接口继承时只能继承接口。
C 接口可以多继承可以被多实现，因为接口中的方法都是抽象的，这些方法都被实现的类所实现，即使多个父接口中有同名的方法，在调用这些方法时调用的时子类的中被实现的方法，不存在歧义；同时，接口的中只有静态的常量，但是由于静态变量是在编译期决定调用关系的，即使存在一定的冲突也会在编译时提示出错；而引用静态变量一般直接使用类名或接口名，从而避免产生歧义，因此也不存在多继承的第一个缺点。 对于一个接口继承多个父接口的情况也一样不存在这些缺点。所以接口可以多继承。
D 子类即使没有显示构造函数，也会有个无参数的默认构造函数，仍然会调用父类的构造函数。

471 如果子类要调用父类的构造函数，则通过super（）调用来实现。 （√）

子类的每一个构造方法都必须显式或隐式调用父类的一个构造方法。如果不显式调用, 则系统隐式调用super(),即父类的无参构造方法(如果父类无任何构造方法, 则系统为父类自动提供一个无参构造方法; 如果父类已经有一个构造方法, 系统不会额外提供无参的构造方法，此时, 如果父类仅定义了有参构造方法, 并且子类没有定义任何的构造方法(系统会为它提供一个无参构造方法, 然后隐式调用父类无参构造方法), 或子类定义的构造方法中没有显式调用父类的有参构造方法(会隐式调用父类的无参构造方法), 就都会因为父类没有无参构造方法而报错。

super关键字在子类内部使用，代表父类对象。 访问父类的属性 super.属性名 访问父类的方法 super.方法名() 子类构造方法需要调用父类的构造方法时，在子类的构造方法体里最前面的位置：super()

472 为什么要使用嵌套类
使用嵌套类，其中有几个令人信服的理由：
加强封装—考虑两个顶级类，A和B，如果B需要访问A的private成员，通过在A类隐藏B类，那么即使A的成员声明为private，那么B也可以访问它们。更多的是，B本身也可以隐藏于外部。
更可读性，可维护性的代码—在顶级类里嵌套小类，让代码更靠近使用的地方。

473 下列选项中是正确的方法声明的是？（ABCD）

protected abstract void f1();

public final void f1() {}

static final void fq(){}

private void f1() {}

1.抽象方法只能定义在抽象类中，抽象方法和抽象类必须由abstract修饰，abstract关键字只能描述类和方法，不能描述变量。抽象方法只定义方法声明，不定义方法实现。抽象类不可以被实例化（创建对象），只有通过子类继承抽象类并覆盖抽象类中的所有抽象方法后，该子类才可以被实例化，否则该子类还是一个抽象类。抽象类中有构造函数用于给子类对象进行初始化，同时抽象类中可以含有非抽象方法。abstract关键字不可以与final，private,static关键字共存，因为被final修饰的方法不可以被重写，意味着子类不可以重写该方法，如果abstract和final共同修饰父类中的方法，子类要实现抽象方法（abstract的作用），而final又不让该方法重写，这相互矛盾。如果private和abstract共同修饰父类中的方法，private修饰则该方法不可以被子类访问，但是abstract修饰需要子类去实现，两者产生矛盾。如果static和abstract共同修饰父类中的方法，static表示是静态的方法，随着类的加载而加载，则该方法不需要在子类中去实现，这与abstract关键字矛盾。

2.static用于修饰成员变量和成员函数，想要实现对象中的共性数据的对象共享，可以将这个数据进行静态修饰，被静态修饰的成员可以直接被类名调用，静态随着类的加载而加载，而且优先于对象存在。静态方法只能访问静态成员（静态方法和静态变量），不可以访问非静态成员，这是因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。静态方法中不能使用this和super关键字，因为this代表本类对象，super代表父类对象，而静态时，有可能没有对象存在，所以this和super无法使用。

3.final关键字可以修饰类，方法，变量（成员变量内，局部变量，静态变量），被final修饰的类是一个最终类，不可以被继承，被final修饰的方法是一个最终方法，不可以被覆盖，但是可以被继承。被final修饰的变量只能是一个常量，只能赋值一次。内部类被定义在类中的局部位置上时，只能访问局部被final修饰的局部变量。

474 Java 程序中使用赋值运算符进行对象赋值时，可以得到两个完全相同的对象。 （×）

对象赋值时，比如A=B，只是把A对象的地址指向了B对象的地址，那就A和B都指向了同一个地址，也就是A和B这两个引用都指向同一个对象，所以其实对象只有一个。 另外，对象是在堆内存，A和B这两个引用是在栈内存。

475 关于如下程序的描述哪个是正确的？（C ）

 public class Person{

static int arr[] = new int[5];

public static void main(String a[]){

System.out.println(arr[0]);

}

} 

编译将产生错误

编译时正确，但运行时将产生错误

正确，输出0

正确，输出 null

类的成员变量会被默认初始化
在方法里面定义的局部变量，用到的时候需要初始化
在方法里面定义数组也会默认初始化

476 针对以下代码，哪些选项执行后是true的：（BC）

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

f1==f2

x==f1[0]

f1==f3

f2==f1[1]

BC正确，选项B解释，java核心卷I中43页有如下表述：两个数值进行二元操作时，会有如下的转换操作：
如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。
否则，如果其中一个操作数是float类型，另一个将会转换为float类型。
否则，如果其中一个操作数是long类型，另一个会转换为long类型。
否则，两个操作数都转换为int类型。
故，x==f1[0]中，x将会转换为float类型。

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

true
true
true
true
true

基本类型之间的比较，应该会将低精度类型自动转为高精度类型再比较。
B、C f1、f2、f3是数组，是引用类型，f、x是基本类型。基本类型之间的比较，会将低精度类型自动转为高精度类型再比较,B选项是long和float比较，相当于long和long比较，所以B对。
477 transient 变量和下面哪一项有关？ B

Cloneable

Serializable

Runnable

Comparable

和序列化有关，这是一个空接口，起标记作用，具体的序列化由ObjectOutputStream和ObjectInputStream完成。transient修饰的变量不能被序列化，static变量不管加没加transient都不可以被序列化

java 的transient关键字的作用是需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

478 java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。（√）

例如平时有这样的用法
for(int i=0;i<10;i++){
a[i+1]=a[i]
}
这个i+1就是整数型表达式 或者a[5+3]就是a[8]