八、复用（1）

本章概要

  • 组合语法
  • 继承语法
    • 初始化基类
    • 带参数的构造函数
  • 委托

代码复用是面向对象编程（OOP）最具魅力的原因之一。

对于像 C 语言等面向过程语言来说，“复用”通常指的就是“复制代码”。任何语言都可通过简单复制来达到代码复用的目的，但是这样做的效果并不好。Java 围绕“类”（Class）来解决问题。我们可以直接使用别人构建或调试过的代码，而非创建新类、重新开始。

如何在不污染源代码的前提下使用现存代码是需要技巧的。学习以下两种方式来达到这个目的：

  1. 第一种方式直接了当。在新类中创建现有类的对象。这种方式叫做“组合”（Composition），通过这种方式复用代码的功能，而非其形式。
  2. 第二种方式更为微妙。创建现有类类型的新类。照字面理解：采用现有类形式，又无需在编码时改动其代码，这种方式就叫做“继承”（Inheritance），编译器会做大部分的工作。继承是面向对象编程（OOP）的重要基础之一。更多功能相关将在多态（Polymorphism）章节中介绍。

组合与继承的语法、行为上有许多相似的地方（这其实是有道理的，毕竟都是基于现有类型构建新的类型）。在本章中，你会学到这两种代码复用的方法。

组合语法

在前面的学习中，“组合”（Composition）已经被多次使用。你仅需要把对象的引用（object references）放置在一个新的类里，这就使用了组合。例如，假设你需要一个对象，其中内置了几个 String 对象，两个基本类型（primitives）的属性字段，一个其他类的对象。对于非基本类型对象，将引用直接放置在新类中，对于基本类型属性字段则仅进行声明。

class WaterSource {
    private String s;

    WaterSource() {
        System.out.println("WaterSource()");
        s = "Constructed";
    }

    @Override
    public String toString() {
        return s;
    }
}

public class SprinklerSystem {
    private String valve1, valve2, valve3, valve4;
    private WaterSource source = new WaterSource();
    private int i;
    private float f;

    @Override
    public String toString() {
        return "valve1 = " + valve1 + " " +
                        "valve2 = " + valve2 + " " +
                        "valve3 = " + valve3 + " " +
                        "valve4 = " + valve4 + "\n" +
                        "i = " + i + " " + "f = " + f + " " +
                        "source = " + source; // [1]
    }

    public static void main(String[] args) {
        SprinklerSystem sprinklers = new SprinklerSystem();
        System.out.println(sprinklers);
    }
}

WaterSource()
valve1 = null valve2 = null valve3 = null valve4 = null
i = 0 f = 0.0 source = Constructed

这两个类中定义的一个方法是特殊的: toString()。每个非基本类型对象都有一个 toString() 方法，在编译器需要字符串但它有对象的特殊情况下调用该方法。因此，在 [1] 中，编译器看到你试图“添加”一个 WaterSource 类型的字符串对象 。因为字符串只能拼接另一个字符串，所以它就先会调用 toString() 将 source 转换成一个字符串。然后，它可以拼接这两个字符串并将结果字符串传递给 System.out.println()。要对创建的任何类允许这种行为，只需要编写一个 toString() 方法。在 toString() 上使用 @Override ** 注解来告诉编译器，以确保正确地覆盖。@Override ** 是可选的，但它有助于验证你没有拼写错误 (或者更微妙地说，大小写字母输入错误)。类中的基本类型字段自动初始化为零，正如 object Everywhere 一章中所述。但是对象引用被初始化为 null，如果你尝试调用其任何一个方法，你将得到一个异常（一个运行时错误）。方便的是，打印 null 引用却不会得到异常。

编译器不会为每个引用创建一个默认对象，这是有意义的，因为在许多情况下，这会导致不必要的开销。初始化引用有四种方法:

  1. 当对象被定义时。这意味着它们总是在调用构造函数之前初始化。
  2. 在该类的构造函数中。
  3. 在实际使用对象之前。这通常称为_延迟初始化_。在对象创建开销大且不需要每次都创建对象的情况下，它可以减少开销。
  4. 使用实例初始化。

以上四种实例创建的方法例子在这：

class Soap {
    private String s;

    Soap() {
        System.out.println("Soap()");
        s = "Constructed";
    }

    @Override
    public String toString() {
        return s;
    }
}

public class Bath {
    private String // Initializing at point of definition:
            s1 = "Happy",
            s2 = "Happy",
            s3, s4;
    private Soap castille;
    private int i;
    private float toy;

    public Bath() {
        System.out.println("Inside Bath()");
        s3 = "Joy";
        toy = 3.14f;
        castille = new Soap();
    }

