1.继承

1. 如果希望指定去调用父类的某个构造器，则显示的调用一下：super(参数列表)。什么都不写的时候，默认调用super()；//父类的无参构造器
2. super在使用时，需要放在构造器第一行（先有父亲再有儿子）
3. super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器。super只能在构造器中使用，this()是调用本类构造器，super()是调用父类的构造器
4. java所有类都是object类的子类，object是所有类的基类
5. 父类构造器的调用不限于直接父类，将一直往上追溯直到Object类（顶级父类）
6. 子类最多只能继承一个父类(指直接继承)，即java中是单继承机制
7. 子类和父类之间满足is-a的逻辑关系
8. 子类继承父类后，当创建子类对象时，内存中到底发生了什么？

9. 子类继承了父类的所有属性和方法，但是不一定能访问（比如private），当属性或方法是私有不能直接访问时，要通过父类提供的可访问的方法来访问属性或方法。
10. 当子类访问某个属性的时候，是一层一层往上寻找，比如儿子有这个属性就输出来，儿子没有就找它的爸爸，爸爸也没有就找爷爷…如果爸爸有，但是是私有的，而且爷爷也有，是公有的，则不能越界直接访问到爷爷的，而是只能通过爸爸提供可访问的方法来访问爸爸的该属性

2.super

1. super代表父类的引用，用于访问父类的属性、方法、构造器
2. 访问父类的属性，但不能访问父类的private属性 super.属性
3. 访问父类的方法，但不能访问父类的private方法 super.方法名
4. 访问父类的构造器：super(参数列表)；只能放在构造器的第一句，并且只能出现一句！
5. 调用父类的构造器好处（分工明确，父类属性由父类初始化，子类的属性由子类初始化）
6. 当子类中有和父类中的成员重名时，为了访问父类的成员，必须通过super，如果没有重名，使用super、this、直接访问的效果是一样的

7. super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；使用super访问遵循就近原则：A→B→C，也需要遵守访问权限的相关规则

8. super的好处就是代码的复用很方便

