C#基础篇九OOP属性结构枚举

1.设计一个Ticket类,有一个距离属性(本属性只读,在构造方法中赋值),不能为负数,有一个价格属性,价格属性只读,并且根据距离计算价格(1元/公里):-----------
0-100公里 票价不打折
101-200公里 总额打9.5折
201-300公里 总额打9折
300公里以上 总额打8折
有一个方法,可以显示这张票的信息.

业务：
不需要设计太多，只需要 提示用户 拥有的票的种类，然后让用户选择，选择后 按照价格打折后 显示给用户
强调：只需要两个类（Ticket 票据类，Saler 售票员类）

Ticket票据类

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace S01Morning
{
    /// <summary>
    /// 票据类
    /// </summary>
    public class Ticket
    {
        /// <summary>
        /// 票据的编号 种子
        /// </summary>
        public static int idSeed = 1;
        /// <summary>
        /// 票据编号
        /// </summary>
        public int id;
 
        /// <summary>
        /// 距离
        /// </summary>
        public int distance;
 
        /// <summary>
        /// 出发地
        /// </summary>
        public string startLocation;
 
        /// <summary>
        /// 目的地
        /// </summary>
        public string endLocation;
 
        public Ticket(int dis, string start, string end)
        {
            this.id = idSeed++;
            this.distance = dis;
            this.startLocation = start;
            this.endLocation = end;
        }
 
        #region 1.0 价格  + int Price()
        /// <summary>
        /// 价格
        /// </summary>
        /// <returns></returns>
        public int Price()
        {
            return distance * 1;
        }
        #endregion
 
        #region 2.0 显示票据内容 + void Show()
        /// <summary>
        /// 显示票据内容
        /// </summary>
        public void Show()
        {
            Console.WriteLine("编号：{0}，出发地：{1} -> 目的地：{2}，票价：{3}", this.id, this.startLocation, this.endLocation, this.Price());
        }
        #endregion
 
        #region 2.1 根据 优惠 输出打折后的价格信息 +void ShowWithDaZhe(float rate)
        /// <summary>
        /// 2.1 根据 优惠 输出打折后的价格信息
        /// </summary>
        /// <param name="rate">折率</param>
        public void ShowWithDaZhe(float rate)
        {
            Console.WriteLine("编号：{0}，出发地：{1} -> 目的地：{2}，票价：{3}", this.id, this.startLocation, this.endLocation, this.Price() * rate);
        }
        #endregion
    }
}

　　Saler售货员

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace S01Morning
{
    /// <summary>
    /// 售票员
    /// </summary>
    public class Saler
    {
        /// <summary>
        /// 票据数组
        /// </summary>
        Ticket[] list;
 
        #region 构造函数  初始化票据
        /// <summary>
        /// 构造函数  初始化票据
        /// </summary>
        public Saler()
        {
            list = new Ticket[10];
            list[0] = new Ticket(600, "广州", "长沙");
            list[1] = new Ticket(150, "广州", "深圳");
            list[2] = new Ticket(1900, "广州", "北京");
            list[3] = new Ticket(1000, "广州", "台北");
            list[4] = new Ticket(40, "广州", "东莞");
            list[5] = new Ticket(800, "广州", "丽江");
            list[6] = new Ticket(3000, "广州", "拉萨");
            list[7] = new Ticket(3000, "广州", "东京");
            list[8] = new Ticket(10000, "广州", "巴黎");
            list[9] = new Ticket(7000, "广州", "莫斯科");
        }
        #endregion
 
        #region 0.0 开始工作 +void StartWork()
        /// <summary>
        /// 0.0 开始工作
        /// </summary>
        public void StartWork()
        {
            do{
                Selling();
                Console.WriteLine("\n是否要继续购买呢？(y/n)");
            }while(Console.ReadLine()=="y");
        }
        #endregion
 
        #region 1.0 卖票 +void Selling()
        /// <summary>
        /// 1.0 卖票
        /// </summary>
        public void Selling()
        {
            while (true)
            {
                //1.0 显示 当前的票
                ShowTickts();
                Console.WriteLine("您要买去哪的票呢？");
                int tId = int.Parse(Console.ReadLine().Trim());
                //2.0 根据用户选择 票据编号 获取 票据对象
                Ticket t = GetTicketById(tId);
                if (t != null)
                {
                    Console.WriteLine("恭喜您购买成功了如下车票：");
                    if (t.distance > 0 && t.distance <= 100)//0-100公里      票价不打折
                    {
                        t.Show();
                    }
                    else if (t.distance > 100 && t.distance <= 200)//101-200公里    总额打9.5折
                    {
                        t.ShowWithDaZhe(0.95f);
                    }
                    else if (t.distance > 200 && t.distance <= 300)//201-300公里    总额打9折
                    {
                        t.ShowWithDaZhe(0.9f);
                    }
                    else//300公里以上    总额打8折
                    {
                        t.ShowWithDaZhe(0.8f);
                    }
                    break;
                }
                else
                {
                    Console.WriteLine("对不起，您输入的编号有误，请重新输入！");
                }
            }
        }
        #endregion
 
        #region 1.1 显示票据信息 -void ShowTickts()
        /// <summary>
        /// 1.1 显示票据信息
        /// </summary>
        private void ShowTickts()
        {
            //循环票据数组
            for (int i = 0; i < list.Length; i++)
            {
                Ticket t = list[i];
                t.Show();
            }
        }
        #endregion
 
        #region 1.2 根据id 查找票据对象 -Ticket GetTicketById(int ticketId)
        /// <summary>
        /// 1.2 根据id 查找票据对象
        /// </summary>
        /// <param name="ticketId">id</param>
        /// <returns>票据对象</returns>
        private Ticket GetTicketById(int ticketId)
        {
            for (int i = 0; i < list.Length; i++)
            {
                Ticket t = list[i];
                if (t.id == ticketId)
                {
                    return t;
                }
            }
            return null;
        }
        #endregion
    }
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace S01Morning
{
    class Program
    {
        /// <summary>
        /// 阅读代码：找到 程序的入口！
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            //1.0 创建售票员
            Saler s = new Saler();
            //2.0 开始工作
            s.StartWork();
 
            Console.ReadLine();
        }
    }
}

　　

