Java笔记-面向对象-继承

• 继承：

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
多个类可以称为子类，单独这个类称为父类、超类或者基类。
子类可以直接访问父类中的非私有的属性和行为。

通过extends关键字让类与类之间产生继承关系，以下是继承的格式
class Student extends Person{} //Student是子类，Person是父类

• 继承的好处：
  可以提高代码的复用性，让类与类之间产生了关系，是多态的前提

• 继承的特点
  Java只支持单继承，不支持多继承，一个类只能有一个父类，不可以有多个父类。
  Java支持多层继承(继承体系)，比如:

class B extends A{}
class C extends B{}```

继承要注意的事项：

    0.如果类之间存在着：is a 的关系，就可以考虑使用继承。
    1. 千万不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承。
    2. 父类私有的成员不能被继承。
    3. 父类的构造函数不能被继承。
    4. 创建子类对象时默认会先调用父类无参的构造函数。

- super关键字：

>super关键字代表了父类空间的引用。

super关键字的 作用：
    1. 子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
    2. 创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。

super关键字调用父类构造方法要注意的事项：
    1. 如果在子类的构造方法上没有指定调用父类的构造方法，那么java编译器会在子类的构造方法上面加上super()语句。
    2. super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。
    3. super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。


super关键字与this关键字的区别：
    1. 代表的事物不一致。
            1. super关键字代表的是父类空间的引用。 
            2. this关键字代表的是所属函数的调用者对象。
    2. 使用前提不一致。
            1. super关键字必须要有继承关系才能使用。
            2. this关键字不需要存在继承关系也可使用。
    3. 调用构造函数的区别：
            1. super关键字是调用父类的构造函数。
            2. this关键字是调用本类的构造函数。

- 方法重写的前提： 必须要存在继承的关系。
>方法的重写: 子父类出了同名的函数，这个我们就称作为方法的重写。

什么是时候要使用方法的重写：父类的功能无法满足子类的需求时。

方法重写要注意的事项：
    1.方法重写时， 方法名与形参列表必须一致。
    2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。
    3.方法重写时，子类的返回值类型必须要小于或者 等于父类的返回值类型。
    4.方法重写时， 子类抛出的异常类型要小于或者等于父类抛出的异常类型。
            Exception(最坏)
            RuntimeException(小坏)

方法的重载：在一个类中 存在两个或者两个 以上的同名函数,称作为方法重载。

方法重载的要求
    1. 函数名要一致。
    2. 形参列表不一致（形参的个数或形参 的类型不一致）
    3. 与返回值类型无关。

- 静态代码块、构造代码块，构造方法的执行顺序：

父类静态代码块→子类静态代码块→父类构造代码块→父类构造方法→子类构造代码块→子类构造方法

- instanceof 关键字

instanceof关键字的作用：判断一个对象是否属于指定的类别。

instanceof关键字的使用前提：判断的对象与指定的类别必须要存在继承或者实现的关系。

instanceof关键字的使用格式：
        
        对象  instanceof 类别

instanceof关键字的作用： 目前没用。但是后天我们学习 到了多态之后就非常有用。
一般我们做强制类型转换之前都会使用该关键字先判断一把，然后在进行转换的。


- final关键字
>每一个方法要运行的时候，jvm虚拟机都会为该方法开辟一片存储空间，方法中的形参也是属于该方法的局部变量

final(最终、修饰符)  
    
final关键字的用法：
    1. final关键字修饰一个基本类型的变量时，该变量不能重新赋值，第一次的值为最终的。
    2. fianl关键字修饰一个引用类型变量时，该变量不能重新指向新的对象。
    3. final关键字修饰一个函数的时候，该函数不能被重写。
    4. final关键字修饰一个类的时候，该类不能被继承。


常量 的修饰符一般为： public static final
常量的命名规范：全部字母大写，单词与单词 之间 使用下划线分隔。
比如 ```public static final double CIRCLE_PI = 3.14;```

- 抽象类：
>抽象类的应用场景：
    我们在描述一类事物的时候，发现该种事物确实存在着某种行为，
但是这种行为目前是不具体的，那么我们可以抽取这种行为 的声明，但是
不去实现该种行为，这时候这种行为我们称作为抽象的行为，我们就需要使用抽象类。

抽象类的好处: 强制要求子类一定要实现指定的方法。


抽象类要注意的细节：
    1. 如果一个函数没有方法体，那么该函数必须要使用abstract修饰,把该函数修饰成抽象 的函数。。
    2. 如果一个类出现了抽象的函数，那么该类也必须 使用abstract修饰。
    3. 如果一个非抽象类继承了抽象类，那么必须要把抽象类的所有抽象方法全部实现。
    4. 抽象类可以存在非抽象方法，也可以存在抽象的方法.
    5. 抽象类可以不存在抽象方法的。 
    5. 抽象类是不能创建对象的。
        疑问：为什么抽象类不能创建对象呢？
        因为抽象类是存在抽象方法的，如果能让抽象类创建对象的话，那么使用抽象的对象
        调用抽象方法是没有任何意义的。
    6. 抽象类是存在构造函数的，其构造函数是提供给子类创建对象的时候初始化父类的属性的。

abstract不能与以下关键字共同修饰一个方法：
    1. abstract不能与private共同修饰一个方法。
    2. abstract 不能与static共同修饰一个方法。
    3. abstract 不能与final共同修饰一个方法。

值传递: 调用一个方法的时候，传递给方法的参数 ，实际上传递变量所存储的值。

- 接口：

>接口：接口是抽象方法和常量值的集合。从本质上讲，接口是一种特殊的抽象类，这种抽象类只包含常量和方法的定义，而没有变量和方法的实现。
接口的出现将”多继承“通过另一种形式体现出来，即”多实现“。

接口的定义格式：

interface 接口名{

}

接口要注意的事项 ：
    1. 接口是一个特殊的类。
    2. 接口的成员变量默认的修饰符为： public static final 。那么也就是说接口中的成员变量都是常量。
    3. 接口中 的方法都是抽象的方法，默认的修饰符为： public abstract。
    4. 接口不能创建对象。
    5. 接口是没有构造方法的。
    6. 接口是给类去实现使用的，非抽象类实现一个接口的时候，必须要把接口中所有方法全部实现。


实现接口的格式：

class  类名 implements 接口名{

}

接口的成员特点：

接口中的成员修饰符是固定的！

成员常量：public static final，接口里定义的变量是全局常量，而且修饰符只能是这三个关键字，都可以省略，常量名要大写。
成员方法：public abstract，接口里定义的方法都是抽象的，两个修饰符关键字可省略。
推荐：永远手动给出修饰符。

类与接口之间关系： 实现关系。

类与接口要注意的事项：
    1. 非抽象类实现一个接口时，必须要把接口中所有方法全部实现。
    2. 抽象类实现一个接口时，可以实现也可以不实现接口中的 方法。
    3. 一个类可以实现多个接口 。
        
接口与接口之间关系： 继承关系。

接口与接口之间要注意事项：
一个接口是可以继承多个接口的。比如, 以下Demo接口继承了Print和Demo1接口

interface Demo extends Print, Demo1 {

}
interface Demo1 {

}

interface Print extends Eraser {

public abstract void println();

}

interface Eraser {

public static final double money = 1.0;

public abstract void remove(); /// 橡皮擦的功能

}

接口的思想特点：

接口是对外暴露的规则；
接口是程序的功能扩展；
接口的出现降低耦合性；(实现了模块化开发,定义好规则,每个人实现自己的模块,大大提高了开发效率)
接口可以用来多实现；
多个无关的类可以实现同一个接口；
一个类可以实现多个相互直接没有关系的接口；
与继承关系类似，接口与实现类之间存在多态性。