1. 多层继承问题

2. 继承中子类的构造要引用super

3. == 比较地址

4. 字符串中找出连续最长的数字串(编程题)

5. 数组中出现次数超过一半的数字（编程题）

6. 另类加法（编程题）

7. Interface 接口中定义方法

8. 实现或继承Collection接口的类

9. 类实现的接口修饰符不能是final

10. 计算糖果（编程题）

11. 进制转换（编程题）

12. 数组复制效率最高：System.arraycopy

1. 多层继承问题

子类继承父类，然后再多往下被继承一次，对这三个实例化，没问题

因为java继承中是支持多层继承的（注意不支持多重继承）

2. 继承中子类的构造要引用super

写子类构造方法，必须要用super

具体还不明白的铁子，可以看我这篇博客，里面对于继承有很好的分析

http://t.csdn.cn/bqINn

我之前对于子类构造是这样总结的

子类对象成员是由两部分组成：

🟧子类对象构造时，需要先调用父类构造方法，将从父类继承下来的成员构造完整，

然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整。

⚜️提几点注意：

🤠（1）如果父类执行默认的构造方法，那么在子类构造方法的第一行默认含有super()的调用

🤠（2）如果父类构造方法是带有参数的，此时编译器给子类不会执行默认的构造方法，

这就要程序员自己给子类定义构造方法了

🤠（3）在子类构造方法中，super()调用父类构造时，必须是子类构造方法中第一条语句。

🤠（4）super()只能在子类构造方法中出现一次，并且不能和this同时出现

3. == 比较地址

==比较的是地址， str1 是放在常量池中的，而str2 这里有new所以是放堆中的，两个指向的不是一个对象

== 比较的是地址！！！不要看内容一样就选true！！！

4. 字符串中找出连续最长的数字串(编程题)

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

题目要求：

题目分析：

上代码

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();

        String cur = "";
        String ret = "";

        for(int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);
            if(ch >='0' && ch <= '9') {
                cur += ch;
            }else {
                if(cur.length() > ret.length()) {
                    ret = cur;
                }
                cur = "";
            }
        }
        //走到这里还需要比较一次,因为
        //如果i走到最后面有一个最长的数字字符串，这只会存到cur中
        if(cur.length() > ret.length()) {
            ret = cur;
        }
        System.out.println(ret);
    }
}

5. 数组中出现次数超过一半的数字（编程题）

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

题目要求：

题目分析：

两个思路

（1）排序

a）先排序，找到中间的数字X

b）再次遍历这个数组，看一下这个X出现了多少次

如果存在，那么遍历的结果，这个数字肯定会出现次数超过一半

（2）两个数字相抵消

如果两个数字不相等，就消去这两个数，最坏情况下

每次消去一个众数和一个非众数，那么如果存在众数，最后留下的数肯定是众数

在最后剩下的这个数，还需要再遍历一下，看这个数出现的次数超过一半了没

如果超过了一半，那就存在，如果没超过一半。就不存在

上代码

（1）排序

import java.util.Arrays;

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

        Arrays.sort(array);
        int len = array.length;
        int count = 0;
        for(int i = 0; i < len; i++) {
            if(array[len/2] == array[i]) {
                count++;
            }
        }
        if(count > len/2) {
            return array[len/2];
        }
        return 0;
    }
}

（2）两个数字相抵消

import java.util.Arrays;

public class Solution {
    public int MoreThanHalfNum_Solution1(int [] array) {
        if(array == null || array.length == 0) {
            return 0;
        }

        Arrays.sort(array);
        int len = array.length;
        int count = 0;
        for(int i = 0; i < len; i++) {
            if(array[len/2] == array[i]) {
                count++;
            }
        }
        if(count > len/2) {
            return array[len/2];
        }
        return 0;
    }