public String say(){
		return super.say()+"id="+id+" score="+score;

3.方法重写/覆盖

1. 方法覆盖（重写）就是子类有一个方法和父类的某个方法的名称、返回类型、参数一样
2. 子类的方法的形参列表，方法名称要和父类方法的形参列表，方法名称完全一样。子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类（兼容）。比如父类返回类型是Object，子类方法返回类型是String
3. 子类方法不能缩小父类方法的访问权限 public>protected>默认>private
4. 方法重载和方法重写的比较
   

4.多态

1. 方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承基础之上的。重写和重载体现多态

2. 一个对象的编译类型和运行类型可以不一致

   Animal animal = new Dog();//animal编译类型是Animal，运行类型是Dog
   //编译类型看=号的左边，运行类型是=号的右边
   animal.cry(); //animal运行类型是Dog，所以cry就是Dog的cry--->看堆里面的对象是谁
   //强调一下：这里的cry()方法是在animal和Dog两个类中都定义了的（方法的重写）
   

3. 编译类型在定义对象时就确定了，不能改变，运行类型是可以改变的

//使用多态机制，可以统一的管理主人喂食问题
//animal编译类型是Animal，可以指向（接收）Animal子类的对象
//food编译类型是Food，可以指向（接收）Food子类的对象
public void feed(Animal animal, Food food){
		System.out.println("主人" +name +"给"+animal.getName()+"吃"+food.getName());
}
//控制台输出：
主人陈明给小猫吃黄花鱼
主人陈明给小狗吃骨头
主人陈明给小猪吃剩饭

5. 多态的前提是：两个对象（类）存在继承关系

6. 多态的向上转型：

   • 本质：父类的引用指向了子类的对象（堆中对象是子类，但编译类l型是父类）
   • 语法：父类类型 引用名 = new 子类类型();

   //父类和子类可以是多层关系（比如爷爷和孙子）
   Animal animal = new Cat();
   Object obj = new Cat();
   

   • 可以调用父类的所有成员（但要遵循访问权限原则），但是不能调用子类的特有成员，最终运行结果看子类的具体实现

   Animal animal = new Cat();
   animal.catchMouse();//这样是错误的，因为能不能调用，调用哪些成员由编译器直接决定，
   //但是animal的编译类型是Animal类，而catchMouse()是Cat类的特有方法，Animal类中没有
   //所以报错
   animal.cry();//cry()方法在两个类中都定义时，首先编译，Animal类中有该方法编译通过
   //编译通过后运行，注意在运行时是看运行时类型，也就是先从Cat类中找方法，有则直接调用
   //若是没有，则层层向上找父类
   

   7. 多态的向下转型：

      • 语法：子类类型 引用名 = （子类类型）父类引用；
      • 只能强转父类的引用，不能强转父类的对象（比如人生下来，是你就是你不会变，但是你可以换很多次名字）
      • 要求父类的引用必须指向的是当前目标类型的对象
      • 当向下转型后，可以调用子类类型中所有的成员

      //接着上面的例子：
      Animal animal = new Cat();
      animal.catchMouse();//这样是错误的，因为能不能调用，调用哪些成员由编译器直接决定，
      //但是animal的编译类型是Animal类，而catchMouse()是Cat类的特有方法，Animal类中没有
      //所以报错
      
      //解决方法如下：将animal先向下转型为Cat类，然后调用其方法
      Cat cat = (Cat) animal; //编译类型和运行类型都是Cat类
      cat.catchMouse();
      //注意之所以能够向下转型为Cat类，
      //是因为父类的引用指向的就是Cat类对象
      //（Animal animal = new Cat(); 原来的animal指向的就是Cat类）
      //所以不能转化成其他类，比如Dog类，只能转成Cat类
      

   8. 属性没有重写之说，属性的值看编译类型

      Base base = new Sub();
      System.out.println(base.count);//看base的编译类型即Base类，则输出的是Base类的count值
      

   9. instanceOf比较操作符，用于判断对象的运行类型是否为xx类型或xx类型的子类型

      //aa编译类型 AA，运行类型是BB
      AA aa = new BB();
      System.out.println(aa instanceof AA);//true
      System.out.println(aa instanceof BB);//true
      

   Sub s = new Sub();
   Base b = s; //这里Sub继承Base
   System.out.println(b == s);//两个指向的是同一个对象，所以为TURE
   

   11. java的动态绑定机制（非常非常重要）：
       1. 当调用对象方法时，该方法会和该对象的内存地址/运行类型绑定
       2. 当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用

  //动态数组
Person[] persons = new Person[5];
Person[0] = new Person("jack",20);//运行类型是Person
Person[1] = new Student("jack",18,20.1);//运行类型是Student
for(int i = 0; i < persons.length; i++){
		persons[i].say();
		//通过判断类型，然后向下转型，即可访问子类中特有的方法了
		if(persons[i] instanceof Student){
				Student student = (Student) persons[i];
				student.study();
	}
}
//person[i] 编译类型是Person类，运行类型是根据实际情况由JVM来判断

5.Object类

idea中看代码的时候，可以通过Structure来方便查找某个属性名或者方法

==和equals的对比

1. ==既可以判断基本类型又可以判断引用类型
2. ==如果判断基本类型，则判断的是值是否相等
3. ==如果判断引用类型，则判断的是地址是否相等，即判定是不是同一个对象

equals用于判断值是否相等

如果是自定义的类，则需要重写equals方法

注意String是引用类型，如果两个String的变量，值虽然一样，但是他们的地址是不一样的！

String str1 = "asf";
String str2 = "asf";
str1.equals(str2);//true，String已经重写了Object的equals()方法
System.out.println(str1 == str2);//false,因为String是引用类型，
//str1和str2是两个不同的对象，所以对象地址不一样

hashCode方法

1. 两个引用如果指向的是同一个对象，则哈希值肯定是一样的
2. 两个引用如果指向的是不同对象，则哈希值是不一样的
3. 哈希值主要根据地址号来的，不能完全将哈希值等价于地址（实际是java内部地址转换得到的，得不到其实际值）
4. 在集合中，需要重写hashCode方法

toString方法

1. 默认返回：全类名+@+哈希值的十六进制（全类名即包名+类名）
2. 子类往往重写toString方法，用于返回对象的属性信息

1. 重写toString方法，打印对象或拼接对象时，都会自动调用对象的toString形式。
2. 当直接输出一个对象时，toString方法会被默认的调用

finalize方法

1. 当对象被回收时，系统自动调用该对象的finalize方法，子类可以重写该方法，做一些释放资源的操作
2. 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁对象（垃圾回收算法确定具体时间），在销毁该对象前，会先调用finalize方法。
3. 垃圾回收机制的调用，是由系统来决定（即有自己的GC算法），也可以通过System.gc()主动触发垃圾回收机制
4. 在实际开发中，几乎不会运用或重写finalize(了解知识点)

6.刷题（03）

题三：在排序数组中查找元素的第一个和最后一个位置

力扣题目链接

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] arr = {-1,-1};
        int arrLeft = getLeft(nums, target);
        int arrRight = getRight(nums,target);
        if(arrLeft == -2 || arrRight == -2){
            return arr;
        }
        //因为arrRight是大于目标值的，arrLeft是小于目标值的
				//所以两者之间至少有一个目标值，其位置的差应该大于等于2
        //比如 [1,2,3,4,5] 若目标值为3，则arrRight为4，arrLeft为2,两者位置只差为2
        if( arrRight - arrLeft >= 2){
            return new int[]{arrLeft + 1, arrRight - 1};
        }
        return arr;
    }

//左边界：其实就是找到第一个小于目标值的且最近的元素，返回其位置
    int getLeft(int[] nums, int target){
        int left = 0;
        int right = nums.length - 1;
        int arrLeft = -2;
        while(left <= right){
            int middle = (right - left)/2 +left;
            if(target <= nums[middle]){
                right = middle - 1;
                arrLeft = right;
            }else{
                left = middle + 1;
                
            }
        }
        return arrLeft;
    }

//右边界：其实就是找到第一个大于目标值的且最近的元素，返回其位置
    int getRight(int[] nums, int target){
        int left = 0;
        int right = nums.length - 1;
        int arrRight = -2;
        while(left <= right){
            int middle = (right - left)/2 +left;
            if(target >= nums[middle]){
                left = middle + 1;
                arrRight = left;
               
            }else{
                right = middle - 1;
                
            }
        }
        return arrRight;
    }
}