2017-02-23-面向对象
Xplorist Lv6
  2017-02-23 14:23:01 2017-02-23 14:23      

2017-02-23-面向对象

实例1：

创建方法，让人能够同时和猫狗玩，让人能够跟很多个猫玩，人能够和很多个狗玩

思路：方法重载

核心代码：

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
public void play(Cat cat, int n) {
        System.out.println(name+"和"+n+"只猫玩");
        for(int i=0;i<n;i++){
            switch (i) {
            case 0:
                cat.name="小灰";
                break;
                
            case 1:
                cat.name="小白";
                break;
            case 2:
                cat.name="小黑";
                break;
            case 3:
                cat.name="小红";
                break;
            case 4:
                cat.name="小黄";
                break;
            case 5:
                cat.name="小蓝";
                break;

            default:
                cat.name="流浪猫";
                break;
            }
            System.out.println(name+"和"+cat.name+"玩");
        }
    }
    
    public void play( int n) {
        System.out.println(name+"和"+n+"只猫玩");
        for(int i=0;i<n;i++){
            Cat cat=new Cat();
            switch (i) {
            case 0:
                cat.name="小灰";
                break;
                
            case 1:
                cat.name="小白";
                break;
            case 2:
                cat.name="小黑";
                break;
            case 3:
                cat.name="小红";
                break;
            case 4:
                cat.name="小黄";
                break;
            case 5:
                cat.name="小蓝";
                break;

            default:
                cat.name="流浪猫";
                break;
            }
            System.out.println(name+"和"+cat.name+"玩");
        }

实例2：

用户要拿什么茶叶，我们通过对象就给用户什么茶叶，杯子也一样

思路：构造方法

核心代码如下：

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
public class Cup {
    
    public String name;
    
    public Cup(){
        
    }
    public Cup(String n){
        name=n;
    }
    
    public void makeTea(Tea t){
        System.out.print(name+"泡了一杯"+t.taste+"味道的"+t.name);
    }
}

public class Tea {
    public String name;
    public String taste;
    
    public Tea(){
        
    }
    public Tea(String n,String t){
        name=n;
        taste=t;
    }
}

public class Human {
    public String name;
    
    public Human(){
        
    }
    public Human(String n){
        name=n;
    }
    
    public void drink(Cup c,Tea t){
        System.out.print(name+"拿起了");
        c.makeTea(t);
        System.out.println("然后喝了");
    }
    
}

public class MainGate {

    public static void main(String[] args) {
        Human h=new Human("【张三】");
        Cup c=new Cup("【玻璃杯】");
        Tea t=new Tea("【茉莉花茶】","【清香扑鼻的】");
        h.drink(c, t);
    }

}

实例3：

开枪 需求： 
 * 1、用户可以选择枪4.ak47 mp4 ，火箭筒,如果用户乱来就给他一把玩具枪
 * 2、选完枪以后，用户可以上子弹，但是上子弹之前用户可以选择上什么子弹 10mm（AK47），11，火箭弹，只有子弹选择正确才能上弹成功
 * 3、如果上弹失败，用户可以继续选择上子弹或者退出 
 * 4、上弹成功以后，如果是全自动的枪则直接打完所有子弹，
 * 5、如果是半自动，上完子弹后，我们输入任意一个字符就可以打出一发子弹 
 * 6、子弹打完以后，询问是否上子弹，还是退出， 选择上子弹则可以继续3-6的过程。

分析：主要是控制流程

核心代码如下：

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
public class GunFire {
    public static void main(String[] args) {
        System.out.println("请输入您要使用的枪：1.AK47;2.MP4;3.RPG火箭筒;");
        Scanner scanner=new Scanner(System.in);
        int inputGun=scanner.nextInt();
        Gun gun=new Gun(inputGun);
        
        gun.reload();
        
        
    }
}

public class Gun {
    public String name;
    public Ammo ammo;
    public boolean auto;

    public Gun(int n) {
        ammo = new Ammo();
        switch (n) {
        case 1:
            name = "AK47";
            ammo.name = "10mm(AK47)";
            auto = false;
            break;
        case 2:
            name = "MP4";
            ammo.name = "11mm(MP4)";
            auto = true;
            break;
        case 3:
            name = "RPG火箭筒";
            ammo.name = "火箭弹(RPG)";
            auto = false;
            break;

        default:
            name = "3岁小孩的玩具枪";
            ammo.name = "气球都打不爆的橡胶子弹";
            auto = false;
            break;
        }
    }

    public void reload() {
        Ammo a = null;
        boolean flag = true;
        boolean flag1 = true;
        boolean flag2 = true;
        boolean flag3 = true;
        Scanner sc = new Scanner(System.in);

        while (flag) {
            System.out.println("开始上弹···");
            flag1 = true;
            while (flag1) {
                //

                System.out.println("恭喜您选择了【" + name + "】，小提示：这种武器一般只使用【" + ammo.name + "】这种弹药哦");
                System.out.println("请输入您要使用的弹药：1.10mm(AK47);2.11mm(MP4);3.火箭弹(RPG);");
                int inputAmmo = sc.nextInt();
                a = new Ammo(inputAmmo);

                flag3 = true;
                while (flag3) {
                    if (ammo.name.equals(a.name)) {
                        System.out.println("上弹成功！");
                        if (auto) {
                            for (int i = 0; i < a.number; i++) {
                                System.out.println("第" + (i + 1) + "发子弹");
                                if (i == (a.number - 1)) {
                                    System.out.println("子弹已经打完了");
                                    System.out.println("请问是否继续上弹，放弃上弹请输入quit，确认上弹请任意输入");
                                    String str = sc.next();
                                    if (str.equals("quit")) {
                                        flag = false;
                                        flag3 = false;
                                    }
                                }

                            }
                            System.out.println("在你试着扣动扳机后，一瞬间打完了所有的弹药。……你被惊呆了！！！");
                        } else {

                            for (int i = 0; i < a.number; i++) {
                                System.out.println("你拿到的是一把半自动的武器【" + name + "】，请输入一个1，发出子弹。");
                                flag2 = true;
                                while (flag2) {
                                    int input = sc.nextInt();
                                    if (input == 1) {
                                        System.out.println(
                                                "biu，这把" + name + "发出了弹匣里" + a.number + "发子弹的第【" + (i + 1) + "】发子弹。");
                                        if (i == (a.number - 1)) {
                                            System.out.println("您已经打完了最后一发子弹");
                                            System.out.println("请问是否继续上弹，放弃上弹请输入quit，确认上弹请任意输入");
                                            String stri = sc.next();
                                            if (stri.equals("quit")) {
                                                System.out.println("您已经退出上弹。");
                                                System.out.println("您已经退出本次使用，欢迎再次光临。");
                                                flag = false;
                                                flag3 = false;
                                            }

                                        }
                                        flag2 = false;

                                    } else {
                                        System.out.println("你并没有扣动扳机，所以什么都没有发生……请继续扣动扳机，按个1没那么难吧。");
                                    }
                                }
                            }
                            flag1 = false;
                        }
                    } else {
                        System.out
                                .println("上弹失败" + name + "并不适合" + a.name + "这种弹药，请问您是否还想继续上弹,退出请输入quit，继续上弹请输入其它任意命令：");
                        String str = sc.next();
                        if (str.equals("quit")) {
                            System.out.println("您已经退出上弹。");
                            System.out.println("您已经退出本次使用，欢迎再次光临。");
                            flag1 = false;
                            flag = false;
                        }
                    }
                }
            }

        }
    }

}

public class Ammo {
    public String name;
    public int number;
    
    public Ammo(){
        
    }
    
    public Ammo(int n){
        switch (n) {
        case 1:
            name="10mm(AK47)";
            number=3;
            break;
        case 2:
            name="11mm(MP4)";
            number=4;
            break;
        case 3:
            name="火箭弹(RPG)";
            number=1;
            break;

        default:
            name="气球都打不爆的橡胶子弹";
            number=1;
            break;
        }
    }
    
}

上面的思路是将所有的流程封装在一个方法里面，在main方法里面调用的时候很方便，缺点是流程太过于复杂。

更好的思路是将流程控制放在一个单独的流程控制类，然后在流程控制类中的主方法里面写具体的流程，但是这样的重用性较差。

新思路核心代码：

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
public class Start {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请选择你的枪：1.手枪，2.AK47，3.Mp4，4.火箭筒");
        // 用户选择的枪
        String inputGun = sc.next();
        // 自己去拿一把枪给用户
        Gun gun = new Gun(inputGun);
        System.out.println("你是否需要上消声器y/n");
        String is = sc.next();
        int i = 0;
        if (is.equalsIgnoreCase("y")) {
            boolean isMuffler=false;
            while (!isMuffler) {
                i++;
                System.out.println("请选择你的消声器：1.1,2.2,3.3,4.4");
                String inputMuffler = sc.next();
                Muffler muffler = new Muffler(inputMuffler);
                // 给枪上消声器
                isMuffler = gun.updateMuffler(muffler);
                if (i == 3) {
                    break;
                }
            }
        }
        while (true) {
            boolean isflag = true;
            boolean flag = false;
            while (!flag) {
                System.out.println("请选择你要上的子弹：1.手枪子弹，2AK47子弹，3MP4子弹，4.火箭弹");
                // 用户选择的子弹
                String inputBullet = sc.next();
                // 给用户拿子弹
                Bullet bullet = new Bullet(inputBullet);
                // 上子弹
                flag = gun.update(bullet);
                // System.out.println(flag);
                // 判断是否继续上子弹
                if (!flag) {
                    System.out.println("继续上子弹输入任意字符，输入quit退出");
                    String isUpBullet = sc.next();
                    // 判断是否在上弹阶段退出游戏；
                    if (isUpBullet.equals("quit")) {
                        isflag = false;
                        break;
                    }
                }
            }
            // 根据用户意愿退出游戏
            if (!isflag) {
                break;
            }
            // 根据子弹数量进行开火
            while (gun.i > 0) {
                // 全自动开火
                if (gun.type.equals("全自动")) {
                    gun.fire();
                } else {
                    // 半自动开火
                    System.out.println("请输入一个任意字符开枪");
                    sc.next();
                    gun.fire();
                }
            }
            // 开火完毕，询问是否退出
            System.out.println("输入reading继续上子弹，输入quit退出");
            String isQuit = sc.next();
            if (isQuit.equals("quit")) {
                break;
            }
        }
    }

}

