精华内容
下载资源
问答
  • 主要给大家介绍了关于java抽象类、抽象方法接口实现接口的相关资料,文中通过示例代码将四者介绍的非常详细,并且简单介绍了抽象类和接口的区别,需要的朋友可以参考借鉴,下面随着小编来一起学习学习吧。
  • 众所周知,在实现类中实现接口时,必须全部重写接口抽象方法,如 public interface MyInter{  function abstract void A();  function abstract voidB(); } //实现类中,必须全部重写A和B方法 public class ...

    众所周知,在实现类中实现接口时,必须全部重写接口的抽象方法,如

    public interface MyInter{
    
      function abstract void A();
    
      function abstract voidB();
    
    }
    

    //实现类中,必须全部重写A和B方法

    public class MyClass implements MyInter{
    
      public void A(){}
    
      public void B(){}
    
    }
    

    如果不重写接口的方法可以吗?可以,但实现类一定要是一个抽象类

    public abstract class MyClass implements MyInter{
    
      public void A(){} 
    
    }
    

    所以总结如下:

    由普通的类来实现接口,必须将接口所有抽象方法重写
    由抽象类来实现接口,则不必重写接口的方法。可以全部不重写或只重写一部分方法。

    展开全文
  • **抽象类可以使用implements关键字实现接口,但又不用在该抽象类里实现接口里的具体方法(不实现接口的具体方法不会报错),那设计抽象类可以使用implements来实现接口有什么意义啊?** 抽象类: public ...
  • java接口抽象方法的定义与使用

    千次阅读 2020-11-05 22:58:21
    1、定义一个接口类,在接口类里面定义抽象方法 抽象方法的格式: public abstract 返回值类型 方法名称(参数列表); 注意: 接口当中的抽象方法,修饰符必须是两个固定的关键字,即public abstract;这两个关键字不...

    1、定义一个接口类,在接口类里面定义抽象方法

    抽象方法的格式:
    public abstract 返回值类型 方法名称(参数列表);

    在这里插入图片描述
    注意:
    接口当中的抽象方法,修饰符必须是两个固定的关键字,即public abstract;这两个关键字不能更换成别的,但是能够省略。因为是默认的。

    代码代码:

    package demo1;
    
    public interface MyInterfaceAbstract {
        public abstract void abs();
        public abstract void abs1();
        public abstract void abs2();
    }
    
    

    2、由于接口不能直接使用,因此要新建一个类来实现调用

    实现接口类的格式:
    public class 实现类的名称 implements 接口名称{
    方法体:
    }

    步骤一:
    在这里插入图片描述步骤二:
    在这里插入图片描述步骤三:
    在这里插入图片描述
    直接ok~
    如下图:
    在这里插入图片描述
    象征性写输出语句啦:
    在这里插入图片描述
    代码代码:

    package demo1;
    
    public class MyInterfaceImplements implements MyInterfaceAbstract {
    
        @Override
        public void abs() {
            System.out.println("这是第一个抽象方法~");
        }
    
        @Override
        public void abs1() {
            System.out.println("这是第二个抽象方法~");
        }
    
        @Override
        public void abs2() {
            System.out.println("这是第三个抽象方法~");
        }
    }
    
    

    3、创建实现类的对象,进行使用
    在这里插入图片描述
    代码代码:

    package demo1;
    
    public class MyInterfaceUse {
        public static void main(String[] args) {
            MyInterfaceImplements impl = new MyInterfaceImplements();
            impl.abs();
            impl.abs1();
            impl.abs2();
        }
    }
    
    

    运行结果:

    在这里插入图片描述
    注意:如果实现类没有覆盖重写完接口所有的抽象方法,那么这个实现类就必须是抽象类

    展开全文
  • java抽象实现接口

    千次阅读 2019-06-04 10:37:22
    阅读集合框架的源码的时候,发现AbstractConllection继承自Collection,我不太明白为什么使用抽象实现接口,但是经过我查阅资料,然后自己又写了个demo,基本弄明白这么写的好处了,而且,我感觉,这就是抽象工厂...

    阅读集合框架的源码的时候,发现AbstractConllection继承自Collection,我不太明白为什么使用抽象类实现接口,但是经过我查阅资料,然后自己又写了个demo,基本弄明白这么写的好处了,而且,我感觉,这就是抽象工厂模式。

    好处就是,假设接口定义了10多个方法,但是好多方法的实现都是固定不变的,唯独有那么一两个需要实现类写出单独的逻辑,这种情况就很恶心,如果直接实现这个接口,好多方法就得复制一遍,造成代码冗余。所以,我们先使用一个抽象类实现这个接口。我们需要注意,抽象类可以实现接口的所有方法,也可以一个都不实现。接下来看我们的demo

    Trainee接口有四个方法,sing(),jump(),rap(),platBasketball().但是我只想实现platBasketball().

    上代码

    package com.study.basicJava.abstractClass;
    
    public interface Trainee {
    
        void sing();
    
    
        void jump();
    
    
        void rap();
    
    
        void playBasketball();
    }
    

    接着,使用抽象类继承接口

    package com.study.basicJava.abstractClass;
    
    public abstract class AbstractTrainee implements Trainee {
        public void sing(){
            System.out.println("唱,");
        }
        public void jump(){
            System.out.println("跳,");
        }
        public void rap() {
            System.out.println("rap,");
        }
        public abstract void playBasketball();
    }
    

    接着,是我自己的普通实现类

    package com.study.basicJava.abstractClass;
    
    public class Cxk extends AbstractTrainee {
    
        @Override
        public void playBasketball() {
            System.out.println("我是NBA**,喜欢打篮球");
        }
    }
    

    然后,看demo

    package com.study.basicJava.abstractClass;
    
    public class Demo01 {
        public static void main(String[] args) {
            AbstractTrainee trainee = new Cxk();
            System.out.print("我喜欢");
            trainee.sing();
            trainee.jump();
            trainee.rap();
            trainee.playBasketball();
        }
    }
    

    程序运行结果:

    溜了溜了。。害怕律师函警告

    展开全文
  • Java接口抽象方法、默认方法

    万次阅读 多人点赞 2019-04-04 18:33:38
    2. 抽象方法 如果是Java 8,还可以额外包含有: 3. 默认方法 4. 静态方法 如果是Java 9,还可以额外包含有: 5. 私有方法 接口使用步骤: 1. 接口不能直接使用,必须有一个“实现类”来“实现”该接口。 格式: ...
    如果是Java 7,那么接口中可以包含的内容有:
    1. 常量
    2. 抽象方法
    
    如果是Java 8,还可以额外包含有:
    3. 默认方法
    4. 静态方法
    
    如果是Java 9,还可以额外包含有:
    5. 私有方法
    接口使用步骤:
    1. 接口不能直接使用,必须有一个“实现类”来“实现”该接口。
    格式:
    public class 实现类名称 implements 接口名称 {
        // ...
    }
    2. 接口的实现类必须覆盖重写(实现)接口中所有的抽象方法。
    实现:去掉abstract关键字,加上方法体大括号。
    3. 创建实现类的对象,进行使用。

    接口的抽象方法

     

    package cn.itcast.day10.demo01;
    
    /*
    在任何版本的Java中,接口都能定义抽象方法。
    格式:
    public abstract 返回值类型 方法名称(参数列表);
    
    注意事项:
    1. 接口当中的抽象方法,修饰符必须是两个固定的关键字:public abstract
    2. 这两个关键字修饰符,可以选择性地省略。(今天刚学,所以不推荐。)
    3. 方法的三要素,可以随意定义。
     */
    public interface MyInterfaceAbstract {
        // 这是一个抽象方法
        public abstract void methodAbs1();
        // 这也是抽象方法
        abstract void methodAbs2();
        // 这也是抽象方法
        public void methodAbs3();
        // 这也是抽象方法
        void methodAbs4();
    }

    public abstract可以选择性省略。

    package cn.itcast.day10.demo01;
    
    //如果实现类并没有覆盖重写接口中所有的抽象方法,那么这个实现类自己就必须是抽象类。
    public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
    //    Alt + Enter 自动生成
        // 需要全部重写
        @Override
        public void methodAbs1() {
            System.out.println("这是第一个方法!");
        }
        @Override
        public void methodAbs2() {
            System.out.println("这是第二个方法!");
        }
        @Override
        public void methodAbs3() {
            System.out.println("这是第三个方法!");
        }
        @Override
        public void methodAbs4() {
            System.out.println("这是第四个方法!");
        }
    }

    必须通过实现类,来实现该接口,以上实现类覆盖重写了接口中所有抽象方法,只要有一个未重写,那么这个实现类自己就必须是抽象类

    package cn.itcast.day10.demo01;
    
    /*
    接口就是多个类的公共规范。
    接口是一种引用数据类型,最重要的内容就是其中的:抽象方法。
    
    如何定义一个接口的格式:
    public interface 接口名称 {
        // 接口内容
    }
    
    备注:换成了关键字interface之后,编译生成的字节码文件仍然是:.java --> .class。
    
    如果是Java 7,那么接口中可以包含的内容有:
    1. 常量
    2. 抽象方法
    
    如果是Java 8,还可以额外包含有:
    3. 默认方法
    4. 静态方法
    
    如果是Java 9,还可以额外包含有:
    5. 私有方法
    
    接口使用步骤:
    1. 接口不能直接使用,必须有一个“实现类”来“实现”该接口。
    格式:
    public class 实现类名称 implements 接口名称 {
        // ...
    }
    2. 接口的实现类必须覆盖重写(实现)接口中所有的抽象方法。
    实现:去掉abstract关键字,加上方法体大括号。
    3. 创建实现类的对象,进行使用。
    
    注意事项:
    如果实现类并没有覆盖重写接口中所有的抽象方法,那么这个实现类自己就必须是抽象类。
     */
    public class Demo01Interface {
    
        public static void main(String[] args) {
    
            // 错误写法!不能直接new接口对象使用。
    //        MyInterfaceAbstract inter = new MyInterfaceAbstract();
    
            // 创建实现类的对象使用
            MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
            impl.methodAbs1();
            impl.methodAbs2();
        }
    
    }

    使用实现类MyInterfaceAbstractImpl,使用接口中的方法。不能直接new接口对象使用。

    接口的默认方法

    从Java 8开始,接口里允许定义默认方法。
    格式:
    public default 返回值类型 方法名称(参数列表) {
        方法体
    }
    
    备注:接口当中的默认方法,可以解决接口升级的问题。

    改成默认方法后则不必覆盖重写,但可以选择重写与否。

    两个实现类:

    A

    package cn.itcast.day10.demo01;
    
    
    public class MyInterfaceDefaultA implements MyInterfaceDefault {
        @Override
        public void methodAbs() {
            System.out.println("实现了抽象方法,AAA");
        }
    }
    

    B

    package cn.itcast.day10.demo01;
    
    public class MyInterfaceDefaultB implements MyInterfaceDefault {
        @Override
        public void methodAbs() {
            System.out.println("实现了抽象方法,BBB");
        }
    
        @Override  // 覆盖重写了接口的默认方法
        public void methodDefault() {
            System.out.println("实现类B覆盖重写了接口的默认方法");
        }
    }
    

    调用方法:

    package cn.itcast.day10.demo01;
    
    /*
    1. 接口的默认方法,可以通过接口实现类对象,直接调用。
    2. 接口的默认方法,也可以被接口实现类进行覆盖重写。
     */
    public class Demo02Interface {
    
        public static void main(String[] args) {
            // 创建了实现类对象
            MyInterfaceDefaultA a = new MyInterfaceDefaultA();
            a.methodAbs(); // 调用抽象方法,实际运行的是右侧实现类。
            // 调用默认方法,如果实现类当中没有,会向上找接口
            a.methodDefault(); // 这是新添加的默认方法
    
            System.out.println("==========");
    
            MyInterfaceDefaultB b = new MyInterfaceDefaultB();
            b.methodAbs();
            b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
        }
    
    }
    

    1. 接口的默认方法,可以通过接口实现类对象,直接调用。
    2. 接口的默认方法,也可以被接口实现类进行覆盖重写。

    可以看到B中覆盖重写了默认方法。

    程序运行结果:

    实现了抽象方法,AAA
    这是新添加的默认方法
    ==========
    实现了抽象方法,BBB
    实现类B覆盖重写了接口的默认方法
    
    Process finished with exit code 0

     

    展开全文
  • java抽象类实现接口可以不用实现方法 学习struts2时,拦截器接口Interceptor继承了Serializable接口,拦截器抽象类AbstractInterceptor实现了Interceptor接口,在AbstractInterceptor类中却没有声明或...
  • java抽象的两种实现方式(抽象类和接口)及其比较

    千次阅读 多人点赞 2018-02-23 20:57:38
    对于面向对象编程来说,抽象是它的一大特征之一。在Java中,可以通过两种形式来体现面向对象的编程(OOP)的抽象...抽象方法是一种特殊的方法:它只有声明,而没有具体的实现抽象方法的声明格式为: abstract v...
  • 1.接口 (1)接口定义前默认修饰符为public。 (2)接口中变量默认修饰符为...public interface Runer {//接口定义,接口里只包含常量和抽象方法 String texing = "动时必产生振动";//常量默认为public static final void
  • 一、Java接口抽象类的区别?

    千次阅读 2019-10-24 15:41:23
    Java接口抽象类的区别
  • Java 抽象接口 继承 实现

    千次阅读 2016-07-23 17:21:14
    接口抽象类的概念不一样。...人可以吃东西,狗也可以吃东西,你可以把“吃东西”定义成一个接口,然后让这些类去实现它(类实现多个接口实现多个动作). 所以,在高级语言上,一个类只能继承一个类(抽象类,jav
  • //如果抽象类的类体里的方法全部都是抽象方法,可以把这个类定义为接口 //换言之,类体里全部都是抽象方法,可以把这个类定义为接口. interface Runer//接口的定义,接口里只包含常量和抽象方法. { String texing="动时...
  • 接口中定义抽象方法的时候 (抽象方法的一般格式;public abstract 返回值类型 方法名();) (1)但是在接口抽象方法,修饰符必须是两个固定的关键字 public abstract (2)其中public abstract 可以省略 (3)方法...
  • 实现的功能的业务是这样的,动态的获取java接口的所有的实现类并且排除抽象类和接口本身。 代码实现 1.创建接口Animal package com.tcp.executor; public interface Animal { public void say(); } 2.创建抽象类...
  • Java 接口实现(详细版)】

    千次阅读 多人点赞 2021-03-31 09:00:37
    接口实现1 接口二级目录三级目录2 实现接口3 理解接口 1 接口 二级目录 三级目录 2 实现接口 3 理解接口
  • Java中的抽象类、抽象方法接口

    千次阅读 2018-10-25 00:17:17
    Java抽象的前提是继承关系,没有了继承,抽象类就失去了灵魂。在继承关系中,子类可以继承父类的成员变量和成员方法,但是每个子类的方法的具体实现可能不一致,(可以通过重写(方法覆盖)父类的方法解决)但是...
  • 抽象类和接口是两个非常相似的类型,许多人认为这俩...1)抽象类可以提供成员方法实现细节,而接口中只能存在public abstract 方法; 2)抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是public s...
  • Java8新特性--接口的默认方法与静态方法Java8用默认方法与静态方法这两个新概念来扩展接口的声明在这之前先来复习下接口,就拿它和抽象类的区别来说吧:1、设计层面上:抽象类是对事物的抽象,包括事物的属性方法...
  • Java抽象类和接口的区别

    万次阅读 多人点赞 2019-02-07 14:10:07
    对于面向对象编程来说,抽象是它的一大特征之一。在Java中,可以通过两种形式来体现OOP的抽象接口抽象类。...抽象方法是一种特殊的方法:它只有声明,而没有具体的实现抽象方法的声明格式为...
  • java接口可以实现接口吗?抽象类呢?

    万次阅读 多人点赞 2017-05-15 15:52:56
    面试中可能会遇到这样的问题: 1.接口可以实现接口吗? ans:不可以. 2.抽象类可以实现接口吗? ans:可以
  • Java8中的默认方法和静态方法的由来,首先还是先重温一下抽象类和接口的区别:抽象抽象类是用来捕捉子类的通用特性的 。它不能被实例化,只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。public ...
  • Java接口

    千次阅读 多人点赞 2018-12-24 12:00:36
    Java接口也表示IS-A关系。它不能像抽象类一样被实例化。 q) Java为什么需要接口 通过接口实现多继承 用于实现耦合 如下图所示,一个类扩展了另一个类,一个接口扩展了另一个接口,一个类实现了一个接口。 接...
  • 接口对象指向实现类对象,可调用实现类的重写方法 以下就是生活中两种多态的实例,**抽象类是模板,接口是功能。 **描述: Door.java 抽象类 package com.dialogd.polymorphic; //抽象类,抽象类是一种模板 public ...
  • 如标题,Java在继承抽象类并且实现接口时产生了错误,有谁知道解答一下吗?代码: public interface hover { public void stop(); } public abstract class plane { String name; public abstract void move(); } ...
  • Java抽象方法抽象

    千次阅读 2019-06-08 11:43:15
    抽象方法是只有方法签名,没有方法实现方法抽象方法抽象类必须使用abstract修饰符来定义,有抽象方法的类只能被定义为抽象类,抽象类里可以没有抽象方法抽象类和抽象方法的规则: 抽象类必须使用...
  • 所以我们 Java 不用多重继承,用多重实现,but,如果实现了两个接口中,有相同名字的抽象方法,那不还是避免不了所谓的“致命方块”吗?Friend 接口:public interface Friend { public abstract void play() ; ...
  • Java接口抽象类的区别

    千次阅读 2020-12-06 15:13:33
    接口中可以有变量和方法,但是变量会被隐式的指定为public static final变量,而方法会被指定为public abstract【所有方法接口中不能有实现,也说明接口中都是抽象方法】,(Java 8 开始接⼝⽅法可以有默认实现)...
  • [Java基础]Java抽象类和接口中有构造方法吗?

    万次阅读 多人点赞 2017-07-05 10:56:13
    2.问题描述:Java抽象类和接口中有构造方法吗? 3.问题解答: (1)Java抽象类和接口中有构造方法吗? ①在接口中 不可以有构造方法接口里写入构造方法时,编译器提示:Interfaces ...
  • 先继承抽象类在实现接口 class C extends B implements A interface A{ public abstract void say(); } abstract class B{ public abstract void fun(); } class C extends B implements A{ public void say() ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 510,662
精华内容 204,264
关键字:

java接口抽象方法的实现

java 订阅