Java中的抽象类与接口

最新推荐文章于 2022-05-17 20:19:03 发布
最新推荐文章于 2022-05-17 20:19:03 发布
阅读量744 收藏 4
点赞数 1
分类专栏： Java编程思想 文章标签： 抽象类 java 接口 编程语言 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lzy410992/article/details/107855854
版权

接口和内部类为我们提供了一种接口与实现分离的更加结构化的方法；不同的子类可以用不同的方式表示此接口。通接口建立起一种基本形式，以此表示所有导出类的共同部分；

抽象类与接口

1.1 抽象类和抽象方法

想要学习接口，首先需要了解抽象类，它是普通的类与接口之间的一种中庸之道；因为不可能总是使用纯接口，所以抽象类仍旧有着重要的作用。

Java提供一个叫做抽象方法的机制，这种方法是不完整的；仅有声明而没有方法体。语法如下：abstract void f();包含抽象方法的类叫做抽象类。创建抽象类和抽象方法非常有用，因为它们可以使类的抽象性明确起来，并告诉用户和编译器打算怎样来使用它们。抽象类还是很有用的重构工具，因为它们使得我们可以很容易地将公共方法沿着继承层次结构向上移动。
例：

abstract class Rodent {
    private String name = "Rodent";
    abstract protected void eat();
    abstract protected void run();
    abstract protected void sleep();
    abstract public String toString();
}

class Mouse extends Rodent {
    private String name = "Mouse";
    protected void eat() {
        System.out.print("Mouse.eat() "); }
    protected void run() {
        System.out.print("Mouse.run() "); }
    protected void sleep() {
        System.out.print("Mouse.sleep() "); }
    public String toString() { return name; }
}

class Rat extends Rodent {
    private String name = "Rat";
    protected void eat() {
        System.out.print("Rat.eat() "); }
    protected void run() {
        System.out.print("Rat.run() "); }
    protected void sleep() {
        System.out.print("Rat.sleep() "); }
    public String toString() { return name; }
}

class Squirrel extends Rodent {
    private String name = "Squirrel";
    protected void eat() {
        System.out.print("Squirrel.eat() "); }
    protected void run() {
        System.out.print("Squirrel.run() "); }
    protected void sleep() {
        System.out.print("Squirrel.sleep() "); }
    public String toString() { return name; }
}

public class RodentTest {
    public static void main(String[] args) {
        Rodent []rodents={ new Mouse(), new Rat(), new Squirrel()};
        for(Rodent r : rodents) {
            System.out.println("\n"+r.toString()+":");
            r.eat();
            r.run();
            r.sleep();
        }
    }
}
   Output:
      Mouse:
      Mouse.eat() Mouse.run() Mouse.sleep() 
      Rat:
      Rat.eat() Rat.run() Rat.sleep() 
      Squirrel:
      Squirrel.eat() Squirrel.run() Squirrel.sleep()

总结：
抽象方法： 前面由abstract声明，只要方法体，没有具体实现

抽象类： 含有一个或多个抽象方法的抽象类，但一般不包括全部都是抽象方法，全部都是抽象方法接下来会介绍是接口；抽象类需要使用abstract声明

注意：

  • 1.如果一个类包含一个或多个抽象方法，该类必须被限定为抽象类。(否则，编译器就会报错。)
  • 2.如果从一个抽象类继承，并想创建该新类的对象，那么必须为基类中的所有抽象方法提供方法定义，如果不这么做，那么导出类便也是抽象类，且编译器将会强制我们用abstract关键字来限定这个类。
  • 3.抽象类并不需要所有的方法都是抽象的，只要有一个抽象方法就是抽象类
  • 4.抽象类可以被继承，但不能创建对象，导出类必须实现所有的抽象方法，否则仍然是抽象类，且必须加abstract声明

1.2 接口

interface关键字使抽象方法的概念更向前迈进了一步。abstract关键字允许人们在类中创建一个或多个没有任何定义的方法–提供了接口部分，但是没有提供任何任何相应的具体实现，这些实现是由此类的继承者创建的。

interface这个关键字产生一个完全抽象的类，它根本没有提供任何具体实现。它允许创建者确定方法名、参数列表和返回类型，但是没有任何方法体。接口只提供了形式，而未提供任何具体实现。任何使用某特定接口的代码都知道可以调用该接口的哪些方法，而且仅需知道这些。因此，接口被用来建立类与类之间的协议。