     public int MoreThanHalfNum_Solution(int [] array) {
         if(array == null || array.length == 0) {
             return 0;
         }

        int result = array[0];
        int times = 1;

        for(int i = 1; i < array.length; i++) {
            if(times != 0) {
                if(array[i] != result) {
                    times--;
                }else {
                    times++;
                }
            }else {
                result = array[i];
                times = 1;
            }
        }

        int count = 0;
        //再次判断剩下的这个数，有没有数组长度的一半
        for(int i = 0; i < array.length; i++) {
            if(array[i] == result) {
                count++;
            }
        }
        if(count > array.length/2) {
            return result;
        }
        return 0;
     }
}

6. 另类加法（编程题）

题目链接： 另类加法__牛客网 (nowcoder.com)

题目要求：

题目分析：

上代码

import java.util.*;

public class UnusualAdd {
    public int addAB(int A, int B) {
        if(B == 0) {
            return 0;
        }
        int sum = 0;//本位
        int carray = 0;//进位
        while(B != 0) {
            sum = A^B;
            carray = (A&B)<<1;
            A = sum;
            B = carray;
        }
        return A;
    }
}

7. Interface 接口中定义方法

这个题选 A、C、D

这个先回顾一下，接口的特性

（1）接口当中的成员变量，默认都是 public static final 修饰的

（2）接口中的成员方法，默认都是抽象方法，也就是public abstract 修饰的

（3）接口中的普通成员方法，是不能有具体的实现的

（4）接口中的普通成员方法，如果要有具体实现，就必须加上default【从JDK8开始】

（5）接口中可以有静态的成员方法，但是不管是静态方法还是default方法都是public修饰

（6）接口本身也是不可以进行实例化的

（7）类和接口的关系是使用 implements 来关联的

（8）接口中不能有静态代码块，实例代码块，构造方法

（9）一个抽象类实现一个接口，可以不重写这个抽象方法，但是这个类一旦被使用，就也要重写构造方法

针对这个题来说，

所以，选ACD，我当时做的时候选了个C、D，没选A是因为看见了main方法，以为接口中是不能有main方法的，现在看来这个main方法没有实现啊！！！

8. 实现或继承Collection接口的类

这道题选B、C

9. 类实现的接口修饰符不能是final

接口不能被final修饰，接口的作用就是被实现重写的

而final的作用就是

（1）final修饰类：表示该类不能被继承（修饰的类也叫做“断子绝孙类”）

（2）final修饰方法：表示方法不能被重写（但可以被继承）

（3）final修饰变量：表示变量只能一次赋值以后，值不能被修改（常量）

a. 当final修饰的是基本数据类型：这个数据的值在初始化后将不能被改变

b. 当final修饰的是引用数据类型：修饰一个对象时，引用在初始化后将永远指向一个内存地址，不能被修改。但是该内存地址中保存的对象信息，是可以进行修改的

也就是基本数据类型，值不能改；引用数据类型，地址不能改，内容可以改

10. 计算糖果（编程题）

题目链接：计算糖果_牛客题霸_牛客网 (nowcoder.com)

题目要求：

题目分析：

上代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int[] array = new int[4];
        for(int i = 0; i < 4; i++) {
            array[i] = in.nextInt();
        }
        int A,B,C,D;
        A = (array[0] + array[2])/2;
        B = (array[1] + array[3])/2;
        C = (array[3] - array[1])/2;

        if((array[0] == A - B) && (array[1] == B - C) && (array[2] == A + B) && (array[3] == B + C)) {
            System.out.println(A + " " + B +" " + C);
        }else {
            System.out.println("No");
        }
    }
}

11. 进制转换（编程题）

题目链接：进制转换_牛客题霸_牛客网 (nowcoder.com)

题目要求：

题目分析：

上代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();

        StringBuilder sb = new StringBuilder();
        String table = "0123456789ABCDEF";
        boolean flag = true;
        if(m == 0) {
            System.out.println("0");
        }
        if(m < 0) {
            m = -m;
            flag = false;
        }
        while(m != 0) {
            sb.append(table.charAt(m%n));
            m /= n;
        }

        if(!flag) {
            sb.append("-");
        }

        System.out.println(sb.reverse().toString());
    }
}