其他分享
首页 > 其他分享> > day13_polymorphism

day13_polymorphism

作者:互联网

使用接口时,需要注意的以下事项:

  1. ​ 接口没有静态代码块没有构造方法

  2. ​ 一个类只能继承一个父类,但是可以实现多个接口

    一个接口可以继承多个接口,类与类之间是单继承关系,类与接口之间是一种多实现关系

  3. ​ 如果一个类实现了多个接口,出现了重名的抽象方法,只需要重写一次抽象方法

  4. ​ 如果一个类没有重写接口的所有抽象方法,该类必须是抽象类

  5. ​ 如果一个类实现了多个接口,接口当中存在有重名的默认方法,那么实现类一定要对冲突的默认方法进行重写

  6. ​ 如果一个类直接继承了一个父类,又实现了多个接口,父类当中的成员方法和接口中的默认方法存在重名,优先调用父类中的成员方法

    今日内容

  7. ​ 多态

  8. ​ final

  9. ​ 权限修饰符

  10. ​ 内部类

多态

​ 概述:多态是继封装、继承之后面向对象的第三大特性

​ 定义:多态是指同一行为,具有多种不同的表现形式。即同一行为,通过不同的事物,表现出不同的状态。

​ 前提:

  1. ​ 继承或实现【二选一】
  2. ​ 出现父类的引用指向子类对象【格式体现】
  3. ​ 方法的重写【不重写无实际意义】

多态的表现

​ 格式:

父类类型 变量名 = new 子类对象;
变量名.方法名();

备注:父类类型指的是子类对象继承的父类类型,或者是实现的父接口类型

public class Fu{
    public void method(){
        System.out.println("这是父类的method方法!!!");
    }
}
public class Zi extends Fu{ //1.继承
    @Override
    public void method(){
        System.out.println("这是子类的method方法!!!");  //2.重写
    }
}
public class PolymorphismTest{
    public static void main(String [] args){
        //父类引用指向子类对象   //3.父类引用指向子类对象
        Fu fu = new Zi();
        fu.method();//调用的是子类重写后的方法
    }
}

如果在使用多态方式调用方法时,首先检查父类当中是否有该方法,如果没有则编译报错

​ 如果有,执行的是子类重写后的方法

多态的优点

​ 在实际开发中,父类类型作为放啊的形式参数,传递子类对象给方法,进行方法的调用,更能体现出多态的扩展性和便利性。

public abstract class Animal{
    public abstract void eat();
}
public class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println("啃骨头");  //重写
    }
}
public class Cat extends Animal{ 
    @Override
    public void eat(){
        System.out.println("吃鱼");  //重写
    }
}
//测试类
public class PolymorphismTest{
    public static void main(String [] args){
        //根据不同的对象表现不同的eat()内容
        Animal animal1 = new Cat();
        Animal animal2 = new Dog();// 编左运右
        show(animal1);
        show(animal2);
    }
    public static void show(Animal animal){
		animal.eat();
    }
}

说明:用于多态特性的支持,show方法中的形式参数Animal类型,是Dog和Cat的父类型,父类类型接受子类对象,可以把cat对象和dog对象传递给方法

当程序执行过程中,执行eat()方法实际执行的是各自子类对象重写之后的eat方法,不仅仅可以做到替代,在扩展性方面,无论之后出现多少个子类,都可以使用show方法。

(多态下)访问父类中成员变量有两种方式:

  1. ​ 直接通过对象名访问成员变量:看等号左边是谁,优先用谁,如果没有,继续往上找
  2. ​ 间接通过成员方法访问成员变量:看该方法属于谁,优先用谁,如果没有,继续往上找
//定义父类
public class Fu{
	int num = 10;
    public void showNum(){
        System.out.println(num);
    }
}
public class Zi extends Fu{
	int num = 20;
    public void showNum(){
        System.out.println(num);
    }
}
public class PolymorphismTest{
    public static void main(String [] args){
        Fu fu = new Zi();
        System.out.println(fu.num);//10 编左运左
        fu.showNum();// 20 
    }

调用属性:编左运左

调用方法:编左运右

向上转型一定是安全的、正确的,但有一个弊端:无法调用子类特有内容。由此需要向下转型

引用数据类型的转型问题

父类类型  变量名  = new 子类类型();
子类类型  变量名  = (子类类型) 父类变量名;

转型的异常

​ 在进行向下转换的过程中,一不小心就会出现 java.lang.ClassCastException类型转换异常。

为了避免这种类型转换异常的发生,java提供了 instanceof关键字,给引用变量做类型转换校验

变量名  instanceof  数据类型 
如果变量属于该数据类型,则返回true
如果变量不属于该数据类型,则返回false

所以,我们在类型转换前,最好进行引用变量的类型判断

public class Test{
    public static void main(String []args){
        //向上转型
        Animal animal = new Cat();
        //向下转型
        if(animal instanceof Cat){
            //表明你就是一只猫
            Cat cat = (Cat)animal;
            cat.eat();
            cat.catchMouse();
        }else if(animal instanceof Dog){
            //表明你就是一只狗
            Dog dog = (Dog)animal;
            dog.lookDoor();
        }else{
            //...
        }
    }
}

学习目标:

final :最终的、不可改变的

常见的四种用法:

  1. ​ 可以修饰一个类

    public final class 类名称 { }

    特点:当前这个类不能有任何子类,这个类依然拥有父类。

    ​ 如果一个类是final的,那么其中的所有成员方法都无法被重写(无子类)

  2. ​ 可以修饰一个方法

    当方法被final修饰,它是一个最终的方法,不能被覆盖重写。

    修饰符 final 返回值类型 方法名称(参数列表){ }

    注意事项:对于类、方法来说,abstract关键字和final关键字矛盾, 不可同时使用

  3. ​ 可以修饰一个局部变量

    一旦赋值,不可更改

    对于基本数据类型,不变的是变量中的数据值 final int n = 1999;

    对于引用数据类型,不变的是变量中的内存地址值,内容值可以变化 final Person p = new Person();

  4. ​ 可以修饰一个成员变量

    对于成员变量来说,如果使用final关键字修饰,那么这个变量也是不可改变的

    ​ ①由于成员变量具有默认值,使用final后【必须】手动赋值,不再有默认值

    ​ ②由于final的成员变量,要么使用直接赋值(包括使用代码块赋值),要么通过构造方法赋值 【二选一】

    ​ ③必须保证类当中的所有的重载的构造方法,都最终对final成员变量赋值

标签:polymorphism,子类,void,public,day13,父类,方法,final
来源: https://www.cnblogs.com/mitoris/p/14039473.html