    // Instance initialization:
    {
        i = 47;
    }

    @Override
    public String toString() {
        if (s4 == null) // Delayed initialization:
        {
            s4 = "Joy";
        }
        return "s1 = " + s1 + "\n" +
                        "s2 = " + s2 + "\n" +
                        "s3 = " + s3 + "\n" +
                        "s4 = " + s4 + "\n" +
                        "i = " + i + "\n" +
                        "toy = " + toy + "\n" +
                        "castille = " + castille;
    }

    public static void main(String[] args) {
        Bath b = new Bath();
        System.out.println(b);
    }
}

在这里插入图片描述

在 Bath 构造函数中，有一个代码块在所有初始化发生前就已经执行了。当你不在定义处初始化时，仍然不能保证在向对象引用发送消息之前执行任何初始化——如果你试图对未初始化的引用调用方法，则未初始化的引用将产生运行时异常。

当调用 toString() 时，它将赋值 s4，以便在使用字段的时候所有的属性都已被初始化。

继承语法

继承是所有面向对象语言的一个组成部分。事实证明，在创建类时总是要继承，因为除非显式地继承其他类，否则就隐式地继承 Java 的标准根类对象（Object）。

组合的语法很明显，但是继承使用了一种特殊的语法。当你继承时，你说，“这个新类与那个旧类类似。你可以在类主体的左大括号前的代码中声明这一点，使用关键字 extends 后跟基类的名称。当你这样做时，你将自动获得基类中的所有字段和方法。这里有一个例子:

class Cleanser {
    private String s = "Cleanser";

    public void append(String a) {
        s += a;
    }

    public void dilute() {
        append(" dilute()");
    }

    public void apply() {
        append(" apply()");
    }

    public void scrub() {
        append(" scrub()");
    }

    @Override
    public String toString() {
        return s;
    }

    public static void main(String[] args) {
        Cleanser x = new Cleanser();
        x.dilute();
        x.apply();
        x.scrub();
        System.out.println(x);
    }
}

public class Detergent extends Cleanser {
    // Change a method:
    @Override
    public void scrub() {
        append(" Detergent.scrub()");
        super.scrub(); // Call base-class version
    }

    // Add methods to the interface:
    public void foam() {
        append(" foam()");
    }

    // Test the new class:
    public static void main(String[] args) {
        Detergent x = new Detergent();
        x.dilute();
        x.apply();
        x.scrub();
        x.foam();
        System.out.println(x);
        System.out.println("Testing base class:");
        Cleanser.main(args);
    }
}

Cleanser dilute() apply() scrub()

Cleanser dilute() apply() Detergent.scrub() scrub() foam()
Testing base class:
Cleanser dilute() apply() scrub()

这演示了一些特性。首先，在 Cleanser 的 append() 方法中，使用 += 操作符将字符串连接到 s，这是 Java 设计人员“重载”来处理字符串的操作符之一 (还有 + )。

第二，Cleanser 和 Detergent 都包含一个 main() 方法。你可以为每个类创建一个 main() ; 这允许对每个类进行简单的测试。当你完成测试时，不需要删除 main(); 你可以将其留在以后的测试中。即使程序中有很多类都有 main() 方法，惟一运行的只有在命令行上调用的 main()。这里，当你使用 java Detergent 时候，就调用了 Detergent.main()。但是你也可以使用 java Cleanser 来调用 Cleanser.main()，即使 Cleanser 不是一个公共类。即使类只具有包访问权，也可以访问 public main()。

在这里，Detergent.main() 显式地调用 Cleanser.main()，从命令行传递相同的参数(当然，你可以传递任何字符串数组)。

Cleanser 中的所有方法都是公开的。请记住，如果不使用任何访问修饰符，则成员默认为包访问权限，这只允许包内成员访问。因此，如果没有访问修饰符，那么包内的任何人都可以使用这些方法。例如，Detergent 就没有问题。但是，如果其他包中的类继承 Cleanser，则该类只能访问 Cleanser 的公共成员。因此，为了允许继承，一般规则是所有字段为私有，所有方法为公共。(protected成员也允许派生类访问;你以后会知道的。)在特定的情况下，你必须进行调整，但这是一个有用的指南。

Cleanser 的接口中有一组方法: append()、dilute()、apply()、scrub() 和 toString()。因为 Detergent 是从 Cleanser 派生的(通过 extends 关键字)，所以它会在其接口中自动获取所有这些方法，即使你没有在 Detergent 中看到所有这些方法的显式定义。那么，可以把继承看作是复用类。如在 scrub() 中所见，可以使用基类中定义的方法并修改它。在这里，你可以在新类中调用基类的该方法。但是在 scrub() 内部，不能简单地调用 scrub()，因为这会产生递归调用。为了解决这个问题，Java的 super 关键字引用了当前类继承的“超类”(基类)。因此表达式 super.scrub() 调用方法 scrub() 的基类版本。

