本文介绍了Java方法重写的规则，包括参数列表、返回类型和访问权限的要求，并讨论了哪些方法可以被重写。接着，文章分析了各种排序算法的稳定性，如冒泡排序、快速排序等。此外，还涵盖了数据操作语言（DML）、数据定义语言（DDL）和数据控制语言（DCL）的概念。最后，文章提到了Java多线程中的变量声明和并发安全，以及JSON表示Java对象的方法。
昨日题目回顾：用友2018秋招Java笔试题(二)
1
正确答案B C
答案解析
方法重写参数列表必须完全与被重写方法的相同；
返回类型必须完全与被重写方法的返回类型相同；
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
父类的成员方法只能被它的子类重写。
声明为final的方法不能被重写。
声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。
方法重载被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。
2
正确答案 D
3
正确答案 A B D
4
正确答案 B C D
5
正确答案 A B D
答案解析
A B D显然都是对的。主要说C选项：
在JDK1.8之前的版本(不包括JDK1.8)，接口中不能有静态方法，抽象类中因为有普通方法，故也可以有静态方法。
在JDK1.8后(包括JDK1.8)，在抽象类中依旧可以有静态方法，同时在接口中也可以定义静态方法了。
以下代码在JDK1.8之后是没有问题的(可以通过接口名来调用静态方法 ：Main.prinf(); )：
public interface Demo{
public static void print() {
System.out.println("Hello World!"); }
}
6
正确答案 C D
答案解析
A：线性表有两种存储方式，一种是顺序表一种是链式表，只有用顺序表时，逻辑顺序才和物理顺序一致
B：顺序存储在内存中是连续的，缺点插入较慢，不可扩容。链式存储并不是连续的，但是因为指向所以占用内存较大。没有特定比较，很难说谁更好
7
正确答案 C D
8
正确答案 B D
答案解析
(1) 冒泡排序
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改 变，所以冒泡排序是一种稳定排序算法。
(2) 选择排序
选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个 元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么 交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9， 我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。
(3) 插入排序
插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开 始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相 等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳 定的。
(4) 快速排序
快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。而右边的j下标一直往左走，当a[j] > a[center_index]。如果i和j都走不动了，i <= j, 交换a[i]和a[j],重复上面的过程，直到i>j。 交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为 5 3 3 4 3 8 9 10 11， 现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j] 交换的时刻。
(5) 归并排序
归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有 序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定 性。那么，在短的有序序列合并的过程中，稳定是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结 果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。
(6) 基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优 先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。
(7) 希尔排序(shell)
希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小， 插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元 素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。
(8) 堆排序
我们知道堆的结构是节点i的孩子为2*i和2*i+1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n 的序列，堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n /2-1, n/2-2, ...1这些个父节点选择元素时，就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没 有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法。
综上，得出结论: 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。
9
正确答案 B C
答案解析
DML(data manipulation language)，数据操作语言，如增删该查
DDL(data definition language)，数据定义语言，如建表删表，修改表字段(改变表结构)
DCL(data control language)，数据控制语言，如权限授权
10
正确答案 C
11
正确答案新建状态、就绪状态、运行状态、阻塞状态及死亡状态。
12
正确答案
true
false
13
正确答案
浅克隆：通常只是对克隆的实例进行复制，但里面的其他子对象，都是共用的。
深克隆：克隆的时候会复制它的子对象的引用，里面所有的变量和子对象都是又额外拷贝了一份。
14
正确答案
下表总结了Java NIO和IO之间的主要差别，我会更详细地描述表中每部分的差异。
Java NIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。
Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。
Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。
15
正确答案
Java虚拟机规范中将Java运行时数据分为6种。
1. 程序计数器：是一个数据结构，用于保存当前正常执行的程序的内存地址。Java虚拟机的多线程就是通过线程轮流切换并分配处理器时间来实现的，为了线程切换后能恢复到正确的位置，每条线程都需要一个独立的程序计数器，互不影响，该区域为“线程私有”。
2. Java虚拟机栈：线程私有的，与线程生命周期相同，用于存储局部变量表，操作栈，方法返回值。局部变量表放着基本数据类型，还有对象的引用。
3. 本地方法栈：跟虚拟机栈很像，不过它是为虚拟机使用到的Native方法服务。
4. Java堆：所有线程共享的一块内存区域，对象实例几乎都在这分配内存。
5. 方法区：各个线程共享的区域，储存虚拟机加载的类信息，常量，静态变量，编译后的代码。
6. 运行时常量池：代表运行时每个class文件中的常量表。包括几种常量：编译时的数字常量、方法或者域的引用。
16
正确答案
public class Prog {
public static void main(String[] args) {
String[] team1 = {"a","b","c"};
String[] team2 = {"x","y","z"};
for(int i=0; i<3; i++){
for(int j=0; j<3; j++){
if(i == 0 && j == 0)//a说他不和x比 continue;
else if(i == 2 && (j == 0 || j == 2))
continue;//c说他不和x,z比 else{
System.out.println(team1[i] + "" + team2[j]);
}
}
}
}
}
17
正确答案
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
private Singleton(){}
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问 public static Singleton getInstance() {
return instance;
}
}
第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次//使用时生成实例，提高了效率！if (instance==null)
instance＝new Singleton();
return instance;}
}
18
正确答案
多种实现方式，没有标准答案。关注线程的写法,队列的实现方式
1
以下哪种JAVA得变量声明方式可以避免程序在多线程竞争情况下读到不正确的值( )
A.volatile
B.static volatile
C.synchronized
D.static
2
以下代码的运行结果是什么( )
class Supper{
public int get()
{
System.out.println("Supper");
return 5;
}
}
public class Sub{
public int get()
{
System.out.println("Sub");
return new Integer("5"); }
public static void main(String args[]) {
new Supper().get();
new Sub().get(); }
}
A.Supper Sub
B.Supper 5 Sub
C.Supper 5 5 Sub
D.Supper Sub 5 5
3
以下JAVA程序的运行结果是什么( )
public static void main(String[] args) {
Object o1 = true ? new Integer(1) : new Double(2.0);
Object o2;
if (true) {
o2 = new Integer(1);
} else {
o2 = new Double(2.0);
}
System.out.print(o1);
System.out.print(" ");
System.out.print(o2);
}A.1 1
B.1.0 1.0
C.1 1.0
D.1.0 1
4
以下哪种JAVA的变量表达式使得变量a和变量b具有相同的内存引用地址( )A.String a = "hello"; String b = "hello";
B.Integer a; Integer b = a;
http://C.int a = 1; Integer b = new Integer(1);
http://D.int a = 1; Integer b = 1;
5
下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：( )A.java.util.ConcurrentHashMap
B.java.util.Map
C.java.util.TreeMap
D.java.util.SortMap
E.java.util.Hashtable
F.java.util.HashMap
6
关于下面程序，哪些描述是正确的: ( )
public class While {
public void loop() {
int x= 10;
while ( x ) {
System.out.print("x minus one is " + (x - 1));
x -= 1;
}
}
}A.行1有语法错误
B.行4有语法错误
C.行5有语法错误
D.行6有语法错误
E.行2有语法错误,loop是关键字
F.程序能够正常编译和运行
7
根据下面这个程序的内容，判断哪些描述是正确的：( )
public class Test {
public static void main(String args[]) {
String s = "tommy";
Object o = s;
sayHello(o); //语句1sayHello(s); //语句2}
public static void sayHello(String to) {
System.out.println(String.format("Hello, %s", to));
}
public static void sayHello(Object to) {
System.out.println(String.format("Welcome, %s", to));
}
}A.这段程序有编译错误
B.语句1输出为:Hello, tommy
C.语句2输出为:Hello, tommy
D.语句1输出为:Welcome, tommy
E.语句2输出为:Welcome, tommy
F.根据选用的Java编译器不同，这段程序的输出可能不同
8
下面哪些描述是正确的：( )
public class Test {
public static class A {
private B ref;
public void setB(B b) {
ref = b;
}
}
public static Class B {
private A ref;
public void setA(A a) {
ref = a;
}
}
public static void main(String args[]) {
…
start();
….
}
public static void start() { A a = new A();
B b = new B();
a.setB(b);
b = null; //a = null;
…
}
}A.b = null执行后b可以被垃圾回收
B.a = null执行后b可以被垃圾回收
C.a = null执行后a可以被垃圾回收
D.a,b必须在整个程序结束后才能被垃圾回收
E.类A和类B在设计上有循环引用，会导致内存泄露
F.a, b 必须在start方法执行完毕才能被垃圾回收
9
关于下面这段Java程序，哪些描述是正确的：( )
public class ThreadTest extends Thread {
public void run() {
System.out.println("In run");
yield();
System.out.println("Leaving run");
}
public static void main(String []argv) {
(new ThreadTest()).start();
}
}A.程序运行输出只有In run
B.程序运行输出只有Leaving run
C.程序运行输出先有In run后有Leaving run
D.程序运行输出先有Leaving run后有In run
E.程序没有任何输出就退出了
F.程序将被挂起，只能强制退出
10
在HTTP请求响应header中，以下哪些状态码表示请求失败( )
A.200
B.500
C.502
D.404
11
64位操作系统理论上最多可以管理()GB内存。
12
一个台阶总共有10级，如果一次可以跳1级，也可以跳2级。求总共有()种跳法？
13
SQL92标准定义的最严格的事务级别是？
14
Java中如果一个public 类的protected方法的可见性是？
15
JSON是一种非常流行的文本格式的数据编码方式，下面有一个Java类Person
public class Person { private String name; private int age; private boolean married; public Person(String name, int age, boolean married) { this.name = name; this.age = age; this.married = married; } public String getName() { return name; } public void setName(String n) { this.name = n; } public void setAge(int a) { this.age = a; } public int getAge() { return age; } public void setMarried(boolean flag) { this.married = flag; } public isMarried() { return married; } }
把下面这个对象ps
Person[] ps = new Person[] {new Person(“tommy”, 16, false”)}
用JSON表式出来(JSON种不用表示类型信息，只表示结构信息即可)
16
SQL性能优化
Customer表定义如下
CREATE TABLE test01 (
custidint(10) NOT NULL, custname varchar(100) NOT NULL,
datedatetime default NULL, money int(10) default NULL,
PRIMARY KEY (custid),
KEY index_test01_custname (custname),
KEY index_test01_custname_union (money,date,custname,),
)
secondinfo 表定义如下
CREATE TABLE test02 (
secidint(10) NOT NULL, firstid int(10) NOT NULL,
custidint(10) default NULL, PRIMARY KEY (secid), KEYIndex_test02_custid(custid `)
)
下列SQL执行速度比较慢，请分析原因并做优化：
1) SELECT * FROM test01 WHERE substring(custname,1,4)='beizhi';
2) SELECT * FROM test01 WHERE money/30<1000; 3) SELECT * FROM test01 WHERE custname=3721; 4) SELECT * FROM test02 s WHERE s.custid NOT IN (SELECT c.custid FROM test01 c); 5) select * from test01 where money<1000 union select * from test01 where date >’20150101’;
来源：公众号
作者：动力节点Java资源库
509
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
