zoukankan      html  css  js  c++  java
  • java第八天---多态、抽象、接口

    一、多态

      1、什么是多态?

        ①多态是同一行为具有表现出多种形态和形式的功能。

        ②多态是父类能够调用子类的对象。在对同一父类的不同子类传入同一消息时,子类表现出不同的行为。

      以上两点结合理解。

        ③多态使用了继承和方法的重写。

      2、多态如何使用?

        场景模拟:有一个动物园,里边有狮子,鹿,丹顶鹤三种动物,三种动物都具有吃的行为,但是吃的东西不一样。饲养员要喂它们吃东西。

        ①实现一:不使用多态

    public class Crane{
        public void eat(){
            System.out.println("丹顶鹤吃鱼");
        }
    }
    View Code
    public class Deer{
        public void eat(){
            System.out.println("鹿吃草");
        }
    }
    View Code
    public class Lion{
        public void eat(){
            System.out.println("狮子吃肉");
        }
    }
    View Code
    public class Feeder {
    //    在方法中传入类作为参数
        public void weishi(Crane crane){
            System.out.println("开始喂食");
    //        喂丹顶鹤
            crane.eat();
        }
    
        public void weishi(Deer deer){
            System.out.println("开始喂食");
    //        喂鹿
            deer.eat();
        }
    
        public void weishi(Lion lion){
            System.out.println("开始喂食");
    //        喂狮子
            lion.eat();
        }
    
    }
    View Code
    public class TestDemo1 {
        public static void main(String[] args) {
    //        创建饲养员类
            Feeder feeder = new Feeder();
    
            Crane crane = new Crane();
            feeder.weishi(crane);
    
            Deer deer = new Deer();
            feeder.weishi(deer);
    
            Lion lion = new Lion();
            feeder.weishi(lion);
        }
    }
    View Code

      可以看到,在饲养员类中,每一个动物类都需要重载一个weishi()方法,如果动物有成千上万种,我们就需要写成千上万个weishi()方法,这样虽然功能都实现了,但是代码无比繁杂,不利于维护。

        ②实现二:使用多态

          创建一个Animal类,各个具体动物类都继承这个类。

    public class Lion extends Animal{
        @Override
        public void eat(){
            System.out.println("狮子吃肉");
        }
    }
    View Code
    public class Deer extends Animal{
        @Override
        public void eat(){
            System.out.println("鹿吃草");
        }
    }
    View Code
    public class Crane extends Animal{
        @Override
        public void eat(){
            System.out.println("丹顶鹤吃鱼");
        }
    }
    View Code
    public class Feeder {
    //    在方法中传入类作为参数,此处使用Animal类作为参数
        public void weishi(Animal animal){
            System.out.println("开始喂食");
            animal.eat();
        }
    }
    View Code
    public class TestDemo1 {
        public static void main(String[] args) {
    //        创建饲养员类
            Feeder feeder = new Feeder();
    
            Animal crane = new Crane();
            feeder.weishi(crane);
    
            Animal deer = new Deer();
            feeder.weishi(deer);
    
            Animal lion = new Lion();
            feeder.weishi(lion);
        }
    }
    View Code

      这里可以看到,在饲养员类中,只需要写一个方法,参数为Animal类。在测试类中,每个创建出来的具体动物对象都使用Animal类修饰。方法中虽然只传入了Animal类,但是会根据传入的具体对象,到对应的类中取调用对应的方法。这样即使有成千上万种动物,也只管创建类就行。这里就是父类可以调用子类的对象,虽然调用的方法相同,但是表现出来的形态却不同。

      3、多态中涉及到向上转型和向下转型

        ①向上转型

          Animal lion=new Lion();

          向上转型是自动转型。创建的是子类对象,使用父类来修饰创建出来的对象。

        缺点:使用向上转型后,子类中的独有的方法和属性就无法使用对象调用。

        ②向下转型

          Lion lionDown=(Lion)lion;

          向下转型是强制转型,慎用。不过这样就可以调用子类中独有的方法和属性了

    在开发中,继承多态使用不多,主要还是下边介绍的接口多态。

    二、抽象   abstract

      1、什么是抽象?

        ①抽象类存在的目的不是创建对象,而是为了让子类继承

        ②抽象类中有类的行为,但是没有具体实现,具体实现是在子类中实现的

        ③抽象类除了不能创建对象,但是类的其他功能都不影响使用,构造方法,成员属性,成员方法的使用和普通类一样

      2、抽象的格式:

        ①抽象类

          访问修饰符  abstract   class  类名{};

        ②抽象方法

          访问修饰符  abstract  返回值  方法名();

        抽象方法没有大括号,也就没有方法体。

      3、使用

        父类(抽象类):

    public abstract class Animal {
        public abstract void  eat();
    }

         子类(继承类):

          子类要继承父类,要么子类是一个抽象类,要么子类中实现了父类中的抽象方法。

        ①子类为抽象类

    public abstract class Cat extends Animal {
    }

        ②子类实现抽象方法

    public class Cat extends Animal {
        public void eat(){
    
        }
    }

        抽象类中可以有普通方法:

    public abstract class Animal {
        public abstract void  eat();
        public void jump(){
            System.out.println("跳");
        }
    }

      4、特点

      ①抽象类或方法使用abstract修饰

      ②抽象方法必须在抽象类中,抽象方法没有方法体

      ③抽象类中也可以有非抽象方法

      ④继承抽象类的子类,要么是抽象类,要么实现了父类中的抽象方法

      ⑤抽象类有构造函数,但是不能new对象

    三、接口

         1、什么是接口?

          ①简单说,接口是一个特殊的抽象类。

          ②接口时java中的一个抽象类型,是抽象方法的集合,使用Interface声明,有特定的语法和结构

          ③广义上讲,接口是一个对象的方法特征的集合,是一种逻辑上的抽象。

        2、接口的定义格式:

          权限修饰符  Interface 接口名{};

          接口中都是抽象方法,没有方法的实现。没有构造方法,不能创建对象

        3、接口的使用步骤:

          ①创建接口

          ②实现接口。接口的实现类必须将接口中的抽象方法全部实现

          ③创建继承类的对象,进行调用

        注意:如果实现类没有全部实现抽象方法,那么这个实现类自身必须是抽象类

        4、接口中的内容

          ①常量(不可变)

            [public static final] int AGE=2;

            中括号中的内容可以不写,常量名全部使用大写字母。

          使用:接口名.常量名

          ②抽象方法

            [权限修饰符  abstract] 返回值  方法名();

          ③默认方法

            假设一个接口,有一万个实现类,但是现在需要在接口写一个只有一个实现类使用的方法,如果还写抽象方法,一万个实现类必须全部      实现,明显不行,这时候就可以使用默认方法,需要就重写,不需要就不用动。

            格式:  默认方法有方法体

              defalut 返回值  方法名(){}; 

    public interface BBB {
        public static final int AGE=0;
        default void sooo(){
            System.out.println("接口");
        }
    }
    View Code
    public class bbImpl implements BBB {
        @Override
        public void sooo() {
            System.out.println("接口的实现类");
        }
    }
    View Code

        5、接口和类的区别

          ①类与类中只能单继继承

          ②接口和接口可以多继承,A接口继承B、C接口,可以同时具有两个接口中的抽象方法,还可以具有自己的抽象方法

          ③类可以实现多个接口

          ④接口没有构造方法

  • 相关阅读:
    彻底解决SQL SERVER 2008无法远程连接的问题
    将ReportingService 2008配置为匿名访问
    将低版本的数据库迁移到sqlserver 2008
    Oracle 11G R2
    Reporting Services 安装的备份和还原操作
    DefaultValue
    用户 'IIS APPPOOL\DefaultAppPool' 登录失败。
    在IIS中为SQL Server 2008配置报表服务
    数据库日志维护方式
    如何卸载的 SQL Server 2008 实例
  • 原文地址:https://www.cnblogs.com/fbbg/p/14135548.html
Copyright © 2011-2022 走看看