努力经营当下，直至未来明朗！

---

普通小孩也要热爱生活！

一、选择

1. 以下代码运行输出的是（）

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

A 输出：Person
B 没有输出
C 编译出错
D 运行出错

2. 以下程序的输出结果为（）

class Base{
    public Base(String s){
        System.out.print("B");
    }
}
public class Derived extends Base{
    public Derived (String s) {
        System.out.print("D");
    }
    public static void main(String[] args){
        new Derived("C");
    }
}

A BD
B DB
C C
D 编译错误

3. 在异常处理中，以下描述不正确的有（）

A try块不可以省略
B 可以使用多重catch块
C finally块可以省略
D catch块和finally块可以同时省略

4. 下列哪种说法是正确的？

A 实例方法可直接调用超类的实例方法
B 实例方法可直接调用超类的类方法
C 实例方法可直接调用本类的类方法
D 实例方法可直接调用其他类的实例方法

5. 程序读入用户输入的一个值，要求创建一个自定义的异常，如果输入值大于 10 ，使用 throw 语句显式地引发异常，异常输出信息为 “something’s wrong!” ，语句为（）

A if(i>10)throw new Exception(“something’swrong!”);
B if(i>10)throw Exception e(“something’swrong!”);
C if(i>10) throw new Exception e(“something’swrong!”); > D if(i>10)throw Exception(“something’swrong!”);

6. 以下关于集合类 ArrayList 、 LinkedList 、 HashMap 描述错误的是（）

A HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值
B ArrayList和LinkedList均实现了List接口
C 添加和删除元素时，ArrayList的表现更佳
D ArrayList的访问速度比LinkedList快

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

A 对
B错

---

二、编程

1. 字符串中找出连续最长的数字串

字符串中找出连续最长的字符串

读入一个字符串str，输出字符串str中的连续最长的数字串。

---

2. 数组中出现次数超过一半的数字

数组中出现次数超过一半的数字

给一个长度为 n 的数组，数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。

数据范围：n<=50000 ，数组中元素的值: 0<=val<=10000，
要求：空间复杂度：O(1) ，时间复杂度：O(N)。

---

答案

1. 选择

1. ① Java中对字段属性是静态绑定，方法成员是动态绑定。
   ② 这里错在：在子类中试图访问父类的private字段，所以编译不通过，将private去掉就可访问。不是动态绑定的问题，它本来就属于静态绑定。

故：选C

2. 子类构造方法在调用时必须先调用父类的，由于父类没有无参构造，必须在子类中显式调用。（无参构造方法会隐式调用）

故：选D

拓展：
修改：
① 要么在子类构造方法中显式调用父类构造方法

此时输出BD

② 要么在父类中增加无参构造方法（此时会隐式调用无参构造方法super()）：

此时输出：D
【但是如果子类构造方法中显式调用super(s)，则输出：BD】

3. ① try语句不可以省略。
   ② finally和catch不可以同时省略。
   ③ 可以有多重catch。
   ④ try语句后面必须要有一个别的语句跟在后面。有如下三种：

try-catch
try-finally
try-catch-finally

4. 该题考察的是继承的特性和实例方法、类方法的区别。
   ① 当类的字节码文件加载到内存中时，类的实例方法并没有被分配入口地址，只有当该类的对象创建以后，实例方法才分配了入口地址。
   ② 当类的字节码文件加载到内存，类方法的入口地址就会分配完成，所以类方法不仅可以被该类的对象调用，也可以直接通过类名完成调用。类方法的入口地址只有程序退出时消失。

① 对于A，实例方法不可以调用超类的私有（private）实例方法。
② 对于B，实例方法不可以调用超类的私有（private）类方法。
③ 对于D，同选项A一样的原因。
④ 对于C，本类的类方法优先于实例方法地址的分配，所以实例方法可以调用优先加载的类方法。

故：选C

5. ... throw new Exception("...");
   自定义异常可参考：异常

故：选A

