站长家园(原代码之家)(www.adminjie.com)网站源码,微信源码,游戏源码,商业源码分享平台。
当前位置:网站首页 技术文章 网络编程 正文

完全掌握Java中的抽象类和接口

时间:2022-06-21 [网络编程]作者:fabuyuan 浏览:1 次

本篇文章给大家带来了关于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. 抽象类当中不一定有抽象方法,但如果一个类中有抽象方法,那么这个类一定是抽象类

接口是什么

抽象类是从多个类中抽象出来的模板,如果将这种抽象进行的更彻底,则可以提炼出一种更加特殊的“抽象类”——接口(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

转载请注明来源:完全掌握Java中的抽象类和接口

本文永久链接地址:https://www.adminjie.com/post/13749.html

免责声明:
本站所发布的一切资源仅限用于学习和研究目的;不得将上述内容用于商业或者非法用途,否则,一切后果请用户自负。本站信息来自网络,版权争议与本站无关。您必须在下载后的24个小时之内,从您的电脑中彻底删除上述内容。如果您喜欢该程序,请支持正版软件,购买注册,得到更好的正版服务。

附:
二○○二年一月一日《计算机软件保护条例》第十七条规定:为了学习和研究软件内含的设计思想和原理,通过安装、显示、传输或者存储软件等方式使用软件的,可以不经软件著作权人许可,不向其支付报酬!鉴于此,也希望大家按此说明研究软件!

版权声明:
一、本站致力于为软件爱好者提供国内外软件开发技术和软件共享,着力为用户提供优资资源。
二、本站提供的部分源码下载文件为网络共享资源,请于下载后的24小时内删除。如需体验更多乐趣,还请支持正版。
三、我站提供用户下载的所有内容均转自互联网。如有内容侵犯您的版权或其他利益的,若有侵犯你的权益请:提交版权证明文件到邮箱 2225329873#qq.com(#换为@) 站长会进行审查之后,情况属实的会在三个工作日内为您删除。

  • 站长家园(原代码之家)会员升级
  • 最新文章
    • 完全掌握Java中的抽象类和接口

      完全掌握Java中的抽象类和接口

      本篇文章给大家带来了关于java的相关知识,其中主要介绍了关于抽象类和接口的相关问题,包括了什么是抽象类、抽象类再实现多态中的意义等等内容,下面一起来看一下,希...

    • 实例讲解Python批量修改文件名

      实例讲解Python批量修改文件名

      本篇文章给大家带来了关于python视频教程的相关知识,其中主要介绍了关于批量修改文件名的相关问题,包括了在原有的名字前中后批量加字、所有文件重新命名并添加序号...

    • mysql中有关键字吗

      mysql中有关键字吗

      mysql中有关键字。mysql中提供了多种关键字:1、BETWEEN,用在WHERE语句之后的时间或者数字的范围查询;2、CALL,用于调用存储过程;3、CU...

    • uni-app入门:项目创建及原生tabbar配置

      uni-app入门:项目创建及原生tabbar配置

      uni-app是使用Vue.js开发跨平台应用的前端框架,开发者编写一套代码,可编译到iOS、Android、H5、小程序等多个平台。相比原生小程序开发,...

    • PHP是一种垂死的语言吗?

      PHP是一种垂死的语言吗?

      似乎这个问题每年都会被问到,因为出于某种原因,人们对PHP的看法是它是业余爱好者使用的一种语言,或者是一种垂死的语言——一种正在消亡的编程语言。在我们了解“...

    热门文章