高亮显示的部分为死循环控制的精辟所在。

实例4：

我们提供1块石头，
，然后人可以将石头磨成对应的石刀，
不同的石头摸出来的刀是不一样的，
人可以拿着刀去看树，不同的树会变成不同的木材，
人可以将木材加工成不同的椅子。

思路分析：关键在于面向对象和流程控制

核心代码：

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
public class Start {
    
    
    public static void main(String[] args) {
        System.out.println("请选择一种石头，【1】石英石，【2】大理石，【3】石灰石，【乱输】泥土：");
        Scanner sc=new Scanner(System.in);
        String inputStone=sc.next();
        
        Stone stone=new Stone(inputStone);
        Human human=new Human();
        
        //人打磨石头得到石刀
        StoneKnife stoneKnife=human.grind(stone);
        System.out.println(human.name+"通过打磨"+stone.solidity+"的"+stone.name+"得到了"+stoneKnife.tartness+"的"+stoneKnife.name);
        
        //
        System.out.println("请选择您要砍的树，【1】松树，【2】桦树，【3】椿树，【乱输】枯树：");
        String inputTree=sc.next();
        
        Tree tree=new Tree(inputTree);
        
        //人砍树得到木材
        Timber timber=human.cutTree(tree, stoneKnife);
        System.out.println(human.name+"用"+stoneKnife.name+"砍了一些"+tree.name+"得到了一些"+timber.name);
        
        //人用得到的木材做椅子
        Chair chair=human.makeChair(timber);
        System.out.println(human.name+"用"+timber.name+"做了一些"+chair.sturdy+"的"+chair.name);
        
        
    }

}