要想创建一个接口，需要用interface关键字来替代calss关键字，就像类一样，可以在interface关键字前面添加public关键字。如果不添加public关键字，则它只具有包访问权限，这样就只能在同一个包内可用。接口也可以包含域，但是这些域隐式的是static和final的。要让一个类遵循某个特定接口(或者是一组接口),需要使用implements关键字，它表示：“interface只是它的外貌，但是现在我要声明它是如何工作的”，除此之外，它看起来还很像继承。

例：

interface Rodent {
    String name = "Rodent";
    void eat();
    void run();
    void sleep();
    String toString();
}

class Mouse implements Rodent {
    private String name = "Mouse";
    public void eat() {
        System.out.print("Mouse.eat()"); }
    public void run() {
        System.out.print("Mouse.run()"); }
    public void sleep() {
        System.out.print("Mouse.sleep()"); }
    public String toString() { return name; }
}

class Rat implements Rodent {
    private String name = "Rat";
    public void eat() {
        System.out.print("Rat.eat()"); }
    public void run() {
        System.out.print("Rat.run()"); }
    public void sleep() {
        System.out.print("Rat.sleep()"); }
    public String toString() { return name; }
}

class Squirrel implements Rodent {
    private String name = "Squirrel";
    public void eat() {
        System.out.print("Squirrel.eat()"); }
    public void run() {
        System.out.print("Squirrel.run()"); }
    public void sleep() {
        System.out.print("Squirrel.sleep()"); }
    public String toString() { return name; }
}

public class RodentTest {
    public static void main(String[] args) {
        Rodent[]rodents={ new Mouse(), new Rat(), new Squirrel()};
        for(Rodent r : rodents) {
            System.out.println("\n"+r.toString()+":");
            r.eat();
            r.run();
            r.sleep();
        }
    }
}
	Output:
	  Mouse:
	  Mouse.eat()Mouse.run()Mouse.sleep()
	  Rat:
	  Rat.eat()Rat.run()Rat.sleep()
	  Squirrel:
	  Squirrel.eat()Squirrel.run()Squirrel.sleep()

1.3 完全解耦

只要一个方法操作的是类而非接口，那么你就只能使用这个类及其子类。如果想要将这个方法应用于不在此继承结构中的某个类，那就会出现问题。接口可以在很大程度上放宽这种限制，因此，它使得我们可以编写可复用性更好的代码。将接口从具体实现中解耦使得接口可以应用于多种不同的具体实现，因此代码也就更具有可复用性。

继承与接口

2.1 Java中的多重继承

接口不仅仅是一种更纯粹形式的抽象类，接口没有任何具体实现–也就是说，没有任何与接口相关的存储；因此，也就无法阻止多个接口的组合。组合多个类的接口的行为被称作多重继承，在Java中，可以执行多重继承，但是只有一个类可以有具体实现；
在这里插入图片描述

在导出类中，不强制要求必须有一个是抽象的或“具体的”基类。如果要从一个非接口的类继承，那么只能从一个类去继承，其余的基元素必须是接口。需要将所有的接口名都置于implements关键字之后，用逗号将它们一一隔开。可以继承任意多个接口，并可以向上转型为每个接口，因为每个接口都是一个独立类型。

下面例子展示了一个具体类组合数个接口之后产生一个新类：

interface CanFight{
    void fight();
}
interface CanSwim{
    void swim();
}
interface CanFly{
    void fly();
}
class ActionCharacter{
    public void fight(){};
}
class Hero extends ActionCharacter implements CanFight,CanSwim,CanFly{
    @Override
    public void swim() {}
    @Override
    public void fly() {}
}
public class Adventure {
    public static void t(CanFight x){x.fight();}
    public static void u(CanSwim x){x.swim();}
    public static void v(CanFly x){x.fly();}
    public static void w(ActionCharacter x){x.fight();}

    public static void main(String[] args) {
        Hero hero=new Hero();
        t(hero);
        u(hero);
        v(hero);
        w(hero);
    }
}

Hero组合了具体类ActionCharacter和接口CanFight、CanSwim和CanFly。当通过这种方式讲一个具体类和多个接口组合到一起时，这个具体类必须放在前面，后面跟着的才是接口。

