精华内容
下载资源
问答
  • 抽象类用在什么地方
    2021-02-27 08:24:55

    最简单的说法也是最重要的理由:接口和实现分离

    老是在想为什么要引用抽象类,一般类不就够用了吗。一般类里定义的方法,子类也可以覆盖,没必要定义成抽象的啊。

    看了下面的文章,明白了一点。

    其实不是说抽象类有什么用,一般类确实也能满足应用,但是现实中确实有些父类中的方法确实没有必要写,因为各个子类中的这个方法肯定会有不同,所以没有必要再父类里写。当然你也可以把抽象类都写成非抽象类,但是这样没有必要。

    而写成抽象类,这样别人看到你的代码,或你看到别人的代码,你就会注意抽象方法,而知道这个方法是在子类中实现的,所以,有个提示作用。

    ==============

    问你个问题,你知道什么是“东西”吗?什么是“物体”吗?

    “麻烦你,小王。帮我把那个东西拿过来好吗”

    在生活中,你肯定用过这个词--东西。

    小王:“你要让我帮你拿那个水杯吗?”

    你要的是水杯类的对象。而东西是水杯的父类。通常东西类没有实例对象,但我们有时需要东西的引用指向它的子类实例。

    你看你的房间乱成什么样子了,以后不要把东西乱放了,知道么?

    又是东西,它是一个数组。而数组中的元素都是其子类的实例。

    ---------

    上面讲的只是子类和父类。而没有说明抽象类的作用。抽象类是据有一个或多个抽象方法的类,必须声明为抽象类。抽象类的特点是,不能创建实例。

    这些该死的抽象类,也不知道它有什么屁用。我非要把它改一改不可。把抽象类中的抽象方法都改为空实现。也就是给抽象方法加上一个方法体,不过这个方法体是空的。这回抽象类就没有抽象方法了。它就可以不在抽象了。

    当你这么尝试之后,你发现,原来的代码没有任何变化。大家都还是和原来一样,工作的很好。你这回可能更加相信,抽象类根本就没有什么用。但总是不死心,它应该有点用吧,不然创造Java的这伙传说中的天才不成了傻子了吗?

    接下来,我们来写一个小游戏。俄罗斯方块!我们来分析一下它需要什么类?

    我知道它要在一个矩形的房子里完成。这个房子的上面出现一个方块,慢慢的下落,当它接触到地面或是其它方块的尸体时,它就停止下落了。然后房子的上面又会出现一个新的方块,与前一个方块一样,也会慢慢的下落。在它还没有死亡之前,我可以尽量的移动和翻转它。这样可以使它起到落地时起到一定的作用,如果好的话,还可以减下少几行呢。这看起来好象人生一样,它在为后来人努力着。

    当然,我们不是真的要写一个游戏。所以我们简化它。我抽象出两个必须的类,一个是那个房间,或者就它地图也行。另一个是方块。我发现方块有很多种,数一下,共6种。它们都是四个小矩形构成的。但是它们还有很多不同,例如:它们的翻转方法不同。先把这个问题放到一边去,我们回到房子这个类中。

    房子上面总是有方块落下来,房子应该有个属性是方块。当一个方块死掉后,再创建一个方块,让它出现在房子的上面。当玩家要翻转方法时,它翻转的到底是哪个方块呢?当然,房子中只有一个方块可以被翻转,就是当前方块。它是房子的一个属性。那这个属性到底是什么类型的呢?方块有很多不同啊,一共有6种之多,我需要写六个类。一个属性不可能有六种类型吧。当然一个属性只能有一种类型。

    我们写一个方块类,用它来派生出6个子类。而房子类的当前方块属性的类型是方块类型。它可以指向任何子类。但是,当我调用当前方块的翻转方法时,它的子类都有吗?如果你把翻转方法写到方块类中,它的子类自然也就有了。可以这六种子类的翻转方法是不同的。我们知道'田'方块,它只有一种状态,无论你怎么翻转它。而长条的方块有两种状态。一种是‘-’,另一种是‘|’。这可怎么办呢?我们知道Java的多态性,你可以让子类来重写父类的方法。也就是说,在父类中定义这个方法,子类在重写这个方法。

    那么在父类的这个翻转方法中,我写一些什么代码呢?让它有几种状态呢?因为我们不可能实例化一个方块类的实例,所以它的翻转方法中的代码并不重要。而子类必须去重写它。那么你可以在父类的翻转方法中不写任何代码,也就是空方法。

    我们发现,方法类不可能有实例,它的翻转方法的内容可以是任何的代码。而子类必须重写父类的翻转方法。这时,你可以把方块类写成抽象类,而它的抽象方法就是翻转方法。当然,你也可以把方块类写为非抽象的,也可以在方块类的翻转方法中写上几千行的代码。但这样好吗?难道你是微软派来的,非要说Java中的很多东西都是没有用的吗?

    当我看到方块类是抽象的,我会很关心它的抽象方法。我知道它的子类一定会重写它,而且,我会去找到抽象类的引用。它一定会有多态性的体现。

    但是,如果你没有这样做,我会认为可能会在某个地方,你会实例化一个方块类的实例,但我找了所有的地方都没有找到。最后我会大骂你一句,你是来欺骗我的吗,你这个白痴。

    把那些和“东西”差不多的类写成抽象的。而水杯一样的类就可以不是抽象的了。当然水杯也有几千块钱一个的和几块钱一个的。水杯也有子类,例如,我用的水杯都很高档,大多都是一次性的纸水杯。

    记住一点,面向对象不是来自于Java,面向对象就在你的生活中。而Java的面向对象是方便你解决复杂的问题。这不是说面向对象很简单,虽然面向对象很复杂,但Java知道,你很了解面向对象,因为它就在你身边。

    更多相关内容
  • PHP抽象类如何定义,PHP...例如,如果某个方法在抽象类中的访问级别是受保护的,继承类中它就必须是受php 抽象类使用时应注意哪些php抽象类使用要点与注意事项如下:abstract 来修饰一个方法,那么该方法就是抽象...

    PHP抽象类如何定义,PHP抽象类的应用规则

    要充分发挥抽象类的特点,就必须牢记以下规则1.某个类只要包含至少一个抽象方法就必须声明为抽象类.2.声明为抽象的方法,在实现的时候必须包含相同的或者更低的访问级别.例如,如果某个方法在抽象类中的访问级别是受保护的,在继承类中它就必须是受

    php 抽象类使用时应注意哪些

    4435cb01c52f1ed49758603841a83b79.png

    php抽象类使用要点与注意事项如下:

    用abstract 来修饰一个方法,那么该方法就是抽象方法;

    php中抽象类的作用是什么?

    刚看完php抽象类,抽象类是为了让一些方法在继承的类中具体去实现,抽象类抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。 在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的。

    php的抽象类和普通类的区别是什么

    如果像例子中从mysql 移植到 sqlserver ,那么逻辑层所有的数据库操作类提供一个规范,继承该抽象类的所有的类, 都要实现抽象类中定义的方法。

    php抽象类和普通类有什么不同

    对接口的使用是通过关键字implements。对抽象类的使用是通过关键字extends。当然接口也可以通过关键字extends继承。

    接口中不可以声明成员变量(包括类静态变量),但是可以声明类常量。抽象类中可以声明各种类型成员变量。

    php的抽象类和接口的区别

    接口中不可以声明成员变量(包括类静态变量),但是可以声明类常量。抽象类中可以声明各种类型成员变量,实现数据的封装。 接口没有构造函数,抽象类可以有构造函数。 接口中的方法默认都是public类型的,而抽象类中的方法可以使用private,prote

    php 什么情况用接口和抽象类

    php 用接口和抽象类的情况: 接口是一种协定,抽象类则相当于类模板。 使用抽象类,而不要使用接口来分离协定与实现。 如果需要提供多态层次结构的值类型,使用接口。 如果一个类型必须实现多个协定,或者协定适用于多种类型,使用接口。

    展开全文
  • 对于面向对象编程来说,抽象是它的一大特征之一。Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。...如果一个类含有抽象方法,则称这个类为抽象类抽象类必须类前abstract关键字修饰。因为
  • 我们的工作学习中都起着很多决定性的作用,学习Java的时候我们的老师或者课本或者一些权威或许会告诉我们抽象类什么什么,接口是什么什么,但是你有没有想过你自己日常的编程当中使用过多少次的抽象类,...

    前言

    总所周知抽象类和接口是Java里面比较重要的俩个对象,在我们的工作学习中都起着很多决定性的作用,在学习Java的时候我们的老师或者课本或者一些权威或许会告诉我们抽象类是什么什么,接口是什么什么,但是你有没有想过你自己在日常的编程当中使用过多少次的抽象类,像常见的MVC架构,业务层我们会去使用一个接口然后一个实现类,如果你写了个抽象类然后一个实现类估计会被骂的狗血临头,像现在使用最多的MyBatis,为什么他是一个接口形式然后对应的mapper文件去映射接口,而不是一个抽象类文件,mapper去映射抽象类。

    实现的区别

    谈到区别就绕不开目前坊间的一些区别,这里我也不细述,毕竟都知道,贴一张图,别的博客找的
    在这里插入图片描述

    那么问题来了,这是他们具体实现上面的区别,但是他们本质又有什么区别,凭什么MVC架构设计师让我们用接口不用抽象类,凭什么MyBatis设计师让我们用接口不用抽象类。
    引用 《计算机科学》 上面的对抽象类的定义:

    抽象类被定义为永远不会也不能被实例化为具体的对象。它往往用于定义一种抽象上的概念,在类的继承关系中它往往被定义在较上层的位置。在程序设计的实践活动中,抽象类与接口存在类似的地方,即它更偏重于对共通的方法和属性进行规约。但与接口存在一个非常大的差异则在于,抽象类往往可以规约一个共同的方法和属性时提供一个对他们的实现。
    以现实世界为例:“水果”可以算作一个抽象类,而“苹果”、“香蕉”则可以作为它的派生类。区别在于,“水果”是个概念,它不会有实例,但是“苹果”、“香蕉”则肯定会有实例。

    那么我们是不是可以认为所有抽象类都是的基层类,而接口就是具体的规则需求,站在面向对象的角度,来看待我们的现实生活,类似于建筑一个房子,你的装修风格,北欧式的日式的,这时候这些设计风格上面统称为实现了抽象类,那具体的怎么去做,每个家具的摆放位置,那就是按照接口去完成。那站在MVC、MyBatis等框架的设计角度来看,房子样式他们已经帮你选好了,你要做的就是摆放家具了。

    引申的思考

    那么除了这些以外是不是应该还有更本质的一点东西,什么装修风格,什么家具摆放,为什么他们就得是这样。那回到他们的本身,Java许多的东西被设计出来都是有自己独特的设计理念和思考在里面的,也就是我们常说的设计模式,那体现在抽象类和接口上面所对应的具体的设计模式,一个是模板模式一个是策略模式。
    模板模式:

    在模板模式(Template Pattern)中,一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现,但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

    策略模式:

    在策略模式(Strategy Pattern)中,一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

    这时候许多东西便可以用这种带点学术性质的东西来描述了,像我们最常见的基类Object,他就是一个很显然易见的模板模式的设计思路,所以他是一个抽象类,而不是接口;像我们最常见的接口List,他会根据你的不同的行为需求,为你提供不同的实现类,这个便是策略模式。

    总结

    标题起的多少会有一些噱头成分,关于抽象类和接口区别是许多面试经常会被问到的一些东西,每次回答也是千篇一律的答案,但是坐下来细细思考,里面耐人寻味的东西还是比较多的,Java的设计思想是很重要的一种东西,作为一个常年CRUD的开发者,弄明白为什么这东西要这样去写,我觉得还是一件很重要的事情。

    展开全文
  • Java中的抽象类和接口

    千次阅读 多人点赞 2022-04-08 15:17:42
    各位铁汁们大家好呀!今天让我们继续学习java,看看java中的抽象类和接口到底是什么? 里面也会讲到多态呀,一起来看看吧

    目录

    什么是抽象类

    抽象类再实现多态中的意义 

    接口是什么


     各位铁汁们大家好呀😊

    😎今天让我们继续学习java,看看java中的抽象类和接口到底是什么🤔? 

    什么是抽象类

    🍑我们之前学过什么是类,那么抽象类是不是也是类的一种呢?

    听名字就感觉好抽象呀!说对了,他就是抽象的,不是具体的。在类中没有包含足够的信息来描绘一个具体的对象,这样的类称为抽象类。

    🌰来看一个抽象类的例子

    // 抽象类和抽象方法需要被 abstract 关键字修饰
    abstract class Shape {
        // 抽象类中的方法一般要求都是抽象方法,抽象方法没有方法体
        abstract void draw();
    }

    大家觉得这个抽象类是不是什么也没干,他唯一的方法draw()还是空的。

    像这样的类是不是就没有包含足够的信息来描绘一个具体的对象,自然也就不能实例化对象了。不信你看:

    🍑那既然一个类不能实例化,那这种抽象类存在的意义是什么呀🤔?别急,存在即合理,听我慢慢道来。


    抽象类在实现多态中的意义 

    🍑抽象类存在的一个最大意义就是被继承,当被继承后就可以利用抽象类实现多态。

    来看一段代码

    // 抽象类和抽象方法需要被 abstract 关键字修饰
    abstract class Shape {
        // 抽象类中的方法一般要求都是抽象方法,抽象方法没有方法体
        abstract void draw();
    }
    // 当一个普通类继承一个抽象类后,这个普通类必须重写抽象类中的方法
    class Cycle extends Shape {
        @Override
        void draw() {  // 重写抽象类中的draw方法
            System.out.println("画一个圆圈");
        }
    }
    
    public class Test4 {
        public static void main(String[] args) {
            //Shape shape = new Shape();  抽象类虽然不能直接实例化
            // 但可以把一个普通类对象传给一个抽象类的引用呀,即父类引用指向子类对象
            Shape shape = new Cycle(); // 这称作:向上转型
            
            /*Cycle cycle = new Cycle();
              Shape shape = cycle // 这是向上转型的另一种写法
             */
            shape.draw();         // 通过父类引用调用被子类重写的方法
        }
    }
    

    运行之后你就会发现神奇的一幕:

     

    大家在看完了代码可能会有很多疑问,别急咱们一个一个的说,

    📝什么是向上转型:一句话总结就是“父类引用指向子类对象”

    向上转型后的变化

    1. 🏀关于方法:父类引用可以调用子类和父类公用的方法(如果子类重写了父类的方法,则调用子类的方法),但子类特有的方法无法调用。
    2. 🏀关于属性: 父类引用可以调用父类的属性,不可以调用子类的属性

    向上转型的作用

    1. 🐟减少一些重复性的代码
    2. 🐟对象实例化的时候可以根据不同需求实例化不同的对象

    🌰这样的话就我们上面的代码就可以理解了

    ​ 

    📝看来,我们可以通过子类对抽象类的继承和重写,抽象类还真有点用呀!

    🍑但这和多态有什么关系呢,抽象类用起来这么麻烦,我还不如直接用普通类,也能达到这样的效果,还不用再写一个子类呢😫?

    🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟

    🌰那行,你再看看下面的代码,你就知道抽象类在实现多态时的好处了。 

    abstract class Shape {
        public abstract void draw(); // 抽象方法不能里有具体的语句
    }
    // 当一个普通类继承一个抽象类的时候,再这个子类中必须重写抽象类中的抽象方法
    class Cycle extends Shape {  
        @Override              // 如果不重写会报错,但如果继承的是普通类则不会报错,用抽象类更安全
        public void draw() {
            System.out.println("画一个圆圈");
        }
    }
    class Flower extends Shape { // 不同的子类对父类的draw方法进行了不同的重写
        @Override
        public void draw() {
            System.out.println("画一朵花");
        }
    }
    class Square extends Shape {
        @Override
        public void draw() {
            System.out.println("画一个正方形");
        }
    }
    
    public class Test4 {
        public static void main(String[] args) {
            Cycle cycle = new Cycle();   // 子类引用cycle
            Flower flower = new Flower(); // 子类引用flower
            Square square = new Square();
            
            // 数组的类型是Shape,即数组中每一个元素都是一个父类引用
            // 在这个过程其实也发生了向上转型,对抽象类中的方法进行了重写
            Shape[] shapes = {cycle, flower, square};  // 父类引用引用不同的子类对象
            for (int i = 0; i < shapes.length; i++) {
                Shape shape = shapes[i]; // 父类引用shape指向—>当前所对应的子类对象
    
                shape.draw();  // 通过父类引用调用子类重写的draw方法
            }
    
        }
    }
    

    🍑调用同一个方法竟然打印出了不同的结果😮,这难道就是所谓的多态🤔 

     是不是有点懵😂,下面我们来解释一下😉

    // 对上面的代码补充一下
    // 可能你对 Shape[] shapes = {cycle, flower, square};不太理解
    // 但上面的代码就相当于 
    
     Shape[] shapes1 = new Shape[3]; // 有三个不同的子类对象呀!数组大小为3
    
    // (将指向->子类对象)的子类引用赋值给父类对象,不就相当于该夫类引用指向->所对应的子类对象吗
    //这是向上转型的另一种写法,应为前面已经实例化了子类对象  Cycle cycle = new Cycle();   
     shapes1[0] = cycle;  // 如果前面没实例化子类对象,就要写成shape1[0] = new Cycle
     shapes1[1] = flower;
     shapes1[2] = square;

    对于多态来说,他有这三个要素

    1. 继承(我们刚才的Cycle类继承Shape抽象类)
    2. 重写(我们子类对draw方法的重写)
    3. 父类指向子类对象(就是shape1[0] = cycle -->也可以称作向上转型) 

    🍑回头再看一下我们的代码,是不是就刚好符合了多态的三要素😉。

    📝当我们的父类引用指向不同的子类对象时,当我们调用同一个draw方法时却输出了不同的结果。(其实就是该方法再子类中被重写成了不同形式)这就叫做多态 。

    嘻嘻😂,其实只要只要结合着例子来看,多态也没那么难理解呀😎

      

    🍑那为啥一定要用抽象类呢😂?我一个普通类继承普通类来实现多态不可以吗🤔

    🌰当然可以,但不太安全有风险;

         

    但如果是抽象类的话,就不一样了😉 

      

    🍑从这我们也可以看出,当用抽象类的时候,编译器自动就对我们是否重写进行了校验,而充分利用编译器的校验, 在实际开发中是非常有意义的 。所以说抽象类还是有用的,嘻嘻😉

    📝好了,相信到这里你对抽象类也有了一个大概的认识😊,下面我们来简单做一下总结

    1. 使用abstract修饰的类或方法,就抽象类或者抽象方法
    2. 抽象类是不能具体的描述一个对象,不能用抽象类直接实例化对象
    3. 抽象类里面的成员变量和成员方法,都是和普通类一样的,只不过就是不能进行实例化了
    4. 当一个普通类继承这个抽象类后,那么这个普通类必须重写抽象类当中的所有的抽象方法🤔(我们之前说过抽象类是不具体的,没有包含足够的信息来描述一个对象,所以我们需要把他补充完整)
    5. 但当一个抽象类A继承了抽象类B,这是抽象类A就可以不重写抽象类B当中的抽象方法
    6. final不能修饰抽象类和抽象方法(因为抽象类存在的最大意义就是被继承,而被final修饰的不能被继承,final和抽象,他们两个是天敌😂)
    7. 抽象方法不能被private修饰(抽象方法一般都是要被重写的,你被private修饰了,还怎么重写😫)
    8. 抽象类当中不一定有抽象方法,但如果一个类中有抽象方法,那么这个类一定是抽象类

    🌰哈哈,上面的8条总结是不是臭长臭长的,大家也不用专门去记(用的多了,自然就记住了😉)

    🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟


    接口是什么

    🍑抽象类是从多个类中抽象出来的模板,如果将这种抽象进行的更彻底,则可以提炼出一种更加特殊的“抽象类”——接口(Interface)🤔。

    📝接口是Java中最重要的概念之一,它可以被理解为一种特殊的类,不同的是接口的成员没有执行体,是由全局常量和公共的抽象方法所组成😎。

    如何定义一个接口呢?下面我们来看一个栗子🌰

    //接口的定义格式与定义类的格式基本相同,将class关键字换成 interface 关键字,就定义了一个接口
    
    public interface 接口名称{
    // 定义变量
    int a = 10;      // 接口当中的成员变量默认都是public static final
    
    // 抽象方法
    public abstract void method1(); // public abstract 是固定搭配,可以不写
    void method2();  //  接口当中的成员方法默认都是public abstract, 更推荐用第二种来定义方法 
    }

    可以看到接口和类其实还是有很多相似点:

    📝接口中也包含抽象方法,所以也不能直接实例化接口🤔,那么我们怎么用接口呢?

    🍑哈哈,很简单😉,我们再用一个普通类实现这个接口不就行了吗😂,不同的是抽象类是被子类来继承而实现的,而接口与类之间则是用关键字implements来实现

    📝就像普通类实现实现抽象类一样,一个类实现某个接口则必须实现该接口中的抽象方法,否则该类必须被定义为抽象类🤔。


     通过接口实现多态

    🍑铁汁们!刚才我们是用抽象类来实现多态,那么现在我们可以尝试用接口来实现多态,嘻嘻😎

    接口可以看成是一种特殊的类,只能用 interface 关键字修饰
    interface IShape {
        int a = 10;   接口当中的成员变量默认都是public static final
        int b = 23;
        void draw();  接口当中的成员方法一般只能是抽象方法,默认是public abstract(JDK1.8以前)
      
        default void show() {
            System.out.println("接口中的其他方法");//接口中的其他方法也可以实现,但要用default修饰
        }
        public static void test() {
            System.out.println("这是接口当中的一个静态的方法");
        }
    }
    
    // 一个普通的类要想实现接口,可以用implement, 
    //因为接口也是抽象方法的,所以实现接口的这个类也要重写抽象方法
    class Cycle implements IShape {
    
        @Override
        public void draw() {
            System.out.println("画一个圆圈");
        }
    }
    class Square implements IShape {
        @Override
        public void draw() {
            System.out.println("画一个正方形");
        }
    }
    class Flower implements IShape {
    
        @Override
        public void draw() {
            System.out.println("画一朵花");
        }
    }
    public class Test4 {
        public static void main(String[] args) {
            // IShape iShape = new IShape(); 接口也不能直接实例化
            Cycle cycle = new Cycle();
            Square square = new Square();
            Flower flower = new Flower();
            // 这里的IShape接口就相当与抽象类中父类,接口类型也是一种引用类型
    
            IShape[] iShapes = {cycle, square, flower}; // 这个过程其实就发生了向上转型
    
            for (IShape iShape : iShapes) { // 增强型的for—each循环,也可以写成普通的for循环形式
                iShape.draw();              // 通过重写实现了多态
            }
        }
    }
    引用变量cycle和square都赋值给了Shape类型的引用变量shape,
    但当执行shape.draw()时,java虚拟机到底要调用谁重写的的draw方法,
    就看此时接口引用的是那个对象的,是shape的、还是cycle的

     😎看一下运行结果😎

     看完代码你可能有点晕😫,但没关系。一般接口咱也不这么用,直接使用抽象类不就好了😉(我只是演示一下用接口也能实现多态😂)

    🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑

    📝下面我们来总结一下Java中接口的几个主要特点

    1. 🌰接口中可以包含变量和方法,变量被隐式指定为 public static final,方法被隐式指定为 public abstract(JDK 1.8 d一个类可以同时实现多个接口,一个类实现某个接口则必须实现该接口中的抽象方法,否则该类必须被定义为抽象类
    2. 🌰接口支持多继承,即一个接口可以继承(extends)多个接口,间接解决了 Java 中类不能多继承的问题。

    🍑那么接口一般用在什么地方呢?

    • 一般情况下,实现类和它的抽象类之前具有 "is-a" 的关系,但是如果我们想达到同样的目的,但是又不存在这种关系时,使用接口。
    • 由于 Java 中单继承的特性,导致一个类只能继承一个类,但是可以实现一个或多个接口,此时可以使用接口。

    🌰下面就让我们来看看接口的正确用法:帮助java实现“ 多继承 ”😎

    由于 Java 中单继承的特性,导致一个类只能继承一个类,但是可以实现一个或多个接口,此时可以使用接口。
    class Animal {
        String name;        // 不能使用private,后面的子类也要用
    
        public Animal(String name) { // 父类的自定义的构造方法
            this.name = name;
        }
    }
    interface IFlying {   // 自定义多种接口
        void fly();
    }
    interface IRunning {
        void run();
    }
    interface ISwimming {
        void swimming();
    }
    // 小鸭子,不仅会跑,还会游泳、飞行
    一个类继承父类,并实现多个接口,间接的解决java中不能多继承的问题
    class Duck extends Animal implements IRunning, ISwimming, IFlying {
    
        public Duck(String name) {  // 子类构造方法
            super(name);            // 必须在子类构造方法的第一行
            // 在给实现子类的构造方法前,先要用super()调用实现父类的构造方法,比较先有父后有子呀!
            // 因为父类自己定义了构造方法,编译器不会自动给给子类构造方法中添加super();来实现父类的构造方法,需要我们自己实现
        }
        // 对接口中的抽象方法进行重写
        @Override
        public void fly() {
            System.out.println(this.name + "正在用翅膀飞");
        }
    
        @Override
        public void run() {
            System.out.println(this.name + "正在用两条腿跑");
        }
    
        @Override
        public void swimming() {
            System.out.println(this.name + "正在漂在水上");
        }
    
    }
    
    public class 接口的使用 {  // 不用学我用中文名作为类名,我只是为演示方便
        public static void main(String[] args) {
            Duck duck = new Duck("第一个小鸭子");  // 实例化鸭子对象
            duck.fly();  // 通过引用 变量名.方法名 输出重写后的方法
            duck.run();
            duck.swimming();
        }
    }
    有人可能会说干嘛用接口,我直接在父类Animal中实现fly、run、swimming这些属性,
    然后不同的动物子类再继承父类这些方法不行吗?
    
    但问题是,鸭子会fly、swimming,那猫会飞和游泳吗?你再写个其他动物的子类是不是就不行了
    而用接口呢?我们只是把这种飞、游泳的行为给抽象出来了,
    
    只要一个子类有这种行为,他就可以实现相对应的接口,接口是更加灵活的
    
    

     📝上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多个接口。

     📝继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 ,能实现接口的类和该接口并不一定有is_a的关系,只要该类有这个接口的特性就行

    猫是一种动物, 具有会跑的特性.

    青蛙也是一种动物, 既能跑, 也能游泳

    鸭子也是一种动物, 既能跑, 也能游, 还能飞

     🍑这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,只要这个类有有这个特性就好。

    举个栗子🌰

    class Robot implements IRunning {
        private String name;
        public Robot(String name) {
            this.name = name;
        }
        // 对run方法进行重写
        @Override
        public void run() {
            System.out.println("机器人" + this.name + "正在跑");
        }
    }
    public class Test4 {
        public static void main(String[] args) {
            Robot robot1 = new Robot("图图");
            robot1.run();
        }
    }
    // 执行结果
    机器人图图正在跑

    😎只要能跑就行,管他是机器人还是动物呢😂,接口是不是很灵活呀!

    同时在实际的开发过程中,一般来说,一个类是一个Java文件,一个接口也是一个Java文件。大家也要在平时就养成这个好习惯呀!

    哈哈,不知道现在你对抽象类和接口的认识是不是又上升了一个高度呢?嘻嘻,我们下篇博客再见了,下篇让我们瞅瞅Java中常用的接口有哪些😉

     每天进步一点点,铁汁们,一起加油😎😎😎

    展开全文
  • 接口与抽象类的区别校招面试时会被经常问的,理论上的知识作为面试经典大家也都背的很好,但是前几天我面试诺瓦科技的时候,面试官给我来了这么一个问题,“工作中,什么时候要接口,什么时候要用抽象类”。...
  • 什么抽象类?怎么定义?

    千次阅读 2021-09-01 09:47:26
    什么抽象类?怎么定义?这是属于java技术里面的一个知识点,本期教程就是围绕这个问题做的相关介绍,当定义一个类时,常常需要定义一些成员方法描述类的行为特征,但有时这些方法的实现方式是无法确定的。例如,...
  • 主要介绍了Java接口和抽象类用法,结合实例形式总结分析了Java接口与抽象类的具体定义、使用技巧与相关注意事项,需要的朋友可以参考下
  • 主要介绍了Java接口和抽象类原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java中的抽象类到底抽哪?

    千次阅读 多人点赞 2022-04-11 19:53:37
    抽象类到底是用来干嘛的呢?它和普通类的区别又是如何呢?
  • 面试中我们经常被问到:Java中抽象类和接口的区别是什么?  然后,我们大说一通抽象类可以有方法,接口不能有实际的方法啦;一个类只能继承一个抽象类,却可以继承多个接口啦,balabala一大堆,好像把标准答案...
  • (2)特点:抽象成员必须在抽象类中声明,但抽象类不要求必须包含抽象成员,抽象类只能当做基类使用,而不能直接实例化。抽象类的用途提供多个派生类可共享的基类的公共定义。 (3)举例: public abstract class ...
  • 抽象类和接口的区别及使用场景

    千次阅读 2020-01-02 15:49:00
    面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就可以称之为抽象类。 1.抽象方法:使用...
  • 1、抽象类有以下几个特性: 1、抽象方法必须为public、protected(若为private,则不能给子类继承,子类无法实现该方法,所以无意义),缺省时为public; 2、抽象类不能直接用来创建对象,必须由子类继承并实现其父...
  • 1.抽象类使用场景既想约束子类具有共同的行为(但不再乎其如何实现),又想拥有缺省的方法,又能拥有实例变量如:模板方法设计模式,模板方法使得子类可以不改变算法结构的情况下,重新定义算法中某些步骤的具体...
  • 什么样的类为抽象类: 1、类被abstract修饰的类为抽象类抽象类中可以抽象方法,也可以有非抽象的方法。 2、类中有抽象方法的时候,这个类一定是抽象类,但是接口也有抽象方法,但不是类。 3、继承父类时,...
  • 嗯~~~~~~~~~哈哈 各位coder们是否想过这么一个问题...接下来,我就想一个抽象类定义CRUD,注意这只是一个案例。 package com.order.model; import com.sun.istack.internal.NotNull; import org.bouncycastle.asn1.
  • 抽象类和接口的区别

    2018-06-27 22:45:03
    抽象类必须类前abstract关键字修饰。因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象。 抽象类不一定必须含有抽象方法。比如: 复制代码 public abstract class Dog { //普通方法 void ...
  • 深入理解Java抽象类

    千次阅读 2021-03-01 08:02:43
    基础部分内容差不多讲解完了,今天开始进入Java提高篇...那什么抽象类呢?顾名思义嘛,就是很“抽象”的类,抽象是具体的代名词,就像老板跟你说,大家加油干,努力干活就跟你涨工资,但很多时候都只是光说不做...
  • 一个良好设计的体系中,每个根都应该有一个有用的接口, 可以被应用代码所使用. 如果我们的应用代码被设计成与根一起工作,那么它也可以和任何一个从根继承出来的子类合作. 抽象方法是就像子类中一般的方法的...
  • Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。这两者有太多相似的地方,又有太多不同的地方。很多人初学的时候会以为它们可以随意互换使用,但是实际则不然。今天我们就一起来学习一下Java中的接口...
  • 接口通常被用来表示附属描述或行为如:Runnable、Clonable、Serializable 等等,因此当你 使用抽象类来表示行为时,你的类就不能同时是 Runnable 和 Clonable(注:这里的意思是指 如果把 Runnable 等实现为抽象
  • 抽象类继承接口

    2020-09-28 10:19:46
    一、抽象类继承接口可以不用完全实现接口中的方法或者不实现接口方法。 1、有利的地方:由于不用完全实现接口,可以实现我们需要的方法,这样就不用全部实现。 2、例子:装饰者模式来解释 (1)、首先创建一个Shape...
  • 抽象类和接口项目中使用的实例

    千次阅读 2018-10-06 19:10:06
    抽象类和接口项目中经常使用如果使用恰当,可以大大精简代码 抽象类:指的是abstract关键字修饰或者类中有抽象方法,那么这个类就是抽象类 特点: 抽象类用关键字 abstract修饰 抽象类的抽象方法没有方法体,...
  • 抽象类还是一个类,但不同的地方在于不能实例化对象,要想使用抽象类,它必须被继承 定义抽象类使用修饰关键字:abstract来修饰类,表示是一个抽象类,例如 public abstract class Employee{ //定义抽象类成员 }...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 355,961
精华内容 142,384
关键字:

抽象类用在什么地方