Javase专项练习一
1.类之间存在以下几种常见的关系：
正确答案: A B C
A;“USES-A”关系
B;“HAS-A”关系
C;“IS-A”关系
D;“INHERIT-A”关系
解析：
USES-A：依赖关系，A类会用到B类，这种关系具有偶然性，临时性。但B类的变化会影响A类。这种在代码中的体现为：A类方法中的参数包含了B类。
关联关系：A类会用到B类，这是一种强依赖关系，是长期的并非偶然。在代码中的表现为：A类的成员变量中含有B类。
HAS-A：聚合关系，拥有关系，是关联关系的一种特例，是整体和部分的关系。比如鸟群和鸟的关系是聚合关系，鸟群中每个部分都是鸟。
IS-A：表示继承。父类与子类，这个就不解释了。
要注意：还有一种关系：组合关系也是关联关系的一种特例，它体现一种contains-a的关系，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分的关系，但这种整体和部分是不可分割的。
2.在jdk1.5之后，下列 java 程序输出结果为______。
int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));
正确答案: true,true
总体主要分为两个方面
①比较的是值
一、基本数据类型与引用数据类型进行比较时，引用数据类型会进行拆箱，然后与基本数据类型进行值的比较
举例：
int i = 12;
Integer j = new Integer(12);
i == j 返回的是true
二、引用数据类型与基本数据类型进行比较（equals方法），基本数据类型会进行自动装箱，与引用数据类型进行比较，Object中的equals方法比较的是地址，但是Integer类已经重写了equals方法，只要两个对象的值相同，则可视为同一对象，具体看API文档，所以这归根到底也是值的比较！
举例：
int i = 12;
Integer j = new Integer(12);
j.equals(i) 返回的是true
②比较的是地址
一、如果引用数据类型是这样 Integer i = 12;直接从常量池取对象，这是如果数值是在-128与127之间，则视为同一对象，否则视为不同对象
举例：
Integer i = 12; Integer j = 12; i == j 返回的是true
Integer i = 128; Integer j = 128; i == j 返回的是false
二、如果引用数据类型是直接new的话，不管值是否相同，这时两个对象都是不相同的，因为都会各自在堆内存中开辟一块空间
举例：
Integer i =new Integer(12);
Integer j = new Integer(12);
i == j 这时返回的是false
三、从常量池取对象跟new出来的对象也是不同的
举例：
Integer i = 12;
Integer j = new Integer(12)
i == j 这时返回的是false，因为第二个语句其实已经是new了两个对象了！！！
3.关于异常的编程，以下描述错误的是：（ ）
正确答案: A
A;在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
B;int i=Integer.parseInt(”123a”);将产生NumberFormatException
C;int a[]=null; a[0]=1; 将产生NullPointerException
D;输入输出流编程中，读和写时都要抛出IOException
Java的异常分为两种，一种是运行时异常（RuntimeException），一种是非运行异常也叫检查式异常（CheckedException）。
1、运行时异常不需要程序员去处理，当异常出现时，JVM会帮助处理。常见的运行时异常有：
ClassCastException(类转换异常)
ClassNotFoundException
IndexOutOfBoundsException(数组越界异常)
NullPointerException(空指针异常)
ArrayStoreException(数组存储异常，即数组存储类型不一致)
还有IO操作的BufferOverflowException异常
2、非运行异常需要程序员手动去捕获或者抛出异常进行显示的处理，因为Java认为Checked异常都是可以被修复的异常。常见的异常有：
IOException
SqlException
4.下面哪种流可以用于字符输入：
正确答案: C
A;java.io.inputStream
B;java.io.outputStream
C;java.io.inputStreamReader
D;java.io.outputStreamReader
1）字节流可以处理字符流；
2）InputStreamReader只是将字节流转换为字符流，OutputStreamWriter将字符流转换为字节流，他们只是用于转换，并不能用于字符的输出！
5.要使某个类能被同一个包中的其他类访问，但不能被这个包以外的类访问，可以( )
正确答案: A
A;让该类不使用任何关键字
B;使用private关键字
C;使用protected关键字
D;使用void关键字
default和protected的区别是：
前者只要是外部包，就不允许访问。
后者只要是子类就允许访问，即使子类位于外部包。
总结：default拒绝一切包外访问；protected接受包外的子类访问
6.下面程序的运行结果：()
public static void main(String args[]) {Thread t=new Thread(){public void run(){dianping();}};t.run();System.out.print("dazhong");}static void dianping(){System.out.print("dianping");
}
正确答案:dianpingdazhong
如果调用run（） 选b
如果调用start（） 选c
因为调用start后并不保证线程启动的顺序
7.下列叙述错误的是（ ）
正确答案: C
A;java程序的输入输出功能是通过流来实现的
B;java中的流按照处理单位可分成两种：字节流和字符流
C;InputStream是一个基本的输出流类。
D;通过调用相应的close（）方法关闭输入输出流
C.InputStream是一个基本的输出流类
这里"基本的"，其实就是将流分为节点流和处理流，而“基本的”是表示节点流
所以C选项可以看成：InputStream是属于节点输出流；
所以我们就要判断InputStream是节点流还是处理流，是输出流还是输入流
这就涉及到哪些是节点流，哪些是处理流了，而且很明显，他是一个输入流
节点流：
FileInputStream，FileOutputStrean，FileReader，FileWriter
StringReader，StringWriter
ByteArrayInputStream ，ByteArrayOutputStream ，CharArrayReader
PipedInputStream PipedOutputStream PipedReaderPipedWriter
处理流：
BufferedInputStrean，BufferedOutputStream，BufferedReader，BufferedWriter
InputStreamReader，OutputStreamReader
DataInputStream，DataOutputStream
PrintWriter
不知道大家发现没有，节点流的前缀都是名词，如File，String，Char等；处理流的前缀都是动词，如input，print，bufferd等等
所以大家别烦分不清一个流到底是节点流还是处理流，看他前缀是名词还是动词就行了
8.将类的成员的访问权限设置为默认的，则该成员能被( )
正确答案: A
A;同一包中的类访问
B;其它包中的类访问
C;所有的类访问
D;所有的类的子类访问
访问修饰符权限如下所示：
访问修饰符的权限常容易搞混，特别是default和protected这两种的访问权限，于是使用简化记忆的方式（访问范围有小到大）:私下（private）里友好（friendly），才能更好地保护（protected）公众（public），通过这种方式，记忆几遍之后就快速准确地解决了这种题型。
具体的说明如下：
private使用范围仅限本类中 ；
protected使用范围为含继承关系的类中（子类可以使用父类）；
什么都不写叫友好类，默认是本包中；
public特别随意，包内包外，类内类外都可访问 。
而default和protected老有人记不住，只要记住protected一个特点是只要子类都能访问，不管在不在一个包即可。
9.关于Java中的ClassLoader下面的哪些描述是错误的：( )
正确答案: B D F 你的答案: A C E (错误)
A;默认情况下，Java应用启动过程涉及三个ClassLoader: Boostrap, Extension, System
B;一般的情况不同ClassLoader装载的类是不相同的，但接口类例外，对于同C;一接口所有类装载器装载所获得的类是相同的
类装载器需要保证类装载过程的线程安全
D;ClassLoader的loadClass在装载一个类时，如果该类不存在它将返回null
E;ClassLoader的父子结构中，默认装载采用了父优先
F;所有ClassLoader装载的类都来自CLASSPATH环境指定的路径
A.Java系统提供3种类加载器：启动类加载器（Bootstrap ClassLoader） 扩展类加载器（Extension ClassLoader） 应用程序类加载器（Application ClassLoader）. A正确
B.《深入理解Java虚拟机》P228：对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性，每一个类加载器，都拥有一个独立的类名称空间。这句话可以表达得更通俗一些：比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个Class文件，被同一个虚拟机加载，只要加载它们的类加载器不同，那么这两个类必定不相等。接口类是一种特殊类，因此对于同一接口不同的类装载器装载所获得的类是不相同的。B错误
C.类只需加载一次就行，因此要保证类加载过程线程安全，防止类加载多次。C正确
D. Java程序的类加载器采用双亲委派模型，实现双亲委派的代码集中在java.lang.ClassLoader的loadClass()方法中，此方法实现的大致逻辑是：先检查是否已经被加载，若没有加载则调用父类加载器的loadClass()方法，若父类加载器为空则默认使用启动类加载器作为父类加载器。如果父类加载失败，抛出ClassNotFoundException异常。D错误
E.双亲委派模型的工作过程：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求时，子加载器才会尝试自己去加载。E正确
F.应用程序类加载器（Application ClassLoader）负责加载用户类路径（ClassPath）上所指定的类库，不是所有的ClassLoader都加载此路径。F错误
10.如下哪些是 java 中有效的关键字（）
正确答案: A D
native
NULL
false
this
const和goto是保留关键字。true和false看起来像关键字，但严格来说，它们是boolean常量；null看起来也像关键字，但严格来说，它是null常量。
综上，true,false,null不是关键字。而是常量。
11.下列Java代码中的变量a、b、c分别在内存的____存储区存放。
class A {
private String a = “aa”;
public boolean methodB() {
String b = “bb”;
final String c = “cc”;
}
}
正确答案: C
堆区、堆区、堆区
堆区、栈区、堆区
堆区、栈区、栈区
堆区、堆区、栈区
静态区、栈区、堆区
静态区、栈区、栈区
堆区：只存放类对象，线程共享；
方法区：又叫静态存储区，存放class文件和静态数据，线程共享;
栈区：存放方法局部变量，基本类型变量区、执行环境上下文、操作指令区，线程不共享;
12.JDK中提供的java、javac、jar等开发工具也是用Java编写的。
正确答案;对
下载OpenJDK的源码，可以看到java,javac这些命令都是用java写的，可以导入eclipse单独运行。这道题也是可以，就对和错两个选项，还是不定项选择题，
13.根据以下代码段,执行new Child(“John”, 10); 要使数据域data得到10，则子类空白处应该填写( )。
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;}}
正确答案: D
data = d;
super.data = d;
Parent(d);
super(d);
1.super可以访问父类中public、default、protected修饰的成员变量，不能访问private修饰的成员变量。格式为super.成员名称。
2.super可以访问父类中public、default、protected修饰的实例方法，不能访问private修饰的实例方法。格式为super.实例方法。
3.super可以访问父类中public、default、protected修饰的构造方法，不能访问private修饰的构造方法，格式为super(参数).
14.类A1和类A2在同一包中，类A2有个protected的方法testA2，类A1不是类A2的子类（或子类的子类），类A1可以访问类A2的方法testA2。（ ）
正确答案: 正确
区别：
public：可以被所有其他类所访问
private：只能被自己访问和修改
protected：自身、子类及同一个包中类可以访问
default：同一包中的类可以访问，声明时没有加修饰符，认为是friendly。
15.请问所有的异常类皆直接继承于哪一个类？（）
正确答案: C
java.applet.Applet
java.lang.Throwable
java.lang.Exception
java.lang.Error
16.下面关于JAVA的垃圾回收机制，正确的是（ ）
正确答案: B
当调用“System.gc()”来强制回收时，系统会立即回收垃圾
垃圾回收不能确定具体的回收时间
程序可明确地标识某个局部变量的引用不再被使用
程序可以显式地立即释放对象占有的内存
java提供了一个系统级的线程，即垃圾回收器线程。用来对每一个分配出去的内存空间进行跟踪。当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的。当对象的引用变量被赋值为null，可能被当成垃圾。
选C多半是认为置为null，但是置为null不一定就不会使用了啊~那我初始化的时候还置为null呢
况且，置为null只是被认为可以当垃圾回收了。不一定会马上回收
局部变量分为引用变量和基本类型变量，基本类型的变量名称和值都是存储在栈中。引用变量只存储引用在栈中，值在堆中，题目中说的是局部变量的引用，而要释放这个需要finalize()方法，这个方法即便使用了也不是一定立刻马上执行。一般局部变量都是随着方法执行结束而释放
17.观察左图相邻数字的规律，要使右图相邻数字也符合这个规律，应选择（ ）
正确答案: A
46
78
68
134
相邻两个数相加，所得结果等于一个完全平方数，完全平方数比如：2（1 * 1） ，4 （22），9（33），16（44）
例如：
1+24 = 25 = 55
1 + 120 = 121 = 11 * 11
18.下列不属于访问控制符的是（）
正确答案: D
public
private
protected
static
访问控制修饰符
访问控制符是一组限定类、属性或方法是否可以被程序里的其他部分访问和调用的修饰符。
类的访问控制符只能是空或者 public。
方法和属性的访问控制符有 4 个，分别是 public、 private、protected 和 friendly，其中 friendly 是一种没有定义专门的访问控制符的默认情况。
19.不考虑反射机制，一个子类显式调用父类的构造器必须用super关键字。（ ）
正确答案: 正确
java中的super关键词
super用于代表子类的直接父类的特征
super可以访问：
父类的成员变量，成员方法，构造方法
使用super关键词的情况：
在子类中，存在与父类相同的属性和方法，由于访问子类中属性和方法的优先级高于父类，可以通过super关键词来访问父类中的属性和方法
在子类中，可以通过super关键词来显示的调用父类的构造方法
子类的构造方法默认调用父类的无参构造方法，当父类中不存在无参构造方法时，可以同过super来调用父类的有参构造芳法来避免编译时错误。
20.java有8种基本类型，请问byte、int、long、char、float、double、boolean各占多少个字节？
正确答案: B
1 2 8 2 4 8 1
1 4 8 2 4 8 1
1 4 4 2 4 4 2
1 4 4 2 4 8 2
byte：8位 一个字节 int：32位 四个字节 long：64位 八个字节 char：16位 两个字节 float:32位 四个字节 double：64位 八个字节 boolean：8位 一个字节
21.分块查找的平均查找长度不仅与索引表的长度有关，而且与块的长度有关。（ ）
正确答案: 真确
索引分块查找就类似于图书馆的索引，我们先找到第几楼，再找第几个书架，然后再找书。
分块查找就是先找到目标所在的数据块，然后块内查找。因此跟表中元素个数和块中元素个数都有关。
22.若在某一个类定义中定义有如下的方法： abstract void performDial( ); 该方法属于（）
正确答案: D
本地方法
最终方法
解态方法
抽象方法
A.JAVA中有两种方法：JAVA方法和本地方法。
JAVA方法是由JAVA编写的，编译成字节码，存储在class文件中；
本地方法是由其它语言编写的，编译成和处理器相关的机器代码，本地方法保存在动态链接库中，即.dll(windows系统)文件中，格式是各个平台专有的。
JAVA方法是与平台无关的，但是本地方法不是。
B.final void A() {}，这样定义的方法就是最终方法，最终方法在子类中不可以被重写。
也就是说，如果有个子类继承这个最终方法所在的类，那么这个子类中就不能再出现void A() {}这样的方法了。
C.不存在解态方法这种东西，应该是笔误打错了，是静态方法。
静态方法的使用完全独立于该类的任何对象。
在类中使用static修饰的静态方***随着类的定义而被分配和装载入内存中；而非静态方法属于对象的具体实例，只有在类的对象创建时在对象的内存中才有这个方法的代码段。
23.通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应的位置并插入的排序算法是（）
正确答案: D
归并排序
选择排序
希尔排序
插入排序
归并操作(merge)，也叫归并算法，指的是将两个顺序序列合并成一个顺序序列的方法。
如 设有数列{6，202，100，301，38，8，1}
初始状态：6,202,100,301,38,8，1
第一次归并后：{6,202},{100,301},{8,38},{1}，比较次数：3；
第二次归并后：{6,100,202,301}，{1,8,38}，比较次数：4；
第三次归并后：{1,6,8,38,100,202,301},比较次数：4；
总的比较次数为：3+4+4=11,；
逆序数为14；
简单选择排序的基本思想：第1趟，在待排序记录r[1]r[n]中选出最小的记录，将它与r[1]交换；第2趟，在待排序记录r[2]r[n]中选出最小的记录，将它与r[2]交换；以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。
以下为简单选择排序的存储状态，其中大括号内为无序区，大括号外为有序序列：
初始序列：{ 49 27 65 97 76 12 38 }
第1趟：12与49交换：12 { 27 65 97 76 49 38 }
第2趟：27不动 ：12 27 { 65 97 76 49 38 }
第3趟：65与38交换：12 27 38 { 97 76 65 49}
第4趟：97与49交换：12 27 38 49 { 97 76 65 }
第5趟：76与65交换：12 27 38 49 65 { 97 76 }
第6趟：97与76交换：12 27 38 49 65 76 97 完成
24.执行下列程序的输出结果为（ ）
public class Test {public static void main(String[] args) {String s1 = "HelloWorld";String s2 = new String("HelloWorld");if (s1 == s2) {System.out.println("s1 == s2");} else {System.out.println("s1 != s2");}if (s1.equals(s2)) {System.out.println("s1 equals s2");} else {System.out.println("s1 not equals s2");}}}
s1 != s2
s1 equals s2
1.== 和 equals():
(1)“–” 用于比较基本数据类型时比较的是值，用于比较引用类型时比较的是引用指向的地址。
(2)Object 中的equals() 与 “==” 的作用相同，但String类重写了equals()方法，比较的是对象中的内容。
25.冒泡排序算法的时间复杂度是什么？
正确答案: A
O(N*N)
O(N)
O(log2N)
O(Nlog2N)
冒泡，直接插入，选择排序 等排序算法时间复杂度是 O（N^2）
快速排序，堆排序，归并排序 等排序算法平均时间复杂度是 O（NlongN）
26.一个栈的输入序列为123、、、、、n，若输出序列的第一个元素是n，输出第i（1<=i<=n）个元素是（）
正确答案: B
不确定
n-i+1
i
n-i
当 i = 2时，输出元素是（n - 1）
符合公式（n - i + 1）
26.int f(int x) return ((x>2) ? x*f(x-1) : 3); } int i; i=f(f(2)):
执行如上函数后. i的值为（9）
答案应该为 9
首先 2 传进去后， 2 > 2 为假，故函数返回 3 ，这时 f(f(2)) 就相当于f(3), 再将 3 传进去应该返回 3 * f(3 - 1) 即 3 * f(2), 又因为 f(2) 为 3，所以 f(3) = 9,因此答案就为 9.
27.public class Test{ static int cnt = 6; static{ cnt += 9; } public static void main(String[] args）{ System.out.println（“cnt =” + cnt); } static{ cnt /=3; }; }
正确答案cnt=5
28.对于关键字序列（16,10,20,12,18,7,14,13,5,19），不可能构成其二叉排序树中一条查找路径的序列是（ ）
正确答案: C 16,10,7,5
16,20,18,19
16,10,7,12,14
16,10,12,14
前面的节点，或者比后面的节点都大，或者比后面的节点都小。
C选项
10>7
10<12,14 所以C不可能构成其二叉排序树中一条查找路径的序列
29.建立Statement对象的作用是？
正确答案: C
连接数据库
声明数据库
执行SQL语句
保存查询结果
1、Statement对象用于执行不带参数的简单SQL语句。
2、Prepared Statement 对象用于执行预编译SQL语句。
3、Callable Statement对象用于执行对存储过程的调用。
30.用希尔排序方法对一个数据序列进行排序时，若第1趟排序结果为9,1,4,13,7,8,20,23,15，则该趟排序采用的增量（间隔）可能是 。
正确答案: B
2
3
4
5
首先，第二个元素为1，是整个序列中的最小元素，所以可知该希尔排序为从小到大排序。然后考虑增量问题，若增量为2，第1+2个元素4明显比第1个元素9要大，A排除；若增量为3，第i、i+3、i+6个元素都为有序序列(i=1,2,3)，符合希尔排序的定义；若增量为4，第1个元素9比第1+4个元素7要大，C排除；若增量为5，第1个元素9比第1+5个元素8要大，D排除，选B。
31.如果一个接口Glass有个方法setColor()，有个类BlueGlass实现接口Glass，则在类BlueGlass中正确的是？ ( )
正确答案: C
protected void setColor() { …}
void setColor() { …}
public void setColor() { …}
以上语句都可以用在类BlueGlass中
JAVA 子类重写继承的方法时,不可以降低方法的访问权限，子类继承父类的访问修饰符要比父类的更大，也就是更加开放，假如我父类是protected修饰的，其子类只能是protected或者public，绝对不能是friendly(默认的访问范围)或者private，当然使用private就不是继承了。还要注意的是，继承当中子类抛出的异常必须是父类抛出的异常的子异常，或者子类抛出的异常要比父类抛出的异常要少。
32.运用下列哪个命令能够获取JVM的内存映像
正确答案: B
jinfo
jmap
jhat
jstat
1、jps：查看本机java进程信息。
2、jstack：打印线程的栈信息，制作线程dump文件。
3、jmap：打印内存映射，制作堆dump文件
4、jstat：性能监控工具
5、jhat：内存分析工具
6、jconsole：简易的可视化控制台
7、jvisualvm：功能强大的控制台
33.对于基本有序的序列，按照那种排序方式最快：
正确答案: B
快速排序
冒泡排序
归并排序
基数排序
34.以下 b 的值是： byte b = (byte)129;
正确答案: B 你的答案: C (错误)
-126
-127
-128
-129
这题考察的就两个知识点：一、强制转换（主要涉及各个类型占几个字节，这里我只简单说一下byte型占一个字节，也就是8位，int型4个字节，32位）；二、在计算机系统中，数值一律用补码来表示（存储）
正数：补码=反码=原码（当然以二进制形式表达）
129 int类型（4个字节）二进制： 00000000 00000000 00000000 10000001
强制转换byte型后，只有一个字节即 10000001（注意这里从二进制角度看，第一位是符号位，即求负数的补码接下来）
只要求出上面原码对应的补码就行了，然后再转换对应的int型数值（因为题干所给的答案都是比较int型）
10000001（原码） 对应的反码为1111 1110
又补码等于反码+1
即1111 1111 该二进制转换int型刚好是-127（1+2+4+8+16+32+64）
普及一下：正数原码，反码，补码相同
负数反码除了符号位不变，其他位取反，补码=反码+1；
35.在程序设计中，要对两个16K×16K的多精度浮点数二维数组进行矩阵求和时，行优先读取和列优先读取的区别是（）
正确答案: B
没区别
行优先快
列优先快
2种读取方式速度为随机值，无法判断
若在内存中,则数据可以”随机存取”,但内存数据被读取或写入时,所需要的时间与这段信息所在的位置无关.但是在读取和写入磁盘时,其所需要的时间与位置就会有关系.因为在BASIC,PASCAL和C/C++语言中,数组的存放是按照行优先来存放的,按行号第一行第二行…以此类推.本体关键是考察内存抖动的问题,如果按列访问则需要跳过一大串内存地址,这样可能需求的内存地址不在当前页中则需要进行页置换,这样便需要硬盘IO,减低速度.
36.下面哪个不属于HttpServletResponse接口完成的功能？
正确答案: C
设置HTTP头标
设置cookie
读取路径信息
输出返回数据
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：输出返回数据
1
HttpServleteResponse.getOutputStream().write();
37.Java1.8之后，Java接口的修饰符可以为（）
正确答案: D
private
protected
final
abstract
接口是一种特殊的抽象类，先说明抽象类中的抽象方法，再说明接口
抽象类中的抽象方法(其前有 abstract1修饰)不能用 private、 static、 synchronized、native访回修饰符修饰。原因如下:1. private
抽象方法没有方法体,是用来被继承的,所以不能用 private修饰;2.static
static修饰的方法可以通过类名来访间该方法(即该方法的方法体),抽象方法用sttic修饰没有意义;3. synchronized
该关键字是为该方法加一个锁。而如果该关键字修饰的方法是 static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。
但是抽象类不能实例化对象,因为该方法不是在该抽象类中实现的。是在其子类实现的。所以，锁应该归其子类所有。所以，抽象方法也就不能用 synchronized关键字修饰了;3. native
native这个东西本身就和 abstract冲突,他们都是方法的声明,只是一个把方法实现移交给子类,另一个是移交给本地操作系统。如果同时出现,就相当于即把实现移交给子类,又把实现移交给本地操作系统,那到底谁来实现具体方法呢
终于说到了接口！
接口是一种特殊的抽象类,接口中的方法全部是抽象方法(但其前的 abstract可以省略),所以抽象类中的抽象方法不能用的访间修饰符这里也不能用。同时额外说明一下protect关键词4. protect
protected访同修饰符也不能使用,因为接口可以让所有的类去实现(非继承),不只是其子类,但是要用public去修饰。接口可以去继承一个已有的接口。
37.给出一个由 n 个数组成的序列 A[1…n] ，要求找出它的最长单调上升子序列，设 m[i] （ 1 ≤ i ≤ n ），表示以 A[i] 结尾的最长单调上升子序列的长度，则 m[1] = 1 ， m[i] （ 1 < i ≤ n ）为（ ）。
正确答案: A
m[i] = 1 + max{0，m[k]（A[k] < A[i]，1≤k < i ）}
m[i] = 1 + m[k] （k = i - 1 && i > 1）
m[i] = 1 + max{-1，m[k] （A[k] ≤ A[i]，1≤k < i ）}
m[i] = max{0，m[k]（A[k] < A[i]，1≤k < i ）}
38.二叉树为二叉排序树的充分必要条件是其任一结点的值均大于其左孩子的值、小于其右孩子的值，这样的说法正确吗？
正确答案: 不正确
二叉排序树（Binary Sort Tree）又称二叉查找树.它或者是一棵空树；或者是具有下列性质的二叉树：（1）若左子树不空,则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空,则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树
39.使用KMP算法在文本串S中找模式串P是一种常见的方法。假设S=P={xyxyyxxyx}，亦即将S对自己进行匹配，匹配过程中正确的next数组是____。
正确答案:
0,1,1,2,2,1,2,2,3
0,1,2,2,3,1,2,2,3
0,1,1,2,3,1,2,2,3
0,1,1,2,3,1,1,2,3
0,1,2,2,3,1,1,2,3
0,1,2,2,2,1,1,2,3
首先求出最长公共元素长度 0 0 1 2 0 1 1 2 3
求出 next 数组 -1 0 0 1 2 0 1 1 2 KMP 应用 next 数组时，当第 j 个元素不匹配时，模式串右移 j-next[j] 个字符
当求出的 next 数组为 0 1 1 2 3 1 2 2 3 时， KMP 应用 next 数组时，当第 j 个元素不匹配时，模式串右移 j-1-next[j] 个字符
40.对文件名为Test.java的java代码描述正确的是()
class Person {String name = "No name";public Person(String nm) {name = nm;}
}
class Employee extends Person {String empID = "0000";public Employee(String id) {empID = id;}
}
public class Test {public static void main(String args[]) {Employee e = new Employee("123");System.out.println(e.empID);}
}
正确答案: C
输出：0000
输出：123
编译报错
输出：No name
父类没有无参的构造函数，所以子类需要在自己的构造函数中显式调用父类的构造函数，
添加
super(“nm”);
否则报错：
Implicit super constructor Person() is undefined. Must explicitly invoke another constructor
41.关于快速排序算法的说法中，哪几个是正确的：（）
正确答案: B C
时间复杂度最坏是（nlogn)
时间复杂度均摊是(nlogn)
C排序是不稳定的
快速排序的是不稳定的。
快速排序最优的情况下时间复杂度为：O( nlogn )
快速排序最差的情况下时间复杂度为：O( n^2 )
43.下列关于while循环、do-while循环和for循环说法错误的是
正确答案: B C
while循环先执行条件判断，do-while循环执行循环体
do-while循环结束的条件是关键字while后的条件表达式成立
for循环结构中的3个表达式缺一不可
while循环能够实现的操作，for循环也能实现
45.下面哪些Java中的流对象是字节流?
正确答案: A B C D
FileInputStream
BufferedInputStream
PushbackInputStream
ByteArrayInputStream
stream结尾都是字节流，reader和writer结尾都是字符流 两者的区别就是读写的时候一个是按字节读写，一个是按字符。 实际使用通常差不多。 在读写文件需要对内容按行处理，比如比较特定字符，处理某一行数据的时候一般会选择字符流。 只是读写文件，和文件内容无关的，一般选择字节流。
46.下面哪些赋值语句是正确的（）
正确答案: A B D 你的答案: C (错误)
long test=012
float f=-412
int other =(int)true
double d=0x12345678
byte b=128
java中不需要强制向下转型的合法数字类型转换图：core java书中有记载
47.请找出下面代码中的所有错误。说明：以下代码是把一个字符串倒序，如“abcd”倒序后变为“dcba”。
1 #include "string.h"
2 int main()
3 {
4 char *src = "hello,world";
5 char *dest = NULL;
6 int len = strlen(src);
7 dest = (char *)malloc(len);
8 char *d = dest;
9 char *s = src[len];
10 while (len-- != 0)
11 *d++ = *s--;
12 printf("%s", dest);
13 return 0;
14
15}
正确答案: A B C D
第7行要为’\0’分配一个空间
第9行改成char * s = &src[len-1]
第12行前要加上*d = ‘\0’
第13行前要加上free(dest)释放空间
strlen所作的仅仅是一个计数器的工作，它从内存的某个位置（可以是字符串开头，中间某个位置，甚至是某个不确定的内存区域）开始扫描，直到碰到第一个字符串结束符’\0’为止，然后返回计数器值(长度不包含’\0’)
48.需要频繁的插入删除操作使用什么结构比较合适?
正确答案: C
数组
队列
链表
栈
49.对于初始关键字(67,66,77,82,78,51,58),使用二路归并排序,第一趟归并之后其序列变为（ ）
正确答案: B
66,67,77,82,51,58,78
66,67,77,82,51,78,58
51,58,66,67,77,78,82
67,66,77,78,82,51,58
按照顺序两两组合，每个组里两个元素进行排序，最后一个元素落单不去管
50.ArrayLists和LinkedList的区别，下述说法正确的有？
正确答案: A B C D
ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要迭代器。
对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据。
ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！