2.2 使用接口的核心原因：

  • 1.为了能够向上转型为多个基类型(以及由此带来的灵活性)；
  • 2.防止客户端程序员创建该类的对象，并确保这仅仅是建立一个接口(这与使用抽象类原因相同)

2.3 通过继承来扩展接口

通过继承，可以很容易地在接口中添加新的方法声明，还可以通过继承在新接口中组合数个接口，这两种方式都可以获得新的接口。

interface Monster{
    void menace();
}
interface DangerousMonster extends Monster{
    void destroy();
}
interface Lethal{
    void kill();
}
class Dragon implements DangerousMonster{
    @Override
    public void menace() {}
    @Override
    public void destroy() {}
}
interface Vampire extends DangerousMonster,Lethal{
    void drinkBlood();
}
class VeryBadVampire implements Vampire{
    @Override
    public void menace(){}
    @Override
    public void destroy(){}
    @Override
    public void kill(){}
    @Override
    public void drinkBlood(){}
}
public class HorrorShow {
    static void u(Monster b){b.menace();}
    static void v(DangerousMonster d){
        d.menace();
        d.destroy();
    }
    static void w(Lethal l){l.kill();}
    public static void main(String[] args) {
        DangerousMonster barney=new Dragon();
        u(barney);
        v(barney);
        Vampire vlad=new VeryBadVampire();
        u(vlad);
        v(vlad);
        w(vlad);
    }
}

DangerousMonster是Monster的直接扩展，它产生了一个新接口。Dragon中实现了这个接口；
在Vampire中使用的语法仅适用于接口继承，一般情况下，只可以将extends用于单一类，但是可以引用多个基类接口，只需用逗号将接口名一一分隔开即可。

2.4 适配接口

接口最吸引人的原因之一就是允许同一个接口具有多个不同的具体实现。在简单的情况中，它的体现形式通常是一个接受接口类型的方法，而该接口的实现和向该方法传递的对象则取决于方法的使用者。

使用接口，你主要就是要声明：“你可以用任何你想要的对象来调用我的方法，只要你的对象遵循我的接口”。这使得方法更加灵活、通用，并更具有可复用性。我们可以再任何有类之上添加新的接口，所以这意味着让方法接受接口类型，是一种让任何类都可以对该方法进行适配的方式。这就是使用接口而不是类的强大之处。

2.5 接口中的域

因为放入接口中的任何域都是static和final的，所以接口就成为了一种很便捷的用来创建常量组的工具。在接口定义的域不能是 “空final”，但是可以被非常量表达式初始化。

2.6 嵌套接口

接口可以嵌套在类或其他接口中。例：

class A{
    interface B{
        void f();
    }
    public class BImp implements B{
        @Override
        public void f() {}
    }
    private class BImp2 implements B{
        public void f(){}
    }
    public interface C{
        void f();
    }
    class CImp implements C{
        @Override
        public void f() {}
    }
    private class CImp2 implements C{
        @Override
        public void f() {}
    }
    public interface D{
        void f();
    }
    class DImp implements D{
        @Override
        public void f() {}
    }
    private class DImp2 implements D{
        @Override
        public void f() {
        }
    }
    public D getD(){
        return new DImp2();
    }
    private  D dRef;
    public void receiveD(D d){
        dRef=d;
        dRef.f();
    }
}
interface  E{
    interface G{
        void f();
    }
    public interface  H{
        void f();
    }
    void g();
}
public class NestingInterfaces {
    public class BImp implements A.B {
        @Override
        public void f() {}
        class CImp implements A.C{
            @Override
            public void f() {}
        }
        class EImp implements  E{
            @Override
            public void g() {}
        }
        class EGImp implements E.G{
            @Override
            public void f() {}
        }
        class EImp2 implements E{
            @Override
            public void g() {}
        }
        class EG implements E.G{
            @Override
            public void f() {}
        }
    }
    public static void main(String[] args){
        A a=new A();
        A.D ad=a.getD();
    }
}

在类中嵌套接口的语法是相当显而易见的，就像非嵌套接口一样，可以拥有public和 “包访问” 两种可视性。

接口与工厂