继承时，你不受限于使用基类的方法。你还可以像向类添加任何方法一样向派生类添加新方法:只需定义它。方法 foam() 就是一个例子。Detergent.main() 中可以看到，对于 Detergent 对象，你可以调用 Cleanser 和 Detergent 中可用的所有方法 (如 foam() )。

初始化基类

现在涉及到两个类：基类和派生类。想象派生类生成的结果对象可能会让人感到困惑。从外部看，新类与基类具有相同的接口，可能还有一些额外的方法和字段。但是继承并不只是复制基类的接口。当你创建派生类的对象时，它包含基类的子对象。这个子对象与你自己创建基类的对象是一样的。只是从外部看，基类的子对象被包装在派生类的对象中。

必须正确初始化基类子对象，而且只有一种方法可以保证这一点 : 通过调用基类构造函数在构造函数中执行初始化，该构造函数具有执行基类初始化所需的所有适当信息和特权。Java 自动在派生类构造函数中插入对基类构造函数的调用。下面的例子展示了三个层次的继承:

class Art {
    Art() {
        System.out.println("Art constructor");
    }
}

class Drawing extends Art {
    Drawing() {
        System.out.println("Drawing constructor");
    }
}

public class Cartoon extends Drawing {
    public Cartoon() {
        System.out.println("Cartoon constructor");
    }

    public static void main(String[] args) {
        Cartoon x = new Cartoon();
    }
}

Art constructor
Drawing constructor
Cartoon constructor

构造从基类“向外”进行，因此基类在派生类构造函数能够访问它之前进行初始化。即使不为 Cartoon 创建构造函数，编译器也会为你合成一个无参数构造函数，调用基类构造函数。尝试删除 Cartoon 构造函数来查看这个。

带参数的构造函数

上面的所有例子中构造函数都是无参数的 ; 编译器很容易调用这些构造函数，因为不需要参数。如果没有无参数的基类构造函数，或者必须调用具有参数的基类构造函数，则必须使用 super 关键字和适当的参数列表显式地编写对基类构造函数的调用:

// reuse/Chess.java
// (c)2017 MindView LLC: see Copyright.txt
// We make no guarantees that this code is fit for any purpose.
// Visit http://OnJava8.com for more book information.
// Inheritance, constructors and arguments

class Game {
  Game(int i) {
    System.out.println("Game constructor");
  }
}

class BoardGame extends Game {
  BoardGame(int i) {
    super(i);
    System.out.println("BoardGame constructor");
  }
}

public class Chess extends BoardGame {
  Chess() {
    super(11);
    System.out.println("Chess constructor");
  }
  public static void main(String[] args) {
    Chess x = new Chess();
  }
}
/* Output:
Game constructor
BoardGame constructor
Chess constructor
*/

如果没有在 BoardGame 构造函数中调用基类构造函数，编译器就会报错找不到 Game() 的构造函数。此外，对基类构造函数的调用必须是派生类构造函数中的第一个操作。(如果你写错了，编译器会提醒你。)

委托

Java 不直接支持的第三种重用关系称为委托。这介于继承和组合之间，因为你将一个成员对象放在正在构建的类中(比如组合)，但同时又在新类中公开来自成员对象的所有方法(比如继承)。例如，宇宙飞船需要一个控制模块:

// reuse/SpaceShipControls.java
// (c)2017 MindView LLC: see Copyright.txt
// We make no guarantees that this code is fit for any purpose.
// Visit http://OnJava8.com for more book information.

public class SpaceShipControls {
  void up(int velocity) {}
  void down(int velocity) {}
  void left(int velocity) {}
  void right(int velocity) {}
  void forward(int velocity) {}
  void back(int velocity) {}
  void turboBoost() {}
}

建造宇宙飞船的一种方法是使用继承:

// reuse/DerivedSpaceShip.java
// (c)2017 MindView LLC: see Copyright.txt
// We make no guarantees that this code is fit for any purpose.
// Visit http://OnJava8.com for more book information.

public class DerivedSpaceShip extends SpaceShipControls {
  private String name;
  public DerivedSpaceShip(String name) {
    this.name = name;
  }
  @Override
  public String toString() { return name; }
  public static void main(String[] args) {
    DerivedSpaceShip protector = new DerivedSpaceShip("NSEA Protector");
    protector.forward(100);
  }
}