2.猜拳游戏---------------
先接收一个玩家的名字，玩家和机器人猜拳
接收玩家的 输入（1-石头；2-剪刀；3-布）
机器人 随机生成 1-3之间的数值
两个数值 按照规则 进行比较，最终显示输赢！

玩家类(Player)、机器人类(Robot)、裁判类(Judge)


//-----------------------------------------------
1.当 程序员 规定 一组数据（石头、剪刀、布） 用 【数值类型】来标识 的时候，需要严格的【限制】 这组 数值 的【取值范围】！
且 对这组数据 要求 有明确 的 【可读性】！
且 提供 给程序员 明确便捷的 操作语法！不容易写错！
解决方案：
【枚举-Enum】
1.1枚举的定义语法：
public enum FistType
{
/// <summary>
/// 枚举值：石头
/// </summary>
Rock = 1,

/// <summary>
/// 枚举值：剪刀
/// </summary>
Scissors = 2,

/// <summary>
/// 枚举值：布
/// </summary>
Cloth = 3
}

1.2枚举类型 变量 的访问
FistType type = FistType.Rock;
type = FistType.Scissors;

1.3可以直接将 枚举类型 作为 方法的 返回值类型 或者 参数类型

2.在C#中，class后跟的 是类名，但其只是 整个类的名字 的一部分而已！
真正的完整的类名 是 命名空间.类名！如：
namespace A
{
public class DongGuan
{
}
}
类名：DongGuan
类的全名称：A.DongGuan

 

出拳类型 枚举

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace S02猜拳
{
    /// <summary>
    /// 出拳类型 枚举
    ///     枚举的本质 就是 用代码的枚举值 来 替代 对应的 数值！
    /// </summary>
    public enum FistType
    {
        /// <summary>
        /// 枚举值：石头
        /// </summary>
        Rock = 1,
 
        /// <summary>
        /// 枚举值：剪刀
        /// </summary>
        Scissors = 2,
 
        /// <summary>
        /// 枚举值：布
        /// </summary>
        Cloth = 3
    }
}

　　工具帮助类

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace S02猜拳
{
    /// <summary>
    /// 工具类
    /// </summary>
    public class Helper
    {
        #region 1.0 获取用户输入的一个 整型数值 +int GetAUserNum()
        /// <summary>
        /// 1.0 获取用户输入的一个 整型数值
        /// </summary>
        /// <returns></returns>
        public static int GetAUserNum(string strMsg)
        {
            int num=-1;
            while (true)
            {
                Console.Write(strMsg);
                string strNum = Console.ReadLine();
                if (int.TryParse(strNum, out num))
                {
                    break;
                }
                else
                {
                    Console.WriteLine("请输入数值！");
                }
            }
            return num;
        }
        #endregion
    }
}

