精华内容
下载资源
问答
  • java 聚合关系

    千次阅读 2015-12-09 21:20:34
    聚合关系概念: 聚合是整体和个体之间的关系, 并且处于 `聚合关系` 的两个类生命周期不同步, 整体与部分之间是可分离的,它们可以具有各自的生命周期 `聚合关系` 一般来说, B类 是 A类 的成员属性 例子: 母亲...

    聚合关系

    概念: 
       聚合是整体和个体之间的关系, 处于 `聚合关系` 的两个类生命周期不同步, 
    整体与部分之间是可分离的,可以有各自的生命周期
       与`组合关系`相比, 组合强调的是'包含', 聚合强调的是'拥有'
    例子: 
       母亲可以有自己的孩子
    
    // 母亲
    class Mother {
        // 母亲可以有自己孩子, 但是不确定什么时候生
        private Children myChildren;
    }
    // 孩子
    class Children {
    
    }

    从上述代码可以看出, 母亲(Mother)孩子(Children) 有着各自的生命周期
    女人对象创建之后, 孩子对象可以不用创建出来
    可以看出聚合关系的整体与部分是可以分离的

    展开全文
  • java合成关系和聚合关系 Java中的聚合(HAS-A关系) (Aggregation (HAS-A relationship) in Java) Aggregation is a term which is used to refer one way relationship between two objects. For example, Student...

    java合成关系和聚合关系

    Aggregation is a term which is used to refer one way relationship between two objects. For example, Student class can have reference of Address class but vice versa does not make sense.

    聚合是一个术语,用于表示两个对象之间的单向关系 。 例如, 学生可以引用 地址类,反之亦然。

    In Java, aggregation represents HAS-A relationship, which means when a class contains reference of another class known to have aggregation.

    在Java中,聚合表示HAS-A关系 ,这意味着当一个类包含另一个已知具有聚合的类的引用时。

    The HAS-A relationship is based on usage, rather than inheritance. In other words, class A has-a relationship with class B, if class A has a reference to an instance of class B.

    HAS-A关系基于用法而不是继承。 换句话说,如果类A引用了类B的实例,则类A与类B具有关系。

    Lets understand it by an example and consider two classes Student and Address. Each student has own address that makes has-a relationship but address has student not makes any sense. We can understand it more clearly using Java code.

    让我们通过一个例子来理解它,并考虑两个类Student和Address。 每个学生都有自己的联系地址,但地址与学生无关。 使用Java代码,我们可以更清楚地了解它。

    Class Address{
    int street_no;
    String city;
    String state;
    int pin;
    Address(int street_no, String city, String state, int pin ){
    this.street_no = street_no;
    this.city = city;
    this.state = state;
    this.pin = pin;
    }
    }
    
    class Student
    {
      String name;
      Address ad;
    }

    Here in the above code, we can see Student class has-a relationship with Address class. We have draw an image too to demonstrate relation between these two classes..

    在上面的代码中,我们可以看到Student类与Address类具有某种关系。 我们也绘制了一个图像来演示这两个类之间的关系。

    Aggregation in Java

    The Student class has an instance variable of type Address. As we have a variable of type Address in the Student class, it can use Address reference which is ad in this case, to invoke methods of the Address class.

    Student类具有类型为Address的实例变量。 由于我们在Student类中具有Address类型的变量,因此它可以使用Address引用(在这种情况下为ad来调用Address类的方法。

    聚集优势 (Advantage of Aggregation)

    The main advantage of using aggregation is to maintain code re-usability. If an entity has a relation with some other entity than it can reuse code just by referring that.

    使用聚合的主要优点是保持代码的可重用性 。 如果一个实体与某个其他实体有关系,则仅通过引用即可重用代码。

    汇总示例 (Aggregation Example)

    Now lets understand it by using an example, here we created two classes Author and Book and Book class has a relation with Author class by having its reference. Now we are able to get all the properties of both class.

    现在让我们通过一个例子来理解它,这里我们创建了两个类Author和Book,并且Book类通过引用与Author类建立了联系。 现在,我们可以获取两个类的所有属性。

    class Author
    {
      String authorName;
      int age;
      String place;
    
      // Author class constructor
      Author(String name, int age, String place)
      {
        this.authorName = name;
        this.age = age;
        this.place = place;
      }
    }
    
    class  Book
    {
      String name;
      int price;
      // author details
      Author auther;
      Book(String n, int p, Author auther)
      {
        this.name = n;
        this.price = p;
        this.auther = auther;
      }
      public static void main(String[] args) {
        Author auther = new Author("John", 42, "USA");
        Book b = new Book("Java for Begginer", 800, auther);
        System.out.println("Book Name: "+b.name);
        System.out.println("Book Price: "+b.price);
        System.out.println("------------Auther Details----------");
        System.out.println("Auther Name: "+b.auther.authorName);
        System.out.println("Auther Age: "+b.auther.age);
        System.out.println("Auther place: "+b.auther.place);
      }
      
    }

    Book Name: Java for Begginer Book Price: 800 ------------Author Details---------- Auther Name: John Auther Age: 42 Auther place: USA

    书籍名称:Java for Begginer书籍价格:800美元------------作者详细信息----------奥瑟(Auther)姓名:约翰·奥瑟(John Auther)年龄:42奥瑟(Auther)所在地:美国

    Lets take one more example to understand aggregation. Suppose we have one more class Publisher then the Book class can reuse Publisher class details by just using its reference as Author class. Lets understand it by Java code.

    让我们再举一个例子来了解聚合。 假设我们再有一个Publisher类,则Book类可以通过仅将其引用用作Author类来重用Publisher类的详细信息。 让我们通过Java代码来理解它。

    class Publisher{
      
      String name;
      String publisherID;
      String city;
      
      Publisher(String name, String publisherID, String city) {
        this.name = name;
        this.publisherID = publisherID;
        this.city = city;
      }
    }
    
    
    class Author
    {
      String authorName;
      int age;
      String place;
    
      // Author class constructor
      Author(String name, int age, String place)
      {
        this.authorName = name;
        this.age = age;
        this.place = place;
      }
    }
    
    class Book
    {
      String name;
      int price;
      // author details
      Author auther;
      Publisher publisher;
      Book(String n, int p, Author auther, Publisher publisher )
      {
        this.name = n;
        this.price = p;
        this.auther = auther;
        this.publisher = publisher;
      }
      public static void main(String[] args) {
        Author auther = new Author("John", 42, "USA");
        Publisher publisher = new Publisher("Sun Publication","JDSR-III4", "LA");
        Book b = new Book("Java for Begginer", 800, auther, publisher);
        System.out.println("Book Name: "+b.name);
        System.out.println("Book Price: "+b.price);
        System.out.println("------------Author Details----------");
        System.out.println("Auther Name: "+b.auther.authorName);
        System.out.println("Auther Age: "+b.auther.age);
        System.out.println("Auther place: "+b.auther.place);
        System.out.println("------------Publisher Details-------");
        System.out.println("Publisher Name: "+b.publisher.name);
        System.out.println("Publisher ID: "+b.publisher.publisherID);
        System.out.println("Publisher City: "+b.publisher.city);
      }
      
    }

    Book Name: Java for Begginer Book Price: 800 ------------Author Details---------- Auther Name: John Auther Age: 42 Auther place: USA ------------Publisher Details------- Publisher Name: Sun Publication Publisher ID: JDSR-III4 Publisher City: LA

    书籍名称:Java for Begginer书籍价格:800美元------------作者详细信息----------奥瑟姓名:约翰·奥瑟年龄:42岁奥瑟所在的地方:美国--------发布者详细信息-------出版者名称:Sun出版者出版者ID:JDSR-III4出版者城市:LA

    用Java编写 (Composition in Java)

    Composition is a more restricted form of Aggregation. Composition can be described as when one class which includes another class, is dependent on it in such a way that it cannot functionally exist without the class which is included. For example a class Car cannot exist without Engine, as it won't be functional anymore.

    组合是更受限制的聚合形式。 可以将组成描述为当一个包含另一个类的类以某种方式依赖于它时,如果没有包含的类,它就无法在功能上存在。 例如,如果没有Engine ,则Car类将不存在,因为它将不再起作用。

    Hence the word Composition which means the items something is made of and if we change the composition of things they change, similarly in Java classes, one class including another class is called a composition if the class included provides core functional meaning to the outer class.

    因此,“ 组成 ”一词的意思是构成某物品的物品,如果我们更改它们改变的事物的组成,则在Java类中,如果包含的类为外部类提供了核心的功能含义,则包含另一类的一个类称为“组合”。

    class Car
    {
      private Engine engine;
      Car(Engine en)
      {
        engine = en;
      }
    }

    Here by examining code, we can understand that if Car class does not have relationship with Engine class then Car does not have existence.

    在这里通过检查代码,我们可以理解,如果Car类与Engine类没有关系,那么Car就不存在。

    Composition is a design technique, not a feature of Java but we can achieve it using Java code.

    合成是一种设计技术 ,不是Java的功能,但是我们可以使用Java代码来实现。

    问:何时使用继承和聚合? (Q. When to use Inheritance and Aggregation?)

    When you want to use some property or behaviour of any class without the requirement of modifying it or adding more functionality to it, in such case Aggregation is a better option because in case of Aggregation we are just using any external class inside our class as a variable.

    如果您想使用任何类的某些属性或行为而无需对其进行修改或为其添加更多功能,则在这种情况下, 聚合是一个更好的选择,因为在聚合的情况下,我们只是将类内部的任何外部类用作变量。

    Whereas when you want to use and modify some property or behaviour of any external class or may be want to add more function on top of it, its best to use Inheritance.

    而当您要使用和修改任何外部类的某些属性或行为,或者可能想在其之上添加更多功能时,最好使用Inheritance

    To understand more on inheritance, you can visit our detailed tutorial here. Click Here to see Inheritance in Java

    要了解有关继承的更多信息,您可以在此处访问我们的详细教程。 单击此处查看Java继承

    翻译自: https://www.studytonight.com/java/aggregation.php

    java合成关系和聚合关系

    展开全文
  • Java聚合

    千次阅读 2018-12-03 12:35:55
    Java聚合聚合 聚合 如果一个类有一个类的实体引用(类中的类),则它称为聚合。 聚合表示HAS-A关系。 考虑有一种情况,Employee对象包含许多信息,例如:id,name,emailId等。它包含另一个类对象:address,其包含它...

    Java聚合

    聚合

    如果一个类有一个类的实体引用(类中的类),则它称为聚合。 聚合表示HAS-A关系。
    考虑有一种情况,Employee对象包含许多信息,例如:id,name,emailId等。它包含另一个类对象:address,其包含它自己的信息,例如:城市,州,国家,邮政编码等,如下所示。

    class Employee{  
        int id;  
        String name;  
        Address address;                                                                        //Address is a class  
    }
    

    在这种情况下,Employee有一个实体引用地址(Address),因此关系是:Employee HAS-A Address。

    聚合示例:

    地址类:

    public class Address {
        String city, province;
    
        public Address(String city, String province) {
            this.city = city;
            this.province = province;
        }
    
    }
    

    雇员类:

    public class Employ {
        int id;
        String name;
        Address address;
    
        public Employ(int id, String name, Address address) {
            this.id = id;
            this.name = name;
            this.address = address;
        }
    
        void display() {
            System.out.println(id + " " + name);
            System.out.println(address.city + " " + address.province);
        }
    
        public static void main(String[] args) {
            Address address1 = new Address("深圳", "广东");
            Address address2 = new Address("乌鲁木齐", "新疆");
    
            Employ e = new Employ(0820, "Wong", address1);
            Employ e2 = new Employ(0528, "Lei", address2);
    
            e.display();
            e2.display();
    
        }
    }
    

    输出结果

    0820 Wong
    深圳 广东
    0529 Lei
    乌鲁木齐 新疆
    
    展开全文
  • 聚合

    Java的聚合与组合关系的区分

    聚合关系

    1.一个类的实例作为另一个类的属性,我们称之为“对象聚合”(aggregation)。
    2.当一个类的实例成为另一个类的成员,我们就说这两个类之间存在“Has a”’关系。
    3.它包含另一个类对象:address,其包含它自己的信息,例如:城市,州,国家,邮政编码等。
    其中整体和部分之间的包含关系相对松散。

    组合关系

    1.如果一个对象只归集于一个聚集对象,那么它和聚集对象之间的关系就称为“组合”(composition)。
    2.一个对象与聚集对象的两个类之间存在是’Part-od’的关系
    3.整体与部分的包含关系相对紧密,部分与整体是与生俱来的,部分的存在依赖于整体。

    展开全文
  • Java教程17—Java中的聚合关系

    千次阅读 2018-09-08 14:22:43
    Java中的聚合示例 例如,考虑两个类Studentclass和Addressclass。 每个学生都有一个地址,所以学生和地址之间的关系是一个Has-A关系。 但是如果你认为它的反之亦然,那就没有任何意义,因为Address它不需要有Stu....
  • Java 组合和聚合关系

    千次阅读 2013-07-15 17:17:38
    组合和聚合是有很大区别的,这个区别不是在形式上,而是在本质上: 比如A类中包含B类的一个引用b,当A类的一个对象消亡时,b这个引用所指向的对象也同时消亡(没有任何一个...人和他的电脑是聚合关系。 class Ha
  • JAVA聚合和组合

    2019-11-12 15:31:12
    JAVA聚合和组合聚合组合对于信息的封装性而言: 聚合 聚合是关联关系的一种特例,他体现的是整体与部分、拥有的关系,即has-a的关系,此时整体与部分之间是可分离的,他们可以具有各自的生命周期,部分可以属于多个...
  • Java聚合和组合

    2019-12-05 20:28:32
    聚合是关联关系的一种特例,聚合关系中两个类的地位是不平等的,它体现的是整体与部分、拥有的关系,即has-a的关系。 class Class{ private List<Student> student; // 一个班里有许多学生 } 在...
  • 这就会涉及到“组合”和“聚合”的关系概念: 1 组合 组合(Composition)用来表示“拥有”关系(has-a relationship)。例如,电脑拥有 CPU,当电脑报废时,CPU 也会跟着报废。 在 Java 代码中,我们会在 A 类的...
  • java 聚合和组合

    2019-11-12 15:51:53
    Java 的 组合和聚合 都可以看作包含 , 有点像 字符串定义的属性 和 它对应的字符串 的关系 Java聚合 是松散的,只是将地址赋给属性, 可以看作浅拷贝, 发生变化会影响属性的值; Java的组合 是紧密的 ,他将内容赋...
  • 2018-03-09 本章我们将学到的知识点: 1、关联关系 2、聚合关系 3、接口与抽象类 一、类的关联关系 1.关联关系:表示不同类的对象之间的结构关系...2.聚合关系聚合关系是关联关系的一种,是强的关联关系,表示...
  • java聚合,组合的理解

    2019-11-26 21:19:03
    聚合是关联的一种属性,代表了两个对象之间的归属关系。即为一个类中有一个类的实体引用(类中的类) 聚合表示HAS-A关系 例如: class Hello{ int i; Address world; } 在这里Hello不仅包括自己的基本对象,还...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 关联(Association)关系: 是类与类之间的联接,它使一个...在Java语言中,关联关系一般使用成员变量来实现。 class Driver { //使用成员变量形式实现关联 Car mycar; public void drive(){ mycar.run(); ...
  • Java中的组合、聚合和关联关系

    千次阅读 2019-09-09 11:37:03
    在本教程中,我们将重点介绍 Java 的三种关系类型,这些关系有时很容易混合:组合、聚合和关联。 2.组合 组成是一种"belong-to"的关系类型。这意味着其中一个对象是逻辑上较大的结构,其中包含另一个对象。 ...
  •  聚合关系中代表部分事物的对象与代表聚合事物的对象的生存期无关,一旦删除了聚合对象不一定就删除了代表部分事物的对象 组合(Composition):----Contains a----------人是由手,脚,脸等部分组成的  组合中...
  • java聚合和组合

    2019-11-12 16:23:59
    组合(Composition) 关系是关联关系的一种,是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分对象的生命周期,组合关系是不能共享的。代表整体的对象需要负责保持部分对象和存活,在一些情况...
  • java聚合

    千次阅读 2018-03-13 20:43:30
    聚合关系概念: 聚合是整体和个体之间的关系, 处于 `聚合关系` 的两个类生命周期不同步, 整体与部分之间是可分离的,可以有各自的生命周期 与`组合关系`相比, 组合强调的是'包含', 聚合强调的是'拥有' 例子: ...
  • Java继承,组合,聚合关系

    千次阅读 2014-12-18 17:27:39
    继承与组合的关系: 比如说: 有一个歌星类: public class MusicStar{ public abstract void singing() ; } 周杰伦类 public class ZhouJieLun extends Music
  • java聚合与组合

    2019-11-12 16:01:20
    什么是聚合? 聚合(Aggregation) 关系是关联关系的一种,是强的...但是关联关系所涉及的两个类是处在同一层次上的,而在聚合关系中,两个类是处在不平等层次上的,一个代表整体,另一个代表部分。 实例: public ...
  • 两个相对独立的系统,当一个系统要构筑另一个系统的实例,或者依赖另一的服务时,这两个就是依赖关系。比如自行车和打气筒之间就是依赖关系。代码表现形式如下: public class A{ public void mehtod(B b) { b....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,011
精华内容 804
关键字:

java聚合关系

java 订阅