在靠近用户的地方部署容器

本工程教育（EngEd）计划由科支持。

在全球范围内即时部署容器。Section是经济实惠、简单而强大的。

免费入门。

Java中的组合入门

11月24日, 2021

主题。
语言

像大多数OOP语言一样，Java不允许多重继承。这个问题限制了程序员用更多具有强关系或类似属性的对象来应用代码重用。

为了解决这个问题，有一个叫做Composition 的属性。在Java中，当两个或更多的对象相互关联时，就存在构成。在这种情况下，一个对象是由于另一个对象的存在而存在的。

Java中的构成

当一个类在一个实例中引用一个或多个其他类的对象时，也会出现这种情况。例如，一个Class Car 是由类Engine和类wheel组成的，一个Class Body 是由类Heart、类Stomach等组成的。

上面的例子表明，无论是引擎类还是车轮类，都不能脱离汽车类而存在。同样地，心类和胃类都依赖于身体类而存在。

类有两类。首先，Parent class ，通常是独立的。例如，Class Car和Class Body是父类。

然而，有一种依赖性的类，如果没有父类的存在就不能存在。这个类被称为child class 。例如，Class Engine ，Class Wheels ，来自父类的Class Car ，Class Heart ，和Class Stomach ，是父类的子类class Body 。

组成的特点

下面是与组合交互时的一些常见特征。

它在对象之间提供了一个has-a 关系。让我们用汽车和发动机的例子来理解这一点。汽车和引擎都是对象，但引擎包含在汽车中，这意味着每辆汽车都有一个引擎。在组合中，一个对象必须有另一个对象，因此有一个关系。
代码重用。这个特点确保了代码的重复使用。在上面的例子中，引擎类一旦写好，就可以在另一个对象汽车上重新使用。因为它仍然包含引擎并需要引擎类。这就节省了程序员为每辆汽车编写引擎类的代码，尽管汽车的属性可能不同。

在Java上的实现

现在，我们要学习如何在解决问题中应用组合。我们将使用Intellij IDE与Java语言。如果你没有Intellij，你可以从Jetbrains的官方网页上下载它。

我们将创建三个类：主类、父类和子类。我们将在主类中运行程序，在父类和子类中创建方法和属性。因此，确保你所有的类都在同一个包里，以便迅速执行代码。

package org.kimcode.composition;

public class Engine {
    private String model;
    private int weight;
    private String color;
    private int price;


    public Engine(String model, int weight, String color, int price) {
        this.model = model;
        this.weight = weight;
        this.color = color;
        this.price = price;
    }

    public Engine(String rpm, int weight, String silver) {
    }

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}

我们在上面的代码中创建了一个名为Engine 的类。我们分配了一些属性，并给出了所有的访问指定符private ，使其只能由类本身或通过另一个类的获取器来访问。我们也有获取器和设置器来使这些属性可以从外部类中访问。

现在我们将创建父类，也就是Vehicle类。最后，我们将通过创建一个Engine属性将Class Engine 与Class Vehicle 。

package org.kimcode.composition;

public class Vehicle {
    private String name;
    private String color;
    private int price;
    private int wheels;
    private Engine engine;


    public Vehicle(String name, String color, int price, int wheels, Engine engine) {
        this.name = name;
        this.color = color;
        this.price = price;
        this.wheels = wheels;
        this.engine = engine;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public int getWheels() {
        return wheels;
    }

    public void setWheels(int wheels) {
        this.wheels = wheels;
    }

    public Engine getEngine() {
        return engine;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }
}

我们已经把子类Engine当作一个属性，尽管它不是。所以我们已经初始化了它，为它创建了一个构造函数，并且为它创建了一个getter和setter，就像其他的属性一样。现在让我们创建Main类，在这里我们将运行和实现代码。

package org.kimcode.composition;

public class Main {
    public static void main(String[] args) {
        Vehicle benz = new Vehicle("benz", "black", 200, 4,
                new Engine("high", 24,"silver"));
        Engine engine = benz.getEngine();
        System.out.println("I have a "+ benz.getColor()+" "+ benz.getName());
        System.out.println("With a weight of "+ benz.getEngine().getWeight()+" TONNES");
        System.out.println("The Price is "+ engine.getPrice());
    }
}

主类，java，使你能够运行指定包中的所有代码。你首先创建一个对象，即车辆；在我们的例子中，我们有一辆奔驰。我们还创建了一个引擎。

在Intellij中，完整代码的预览如下所示。

Main Page

代码的输出是通过组合得到的。

组合和继承的区别

Inheritance 是一个对象获得所有属性和行为的类似属性，通常被称为。parent object

组成与继承的区别在于以下几个方面。

组成是基于has-a 关系，而继承是基于is-a 关系。
使用继承，你只能将你的代码扩展到一个接口，但使用组合，你可以多次重复使用你的代码。
通过组合，我们可以重复使用代码，甚至是最终的类，但这是继承无法实现的。

现在让我们用一个代码片断来展示如何评估组合。

class Vehicle{
   String name="V8";
}
class Car extends vehicle {
   String type="Car";
   public static void main(String args[]){
      Car c=new Car();
      System.out.println("Name:"+c.name);
      System.out.println("Type:"+c.type);
   }
}

public class Student {
}
public class College {
   private Student student;
   public College() {
      this.student = new Student();
   }
}

总结

这篇文章介绍了在编码时，组合如何能起到相当大的作用。通过利用代码重用，人们可以有一个更干净、更有组织的代码，并有最大的字符。

组成有助于定位你的代码中的错误，因为整齐的排列使代码的解释变得简单明了。下面是我们在教程中提到的其他几个关键概念。

Java中的组合简介。
组合的特点。
用一个例子实现组合。
组合与继承的区别。

编码愉快!

同行评议的贡献者。Jerim Kaura

类似文章

[

How to Create a Reusable React Form component Hero Image

语言

如何创建一个可重复使用的React表单组件

](www.section.io/engineering…

Building a payroll system with next.js Hero Image

语言, Node.js

用Next.js构建一个薪资系统

](www.section.io/engineering…

Creating and Utilizing Decorators in Django example image

架构

在Django中创建和使用装饰器

](www.section.io/engineering…)