6. ① ArrayList的实现是基于数组，LinkedList的实现是基于双向链表。
   ② 对于随机访问ArrayList要优于LinkedList，ArrayList可以根据下标以O(1)时间复杂度对元素进行随机访问，而LinkedList的每一个元素都依靠地址指针和它后一个元素连接在一起，查找某个元素的时间复杂度是O(N)。
   ③ 对于插入和删除操作，LinkedList要优于ArrayList，因为当元素被添加到LinkedList任意位置的时候，不需要像ArrayList那样重新计算大小或者是更新索引。
   ④ TreeMap和TreeSet的key都不可以为null（因为根据key来排序），但是HashMap中的key、value都可以为null（HashSet中key可以null）。【Set中只存储key】
   参考：Map和Set、ArrayList

故：选C

7. 考虑一个程序中有很多类，只有public修饰的类的类名才与源文件名相同。

故：选B

8. Java是强类型语言，JavaScript是弱类型语言。
   参考：Java和JavaScript

---

2. 编程

1. 字符串中找出连续最长的数字串
   1）思路：
   记录 -> 比较 -> 更新

① 遍历字符串，使用cur去记录连续的数字串，如果遇到不是数字字符，则表示一个连续的数字串结束了；
② 则将数字串跟之前的数字串比较，如果更长，则更新更长的数字串更新到ret。

2）注意点：

① 字符串的拼接 +"";
② 每次统计完一次后要对cur清空，以便下一次统计
③ 要对特殊情况进行单独处理（最后一位还是数字！）

3）代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // str是输入的字符串
        String str = in.nextLine();
        // cur是统计当前最长的字符串
        String cur = "";
        // ret是更新最长的字符串（要存储最终结果）
        String ret = "";
        // 不用单独声明一个统计长度的变量，.length()直接可以统计

        // 遍历字符串
        int i = 0;
        for (; i < str.length(); i++) {
            char ch = str.charAt(i);
            if(ch>='0' && ch<='9') {
                // String是进行字符串的拼接+，注意拼接方式
                cur = cur + ch + "";
            } else  {
                // 说明不是数字，结束本次cur的拼接
                // 并进行判断
                if(cur.length() > ret.length()) {
                    // 更长就更新
                    ret = cur;
                }
                // 不管是长or不长，此时一轮拼接结束，
                // 都要对cur进行清空，让下次来使用
                cur = "";
            }
        }
        // 此时 走到最后
        // 但是可能最后还是数字，但是此时还没来得及比较更新
        // 单独处理
        //处理123abc123456这种情况
        if(i==str.length() && cur.length()>ret.length()) {
            // 更新
            ret = cur;
        }

        System.out.println(ret);
    }
}

---

2. 数组中出现次数超过一半的数字
   1）思路：

① 使用HashMap 或者 数组 统计出现次数
② 排序算法：如果存在，则中间的数字就符合条件。（排完序找到之后统计该数字出现的次数是否满足条件）
③ 相消法，借助次数【推荐】

2）代码：
② 排序算法：
涉及到快排，时间复杂度为O(N*logN)，并非最优。

import java.util.Arrays;

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        // 判空
        if(array == null || array.length == 0) {
            return 0;
        }
        // 计算数组长度以及半长
        int len = array.length;
        int half = len / 2;

        // 进行升序排列
        // 涉及到快排sort，其时间复杂度为O(NlogN
        Arrays.sort(array);

        // 找中间的数字
        // half直接就是超过一半的数组下标
        int midNum = array[half];

        // 遍历统计出现次数是否满足题意
        int count = 0;
        for (int i = 0; i < len; i++) {
            if(array[i] == midNum) {
                count++;
            }
        }
        if(count > half) {
            return midNum;
        }
        return 0;
    }
}

③ 相消法：
时间复杂度: O(N)

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        // 首先判空
        if(array==null || array.length==0) {
            return 0;
        }

        int len = array.length;
        int half = len/2;

        // 进行遍历相消【借助次数】
        int ret = array[0];
        int times = 1;  // 统计次数

        for (int i = 1; i < len; i++) {  // 从1开始：times=1
            // 如果times==0,从新给ret赋值,更新times
            if(times == 0) {
                ret = array[i];
                times++;
            } else if(ret == array[i]) {
                // 相等 times++
                times++;
            } else {
                // 不相等 times--
                times--;
            }
        }

        // 为了以防万一，再次进行统计次数
        times = 0;
        for (int i = 0; i < len; i++) {
            if(ret == array[i]) {
                times++;
            }
        }

        // 返回
        return (times>half)? ret:0;
    }
}

① HashMap方法参考：
参考第4题