java基础_day09

多态

一 多态的实现原理

多态：在代码中的描述的是用父类对象的引用指向子类对象的方法。
​
父子关系：Student extends Person       Person extends Object
//直接父类的引用只想子类对象----多态
Person person = new Student();
Object不是Student的直接父类,但是是间接父类,这里也是多态
Object o = new Student();
​
​
多态的优点(会)
可以提高代码的扩展性,使用之前定义好的功能,后面直接拿来使用,不用再创建新的方法.
 
 
 示例代码： 
 public class Demo5 {
    public static void main(String[] args) {
//创建狗,猫,动物对象
    Dog dog = new Dog();
    Cat cat = new Cat();
    Animal animal = new Animal();
//创建猪对象
    Pig pig = new Pig();
    feedAnimal(animal);
// feedDog(dog);
// feedCat(cat);
    feedAnimal(dog);
    feedAnimal(cat);
//调用feedAnimal方法喂猪
feedAnimal(pig);
}
//喂狗,喂猫,喂动物
public static void feedAnimal(Animal animal) {//animal = dog = new
    Dog() 多态
    animal.eat();
}
// public static void feedDog(Dog dog) {
// dog.eat();
// }
// public static void feedCat(Cat cat) {
// cat.eat();
// }
// public static void feedPig(Pig pig) {
// pig.eat();
// }
}
class Animal{
public void eat() {
    System.out.println("动物吃");
    }
}
class Dog extends Animal{
@Override
public void eat() {
    System.out.println("狗吃骨头");
    }
}
class Cat extends Animal{
@Override
public void eat() {
    System.out.println("猫吃");
    }
}
class Pig extends Animal{
public void eat() {
    System.out.println("猪吃");
    }
}

二 对象的转型

注意:在多态的前提下再说向上转型,向下转型

2.1 向上转型

对象由子类类型， 转型为父类类型， 即是向上转型。
向上转型是一个隐式转换，相当于自动类型转换, 一定会转型成功。
向上转型后的对象， 只能访问父类中定义的成员。
作用:实现多态
​
示例代码：
class Test {
    public static void main(String[] args) {
// 1. 实例化一个子类对象
        Dog dog = new Dog();
// 2. 转成父类类型
        Animal animal = dog;
// 此时， 这个animal引用只能访问父类中的成员
        animal.name = "animal";
        animal.age = 10;
        animal.furColor = "white"; // 这里是有问题的， 访问不到
}
}
class Animal {
    String name;
    int age;
}
class Dog extends Animal {
    String furColor;
}
​

2.2 向下转型

对象由父类类型， 转型为子类类型， 即是向下转型。
向下转型是一个显式转换，相当于强制类型转换, 有可能转型失败.
向下转型后的对象， 将可以访问子类中独有的成员。
​
示例代码：
class Test   {
    Dog dog = new Dog();
// 2. 转成父类类型
    Animal animal = dog;
// 3. 转成子类类型
    Dog sub = (Dog)animal;
//注意:
//1.这不是父类的引用指向子类的对象,不是向上转型.这是使用子类的引用指向父
类的对象是错误的.
    Dog dog1 = new Animal();
//2.这里在编译的时候不会报错,但是运行时出错,还是相当于子类引用指向父类对
象.
    Animal animal1 = new Animal();
    Dog dog2 = (Dog)animal1;
    }
}
    class Animal {
    String name;
    int age;
}
    class Dog extends Animal {
    String furColor;
}public static void main(String[] args) {
// 1. 实例化一个子类对象
    Dog dog = new Dog();
// 2. 转成父类类型
    Animal animal = dog;
// 3. 转成子类类型
    Dog sub = (Dog)animal;
//注意:
//1.这不是父类的引用指向子类的对象,不是向上转型.这是使用子类的引用指向父
类的对象是错误的.
    Dog dog1 = new Animal();
//2.这里在编译的时候不会报错,但是运行时出错,还是相当于子类引用指向父类对
象.
    Animal animal1 = new Animal();
    Dog dog2 = (Dog)animal1;
    }
}
    class Animal {
    String name;
    int age;
}
    class Dog extends Animal {
    String furColor;
}

2.3 instanceof关键字(会)

向下转型， 存在失败的可能性。 如果引用实际指向的对象， 不是要转型的类型， 此时强制
转换， 会出现 ClassCastException 异常。
所以， 在向下转型之前， 最好使用 instanceof 关键字进行类型检查。
instanceof:是一个运算符
构成: 对象 instanceof 类或类的子类
原理说明:确定当前的对象是否是后面的类或者子类的对象,是返回true,不是false
作用:进行容错处理,增加用户体验

三 多态中的方法重写

当向上转型后的对象， 调用父类中的方法。 如果这个方法已经被子类重写了， 此时调用的就是子类的重写实现！
​
示例代码：
public class Demo2 {
    public static void main(String[] args) {
        //1.实例化一个对象，并向上转型
        Animal animal = new Dog();
        //2.调用父类方法
        animal.bark();// 因为在子类中已经重写过这个方法了， 此时的输出结果是Won~
​
    }
}
​
class Animal{
    public void bark(){
        System.out.println("Animal Bark~");
    }
}
​
class Dog extends Animal{
    public void bark(){
        System.out.println("Won~");
    }
}

抽象类

一 抽象类的定义

在继承中,提取父类方法的时候,每个子类都有自己具体的方法实现,父类不能决定他们各自的实现方法,所以父类干脆就不管了,在父类中只写方法的声明(负责制定一个规则),将方法的实现交
给子类.在类中只有方法声明的方法叫抽象方法,拥有抽象方法的类叫抽象类
abstract:抽象的
声明:不写函数体的函数,可以叫声明
abstract修饰方法:抽象方法
abstract修饰类:抽象类
抽象类的功能:1.可以节省代码 2.可以制定一批规则
​
示例代码
 abstract class Animal {
    public void bark() {
    System.out.println("Animal bark");
    }
}
class Dog extends Animal {
@Override
public void bark() {
    System.out.println("Won~");
    }
}
class Cat extends Animal {
@Override
    public void bark() {
System.out.println("Miao~");
    }
}
​

二 抽象方法的特点

抽象方法只有方法的声明， 没有实现。
抽象方法只能定义在抽象类中。
​
abstract class Animal {
// 抽象方法， 只有方法的声明， 没有方法的实现
// 只能定义在抽象类中
    public abstract void bark();
}
​

三 抽象类的继承

抽象方法有一个特点， 就是只能定义在抽象类中。 如果一个非抽象子类继承自一个抽象父类， 此时， 可以继承到抽象父类中的抽象方法。 那么这个时候， 抽象方法就存在于一个非
抽象的子类中了。 此时会有问题。
所以， 非抽象的子类， 在继承自一个抽象父类的时候， 必须重写实现抽象父类中所有的抽象
方法或者将自己也变成抽象类
注意:抽象类不能直接创建对象,可以通过子类间接的创建对象.

四 抽象类的总结

基本点总结:
抽象类不一定有抽象方法,但是有抽象方法的一定是抽象类.
继承了抽象类的子类一定要实现抽象方法,如果不实现就只能将自己也变成抽象的.
抽象类不能直接创建对象,必须通过子类实现,所以抽象类一定有子类
​
比较普通类与抽象类:
普通类可以直接创建对象
抽象类可以有抽象方法
​
​
比较:final,abstract,static,private
三个都是不能与abstract同时存在的关键字
final:被final修饰的类不能有子类,方法不能重写,但是abstract必须有子类,必须重写
static:修饰的方法可以通过类名调用,abstract必须通过子类实现
private:修饰的方法不能重写,abstract必须重写