public class Stone {
    /** 石头的名字 */
    public String name;
    /** 石头的坚固程度 */
    public String solidity;
    

    public Stone(String n) {
        switch (n) {
        case "1":
            name = "石英石";
            solidity = "最硬";
            break;
        case "2":
            name = "大理石";
            solidity = "坚固";
            break;
        case "3":
            name = "石灰石";
            solidity = "松软";
            break;

        default:
            name = "泥土";
            solidity = "松散";
            break;
        }
    }
}

public class StoneKnife {
    /** 石刀的名字 */
    public String name;
    /** 石刀的锋利程度 */
    public String tartness;
    /** 石刀的材料 */
    public Stone material;

    public StoneKnife(){
        
    }

}

public class Tree {
    public String name;
    public String sturdy;
    
    public Tree(String n){
        switch (n) {
        case "1":
            name="松树";
            sturdy="坚固";
            break;
        case "2":
            name="桦树";
            sturdy="结实";
            break;
        case "3":
            name="椿树";
            sturdy="松动";
            break;

        default:
            name="枯树";
            sturdy="一碰就碎";
            break;
        }
    }
}

public class Timber {
    public String name;
    public String sturdy;
    public Tree material;
    
    public Timber(){
        
    }
}

public class Chair {
    public String name;
    public String sturdy;
    public Timber material;
    