然而， DerivedSpaceShip 并不是真正的“一种” SpaceShipControls ，即使你“告诉” DerivedSpaceShip 调用 forward()。更准确地说，一艘宇宙飞船包含了 SpaceShipControls，同时 SpaceShipControls 中的所有方法都暴露在宇宙飞船中。委托解决了这个难题:

// reuse/SpaceShipDelegation.java
// (c)2017 MindView LLC: see Copyright.txt
// We make no guarantees that this code is fit for any purpose.
// Visit http://OnJava8.com for more book information.

public class SpaceShipDelegation {
  private String name;
  private SpaceShipControls controls = new SpaceShipControls();
  public SpaceShipDelegation(String name) {
    this.name = name;
  }
  // Delegated methods:
  public void back(int velocity) {
    controls.back(velocity);
  }
  public void down(int velocity) {
    controls.down(velocity);
  }
  public void forward(int velocity) {
    controls.forward(velocity);
  }
  public void left(int velocity) {
    controls.left(velocity);
  }
  public void right(int velocity) {
    controls.right(velocity);
  }
  public void turboBoost() {
    controls.turboBoost();
  }
  public void up(int velocity) {
    controls.up(velocity);
  }
  public static void main(String[] args) {
    SpaceShipDelegation protector = new SpaceShipDelegation("NSEA Protector");
    protector.forward(100);
  }
}

方法被转发到底层 control 对象，因此接口与继承的接口是相同的。但是，你对委托有更多的控制，因为你可以选择只在成员对象中提供方法的子集。

虽然Java语言不支持委托，但是开发工具常常支持。例如，上面的例子是使用 JetBrains Idea IDE 自动生成的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/66269.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

使用JProfiler进入JVM分析

使用JProfiler进入JVM分析

要评测JVM，必须将JProfiler的评测代理加载到JVM中。这可以通过两种不同的方式发生：在启动脚本中指定-agentpath VM参数，或者使用attach API将代理加载到已经运行的JVM中。 JProfiler支持这两种模式。添加VM参数是评测的首选方式，集…
阅读更多...
【MMU】认识 MMU 及内存映射的流程

【MMU】认识 MMU 及内存映射的流程

MMU（Memory Manager Unit），是内存管理单元，负责将虚拟地址转换成物理地址。除此之外，MMU 实现了内存保护，进程无法直接访问物理内存，防止内存数据被随意篡改。 目录 一、内存管理体系结构 1、…
阅读更多...
openssl安装问题合辑

openssl安装问题合辑

1.openssl拖累nginx编译失败 问题描述： 因为漏洞原因，升级openssl之后需要重新编译nginx，进行了以下步骤： config没问题，但是make一直报错 初步判断是openssl安装有问题，原因不明，重装了opens…
阅读更多...
Java后台生成ECharts图片

Java后台生成ECharts图片

前言 通过echarts的jar包，Java后台生成一张图片，并把图片插入到word中。关于word插图片的代码在下一章。 需要用到的工具PhantomJS,Echarts-convert.js,jquery.js,echarts.js。 1.PhantomJS 介绍 PhantomJS是一个不需要浏览器的富客户端。 官方介绍&…
阅读更多...
第八章：Linux信号

第八章：Linux信号

系列文章目录 文章目录 系列文章目录前言linux中的信号进程对信号的处理信号的释义 信号的捕捉信号的捕捉signal()信号的捕捉sigaction() 信号的产生通过终端按键产生信号前台进程与后台进程 kill()用户调用kill向操作系统发送信号raise()进程自己给自己发任意信号（…
阅读更多...
利用Google Docs的评论功能投递钓鱼链接

利用Google Docs的评论功能投递钓鱼链接

情报背景 利用Google drive等可信云服务进行的网络钓鱼攻击活动日益增长，这种攻击手段利用了高可信度的云服务骗取受害者的信任，并且可以绕过基于域名的安全策略。 近期Avanan公司发现了一种新的邮件钓鱼方式，攻击者利用Google docs的评论功…
阅读更多...
计蒜客T1115——字符串判等

计蒜客T1115——字符串判等

水题不解释，考研复习压力偶尔写一道换换心情还不错~ 这里有一个比较有趣的知识点，对于同时输入多个字符串时还要允许空格的输入，那么普通的cin函数就不能满足要求了，这里采用getline函数解决，如下： string …
阅读更多...
使用最新技术实现智能考试系统源码

使用最新技术实现智能考试系统源码

智能考试系统是一种重要的教育技术应用，它能够通过结合计算机科学和教育理论，为教育工作者提供一个高效、灵活和可靠的考试平台。最近，随着人工智能和大数据技术的飞速发展，智能考试系统受到了越来越多的关注。本文将详细介绍如何…
阅读更多...
接口测试如何在json中引用mock变量

