January Star

A Little Java, A Few Patterns: Methods to Our Madness

上一章讲解了如何在 Java 中的定义类型，这一章主要讲如何向这些类型添加方法。

PointD

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
abstract class PointD{
    abstract int distanceTo0();
}

class CartesianPt extends PointD{ // 笛卡尔坐标 
    int x;
    int y;
    CartesianPt(int _x, int _y){
        x = _x;
        y = _y;
    }
    int distanceTo0(){
        return (int)Math.sqrt(x * x + y * y);
    }
}

class ManhattanPt extends PointD{ // 曼哈顿坐标 
    int x;
    int y;
    ManhattanPt(int _x, int _y){
        x = _x;
        y = _y;
    }
    int distanceTo0(){
        return x + y;
    }
}

当具体类从抽象类继承时，需要同时具体出抽象类中的抽象方法。

ShishD

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
// 下面的例子中各类的一层层的套在一起，你可以理解成一个烤串 
abstract class ShishD { // 羊肉 
    abstract boolean onlyOnions(); // 烤串上是不是只有洋葱 
    abstract boolean isVegetarian(); // 烤串上是不是全是蔬菜 
}

class Skewer extends ShishD { // 串 
    boolean onlyOnions(){
        return true;
    }

    boolean isVegetarian(){
        return true;
    }
}

class Onion extends ShishD { // 洋葱 
    ShishD s;
    Onion(ShishD _s) {
        s = _s;
    }

    boolean onlyOnions(){
        return s.onlyOnions();
    }

    boolean isVegetarian(){
        return s.isVegetarian();
    }
}

class Lamb extends ShishD { // 羔羊肉 
    ShishD s;
    Lamb(ShishD _s) {
        s = _s;
    }

    boolean onlyOnions(){
        return false;
    }

    boolean isVegetarian(){
        return false;
    }
}

class Tomato extends ShishD { // 西红柿 
    ShishD s;
    Tomato(ShishD _s) {
        s = _s;
    }

    boolean onlyOnions(){
        return false;
    }

    boolean isVegetarian(){
        return s.isVegetarian();
    }
}

第二条建议

当在数据类型中添加了一个方法，就需要在它所有的变体类型中添加对应的方法。

如果一个变体类型的一个属性和它同属于一个数据类型，该方法在进行运算时就会调用该属性对应的方法。

KebabD

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
abstract class KebabD { // 烤肉 
    abstract boolean isVeggie(); // 是否是纯蔬菜为辅料的烤肉 
    abstract Object whatHolder(); // 烤肉的摆放工具是什么 
}

class Holder extends KebabD { // 烤肉摆放工具（意译）
    Object o;
    Holder (Object _o) {
        o = _o;
    }
    boolean isVeggie(){
        return true;
    }
    Object whatHolder(){
        return o;
    }
}

class Shallot extends KebabD { // 葱 
    KebabD k;
    Shallot(KebabD _k) {
        k = _k;
    }
    boolean isVeggie(){
        return k.isVeggie();
    }
    Object whatHolder(){
        return k.whatHolder();
    }
}

class Shrimp extends KebabD { // 小虾 
    KebabD k;
    Shrimp(KebabD _k) {
        k = _k;
    }
    boolean isVeggie(){
        return false;
    }
    Object whatHolder(){
        return k.whatHolder();
    }
}

class Radish extends KebabD { // 萝卜 
    KebabD k;
    Radish(KebabD _k) {
        k = _k;
    }
    boolean isVeggie(){
        return k.isVeggie();
    }
    Object whatHolder(){
        return k.whatHolder();
    }
}

class Pepper extends KebabD { // 胡椒粉 
    KebabD k;
    Pepper(KebabD _k) {
        k = _k;
    }
    boolean isVeggie(){
        return k.isVeggie();
    }
    Object whatHolder(){
        return k.whatHolder();
    }
}

class Zucchini extends KebabD { // 西葫芦 
    KebabD k;
    Zucchini(KebabD _k) {
        k = _k;
    }
    boolean isVeggie(){
        return k.isVeggie();
    }
    Object whatHolder(){
        return k.whatHolder();
    }
}

定义一下烤肉摆放的工具。

大致分成两种 :

  • 一种是将烤肉串起来的工具 

    1
2
3
4
5
6
7
    abstract class RodD{} // 杆，用于将烤肉串起来 

class Dagger extends RodD{} // 匕首 

class Sabre extends RodD{} // 军刀 

class Sword extends RodD{} // 剑

  • 一种将烤肉平铺的工具。

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    abstract class PlateD{} // 盘子 

class Gold extends PlateD{} // 金盘子 

class Silver extends PlateD{} // 银盘子 

class Brass extends PlateD{} // 黄铜盘子 

class Copper extends PlateD{} // 镀铜盘子 

class Wood extends PlateD{} // 木盘子

PointD

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
abstract class PointD{
    abstract int distanceTo0();
}

class CartesianPt extends PointD{ // 笛卡尔坐标 
    int x;
    int y;
    CartesianPt(int _x, int _y){
        x = _x;
        y = _y;
    }
    int distanceTo0(){
        return (int)Math.sqrt(x * x + y * y);
    }
    boolean closerTo0(CartesianPt p){
        return distanceTo0() <= p.distanceTo0();
    }
}

class ManhattanPt extends PointD{ // 曼哈顿坐标 
    int x;
    int y;
    ManhattanPt(int _x, int _y){
        x = _x;
        y = _y;
    }
    int distanceTo0(){
        return x + y;
    }
    boolean closerTo0(ManhattanPt p){
        return distanceTo0() <= p.distanceTo0();
    }
}

抽取变体类型中公共的部分到抽象类型中。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
abstract class PointD{
    int x;
    int y;
    PointD(int _x, int _y){
        x = _x;
        y = _y;
    }
    abstract int distanceTo0();
    boolean closerTo0(PointD p){
        return distanceTo0() <= p.distanceTo0();
    }
}

class CartesianPt extends PointD{ // 笛卡尔坐标 
    CartesianPt(int _x, int _y){
        super(_x, _y);
    }
    int distanceTo0(){
        return (int)Math.sqrt(x * x + y * y);
    }
}

class ManhattanPt extends PointD{ // 曼哈顿坐标 
    ManhattanPt(int _x, int _y){
        super(_x, _y);
    }
    int distanceTo0(){
        return x + y;
    }
}
Comments
comments powered by Disqus

Published

Category

java

Tags

Contact