乐观学习，乐观生活，才能不断前进啊！！！

我的主页：optimistic_chen
我的专栏：c语言
欢迎大家访问~
创作不易，大佬们点赞鼓励下吧~

前言

前面博客了解了Java语法中继承的相关知识，今天我们要对多态有一个基本的认识。

protected 关键字

	范围	private	default	protected	public
1	同一包中的同一类	✅	✅	✅	✅
2	同一包中的不同一类		✅	✅	✅
3	不同一包中的子类			✅	✅
4	不同一包中的非子类				✅

//extends1包中
public class B {
  protected int b;
  public int c;
}

// extends1包中
// 同一个包中的子类
public class D extends B{
  public void method(){
    super.b = 20;     // 父类中protected成员在相同包子类中可以直接访问
    super.c = 30;     // 父类中public成员在相同包子类中可以直接访问
 }
}


// extends2包中
// 不同包中的子类
public class C extends B {
  public void method(){
    super.b = 20;     // 父类中protected修饰的成员在不同包子类中可以直接访问
    super.c = 30;     // 父类中public修饰的成员在不同包子类中可以直接访问
    }
}

// 不同包中的非子类
public class TestC {
  public static void main(String[] args) {
    C c = new C();
    c.method();
    System.out.println(c.b);  // 父类中protected成员在不同包其他类中不能直接访问,编译报错
    System.out.println(c.c);    // 父类中public成员在不同包其他类中可以直接访问
 }
}

多态

什么是多态

多态的概念：通俗来说，就是多种形态。具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态

实现条件

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法

多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法

public class Animal {
  String name;
  int age;
  public Animal(String name, int age){
    this.name = name;
    this.age = age;
 }
  public void eat(){
    System.out.println(name + "吃饭");
 }
}
public class Cat extends Animal{
  public Cat(String name, int age){
    super(name, age);
 }
  @Override
  public void eat(){
    System.out.println(name+"吃鱼~~~");
 }
}
public class Dog extends Animal {
  public Dog(String name, int age){
    super(name, age);
 }
  @Override
  public void eat(){
    System.out.println(name+"吃骨头~~~");
 }
}


public class TestAnimal {
  // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
  // 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
  // 注意：此处的形参类型必须是父类类型才可以
  public static void eat(Animal a){
    a.eat();
 }
  public static void main(String[] args) {
    Cat cat = new Cat("猫",2);
    Dog dog = new Dog("狗", 1);
    eat(cat);
    eat(dog);
 }
}

当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的a 引用指向的是哪个类型(哪个子类)的实例.此时，a这个引用调用 eat方法可能会有多种不同的表现，这就是多态。

重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程
进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。

方法重写的规则：

1. 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
2. 被重写的方法返回值类型可以不同，但是必须是具有父子关系
3. 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected
4. 父类被static、private修饰的方法、构造方法都不能被重写。
5. 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验.

重写与重载

区别点	重写	重载
参数列表	一定不能修改	必须修改
返回值类型	一定不能修改（除非可以构成父子关系）	可以修改
访问限定符	一定不能做更严格的限制	可以修改

方法重载是一个类的多态性表现,方法重写是子类与父类的一种多态性表现(重点理解)

向上转型和向下转型

向上转型

创建一个子类对象，将其当成父类对象来使用
语法格式：

父类类型 对象名 = new 子类类型（）;

Animal animal = new Cat("猫",2);

猫是动物，因此将猫（子类对象）转化为动物（父类）引用是合理的，大范围可以包含小范围。

使用场景：

1.直接赋值
 Animal cat = new Cat("猫",2);  子类对象赋值给父类对象

2. 方法传参
 public class TestAnimal {
 //形参为父类型引用，可以接收任意子类的对象
  public static void eatFood(Animal a){
    a.eat();
 }
 
3.作返回值
 public static Animal buyAnimal(String var){
    if("狗".equals(var) ){
    //返回任意子类对象
      return new Dog("狗狗",1);
   }else if("猫" .equals(var)){
   //返回任意子类对象
      return new Cat("猫猫", 1);
   }else{
      return null;
   }
 }

向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换

public class TestAnimal {
  public static void main(String[] args) {
    Cat cat = new Cat("猫",2);
    Dog dog = new Dog("狗", 1);
    // 向上转型
    Animal animal = cat;
    animal.eat();
    animal = dog;
    animal.eat();
    
//向下转型
// 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
// 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException
    cat = (Cat)animal;
    cat.mew();
    // animal本来指向的就是狗，因此将animal还原为狗也是安全的 
    dog = (Dog)animal;
    dog.bark();
    }
}

Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换

 if(animal instanceof Cat){
      cat = (Cat)animal;
      cat.mew();
   }
    if(animal instanceof Dog){
      dog = (Dog)animal;
      dog.bark();

完结

好了，这期的分享到这里就结束了~
如果这篇博客对你有帮助的话，可以点一个免费的赞并收藏起来哟~
可以点点关注，避免找不到我~
我们下期不见不散~~

下期预告：java—抽象类和接口