1
00:00:00,360 --> 00:00:07,030
这里面实际上就是通过一个方法，一个操作来封装了
2
00:00:08,790 --> 00:00:10,630
它不直接就操纵这里面
3
00:00:10,640 --> 00:00:12,070
不是直接把里面露出来
4
00:00:14,990 --> 00:00:20,430
产品ID进来，返回是产品类型
5
00:00:22,440 --> 00:00:23,660
产品类型，我们前面讲
6
00:00:23,670 --> 00:00:24,780
它是一个枚举的
7
00:00:26,150 --> 00:00:28,650
单独搞了个枚举来表示它
8
00:00:28,660 --> 00:00:31,890
这种封装
9
00:00:32,300 --> 00:00:33,690
什么时候用是值得的
10
00:00:34,760 --> 00:00:37,000
如果说你这里面是比较复杂的
11
00:00:37,530 --> 00:00:38,720
或者容易变化的
12
00:00:38,890 --> 00:00:40,480
封装可以，否则的话
13
00:00:40,860 --> 00:00:42,710
为了又多一个封装
14
00:00:42,980 --> 00:00:44,010
就不值得了
15
00:00:44,880 --> 00:00:45,540
1
00:00:00,590 --> 00:00:03,620
这里类型的话
2
00:00:05,870 --> 00:00:08,180
我们看它是哪一个
3
00:00:09,810 --> 00:00:11,780
这里写了，是D
4
00:00:12,460 --> 00:00:19,990
显然它跟这个是不等的
5
00:00:20,000 --> 00:00:20,270
6
00:00:22,960 --> 00:00:24,310
D跟这个也不等
7
00:00:25,060 --> 00:00:26,650
跳到下面来了
8
00:00:29,160 --> 00:00:29,540
9
00:00:29,550 --> 00:00:35,880
然后这里，跟前面封装一样
10
00:00:36,200 --> 00:00:38,710
把什么时候签约时间拿出来
11
00:00:39,870 --> 00:00:40,810
跟这里一样
12
00:00:46,080 --> 00:00:51,630
然后这里面我们前面讲过了
13
00:00:51,640 --> 00:00:58,340
它自己定义了一个分配金钱的一个操作
14
00:00:58,910 --> 00:00:59,950
你要把它分3份
15
00:01:00,840 --> 00:01:01,160
对吧
16
00:01:02,220 --> 00:01:03,530
分配在哪里
17
00:01:03,820 --> 00:01:04,770
就在这里
18
00:01:05,880 --> 00:01:07,640
就在这个合同类里面
19
00:01:07,650 --> 00:01:08,920
它定义了一个操作
20
00:01:09,730 --> 00:01:14,300
参数是金额、份数
21
00:01:17,710 --> 00:01:24,330
然后先定义了一个低值结果变量
22
00:01:25,290 --> 00:01:27,470
然后先把它分
23
00:01:27,480 --> 00:01:32,170
分完之后这里取整
24
00:01:34,370 --> 00:01:37,890
因为我们那个数值只能到分了
25
00:01:39,540 --> 00:01:41,760
比如说，你有7块钱
26
00:01:41,770 --> 00:01:43,080
你分3份怎么分呢
27
00:01:44,340 --> 00:01:45,660
你肯定分不了的
28
00:01:46,230 --> 00:01:47,740
最后你只能分到什么
29
00:01:48,360 --> 00:01:50,300
要么是2块
30
00:01:52,670 --> 00:01:55,270
2块、3块这样
31
00:01:55,280 --> 00:01:58,670
但这个肯定不是，因为这个是以元为单位的
32
00:01:59,530 --> 00:02:00,690
如果你是7分钱
33
00:02:00,820 --> 00:02:01,930
我们说7分钱的话
34
00:02:02,570 --> 00:02:04,300
只能分2、2、3
35
00:02:04,310 --> 00:02:06,420
估计已经是最接近的，没有办法了
36
00:02:07,190 --> 00:02:09,940
当然你是700块（口误）的话
37
00:02:10,190 --> 00:02:13,320
700分，7块钱就是700分的话
38
00:02:14,110 --> 00:02:15,100
700的话
39
00:02:15,110 --> 00:02:20,880
699算是可以分的
40
00:02:21,410 --> 00:02:24,070
699可以分，剩下1分怎么分
41
00:02:25,030 --> 00:02:26,270
剩下1分的话
42
00:02:26,280 --> 00:02:29,750
你只能分给某一个了
43
00:02:30,330 --> 00:02:33,550
有一个是得234的
44
00:02:33,560 --> 00:02:38,300
其它是233、233，这样分
45
00:02:38,310 --> 00:02:44,250
那么这个实际上就展示了这个过程
46
00:02:44,260 --> 00:02:45,130
低值结果，高值结果
47
00:02:45,140 --> 00:02:46,380
高值结果
48
00:02:46,390 --> 00:02:49,410
就是往上加一分钱了
49
00:02:51,100 --> 00:02:52,170
然后看余数
50
00:02:52,450 --> 00:02:53,520
看余数是多少
51
00:02:55,810 --> 00:02:57,530
然后余数前面的元素
52
00:02:57,740 --> 00:02:59,720
所以，余数是多少
53
00:03:00,210 --> 00:03:03,470
余数因为它就已经是整数了
54
00:03:04,590 --> 00:03:07,060
所以这里面的话，余数前面的元素
55
00:03:07,750 --> 00:03:11,380
就是高值的结果
56
00:03:11,910 --> 00:03:18,480
余数后面的元素就，这写错了
57
00:03:19,320 --> 00:03:20,530
标错了
58
00:03:20,920 --> 00:03:22,320
就用低值的结果
59
00:03:24,750 --> 00:03:28,150
60
00:03:36,310 --> 00:03:40,350
然后就把这三个插进去了
61
00:03:40,560 --> 00:03:41,790
怎么插入
62
00:03:41,920 --> 00:03:45,130
就调用这个表模块的
63
00:03:45,140 --> 00:03:47,080
一个插入的操作
64
00:03:50,690 --> 00:03:51,940
先定义一个新行
65
00:03:51,950 --> 00:03:54,480
然后取下一个ID
66
00:03:55,710 --> 00:03:58,290
之前那个作用
67
00:03:58,300 --> 00:04:02,160
你看，取下一个ID怎么实现的
68
00:04:03,580 --> 00:04:12,170
这里有一个锁，在这里定义，我们前面
69
00:04:13,550 --> 00:04:14,870
你看，定义了一个
70
00:04:15,120 --> 00:04:17,430
它类型就是对象
71
00:04:17,640 --> 00:04:19,670
一个静态的对象，就代表这个锁
72
00:04:22,680 --> 00:04:26,030
然后，你看这个是怎么做
73
00:04:27,880 --> 00:04:31,740
锁的目的就是为了保证原子操作
74
00:04:31,750 --> 00:04:35,360
就是说被锁住的这段里面的
75
00:04:35,370 --> 00:04:37,620
当然这里代码只有一行
76
00:04:38,350 --> 00:04:40,830
当然这一行里面可能它会分很多个指令了
77
00:04:40,840 --> 00:04:41,230
对不对
78
00:04:42,300 --> 00:04:45,710
就是说，如果有多个线程
79
00:04:46,410 --> 00:04:47,570
来执行这段代码
80
00:04:47,580 --> 00:04:50,090
如果A线程执行到
81
00:04:50,100 --> 00:04:52,470
这里面的时候，还没执行完
82
00:04:52,890 --> 00:04:54,680
B线程已经执行到这里了
83
00:04:57,040 --> 00:04:58,630
B线程执行到这里的时候
84
00:04:58,640 --> 00:05:00,190
它一看被锁住了
85
00:05:01,800 --> 00:05:03,480
有锁，它就等待
86
00:05:04,120 --> 00:05:05,250
等待A执行完了
87
00:05:05,260 --> 00:05:07,210
这个锁不存在了，被释放了
88
00:05:07,890 --> 00:05:10,420
保证多线程执行
89
00:05:11,170 --> 00:05:14,050
这段代码有多个线程
90
00:05:14,060 --> 00:05:15,050
同时执行的时候
91
00:05:16,810 --> 00:05:19,630
另外一个后面的线程
92
00:05:19,640 --> 00:05:21,470
要等待前面的线程
93
00:05:21,480 --> 00:05:22,990
把这一段执行完了
94
00:05:23,940 --> 00:05:25,210
把它释放出来了
95
00:05:26,850 --> 00:05:30,460
它才能够执行它的那一段程序
96
00:05:32,020 --> 00:05:34,120
这样才不会导致冲突
97
00:05:34,910 --> 00:05:37,020
像标识，我正在递增了
98
00:05:39,410 --> 00:05:41,020
原来那个数还没改
99
00:05:41,240 --> 00:05:43,650
结果你另外一个线程进来又递增一个
100
00:05:45,510 --> 00:05:48,220
最后得出来可能是两个一样的
101
00:05:48,230 --> 00:05:50,260
新的标识，冲突了
102
00:05:50,960 --> 00:05:53,160
所以你等我把递增做完了
103
00:05:54,440 --> 00:05:57,450
才能够轮到你来做下一步
104
00:05:59,240 --> 00:06:02,070
保证操作的原子性
105
00:06:04,470 --> 00:06:07,120
但这个的话我们自己来实现
106
00:06:08,270 --> 00:06:12,290
没有必要，最好是交给平台来做
107
00:06:12,460 --> 00:06:13,930
交给相应第三方
108
00:06:14,140 --> 00:06:20,610
不能写在我们这个领域的代码里面来
109
00:06:20,620 --> 00:06:21,210
不应该
110
00:06:22,320 --> 00:06:23,820
但这个是演示，无所谓了
111
00:06:25,900 --> 00:06:27,280
然后继续
1
00:00:01,260 --> 00:00:02,560
后面就是一样了
2
00:00:03,090 --> 00:00:03,760
ID
3
00:00:06,780 --> 00:00:13,590
一个字段一个字段往里面赋值
4
00:00:13,600 --> 00:00:16,410
赋好了，这一行就把它添加到
5
00:00:17,310 --> 00:00:20,190
Table的行的集合里面来
6
00:00:20,860 --> 00:00:22,570
实际上就是我们刚才类图上
7
00:00:24,800 --> 00:00:28,400
Table跟行之间的角色名
8
00:00:28,780 --> 00:00:32,040
添加，下面一样
1
00:00:00,360 --> 00:00:01,540
我们就一直运行
2
00:00:02,190 --> 00:00:05,280
后面一样
3
00:00:13,440 --> 00:00:14,550
计算完了
4
00:00:15,560 --> 00:00:21,240
实际上就是往表里面插入数据
5
00:00:22,290 --> 00:00:24,400
然后下面一样的
1
00:00:01,390 --> 00:00:02,310
你看，这一步
2
00:00:03,010 --> 00:00:07,800
我们现在是在主程序里面
3
00:00:08,140 --> 00:00:11,960
这一步就新建了一个收入确认的表模块
4
00:00:12,320 --> 00:00:14,260
然后调用这个表模块的操作
5
00:00:14,350 --> 00:00:16,990
我们来看怎么做
6
00:00:18,170 --> 00:00:22,840
构造，一样的
7
00:00:23,340 --> 00:00:25,140
前面都已经见过了
8
00:00:26,890 --> 00:00:28,610
好，接下来看，收入确认这个
9
00:00:33,290 --> 00:00:34,670
这个实际上就相当于
10
00:00:35,770 --> 00:00:39,930
传入的参数是合同ID
11
00:00:40,840 --> 00:00:42,940
这是某个日期
12
00:00:43,700 --> 00:00:45,260
那么通过这个来计算
13
00:00:45,270 --> 00:00:48,260
某合同、某日期之前已确认的收入
14
00:00:49,000 --> 00:00:52,500
相当于根据这个来查询，得到结果
15
00:00:55,340 --> 00:00:57,680
那么这里面查询的内容
16
00:00:57,690 --> 00:01:00,920
主要是在收入确认这个表里面
17
00:01:00,930 --> 00:01:06,890
所以操作就会放在这个表模块里面
18
00:01:08,230 --> 00:01:09,150
放在这里面
19
00:01:12,100 --> 00:01:16,280
跟我们的面向对象专家原则
20
00:01:16,890 --> 00:01:18,230
分配责任那个是类似的
21
00:01:20,190 --> 00:01:22,270
用到谁的数据最多
22
00:01:22,360 --> 00:01:26,570
那么它就有可能，最应该成为这个类的操作
23
00:01:30,300 --> 00:01:35,510
这里，首先第一步，就构建筛选条件
24
00:01:35,990 --> 00:01:37,480
构建一个查询条件了
25
00:01:38,140 --> 00:01:46,350
然后使用Table的一个操作
26
00:01:47,150 --> 00:01:50,400
select操作，然后把这个条件放进去
27
00:01:50,610 --> 00:01:51,880
筛选出符合条件的行
28
00:01:55,400 --> 00:01:58,400
得到这一行以后，它放到这里来了
29
00:01:58,530 --> 00:02:00,380
行的一个集合了
30
00:02:00,390 --> 00:02:07,280
然后它就根据这些行来累计行里面的字段
31
00:02:08,140 --> 00:02:09,280
金额
32
00:02:09,290 --> 00:02:10,640
金额字段累计起来
33
00:02:11,180 --> 00:02:12,210
但像这个的话
34
00:02:12,220 --> 00:02:15,640
如果是用SQL语句
35
00:02:15,650 --> 00:02:18,220
或者是用集合运算的
36
00:02:18,230 --> 00:02:19,900
像LINQ这样的语句的话
37
00:02:20,340 --> 00:02:23,230
直接用聚合函数就可以了
38
00:02:23,400 --> 00:02:26,530
没有必要让自己又单独搞一遍这样
39
00:02:26,540 --> 00:02:27,690
但没有关系
40
00:02:27,700 --> 00:02:31,350
这只是演示，聚合函数就可以了
41
00:02:32,240 --> 00:02:33,940
包括前面的所有的一切
42
00:02:34,880 --> 00:02:38,280
实际上，只要我们的表结构是合理的
43
00:02:38,410 --> 00:02:43,430
完全就可以通过一个查询语句把它写出来
44
00:02:43,600 --> 00:02:46,530
又这个，又那个，没有必要
45
00:02:48,090 --> 00:02:52,760
实际上最终的目的就是要做这个
46
00:02:52,770 --> 00:02:55,400
计算某合同某日期之前的已确认收入
47
00:02:55,950 --> 00:02:59,460
包括前面讲的，我们前面也说到过了
48
00:02:59,800 --> 00:03:01,750
写收入确认表都没有必要
49
00:03:01,760 --> 00:03:03,070
因为是冗余的数据
50
00:03:04,590 --> 00:03:07,610
我们就完全可以通过简单的
51
00:03:07,620 --> 00:03:11,260
这种标准的集合运算
52
00:03:12,950 --> 00:03:14,150
直接得到我们的结果
53
00:03:14,440 --> 00:03:17,010
这个我们最后再演示
54
00:03:18,550 --> 00:03:21,600
没有必要来这样做，但这个演示的话
55
00:03:23,250 --> 00:03:24,300
我们就按照书上这样
56
00:03:25,050 --> 00:03:25,870
来把它过一下
57
00:03:26,680 --> 00:03:30,830
来比较一下，自己来完成这个
58
00:03:30,840 --> 00:03:34,030
没有必要，好，得到结果了
59
00:03:34,690 --> 00:03:35,330
60
00:03:37,830 --> 00:03:41,740
然后这里就把它写到控制台
61
00:03:42,900 --> 00:03:46,010
控制台，就是这一行
62
00:03:47,010 --> 00:03:49,690
在这之前的收入是3333
63
00:03:51,020 --> 00:03:52,650
显然这是分3份了
64
00:03:53,570 --> 00:03:55,230
3333那三份
65
00:03:56,060 --> 00:03:58,730
后面可能就有3334什么的
66
00:04:01,200 --> 00:04:02,550
我们继续往下走
67
00:04:03,580 --> 00:04:05,540
先执行到这里
68
00:04:08,670 --> 00:04:14,400
好，我们看666.67，这是数据库
69
00:04:14,490 --> 00:04:19,840
另外两项就没有显示了
70
00:04:20,830 --> 00:04:22,350
这是数据库的
71
00:04:22,360 --> 00:04:23,630
这是电子表格的
72
00:04:24,760 --> 00:04:26,470
另外一个合同了，合同2
73
00:04:26,480 --> 00:04:27,650
合同3
74
00:04:31,530 --> 00:04:32,750
我们看合同3
75
00:04:36,690 --> 00:04:43,820
文字处理器的
扫一扫
508
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
