继承：

继承的关键字：extends

  1. public class Dog extends pet{//Dog继承父类Pet
  2.     String strain;
  4.     public Dog() {
  5.     }
  7.     public Dog(int age, String name,String strain) {
  8.         super(age, name);
  9.         this.strain=strain;
  10.     }
  11.     public void print(){
  12.         System.out.println(super.name+this.strain);
  13.     }
  14. }

java类与类之间实现代码复用的手段之一，类和类符合使用继承的条件是必须满足is-a关系
在继承中一个子类只能有一个直接父类，（只支持单继承）如果要实现复用多个类代码的复用可以使用继承体系
如果类 A 是类 B 的父类，而类 B 是类 C 的父类，我们也称类 C 是 A 的子类，类 C 是从类 A 继承而来的。在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类。
不能被继承的父类成员：

  • 构造方法
  • 静态成员，包括静态方法静态属性
  • 子类与父类不在同包，父类默认权限的成员

继承的特性：

  • 子类拥有父类非 private 的属性、方法。
  • 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
  • 子类可以用自己的方式实现父类的方法。
  • Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
  • 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

继承条件下构造方法的调用规则

  • 子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法，系统默认调用父类的无参构造方法
  • 子类构造方法通过super显式调用父类的有参构造方法，执行父类相应构造方法，而不执行父类无参构造方法

  • 子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则

    super关键字

    super关键字是子类用来访问父类的方法和属性
    super.属性名//访问父类的属性
    super.方法名(参数);//调用父类的方法。
    super(参数);//调用父类的构造方法。
    //初始化当前对象的父类型特征
    super能出现在实例方法和构造方法中，不能使用在静态方法中。且大部分情况下可以省略。
    4super()只能出现在构造方法第一行，通过当前的构造方法去调用、”父类”中其它的构造方法，目的是:代码复用（创建子类对象的时候，先初始化父类型特征）。

    1. public Dog(int age, String name,String strain) {
    2.       super(age, name);//super调用父类构造方法
    3.       this.strain=strain;
    4.   }
    5.   public void print(){
    6.       System.out.println(super.name+this.strain);//super调用父类属性
    7.   }

    重写父类方法：

  • 方法名和参数必须完全一致

  • 返回值类型相同或者是其子类
  • 访问权限不能严于父类
  • 父类的静态方法不能被子类重写
  • 父类的私有方法不能被子类重写

重写父类规则：
A、重写规则之一：重写方法不能比被重写方法限制有更严格的访问级别。
B、重写规则之二：参数列表必须与被重写方法的相同。
C、重写规则之三：返回类型必须与被重写方法的返回类型相同。
D、重写规则之四：重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。
E、重写规则之五：不能重写被标识为final的方法。
F、重写规则之六：如果一个方法不能被继承，则不能重写它。
多态只看父类引用的方法，而不看子类对象的方法