接口是实现多重继承的途径，而生成遵循某个接口的对象的典型方式就是工厂方法设计模式。这与直接调用构造器不同，在工厂对象上调用的是创建方法，而该工厂对象将生成接口的某个实现的对象。
理论上，通过这种方式，我们的代码将完全与接口的实现分离，这就使得我们可以透明地将某个实现替换为另一个实现。下面的实例展示了工厂方法的结构：

interface Service{
    void method1();
    void method2();
}
interface ServiceFactory{
    Service getService();
}
class Implementation1 implements Service{
    Implementation1(){}
    public void method1() {
        System.out.println("Implementation1 method1");
    }
    public void method2() {
        System.out.println("Implementation1 method2");
    }
}
class Implementation1Factory implements ServiceFactory{

    public Service getService() {
        return new Implementation1();
    }
}
class Implementation2 implements Service{
    Implementation2(){}
    public void method1() {
        System.out.println("I2menthod");
    }
    public void method2() {
        System.out.println("I2method2");
    }
}
class Implementation2Factory implements ServiceFactory{

    @Override
    public Service getService() {
        return new Implementation2();
    }
}
public class Factories {
    public static void serviceConsumer(ServiceFactory fact){
        Service s=fact.getService();
        s.method1();
        s.method2();
    }
    public static void main(String[] args){
        serviceConsumer(new Implementation1Factory());
        serviceConsumer(new Implementation2Factory());
    }
}
龙源lll
关注
专栏目录
Java之抽象类与接口
清风与岚的博客
04-18 181
一、抽象类与抽象方法 1、定义： 1）抽象方法： a、在抽象类中被创建，只定义而不实现，由子类重写的方法。 b、只能方法头，没有方法体。即不存在方法头后没有{ } 2）抽象类： a、只声明而不实现的类。 b、抽象类中可以有抽象方法，也可以有非抽象的方法。 2、格式： 定义抽象类： 在class前加上abstract abstract class 类名{ 类体 } cl...
接口与抽象类
谷雨
08-20 332
抽象类 包含抽象方法的叫做抽象类，抽象类中也可以含普通方法。 接口 接口没有提供任何实现，而抽象类中还可以有一些实现。 接口中可以包含成员变量，比如说int x=5；但默认的就是static final的。 接口中的多重继承 //: interfaces/Adventure.java // Multiple interfaces. interface CanFight { v
Zookeeper学习笔记(二)--通过Java操作Zookeeper
qq_43404873的博客
12-24 1641
Zookeeper JavaAPI znode是zooKeeper集合的核心组件，zookeeper API提供了一小组方法使用zookeeper集合来操纵znode的所有细节。 客户端应该遵循以下步骤，与zookeeper服务器进行清晰和干净的交互 连接到zookeeper服务器，zookeeper服务器为客户端分配会话ID。 定期向服务器发送心跳。否则，zookeeper服务器将过期会话ID，客户端需要重新连接。 只要会话ID处于活动状态，就可以获取/设置znode 所有任务完成后，断开与zookee
java编程思想 接口_java编程思想——接口
weixin_35838394的博客
02-26 174
接口与内部类为我们提供了一种接口与实现分离的更加结构化的方法。1.抽象类与抽象方法抽象类，作为普通的类和接口之间的一种中庸之道。抽象方法：仅有声明而没有方法体，如abstract void play();抽象方法必须用abstract修饰，且必须为public或者protected。抽象类:包含抽象方法的类。若一个类包含一个或者多个抽象方法，该类必须限定为abstract(抽象的)。抽象类不能实例...
JAVA基础 - abstract - 抽象类/抽象方法
一名小安卓的博客
05-10 401
/** * 抽象类 * * @author LXL 2017年5月8日 */ // 父类 public abstract class Person { /** * 抽象类: 专门用来当做父类, 含有抽象方法, 用abstract关键字来修饰的类 * 含有抽象方法的类必须是抽象类. * 抽象类不能被实例化. 即不能直接用new关键字去产生对象. * 抽象类的子类必须覆
Java中抽象类与接口的比较.pdf
最新发布
12-27
Java 中抽象类与接口的比较 Java 语言中，抽象类（abstract class）和接口（interface）是两种支持抽象类定义的机制。抽象类和接口之间存在着许多相似性，但是也存在本质的区别。 一、 抽象类 在 Java 程序设计中...
JAVA中抽象类与接口的应用.pdf
12-27
JAVA中抽象类与接口的应用
java抽象类与接口实例java抽象类与接口实例
06-22
java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例...
Java中抽象类和接口的区别
05-03
在Java语言中，abstract class和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，...
Java使用ZooKeeper和节点的增删改查
tanxinji的博客
05-17 420
 1.导入依赖 <dependency> <groupId>org.apache.zookeeper</groupId> <artifactId>zookeeper</artifactId> <version>3.4.6</version> </dependency>  2.创建ZooKeeper对象 ...
