java每日一练(3)

单选部分 ：

 

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

public class Person{
    private 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);
    }
}

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

答案 C ：

 
这里我们通过 Person p = new Child() ， 此时相当于父类引用引用了子类对象， 但是我们的 name字段是被private修饰的，只能在Person内使用，所以这里会直接报错，也就是编译出错 ， 通过编译器 也就非常明显了.

 
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 : 编译错误

这里考的就是继承中的 创建子类对象时会通过子类的构造方法先帮助父类进行构造， 但题目中的父类拥有带一个参数的构造方法， 所以此时就不会提供不带参数的构造方法，但因为我们的子类中没有通过super(s) 帮助父类进行构造所以此时就会报错编译错误.

放在 编译器上也能很明显的看到 ：

3.下面关于构造方法的说法不正确的是 ()

A 构造方法也属于类的方法，可以创建对象的时候给成员变量赋值

B 构造方法不可以重载

C 构造方法没有返回值

D 构造方法一定要和类名相同

 

这里 B 一看就是错误的，这里我们的构造方法可以有多个， 不带参数 ，带一个参数 等，此时不就满足了我们重载的定义了吗，
 
重载 ： 方法名相同， 返回类型不做要求， 参数类型 和 参数个数不同 .

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

 
A try块不可以省略

B 可以使用多重catch块

C finally块可以省略

D catch块和finally块可以同时省略

 
答案 ： 这里 catch 是不能省略的，本来就是通过catch来捕获我们的异常，如果它都省略了，那么咋来处理异常呢？ 所以很明显直接选 D

finally ：是可以省略的，如果加上了finally 那么就一定会执行 finally中的代码.

 
5.下列描述中，错误的是

 
A SQL语言又称为结构化查询语言

B java中”static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问

C 面向对象开发中，引用传递意味着传递的并不是实际的对象，而是对象的引用，因此，外部对引用对象所做的改变不会反映到所引用的对象上

D java是强类型语言，javascript是弱类型语言

E 面向对象的三大特性包括：封装，继承，多态

 

答案 ： C ， 这里外部对引用对象的改变会反映到我们的对象上 。

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

 

A 实例方法可直接调用超类的实例方法

B 实例方法可直接调用超类的类方法

C 实例方法可直接调用本类的类方法

D 实例方法可直接调用其他类的实例方法

 
答案 ： A ： 这里我们实例方法想要调用超类(父类)的实例方法需要通过 super. 来调用，所以这里是错误的

B : 实例方法不能直接调用超类的 类方法(也就是 被 static 修饰的方法) ,这里就需要通过类名进行调用 如 ：Test.sum

C ：正确，我们可以在同一个类中直接调用

 
D ： 我们实例方法去调用其他类的实例方法需要其他类的对象才能调用，所以D也是错的

 
7.请问输出的结果是：
 

String str1="hello";

String str2="he"+ new String("llo");

System.out.println(str1==str2);

 
A true

B 都不对

C null

D false

 
这里主要考察 字符串常量池 与 == 比较是否为一个对象， str1 就会将 hello 放入到字符串常量池中，但是 str2 中 he 拼接了 一个 llo 就会产生一个新的对象
 
所以 == 两边 不是同一个对象，所以 打印的 结果为 false

 
8.程序读入用户输入的一个值，要求创建一个自定义的异常，如果输入值大于 10 ，使用 throw 语句显式地引
发异常，异常输出信息为 ”something’swrong!” ，语句为（）
 
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!”);

 
这里主要考 如何抛出异常， 很明显答案 为 A

 
9.以下关于集合类 ArrayList 、 LinkedList 、 HashMap 描述错误的是（）
 
A HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值

B ArrayList和LinkedList均实现了List接口

C 添加和删除元素时，ArrayList的表现更佳

D ArrayList的访问速度比LinkedList快

 
答案 ： C ： ArrayList底层是一个数组，每次增加和删除元素都需要挪动元素，时间复杂度能达到 O(N)

A ： 在 Map 那章说过， HashMap 是可以 将null当作 键和值的

B : ArrayList 和 LinkedList 是实现了List接口的， 这里再初始数据结构那文，有一张图 上面就可以看到

D : 大部分情况下 ArrayList是比 LinkedList快的，因为我们的数组是执行随机访问的。

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

 
A 对 B 错
 
