I Love You-趣谈类和类之间的关系

或

2.2 代码

package relationship.love.ver2;

public class I {
    private You you;

    public You getYou() {
        return you;
    }

    public void setYou(You you) {
        this.you = you;
    }

    public void longPhone()
    {
        System.out.print(this + "和" + you + "打电话");
    }

    @Override
    public String toString() {
        return "我";
    }
}

package relationship.love.ver2;

public class You {
    @Override
    public String toString() {
        return "你";
    }
}

package relationship.love.ver2;

public class Tester {
    public static void main(String[] args) {
        I i = new I();
        You you = new You();
        i.setYou(you);
        i.longPhone();
    }
}

输出：

我和你打电话

点评：

这里只展示了单向关联关系，你可以尝试着写一下双向关联关系。

2.3 知识点

A关联B的关系是一种强的use（使用）关系，一般带有永久性，B的改变可能会影响到A。

在代码上，一般表现为下面的形式：

• A类的属性是B

• 关联关系可以是单向的，也可以是双向的

3 内聚

终于，我向你表白了，我们顺理成章的成为了一对恋人。美中不足的是，两个城市之间的距离让我们总是聚少离多。这个时候，我们之间的关系叫做内聚。

3.1 UML图

3.2 代码

package relationship.love.ver3;

public class I {
    private You you;

    public You getYou() {
        return you;
    }

    public void setYou(You you) {
        this.you = you;
    }

    public void loving()
    {
        System.out.print(this + "和" + you + "恋爱中");
    }

    @Override
    public String toString() {
        return "我";
    }
}

package relationship.love.ver3;

public class You {
    @Override
    public String toString() {
        return "你";
    }
}

package relationship.love.ver3;

public class Tester {
    public static void main(String[] args) {
        I i = new I();
        You you = new You();
        i.setYou(you);
        i.loving();
    }
}

输出：

我和你恋爱中

点评：

仅仅从代码来看，内聚关系和关联关系也差不多，需要从语义的层次进行区分，内聚关系是has的关系，关联关系是use的关系。

3.3 知识点

A内聚B的关系是一种弱的has（拥有）关系，即常用的has-a的关系。一般带有永久性，B的改变一般会影响到A。

在代码上，一般表现为下面的形式：

Ø  A类的属性是B

Ø  A和B的生命周期一般不同

Ø  A内聚B并不意味着A唯一拥有B

4 组合

后来，我们结婚了，一起走进了婚姻的殿堂，正式组成了一个家庭。这个时候，我们和我们的家庭之间的关系叫做组合。

4.1 UML图

4.2 代码

package relationship.love.ver4;

public class We {
    @Override
    public String toString() {
        return "我们";
    }

    private Family family = new Family();

    public void live()
    {
        System.out.println(this + "的" + family + "，快乐的生活。");
    }

}

package relationship.love.ver4;

public class Family {
    @Override
    public String toString() {
        return "家庭";
    }
}

package relationship.love.ver4;

public class Tester {
    public static void main(String[] args) {
        We we = new We();
        we.live();
    }
}

输出：

我们的家庭，快乐的生活。

点评：

内聚关系和组合关系的区别在于生命周期的控制不同。

4.3 知识点

A组合B的关系是一种强的has（拥有）关系，即常用的contains-a的关系。一般带有永久性，B的改变一般会影响到A。

在代码上，一般表现为下面的形式：

Ø  A类的属性是B

Ø  A管理B的生命周期

Ø  A组合B意味着A唯一拥有B

5 实现

我小心地呵护着我们的婚姻，在公司，我是一个好员工；在家里，我是一个好丈夫。我同时实现了员工和丈夫两个接口，这种关系叫做实现。

5.1 UML图

5.2 代码

package relationship.love.ver5;

public interface IEmployee {
    public void work();
}

package relationship.love.ver5;

public interface IHusband {
    public void love();
}

package relationship.love.ver5;

public class I implements IEmployee, IHusband{
    @Override
    public String toString() {
        return "我";
    }

    @Override
    public void work() {
        System.out.println(this + "努力工作");
    }

    @Override
    public void love() {
        System.out.println(this + "全心爱你");
    }
}

package relationship.love.ver5;

public class Tester {
    public static void main(String[] args) {
        I i = new I();
        i.work();
        i.love();
    }
}

输出：

我努力工作
我全心爱你

点评：

一个类可以实现多个接口。

5.3 知识点

B实现A的关系是一种弱is（是）关系，一般带有永久性，A的改变一定会影响到B。

在代码上，B一般表现为下面的形式：

• B类实现了A接口

• Java关键字是implements

• B可以实现多个接口

6 继承

再后来，我们生了一个漂亮的宝宝，孩子继承了我们俩的优点。我们和我们的孩子之间的关系叫做继承。

6.1 UML图