　　裁判类

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace S02猜拳
{
    /// <summary>
    /// 裁判类
    /// </summary>
    public class Judger
    {
        #region 1.0 机器人 判定 两个输入 的输赢 void Judge(int playerNum, int robotNum)
        /// <summary>
        /// 1.0 机器人 判定 两个输入 的输赢
        /// </summary>
        /// <param name="playerFistType">玩家输入</param>
        /// <param name="robotFistType">机器人输入</param>
        public void Judge(FistType playerFistType, FistType robotFistType)
        {
            //1.0 如果相等，则是平局
            if (playerFistType == robotFistType)
            {
                Console.WriteLine("平局~~！");
            }
            else//2.否则，对各种情况进行判断
            {
                // 石头1 吃 剪刀2 吃 布3  吃 石头
                //直接 用 两个 枚举值 进行 相减运算 （实际运算的 是 两个枚举值对应的 数值）
                int num = playerFistType - robotFistType;
                if (num == -1 || num == 2)
                {
                    Console.WriteLine("玩家赢了~~~~");
                }
                else {
                    Console.WriteLine("机器人赢了~~~~");
                }
            }
        }
        #endregion
    }
}

　　玩家类

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace S02猜拳
{
    /// <summary>
    /// 玩家类
    /// </summary>
    public class Player
    {
        public string name;
         
        public Player(string name)
        {
            this.name = name;
        }
 
        #region 1.0 玩家进行 猜拳 +int Play()
        /// <summary>
        /// 1.0 玩家进行 猜拳
        /// </summary>
        /// <returns></returns>
        public FistType Play()
        {
            while (true)
            {
                int num = Helper.GetAUserNum("输入值(1-石头；2-剪刀；3-布)：");
                if (num >= 1 && num <= 3)
                {
                    //if (num == 1)
                    //    return FistType.Rock;
                    //else if (num == 2)
                    //    return FistType.Scissors;
                    //else
                    //    return FistType.Cloth;
 
                    return (FistType)num;//直接将 接收到 的 1~3 的一个数值 转成对应的枚举值！
                }
                else
                {
                    Console.WriteLine("数值必须在 1-3之间！");
                }
            }
        }
        #endregion
    }
}

　　机器人类

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace S02猜拳
{
    /// <summary>
    /// 机器人 类
    /// </summary>
    public class Robot
    {
        Random ran = new Random();
 
        #region 1.0 机器人返回 猜拳编号 +int Play()
        /// <summary>
        /// 1.0 机器人返回 猜拳编号
        /// </summary>
        /// <returns></returns>
        public FistType Play()
        {
             int num = ran.Next(1, 4);// 1 <= x < 4
             FistType type = (FistType)num;//将 数值 转成对应的 枚举值
             switch (type)
             {
                 case FistType.Rock:
                     {
                         Console.WriteLine("机器人出的 是 【石头】！");
                         break;
                     }
                 case FistType.Scissors:
                     {
                         Console.WriteLine("机器人出的 是 【剪刀】！");
                         break;
                     }
                 default:
                     {
                         Console.WriteLine("机器人出的 是 【布】！");
                         break;
                     }
             }
             return type;
        }
        #endregion
    }
}

　　

?
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace S02猜拳
{
    class Program
    {
        /*  先接收一个玩家的名字，玩家和机器人猜拳
            接收玩家的 输入（1-石头；2-剪刀；3-布）
            机器人 随机生成 1-3之间的数值
            两个数值 按照规则 进行比较，最终显示输赢！
            玩家类(Player)、机器人类(Robot)、裁判类(Judger)
         */
        static void Main(string[] args)
        {
            //1.创建玩家 (接收玩家名字)
            Console.WriteLine("请输入玩家的名字：");
            string strName = Console.ReadLine().Trim();
            Player player = new Player(strName);
            //2.创建机器人
            Robot robot = new Robot();
            //3.创建 裁判
            Judger judger = new Judger();
            do
            {
                //1.接收玩家的输入
                FistType typeA = player.Play();
                //2.接收机器人的输入
                FistType typeB = robot.Play();
                //3.将两个输入 传给 裁判，判断并显示结果
                judger.Judge(typeA, typeB);
                //4.是否继续
                Console.WriteLine("是否继续？(y/n)");
            } while (Console.ReadLine() == "y");
        }
    }
}

　　

posted @   枫伶忆  阅读(453)  评论(0)  编辑  收藏  举报
编辑推荐：
· go语言实现终端里的倒计时
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
阅读排行：
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 分享 3 个 .NET 开源的文件压缩处理库，助力快速实现文件压缩解压功能！
· Ollama——大语言模型本地部署的极速利器
· DeepSeek如何颠覆传统软件测试？测试工程师会被淘汰吗？
点击右上角即可分享
微信分享提示
AI IDE Trae