接口测试如何在json中引用mock变量

在测试接口的时候，有的接口需要测试随机传入大量数据，查看数据库是否正常，但是大量的随机数据全靠自己手写会很慢，而且是通过json传递的数据。 这里我们就可以使用mock生成随机变量，然后在json中引用mock变量 首先看…
阅读更多...
ElasticSearch 7.4学习记录（基础概念和基础操作）

ElasticSearch 7.4学习记录（基础概念和基础操作）

若你之前从未了解过ES，本文将由浅入深的一步步带你理解ES，简单使用ES。作者本人就是此状态，通过学习和梳理，产出本文，已对ES有个全面的了解和想法，不仅将知识点梳理，也涉及到自己的理解&#xf…
阅读更多...
vue3：新特性

vue3：新特性

一、react和vue的主要区别 （1）数据更新上： 1、 react 采用 fiber架构 ，使用 链表 表示 DOM 结构可以在 diff 时随时中断和继续，利用requestIdleCallback 在空闲时 diff ，防止数据量大 diff 时间长导致卡顿…
阅读更多...
线程池-手写线程池C++11版本（生产者-消费者模型）

线程池-手写线程池C++11版本（生产者-消费者模型）

本项目是基于C11的线程池。使用了许多C的新特性，包含不限于模板函数泛型编程、std::future、std::packaged_task、std::bind、std::forward完美转发、std::make_shared智能指针、decltype类型推断、std::unique_lock锁等C11新特性功能。 本项目有一定的上手难度。推…
阅读更多...
【Linux升级之路】5_基础IO

【Linux升级之路】5_基础IO

🌟hello，各位读者大大们你们好呀🌟 🍭🍭系列专栏：【Linux升级之路】 ✒️✒️本篇内容：文件操作，文件管理，重定向，简易shell添加重定向功能，文件属…
阅读更多...
人物启示-张一鸣与陆奇

人物启示-张一鸣与陆奇

在科技行业中，张一鸣与陆奇可谓是两位颇具影响力的人物。张一鸣和陆奇分别是字节跳动（TikTok 的母公司）的创始人和百度前总裁。张一鸣作为字节跳动的创始人，成功打造了今日头条、抖音等知名产品，而陆奇则曾任微软副总裁…
阅读更多...
Django Rest_Framework（二）

Django Rest_Framework（二）

文章目录 1. http请求响应1.1. 请求与响应1.1.1 Request1.1.1.1 常用属性1）.data2）.query_params3）request._request 基本使用 1.1.2 Response1.1.2.1 构造方式1.1.2.2 response对象的属性1）.data2）.status_code3&…
阅读更多...
4G型无线液位变送器是什么？

4G型无线液位变送器是什么？

4G型无线液位变送器采用了四代无线通讯技术，与普通液位计相比，免去了布线的烦恼，无需时刻监控现场，在大幅提高工作效率和减少人力成本的同时，还可以随时随地获取监测数据。 4G型无线液位变送器的功能优势：…
阅读更多...
jmeter创建一个压测项目

jmeter创建一个压测项目

1.jemeter新建一个项目： 2.接下来对Thread进行描述，也可以先使用默认的Thread进行操作。 3.添加http请求头的信息。按照如图所示操作 4.在请求头里面添加必要的字段，可以只填必要字段就可以 5.添加Http请求信息，如下图&#xff…
阅读更多...
第三章 图论 No.4最小生成树的简单应用

第三章 图论 No.4最小生成树的简单应用

文章目录 裸题：1140. 最短网络裸题：1141. 局域网裸题：1142. 繁忙的都市裸题：1143. 联络员有些麻烦的裸题：1144. 连接格点 存在边权为负的情况下，无法求最小生成树 裸题：1140. 最短网络 1140. 最…
阅读更多...
八大排序

八大排序

目录 选择排序-直接插入排序 插入排序-希尔排序 选择排序-简单选择排序 选择排序-堆排序 交换排序-冒泡排序 交换排序-快速排序 归并排序 基数排序 选择排序-直接插入排序 基本思想: 如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素…
阅读更多...
Golang空结构体struct{}的作用是什么？

Golang空结构体struct{}的作用是什么？

文章目录 占位符：通道标识：键集合：内存占用优化：总结： 在Go语言中，空结构体 struct{}是一种特殊的数据类型，它不占用任何内存空间。空结构体没有任何字段，也没有任何方法。尽管它看起…
阅读更多...
最新文章

Copyright @ 2022~2023