重载和重写的区别：

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。
(1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
(2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
(3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

重写：在继承关系中，子类重写父类方法，方法名必须相同，参数表也需要相同，返回值与父类相同或是父类的子类，访问修饰符不能严于父类。
重载：同一个方法中，两个方法，方法名相同，参数表不同，这种现象叫方法重载，方法重载与返回值和访问修饰符无关。
QQ图片20210420091541.png
重写toString方法：方便打印对象值
重写equals方法：比较两个对象的值，默认是比较内存地址，重写以后比较的是值

== 和 equals 的区别

当大家看了上面的内容，相信大家对这两种方式比较对象的区别应该有点了解

对于基本类型：

== 比较的是具体的值
equals 无法用于基本类型的比较，要注意
对于引用类型：

== 比较的是地址值
equals 一般情况下比较的也是地址值，除非重写 equals 方法，自定义比较规则

多态：

多态是同一个行为具有多个不同表现形式或形态的能力
同一个引用类型，使用不同的对象而执行不同的操作
QQ图片20210419152949.png

向上转型

pet p=new dog();

特点:
此时父类应用变量调用的是子类覆盖或继承的方法，不是父类的方法
不能调用子类中特有的方法，但是可以调用子类重写父类的方法

向下转型

dog d=(dog)p;
可以调用子类中特有的方法，可以调用父类中公开的方法
转换目标对象必须与转换类型一致，不然会报错

多态的两种体现形式：

  • 父类作为返回值

父类作为返回值好处：return的时候可以return任意子类，就不固定某一种

  • 父类作为参数

    多态的优点

  1. 消除类型之间的耦合关系
    2. 可替换性
    3. 可扩充性
    4. 接口性
    5. 灵活性
    6. 简化性

    多态存在的三个必要条件

  • 继承
  • 重写
  • 父类引用指向子类对象：Parent p = new Child();

    多态的实现方式

    方式一：重写：
    方式二：接口
    方式三：抽象类和抽象方法

    抽象类

    抽象类不能被实例化
    抽象类中可以有构造方法，但是不能创建实例
    抽象类中可以没有抽象方法但是有抽象方法的类一定是抽象类
    如果子类没有实现父类的所有抽象方法，子类必须被定义成抽象类
    抽象类的缺点：
    1.由于是基于继承，所以只能单继承

关键字：abstract

  1. public abstract  class Goods {
  3.     public abstract void pringprice();
  5. }

抽象方法没有方法体
抽象方法必须放在抽象类中
抽象方法必须在子类中被实现，除非子类是抽象类

接口：

抽象方法和常量值的定义的集合
接口里面可以写的内容：
1.抽象方法
2.静态常量
3.静态方法

  1. public interface Networkinterface {
  2.     int MONEY =100;//public final static int MONEY==100;静态常量
  3.     void networkCon();//public sbstract void networlCon();抽象方法
  4.     //静态方法
  5.     static  void show(){
  7.     }
  8. }

接口和抽象类的思想区别：
抽象类的思想：
Dog，Penguin，Pet之间的关系是is-a关系
接口的思想：
接口表示一种能力，has-a关系（拥有关系）
图片1.png

抽象方法

接口和抽象类

1，抽象类需要被继承，而且只能单继承。

  1.    接口需要被实现，而且可以多实现。
  3. 2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
  5.     接口中只能定义抽象方法，必须由子类去实现。
  7. 3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。
  9.     接口的实现是 是like a 关系。（像，相似） 在定义体系额外功能。<br />**相同点：**<br />代表系统的抽象层<br />都不能被实例化<br />都能包含抽象方法：用于描述系统提供的服务，不必提供具体实现<br />**不同点:**<br />在抽象类中可以为部分方法提供默认实现，而接口中只能存在抽象方法：抽象类便于复用，接口便于代码维护<br />一个类只能继承一个直接的父类，但可以实现多个接口

接口的使用原则：

接口做系统与外界交互的窗口：接口提供服务
接口本身一旦指定就不允许随意修改
抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点

异常：

好处：
可以保证程序在报错的情况下继续运行，不会停止
可以使用catch捕获到指定异常，然后进行自己的逻辑处理
捕获异常：
try:执行可能产生异常的代码
catch：捕获异常
finally：无论是否发生异常，代码总能执行
声明异常：
throws：声明方法肯要抛出的各种异常
抛出异常：
throw：手动抛出异常
QQ图片20210508103920.png

特殊：

封装继承多态的好处：
封装：隐藏类的内部细节
继承：将公共的代码提到父类，子类继承，减少代码冗余，代码的复用
多态：增强程序的扩展性

不管是父类子类，创建好有，最好将set/get，有参构造，无参构造，全写上，反正迟早得用

IS-A 关系
IS-A 就是说：一个对象是另一个对象的一个分类。例如：学生是一个人类

instanceof：
判断前面的对象是否属于后面的类
格式：

  1.         String a  = "124";
  2.         String b = "124";
  3.         Object c = 1;
  4.         Pet pet = new Pet();
  5.         Dog dog = new Dog();
  6.         System.out.println(c instanceof String); //false
  7.         System.out.println(a instanceof String); //true
  8.         System.out.println(c instanceof Pet);//false
  9.         System.out.println(pet instanceof Pet);//true
  10.         System.out.println(dog instanceof Pet);//true
  11.         System.out.println(c instanceof Object);//true