这里的 B 就与我们的存放该类的文件名不同，所以这里就为 B

 

编程题

 
题目一 ：字符串中找出连续最长的数字串_牛客题霸_牛客网 (nowcoder.com)

本题比较简单 直接来看代码 ：

   public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        int left = 0;
        int right = 0;
        int count = 0, max = 0;
        String str2 = new String();
        for (int i = 0; i < str.length(); i++) {

            if (str.charAt(i) < '0' || str.charAt(i) > '9') {
                // 此时是字母部分 :
                continue;
            }
            // 此时是数字部分
            left = i;
            while (i < str.length() && !(str.charAt(i) < '0' || str.charAt(i) > '9')) {
                i++;
                count++;
            }
            // 此时 走到了 i 为字母的地方
            count = i - left;
            right = i;
            if (count > max) {
                // 更新 数字字符串
                str2 = str.substring(left, right);
                max = count;
                count = 0;
            }
            i = i - 1;

        }
        System.out.println(str2);
    }

 
题目二 ：数组中出现次数超过一半的数字_牛客题霸_牛客网 (nowcoder.com)

 
本题也非常简单， 我们只需要排序后 ，取中间的数即可，(树超过数组长度的一半所以，必定为中间数), 但正因为此我们需要让排序达到最优的时间复杂度就可以采用快排 ：注意 这里题目说了数组中有一个数字出现的次数超过了数字长度的一半所以这里我们省略再遍历一次,去判断这个中间数是否真的出现次数大于 numbers.length / 2

 
最好自己实现一下我们的快排 :

  public static int MoreThanHalfNum_Solution(int[] numbers) {
        // write code here
        if (numbers == null || numbers.length == 0) {
            return -1;
        }
        quickSort(numbers, 0, numbers.length - 1);
        return numbers[numbers.length / 2];
    }


    public static void swap(int[] arr, int start, int end) {
        int tmp = arr[start];
        arr[start] = arr[end];
        arr[end] = tmp;
    }

    public static void quickSort(int[] arr, int start, int end) {
        if (start >= end) {
            return;
        }
        // 三数取中
        int mid = fidMid(arr, start, end);
        swap(arr, start, mid);
        int p = fid(arr, start, end);
        quickSort(arr, start, p - 1);
        quickSort(arr, p + 1, end);
    }

    public static int fidMid(int[] arr, int start, int end) {
        int mid = start + ((end - start) >>> 1);
        if (arr[start] < arr[end]) {
            if (arr[mid] < arr[start]) {
                return start;
            } else if (arr[end] < arr[mid]) {
                return end;
            } else {
                return mid;
            }
        } else {
            // arr[start] > arr[end]
            if (arr[mid] < arr[end]) {
                return end;
            } else if (arr[start] < arr[mid]) {
                return start;
            } else {
                return mid;
            }
        }
    }

    // 找基准
    public static int fid(int[] arr, int start, int end) {
        int tmp = arr[start];
        while (start < end) {
            while (start < end && arr[end] >= tmp) {
                end--;
            }
            arr[start] = arr[end];
            while (start < end && arr[start] <= tmp) {
                start++;
            }
            arr[end] = arr[start];
        }
        // 此时 end == start
        arr[end] = tmp;
        return end;
    }

 
另外一种思路 ：

 
众数：就是出现次数超过数组长度一半的那个数字
如果两个数不相等，就消去这两个数，最坏情况下，每次消去一个众数和一个非众数，那么如果存在众数，
最后留下的数肯定是众数。

public class Solution {
    public int MoreThanHalfNum_Solution(int[] array) {
        if (array == null || array.length == 0) {
            return -1;
        }
        int result = array[0];
        int times = 1;
        for (int i = 1; i < array.length; i++) {
            if (times != 0) {
                // 向后判断  result 与 array[i] 是否相同
                if (result == array[i]) {
                    times++;
                } else {
                    // 此时不相等 ,如果 times 为 0 下次进入 if 语句就会直接走到
                    // else 更新 result 
                    times--;
                }
            } else {
                // 此时 times == 0 就需要更新 我们的 result
                result = array[i];
                times = 1;
            }
        }
        // 此时 遍历完数组 result 就是我们的中间数 另外需要判断一下
        times = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == result) {
                times++;
            }
        }
        return times > array.length / 2 ? result : 0;
    }
}