java回顾和leetcode刷题(一)

1、继承

1.1重写和重载的区别

1.1.1 重写（Override）

• (1)、发生在父类与子类之间
• (2)、方法名相同，参数列表相同（参数顺序、个数、类型），方法返回值相同
• (3)、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private)
• (4)、与方法的参数名无关
  其实就是在子类中把父类本身有的方法重新写一遍（把那些不适合子类自己的方法再写一遍）

示例如下：

public class Father {

    public static void main(String[] args) {
        Son s = new Son();
        s.sayHello();
    }

    public void sayHello() {
        System.out.println("Hello");
    }
}

class Son extends Father{

    @Override
    public void sayHello() {
        System.out.println("hello Son");
    }

}

1.1.2 重载（Overload）

• (1)、重载Overload是一个类中多态性的一种表现
• (2)、方法名相同，参数列表不同(参数的顺序，参数的个数，参数的类型)
• (3)、方法返回值随意
• (4)、与方法的参数名无关

public class Father {

    public static void main(String[] args) {
        Father s = new Father();
        s.sayHello();
        s.sayHello("wintershii");
    }

    public void sayHello() {
        System.out.println("Hello");
    }

    public void sayHello(String name) {
        System.out.println("Hello" + " " + name);
    }
}

面试时候提问（烤面筋里面的）

重载（overload）和重写（override）的区别？重载的方法能否根据返回类型进行区分
方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。
方法重载的规则：
1.方法名一致，参数列表中参数的顺序，类型，个数不同。
2.重载与方法的返回值无关，存在于父类和子类，同类中。
3.可以抛出不同的异常，可以有不同修饰符。
方法重写的规则：
1.参数列表必须完全与被重写方法的一致，返回类型必须完全与被重写方法的返回类型一致。
2.构造方法不能被重写，声明为final的方法不能被重写，声明为static的方法不能被重写，但是能够被再次声明。
3.访问权限不能比父类中被重写的方法的访问权限更低。
4.重写的方法能够抛出任何非强制异常（UncheckedException，也叫非运行时异常），无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

1.2访问修饰符

继承的概念

1、一种类与类之间的关系
2、使用已存在的类的定义作为基础建立新类
3、新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类

leetcode（一）

假设对一组数据进行排序

快速排序算法 O（nlogn）

• 环境1:这组数据包含着大量重复的元素，三路快排是更好的选择
• 环境2：这组数据包含着普通的元素。普通的快速排序就可以解决
• 环境3：是否大部分数据距离它正确的位置很近？是否近乎有序？（按照银行的业务来进行排序），插入排序是更好的选择
• 环境4：对高考成绩进行排序。由于分值在0–750分之内的，计数排序是更好的选择
• 环境5：对排序是否有额外的要求，比如是都需要稳定排序，这个时候快排不适合，归并排序是更好的选择
• 环境6：数据是使用链表来进行存储的，归并排序是更好的选择
• 环境7：数据的大小是否可以装载在内存里？
  数据量很大，或者内存很小，不足以装载在内存里，需要使用外排序算法。

先去leetcode官网上面看看

leetcode 第一题 Two Sum

解法1：使用暴力法

Your runtime beats 11.83 % of java submissions(较为一般)

时间复杂度：O（n^2）
解题思路：使用暴力法，双重for循环。第一个for循环，就是整个数组的长度，第二个for循环，就是j+1到nums.length为止。然后两个数组的下标对应相加看看是不是等于target,代码如下：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target)
                    return new int[] { i, j };
            }
        }
        return null;
    }
}

解法2：两遍哈希表

这里回顾一下HashMap的知识，详情看这个链接
https://www.jianshu.com/p/ee0de4c99f87

public class HashMapTest {
    /**
     * @ Description
     * (1)、键值对存储一组对象
     * (2)、key是唯一的，value可以有重复的
     * (3)、具体的实现类： HashMap、 TreeMap、Hashtable、 LinkedHashMap
     **/
    public static void hashMap() {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "hws");
        map.put(2, "zsm");
        map.put(3, "hyj");

        System.out.println("map的长度是" + map.size());

        //方法一：获得value ,通过key去取value
        System.out.println("第一个值是：" + map.get(1));

        //方法二：通过遍历的方式去取值
        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        for (Map.Entry e : entrySet) {
            System.out.println(e.getKey() + "-->" + e.getValue());
        }
        System.out.println("======================");

        //方法三：keySet()来取值
        Set<Integer> keySet = map.keySet();
        for (Integer k : keySet) {
            String value = map.get(k);
            System.out.println(k + "-->" + value);
        }
        System.out.println("======================");

    }

    public static void main(String[] args) {
        hashMap();
    }
}

正式解题:

Your runtime beats 72.63 % of java submissions
代码如下：

class Solution {
    public int[] twoSum(int[] nums, int target) {
       HashMap<Integer, Integer> map = new HashMap<>();
       for (int i = 0; i < nums.length; i++) {
           map.put(nums[i], i);
       } 
       for (int i = 0; i < nums.length; i++) {
           int complement = target - nums[i];
           if(map.containsKey(complement) && map.get(complement) != i){
               return new int[]{i,map.get(complement)};
           }
       }
       throw new IllegalArgumentException("no this sum");
    }
}

解法3：一遍哈希表

思路：所求的两个值，一旦有一个已经在哈希表中，那么另一个值便可在数组遍历过程中找出

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] res = new int[2];
        if(nums == null || nums.length<2)
            return res;
        HashMap<Integer,Integer> map = new HashMap<Integer, Integer>();
        for(int i=0; i<nums.length; i++) {                      
            if(map.containsKey(target-nums[i])) {
                res[0] = map.get(target-nums[i]);
                res[1] = i;
                return res;
            }
            map.put(nums[i],i); 
        }
        return res;
    }
}