接口（3）：java中的多重继承、通过继承来扩展接口、适配接口
游王子的博客
02-08 1107
一、java中的多重继承 接口不仅仅只是一种更纯粹形式的抽象类，它的目标比这要高。因为接口是根本没有任何具体实现的--也就是说，没有任何与接口相关的存储；因此，也就无法阻止多个接口的组合。这一点是很有价值的，因为你有时需要去表示“一个x是一个a和一个b以及一个c”。在C++中，组合多个类的接口的行为被称作多重继承。它可能会使你背负很沉重的包袱，因为每个类都有一个具体实现。在java中，你...
Java源码分析——String、AbstractStringBuilder、StringBuffer、StringBuilder类（一）——String类、intern方法
溯夜，逆流而上
10-24 168
在Java中，与C++一样，也是亲自封装了字符串，命名为String类，用来对字符串的常用操作，其中Java也仿照String类设计出了其它的几个字符串类，用来处理String类不能处理的场景，分别是StringBuffer类与StringBuilder类
Java 抽象类（学习 Java 编程语言 045）
bupuxiang的专栏
01-29 176
如果将一个类声明为 abstract，那么这个类就是抽象类。抽象类可以包含抽象方法、字段和具体方法。抽象类不能被实例化，但抽象类的对象变量可以引用了一个非抽象子类的实例。 如果自下而上在类的继承层次结构中上移，位于上层的类更具有通用性，可能更加抽象。从某种角度看，祖先类更有一般性，人们只将它作为派生其他类的基类，而不是用来构造你想使用的特定的实例。例如，考虑扩展 Employee 类层次结构。员工是一个人，学生也是一个人。下面扩展我们的类层次结构来加入类 Person 和类 Student。下图显示了这三个
abstract类_012、Java的抽象方法、接口和String类
weixin_39546312的博客
11-22 131
1. 抽象方法和抽象类·抽象方法 使用abstract修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。·抽象类 包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。抽象类和抽象方法的基本用法抽象类的使用要点: 1. 有抽象方...
通过继承来扩展接口
Lazy_Die的博客
05-29 353
package interfaces.filter; /**  * 通过继承来扩展接口  *   * */ interface Monster{ void menace(); } interface DangerousMonster extends Monster{ void destroy(); } interface lethal{ void kill(); } c
java zookeeper 使用_java 中 zookeeper简单使用
weixin_42514222的博客
02-12 3856
一、zookeeper的基本原理数据模型，如下：ZooKeeper数据模型的结构与Unix文件系统很类似，整体上可以看作是一棵树，每个节点称做一个ZNode。每个ZNode都可以通过其路径唯一标识，比如上图中第三层的第一个ZNode,它的路径是/app1/c1。在每个ZNode上可存储少量数据(默认是1M, 可以通过配置修改,通常不建议在ZNode上存储大量的数据)，这个特性非常有用。另外，每个Z...
深入理解Java的接口和抽象类
zhouhero的博客
09-11 307
深入理解Java的接口和抽象类 　　对于面向对象编程来说，抽象是它的一大特征之一。在Java中，可以通过两种形式来体现OOP的抽象：接口和抽象类。这两者有太多相似的地方，又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用，但是实际则不然。今天我们就一起来学习一下Java中的接口和抽象类。下面是本文的目录大纲： 　　一.抽象类 　　二.接口 　　三.抽象类和接口的区别
Java中抽象类与接口的区别与选择
"理解抽象类与接口的区别，包括它们在Java中的应用、目的和设计原则。" 在Java编程中，抽象类（abstract class）和接口（interface）都是用于实现抽象化，以支持面向对象的设计。虽然它们在某些方面相似，但它们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

龙源lll

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值