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
文字处理器的