2020年3月7日：Java

第一节：接口与继承

知识点1：
接口是一种约定，接口里的方法不列出来，具体为什么要用到接口要从多态的内容去了解。

知识点2：
继承类之间转换上级不一定能转化为下级、没有继承关系的一定会失败。

知识点3：
重写提高了写代码的效率

知识点4：
多态类的特点：继承父类，且重写父类方法， 使用的时候只需要用父类去指向子类就行了。

知识点5：
隐藏就是把父类的类方法重写了

知识点6：
父类和子类如果都有构造方法会先执行父类的。

知识点7：
super调用父类的有参构造方法super（ ）；  super.属性返回父类的属性；super.父类方法调用父类方法。

知识点8：
所有的类都继承自Object，toString返回当前字符串，finalize方法垃圾自动回收机制，h1.equals(h2)判断两个对象内容是否相似，

知识点9：
final修饰类，类不会被继承。被final修饰的方法不能被重写。final修饰基本类型变量只能赋值一次，static final int 一个常数常用

抽象类定义：在一个类中没有方法体用abstract修饰。所属类也被abstract修饰
特点：如果有子类继承抽象类所属类，则必须@Override这个方法；抽象类中不一定非得有抽象方法；不能直接被实例化；跟接口差不多。子类只能继承一个抽象类
接口的定义：同一个方法不同的实现方式，可以设置无方法体的方法也可以设置有方法体的方法（JDK8新特性）。
特点：子类可实现多个接口，只能用public  static final这三种修饰

非静态内部类定义：类里面有一个类（名称很复杂，是相对静态内部类而言）
特点：这个内部类必须是有对象存在才有意义，存在的目的是对类对象的划分吧。
使用方法：内部类名  引用= 实例引用.new 内部类名(); Score score = meixi.new Score();

静态内部类定义：类不需要实例化就可以实现。
特点：不能随便用类外边的属性（属性加static可以）
使用方法：Hero.EnemyCrystal crystal = new Hero.EnemyCrystal();

匿名类定义：声明类的时候自动实例化这个匿名类。
特点：类有abstract修饰，类里面有个抽象方法没有方法体，匿名类中使用外部变量时要用final修饰看上去不能改。
使用方法：

     Hero h = new Hero(){
            //当场实现attack方法
            public void attack() {
                System.out.println("新的进攻手段");
            }
        };

本地类的定义：是在main方法体里面的类且extends上面的类
特点：可以任意位置放，for循环里，方法体里等。
使用方法：

     public static void main(String[] args) {
        class SomeHero extends Hero{
            public void attack() {
                System.out.println( name+ " 新的进攻手段");
            }
        }
    }

默认方法：接口里面实现方法具体的细节
特点：如果一个对象同时继承2个接口，2个接口都有同名的默认方法，那么这个对象实现就可以自己重现自己的方法。

 

二、JAVA基础之集合框架：

为什么存在集合：
数组的局限：1.声明对象后用少了浪费，用多了不够。

ArrayList定义：存放类的容器
使用条件：import java.util.ArrayList
特点：capacity会随着容量不断增长
使用方法（其他方法去查）：

        ArrayList heros = new ArrayList();
        heros.add( new Hero("盖伦"));

List接口定义：是ArrayList的父类
使用条件： import  java.util.List
使用方法：

 List heros = new ArrayList();

思考：List是接口一般不提供默认方法，用ArrayList提供方法。

 

泛型Generic
出现泛型的原因：就是在容器里面如果没有泛型，那么存的数据会很乱。起到分类整理的作用。
使用方法：

    List<Hero> genericheros = new ArrayList<Hero>();

思考：只能List加泛型吗？好像是。
泛型的简写：List<Hero> genericheros2 = new ArrayList<>();  后面的<>可以放Hero，但没必要。
 

三种遍历方法：
1.for循环
2.iterator迭代器遍历
定义：用hasNext去判断这个位置是否有对象
使用条件：import java.util.Iterator
使用方法：

        Iterator<Hero> it = heros.iterator();
        while(it.hasNext()){
            Hero h = it.next();
            System.out.println(h);
        }

3. ☆增强型for循环：
使用方法：

        for (Hero h : heros) {//heros就是集合的引用非常非常方便
            System.out.println(h);
        }

iterator和for增强型是不能删除数据的，那怎么办呢？这么办：

    //把符合要求的数据存入deletingHeros里头，在一个增强型for循环了，用heros去语出deletingHeros里的对象。完美
    for (Hero h : deletingHeros) {
            heros.remove(h);
        }

LinkedList定义：同ArrayList实现了List接口
特点：两种结构：
1.双向链表（Deque):方便在头尾插入删除数据
使用条件：import java.util.LinkedList;
2.先进先出队列（Queue)：
3.根据Queue方法可以自己实现先进后出Stack栈。

二叉树定义：分为左中右三个节点，小的相同的放左边，大的放右边。
二叉树疑惑leftNode.values()这个values 是怎么得来的？固定的方法？

HashMap定义：键值对储存数据。
条件：import java.util.HashMap
特点：相同的KEY，插入不同的值，会覆盖原有值。 相同的值可以插入不同的KEY中。
使用方法：

        HashMap<String,String> dictionary = new HashMap<>();
        dictionary.put("adc", "物理英雄");

HashSet定义：Set不能重复插入数据，且没有get()方法，只能用iterator或for增强型遍历
条件：import java.util.HashSet；
特点：HashSet其实是用HashMap的方法写出来的，对象改为了KEY。
使用方法：

     HashSet<Integer> numbers = new HashSet<Integer>();

Collection接口定义：是Set List Queue Deque

Collections定义：容器的工具类，类似Array是数组的工具类。
具体方法：用到再去查询。
小技术：Collections.sort当涉及集合里的类型有多样时无法进行排序，这是用comparator
comparator用法：

       Comparator<Hero> c = new Comparator<Hero>() {
            @Override
            public int compare(Hero h1, Hero h2) {
                //按照hp进行排序
                if(h1.hp>=h2.hp)
                    return 1;  //正数表示h1比h2要大
                else
                    return -1;
            }
        };

comparable是接口，在类中实行自动执行

ArrayList 和 HashSet
区别：前者有顺序，后者无序（LinkedHashSet按照插入顺序，TreeSet按照从小到大顺序）；前者可重复，后者不能重复

ArrayList和LinkedList的区别：
ArrayList：找数据快，因为是排序好的。为什么插入删除慢呢，因为你插入一个就要动所有的数据，这些数据的位置都会发生改变。
LinkedList：找的时候慢，因为要一个一个区找。为什么插入删除快呢，可以在链表中任意位置断开，插入即可。。

HashMap和HashTable的区别：
都实现了Map接口，前者可以存放null，后者是线程安全的类
联系：继承Set