    public Chair(){
        
    }
    }



public class Human {
    /**人的名字*/
    public String name;
    
    public Human(){
        name="张三";
    }
    
    /**打磨石头得到石刀*/
    public StoneKnife grind(Stone stone){
        StoneKnife sk=null;
        switch (stone.name) {
        case "石英石":
            sk=new StoneKnife();
            sk.name=stone.name+"刀";
            sk.tartness="锐利";
            sk.material=stone;
            break;
        case "大理石":
            sk=new StoneKnife();
            sk.name=stone.name+"刀";
            sk.tartness="锋利";
            sk.material=stone;
            break;
        case "石灰石":
            sk=new StoneKnife();
            sk.name=stone.name+"刀";
            sk.tartness="很钝";
            sk.material=stone;
            break;

        default:
            sk=new StoneKnife();
            sk.name=stone.name+"刀";
            sk.tartness="什么都砍不动";
            sk.material=stone;
            break;
        }
        return sk;
    }
    
    /**拿刀砍树*/
    public Timber cutTree(Tree tree,StoneKnife stoneKnife){
        Timber timber=null;
        switch (tree.name) {
        case "松树":
            timber=new Timber();
            timber.name=tree.name+"木材";
            timber.sturdy=tree.sturdy;
            timber.material=tree;
            break;
        case "桦树":
            timber=new Timber();
            timber.name=tree.name+"木材";
            timber.sturdy=tree.sturdy;
            timber.material=tree;
            break;
        case "椿树":
            timber=new Timber();
            timber.name=tree.name+"木材";
            timber.sturdy=tree.sturdy;
            timber.material=tree;
            break;

        default:
            timber=new Timber();
            timber.name=tree.name+"木材";
            timber.sturdy=tree.sturdy;
            timber.material=tree;
            break;
        }
        
        
        return timber;
    }
    
    /**用木材做椅子*/
    public Chair makeChair(Timber timber){
        Chair chair=null;
        
        switch (timber.name) {
        case "松树木材":
            chair=new Chair();
            chair.name="椅子";
            chair.sturdy=timber.sturdy;
            chair.material=timber;
            break;
        case "桦树木材":
            chair=new Chair();
            chair.name="椅子";
            chair.sturdy=timber.sturdy;
            chair.material=timber;
            break;
        case "椿树木材":
            chair=new Chair();
            chair.name="椅子";
            chair.sturdy=timber.sturdy;
            chair.material=timber;
            break;

        default:
            chair=new Chair();
            chair.name=timber.name+"椅子";
            chair.sturdy=timber.sturdy;
            chair.material=timber;
            break;
        }
        
        return chair;
    }
    
}
  • 本文标题：2017-02-23-面向对象
  • 本文作者：Xplorist
  • 创建时间：2017-02-23 14:23:01
  • 本文链接：https://xplorist.tech/2017/02/23/fa602e73a9d1/
  • 版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
 评论