1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [讲座] [Android应用程序（现在糖豆！）]

2
00:00:02,610 --> 00:00:04,210
[约旦Jozwiak] [哈佛大学]

3
00:00:04,210 --> 00:00:06,780
[这是CS50。] [CS50.TV]

4
00:00:06,780 --> 00:00:11,600
>> 大家好，欢迎到Android应用程序（现在糖豆）研讨会。

5
00:00:11,600 --> 00:00:14,530
这就是所谓的现在与糖豆，当然，因为

6
00:00:14,530 --> 00:00:17,310
最新版本的操作系统被称为果冻豆。

7
00:00:17,310 --> 00:00:22,950
当我谈到去年的Andr​​oid这样做基本上是相同的研讨会

8
00:00:22,950 --> 00:00:29,150
我提出的设计图案和风格的选择，姜饼，

9
00:00:29,150 --> 00:00:31,250
尽管冰淇淋三明治已经出来的时候，

10
00:00:31,250 --> 00:00:33,680
这是后话，我们会谈论前进一点点。

11
00:00:33,680 --> 00:00:35,720
Android的，当然，有一些碎片问题，

12
00:00:35,720 --> 00:00:40,240
所以最新的谷歌操作系统通常是

13
00:00:40,240 --> 00:00:44,710
不是真的要成为常见的用户之间可能高达一年，不幸的。

14
00:00:44,710 --> 00:00:49,960
>> 但无视这一点，我们会谈论很多原因，

15
00:00:49,960 --> 00:00:53,000
Android是远远优于iOS的。

16
00:00:53,000 --> 00:00:56,410
好吧，我们来谈谈Android与iOS的，

17
00:00:56,410 --> 00:00:59,770
一些设计范例，您将如何设立只是一个幻灯片，

18
00:00:59,770 --> 00:01:03,410
大的区别，我只是想，这与去年的

19
00:01:03,410 --> 00:01:06,860
通过一些概念性的东西，使用变焦

20
00:01:06,860 --> 00:01:09,950
操作系统，然后进入一个非常基本的例子。

21
00:01:09,950 --> 00:01:13,730
事实上，就在建立你的第一个应用程序，谷歌描述的例子，

22
00:01:13,730 --> 00:01:17,070
通过它，我们会去一起，只是描述。

23
00:01:17,070 --> 00:01:22,100
>> 我知道你们许多人只用C语言编写的，所以Java已经

24
00:01:22,100 --> 00:01:27,220
不同的角度，这样你会得到你的脚湿

25
00:01:27,220 --> 00:01:31,540
和感觉舒服些希望。

26
00:01:31,540 --> 00:01:35,330
一个快速的总结，Android与iOS的。

27
00:01:35,330 --> 00:01:39,200
在Android中，有这种一次性的开发费用为25美元，

28
00:01:39,200 --> 00:01:42,390
没有这个每年100美元的事情。

29
00:01:42,390 --> 00:01:45,440
有没有限制，这意味着，如果我想提交一个应用程序，

30
00:01:45,440 --> 00:01:51,560
我刚提交它，就像是有适用于iOS有没有审批流程。

31
00:01:51,560 --> 00:01:53,890
您可以使用Eclipse与Java开发，

32
00:01:53,890 --> 00:01:57,090
它是跨平台的，所以它并不重要，如果你有一个苹果，

33
00:01:57,090 --> 00:01:59,600
Windows，或者一些Linux机器。

34
00:01:59,600 --> 00:02:03,730
当然，你必须与iOS在Mac上使用XCode，

35
00:02:03,730 --> 00:02:06,930
Android是越来越多的人使用，

36
00:02:06,930 --> 00:02:11,580
所以，如果你希望你的应用程序有某种形式的知名度，或者

37
00:02:11,580 --> 00:02:14,110
从广告，赚小钱

38
00:02:14,110 --> 00:02:17,450
你可能更容易从Android获益。

39
00:02:17,450 --> 00:02:20,630
>> 还有一件事，一直被称为关于Android

40
00:02:20,630 --> 00:02:25,100
是极端的定制量，而以自己的方式是非常固定的iOS

41
00:02:25,100 --> 00:02:29,380
这样他们可以维护每一个小环节的安全性和控制权

42
00:02:29,380 --> 00:02:34,180
在其操作系统和单个应用程序的设计。

43
00:02:34,180 --> 00:02:40,180
Android是非常自由的形式，而且有那么多的可能性。

44
00:02:40,180 --> 00:02:42,530
好吧，有些设计范例。

45
00:02:42,530 --> 00:02:49,600
请注意，这里就像iOS的平板电脑和iPhone和iPod touch

46
00:02:49,600 --> 00:02:53,840
如果你想支持，他们有支持，比方说，有十几设备

47
00:02:53,840 --> 00:02:55,450
历史的东西为好。

48
00:02:55,450 --> 00:02:58,410
有了Android，你的设备必须支持数百个，

49
00:02:58,410 --> 00:03:01,240
所以有一些事情，谷歌一直试图实现

50
00:03:01,240 --> 00:03:04,970
使用户体验到一个更加一致的一点，

51
00:03:04,970 --> 00:03:08,560
但我们还将讨论如何这意味着有碎片问题

52
00:03:08,560 --> 00:03:11,700
你不断地有要注意的支持。

53
00:03:11,700 --> 00:03:16,140
碎片意味着有许多不同的操作系统，

54
00:03:16,140 --> 00:03:20,330
许多不同的手机，不同的硬件上运行Android同时，

55
00:03:20,330 --> 00:03:29,680
所以这个图可以追溯到约6个月。

56
00:03:29,680 --> 00:03:36,460
是啊，6个月，你可以看到如何在最黑暗的乐队

57
00:03:36,460 --> 00:03:39,330
在底部是糖豆，在夏季出来，

58
00:03:39,330 --> 00:03:42,970
你可以看到现在大概2％左右的手机。

59
00:03:42,970 --> 00:03:45,520
>> 冰淇淋三明治出来一年多前，

60
00:03:45,520 --> 00:03:47,770
一季度的手机。

61
00:03:47,770 --> 00:03:53,910
仍然有很多手机从几年前正在使用的操作系统版本。

62
00:03:53,910 --> 00:03:57,820
有一件事，谷歌一直试图做才能让用户体验

63
00:03:57,820 --> 00:04:01,400
更一致的应用程序有很多蜂窝，开始

64
00:04:01,400 --> 00:04:04,320
这是平板版本，冰淇淋三明治和果冻豆，

65
00:04:04,320 --> 00:04:06,750
他们真的想强调这个动作栏，

66
00:04:06,750 --> 00:04:10,430
这是你可以在上面看到这里，

67
00:04:10,430 --> 00:04:14,730
这里的一切权利，包括这个小设置“按钮。

68
00:04:14,730 --> 00:04:16,079
它的设计选择。

69
00:04:16,079 --> 00:04:18,000
现在，每当你看到三个点，这意味着在此，

70
00:04:18,000 --> 00:04:21,880
而且会有一个下拉菜单，其中有某种设置。

71
00:04:21,880 --> 00:04:28,900
这只能说明，因为我点击这个按钮。

72
00:04:28,900 --> 00:04:32,040
这是，他们正试图用一点点，使应用程序更加一致

73
00:04:32,040 --> 00:04:39,210
一刀切的，所以用户有一个统一的体验更好的感觉。

74
00:04:39,210 --> 00:04:42,640
>> 好吧，如果你还没有这样做已经或者如果你在家里看

75
00:04:42,640 --> 00:04:50,210
那么你可以按照以下步骤设置你的编码环境。

76
00:04:50,210 --> 00:04:52,630
这将涉及网站。

77
00:04:52,630 --> 00:04:56,260
您可以在Google安装Android SDK

78
00:04:56,260 --> 00:04:59,130
并遵循一些描述。

79
00:04:59,130 --> 00:05:01,310
他们会告诉你一切。

80
00:05:01,310 --> 00:05:05,160
他们有你安装SDK，下载Eclipse Classic的版本，

81
00:05:05,160 --> 00:05:07,450
当然，即使我们在Java编码。

82
00:05:07,450 --> 00:05:12,190
他们建议这一项，那么这个ADT，Android开发工具，

83
00:05:12,190 --> 00:05:17,300
是一个插件安装到Eclipse中，它允许你

84
00:05:17,300 --> 00:05:20,550
在Eclipse有一个更精简的体验与Android。

85
00:05:20,550 --> 00:05:24,070
它会给你一些图形用户界面

86
00:05:24,070 --> 00:05:29,610
设计的意见，它会给你更多的支持

87
00:05:29,610 --> 00:05:34,840
并有能力推出与仿真器和所有诸如此类的事情。

88
00:05:34,840 --> 00:05:36,090
应用程序框架。

89
00:05:36,090 --> 00:05:41,590
>> 我想谈谈如何在Android项目结构，

90
00:05:41,590 --> 00:05:44,830
然后我们将进入一个简单的例子，希望

91
00:05:44,830 --> 00:05:48,820
你可以问的问题在任何时候，感觉很舒服，它的结束。

92
00:05:48,820 --> 00:05:50,090
我们有一些行话。

93
00:05:50,090 --> 00:05:55,330
当你启动一个应用程序时，您看到的屏幕就像是一个活动。

94
00:05:55,330 --> 00:05:57,840
整个体验活动本身，

95
00:05:57,840 --> 00:06:00,790
所以你可以把它看作是一个屏幕或视图，

96
00:06:00,790 --> 00:06:04,540
但它实际上是它的源代码方面。

97
00:06:04,540 --> 00:06:12,680
我们仍然调用实际的接口视图。

98
00:06:12,680 --> 00:06:17,230
它有点像我们如何在习题集7控制器和视图。

99
00:06:17,230 --> 00:06:20,690
的活性或多或少控制器，

100
00:06:20,690 --> 00:06:23,360
的观点是我们在做什么的XML

101
00:06:23,360 --> 00:06:25,260
是与该活动相关联。

102
00:06:25,260 --> 00:06:29,340
片段是东西的实施冰淇淋三明治前进。

103
00:06:29,340 --> 00:06:36,380
这只是一个想法，采取部分视图或活动

104
00:06:36,380 --> 00:06:39,990
这样我们就可以把它们分成不同的领域

105
00:06:39,990 --> 00:06:45,030
这许多不同的设备，使我们的代码更可用

106
00:06:45,030 --> 00:06:51,890
我们要支持，它只是一个尝试的方式

107
00:06:51,890 --> 00:06:54,290
分解出更多的代码。

108
00:06:54,290 --> 00:07:01,090
服务播放音乐或导航方向可能的背景之类的东西。

109
00:07:01,090 --> 00:07:05,640
内容提供者，这些都是在操作系统内的API

110
00:07:05,640 --> 00:07:09,070
允许您访问共享数据，如联系人信息，

111
00:07:09,070 --> 00:07:12,790
然后意图是什么时，我们将使用我们要启动

112
00:07:12,790 --> 00:07:17,210
一个新的活动，从我们目前的活动。

113
00:07:17,210 --> 00:07:20,980
>> 您好Android的，这是怎么回事，是一个项目，我们将谈论。

114
00:07:20,980 --> 00:07:25,410
实际上，我会为你做它，那么我们就做了一件事情，在这里我们点击一​​个按钮

115
00:07:25,410 --> 00:07:27,650
一些文字，并推出一个新的活动。

116
00:07:27,650 --> 00:07:30,110
非常简单，但我想通过

117
00:07:30,110 --> 00:07:34,480
什么将进入这样一个项目。

118
00:07:34,480 --> 00:07:39,260
当你做出新的项目，你会看到在Eclipse

119
00:07:39,260 --> 00:07:41,900
这个项目名为Hello的Andr​​oid。

120
00:07:41,900 --> 00:07:43,470
然后有一大堆的文件夹，在这里。

121
00:07:43,470 --> 00:07:46,760
你真正关心的是源文件夹，

122
00:07:46,760 --> 00:07:54,540
资源文件夹，水库，以及一定程度上的libs文件夹库。

123
00:07:54,540 --> 00:08:00,070
只是让我们在相同的页面

124
00:08:00,070 --> 00:08:03,240
如果你要创建一个新的项目，

125
00:08:03,240 --> 00:08:08,270
你可以做到这一点就在这里，所以如果我想叫它HelloAndroid

126
00:08:08,270 --> 00:08:11,100
，然后它会自动为我们的信息做了一大堆。

127
00:08:11,100 --> 00:08:14,110
包的名称应该是一个唯一的标识符

128
00:08:14,110 --> 00:08:16,710
通常会与网站关联，如果你有一个。

129
00:08:16,710 --> 00:08:24,430
>> 例如，我会打电话这个net.cs50.helloandroid。

130
00:08:24,430 --> 00:08:30,070
我已经取得了这个项目一次。

131
00:08:30,070 --> 00:08:40,059
好吧，对不起。让我们叫它HelloCS50。

132
00:08:40,059 --> 00:08:42,929
然后它会问喜欢什么样的图标，我们想的事情。

133
00:08:42,929 --> 00:08:48,840
这是因为Android开发工具界面，

134
00:08:48,840 --> 00:08:53,350
我们加入到Eclipse的插件，所以我们可以选择喜欢的东西

135
00:08:53,350 --> 00:08:58,320
什么样的图标，我们想，如果我们想要的话，会去到那个深度。

136
00:08:58,320 --> 00:09:04,360
但到最后，才使这个项目，

137
00:09:04,360 --> 00:09:07,040
一切都显示在这里。

138
00:09:07,040 --> 00:09:10,030
正如我另一个屏幕上显示，

139
00:09:10,030 --> 00:09:14,070
大家都有源文件夹，我将谈论什么都很快，这意味着，

140
00:09:14,070 --> 00:09:19,090
但你可以看到，它立刻把我们带到的HelloCS50屏幕。

141
00:09:19,090 --> 00:09:24,690
在这里有一些按钮添加文本和文本字段布局。

142
00:09:24,690 --> 00:09:28,910
这有点像XCode的，但不幸的是没有相当精简。

143
00:09:28,910 --> 00:09:37,790
但剪辑将成为您的朋友和ADT尤其是这样做的。

144
00:09:37,790 --> 00:09:40,920
>> 好吧，源文件夹是

145
00:09:40,920 --> 00:09:43,820
持有的Java文件，这其实是你的程序的启动。

146
00:09:43,820 --> 00:09:45,990
这基本上就像控制器。

147
00:09:45,990 --> 00:09:49,020
资源文件夹或水库是在这里，我们将保持屏幕布局，

148
00:09:49,020 --> 00:09:54,110
图像，声音，文字，动画和一切，很明显，库库。

149
00:09:54,110 --> 00:10:01,700
和清单，这是Android系统知道的方式，

150
00:10:01,700 --> 00:10:03,130
如何与您的应用程序进行交互。

151
00:10:03,130 --> 00:10:07,980
它告诉它有关权限和什么样的活动将实际运行。

152
00:10:07,980 --> 00:10:12,350
这一切都需要运行你的应用程序的基本信息。

153
00:10:12,350 --> 00:10:17,990
源文件夹，如果我们展开它，你可以看到这里。

154
00:10:17,990 --> 00:10:23,920
一个例子，代码会看这是默认的代码。

155
00:10:23,920 --> 00:10:27,930
我们把它称为，MainActivity。

156
00:10:27,930 --> 00:10:33,230
默认情况下，我们得到的倚仗，这就是所谓的这项活动负载时，这是一个函数，

157
00:10:33,230 --> 00:10:37,150
所以你想调用的onCreate（savedInstanceState），的。

158
00:10:37,150 --> 00:10:40,440
这将恢复信息的任何位

159
00:10:40,440 --> 00:10:44,910
情况下，应用程序被暂停。

160
00:10:44,910 --> 00:10:48,790
>> 整个活动有一个生命周期的图表，你可以看看

161
00:10:48,790 --> 00:10:50,380
当你得到一点点更深入，

162
00:10:50,380 --> 00:10:56,210
但最重要的一行代码的setContentView有这个功能

163
00:10:56,210 --> 00:11:00,290
这将加载资源文件的布局。

164
00:11:00,290 --> 00:11:03,590
这里倚仗基本上是做什么它说

165
00:11:03,590 --> 00:11:07,010
当我创建这个活动，我想加载此布局。

166
00:11:07,010 --> 00:11:12,030
我们会谈论什么，布局是在第二。

167
00:11:12,030 --> 00:11:16,230
如果我们要推出，这里看起来酷似，

168
00:11:16,230 --> 00:11:22,880
默认情况下，因为我们已经这样做了Eclipse和ADT我们这样做是为了

169
00:11:22,880 --> 00:11:28,210
这是为我们创造的所有样板代码，

170
00:11:28,210 --> 00:11:34,630
我们可以将改变，因为我们喜欢的东西。

171
00:11:34,630 --> 00:11:38,190
资源文件夹，就像我说的，这是我们持有的所有布局，

172
00:11:38,190 --> 00:11:41,150
可绘制任何形式的图像

173
00:11:41,150 --> 00:11:46,360
他们是所谓的可绘制，然后声音文件，菜单。

174
00:11:46,360 --> 00:11:51,170
这是一种XML在一个很好的排序方式了一大堆。

175
00:11:51,170 --> 00:11:58,030
正如你可以看到，有华电国际，LDPI MDPI和xhdpi文件夹的可绘制。

176
00:11:58,030 --> 00:12:02,220
这些不同的屏幕密度，如此高密度每英寸的像素，

177
00:12:02,220 --> 00:12:05,710
低密度，中密度，超高密度。

178
00:12:05,710 --> 00:12:08,900
>> 再次，这是我们可以支持所有这些不同的设备，

179
00:12:08,900 --> 00:12:15,100
理想情况下，你将不得不为每个不同的分辨率不同的图像。

180
00:12:15,100 --> 00:12:20,740
布局是我们包括所有不同的布局将被用来在不同的活动中。

181
00:12:20,740 --> 00:12:24,150
他们还可能包括片段的布局，

182
00:12:24,150 --> 00:12:26,670
这意味着基本部分活动。

183
00:12:26,670 --> 00:12:29,610
如果你想要做一些很酷的东西一样，只要你转动手机

184
00:12:29,610 --> 00:12:33,900
你想让它有一个不同的布局，为不同的文件夹，你可以做布局景观，

185
00:12:33,900 --> 00:12:39,000
和Android会自动的资源文件夹内有一大堆这些规则，

186
00:12:39,000 --> 00:12:44,690
所以它会知道来看看目前的手机设置的基础上的不同的文件夹，

187
00:12:44,690 --> 00:12:46,740
你使用什么样的硬件。

188
00:12:46,740 --> 00:12:52,350
同样，这个值-V11在这里和值-V14

189
00:12:52,350 --> 00:12:55,460
默认值文件夹这是为

190
00:12:55,460 --> 00:13:01,730
好了，本身的值，这将是在所有版本的操作系统的默认值。

191
00:13:01,730 --> 00:13:06,390
另一方面，卷11和卷14的通讯与蜂窝

192
00:13:06,390 --> 00:13:08,780
冰淇淋三明治。

193
00:13:08,780 --> 00:13:12,800
同样，这些方式，在这些文件夹是不同的字符串

194
00:13:12,800 --> 00:13:17,550
和风格，所以你可以自定义您的应用程序的外观

195
00:13:17,550 --> 00:13:22,660
或潜在的甚至是它的功能，虽然这很可能是一个坏主意，

196
00:13:22,660 --> 00:13:25,890
基于版本的操作系统。

197
00:13:25,890 --> 00:13:28,760
>> 和我谈起这一切都在这里。

198
00:13:28,760 --> 00:13:35,870
同样，绘制，原材料，布局，价值观。

199
00:13:35,870 --> 00:13:41,380
默认值，如果我们进入您好Android或你好CS50现在

200
00:13:41,380 --> 00:13:43,310
它看起来就像这。

201
00:13:43,310 --> 00:13:45,800
它会说你好世界。

202
00:13:45,800 --> 00:13:58,430
正如你可以看到这里与Android文本

203
00:13:58,430 --> 00:14:04,420
这个文本视图的文本，这基本上只是一个标签，

204
00:14:04,420 --> 00:14:06,900
就是我们将调用它的iOS。

205
00:14:06,900 --> 00:14:11,580
它有这个有趣的符号@串/的hello_world。

206
00:14:11,580 --> 00:14:16,200
是这样的话，我们可以，我们尝试提取的所有字符串，

207
00:14:16,200 --> 00:14:19,740
到一个单独的文件夹中的所有硬编码字符串在Android，

208
00:14:19,740 --> 00:14:23,610
发生在values​​.strings。

209
00:14:23,610 --> 00:14:29,300
如果我们看一下这里，我们可以看到，我们有一个硬编码的字符串保存在这里

210
00:14:29,300 --> 00:14:33,910
你好世界，它被称为“世界，你好，这是样的

211
00:14:33,910 --> 00:14:39,230
在许多平台上常见的设计决定您要到

212
00:14:39,230 --> 00:14:41,780
字符串的事情，我们希望能够改变可能是那种。

213
00:14:41,780 --> 00:14:48,050
我们不希望我们的XML控制F在我们的源代码文件，。

214
00:14:48,050 --> 00:14:50,760
我们希望能够改变这种每当我们得到了机会。

215
00:14:50,760 --> 00:14:53,640
>> 此XML文件的strings.xml，是一种解压方式

216
00:14:53,640 --> 00:14:56,710
硬编码字符串，否则将在我们的布局资源

217
00:14:56,710 --> 00:15:03,530
或者在我们的源代码。

218
00:15:03,530 --> 00:15:08,190
该清单是我们保持这个重要的信息有关的应用程序。

219
00:15:08,190 --> 00:15:11,050
它包括包名。这是一个独特的标识符。

220
00:15:11,050 --> 00:15:16,020
在App Store的iOS应用程序的名称不同

221
00:15:16,020 --> 00:15:19,980
不必是唯一的，事实上，你可以在你的应用程序的名称更改

222
00:15:19,980 --> 00:15:23,570
您提交后，所以如果我开始了与“愤怒的小鸟”

223
00:15:23,570 --> 00:15:26,840
然后我进行更新，我不想发布一个新版本

224
00:15:26,840 --> 00:15:34,230
我想我可以把它称为“愤怒的小鸟”2，而我在同一个发行周期。

225
00:15:34,230 --> 00:15:36,780
这只是显示更新。

226
00:15:36,780 --> 00:15:39,790
唯一的东西，都必须是唯一的，这是包名，

227
00:15:39,790 --> 00:15:41,280
没有多少人会看到。

228
00:15:41,280 --> 00:15:44,680
那么，你只能看到，如果你正在寻找的源代码或者如果有某种错误。

229
00:15:44,680 --> 00:15:47,580
这些组件包括的活动，所以我们必须声明

230
00:15:47,580 --> 00:15:49,070
我们使用任何形式的活动。

231
00:15:49,070 --> 00:15:53,430
这是一个权限之类的事情。

232
00:15:53,460 --> 00:15:58,150
>> 由于Android没有这种严格的申请程序

233
00:15:58,150 --> 00:16:02,210
提交的应用程序，而不是他们只是尽一切基于权限

234
00:16:02,210 --> 00:16:04,300
并宣布在清单中的东西。

235
00:16:04,300 --> 00:16:06,380
SDK版本也很重要。

236
00:16:06,380 --> 00:16:10,330
我们可以设置使用SDK的最低版本的东西。

237
00:16:10,330 --> 00:16:16,010
很显然，你要创建的代码

238
00:16:16,010 --> 00:16:18,570
和设计新的操作系统。

239
00:16:18,570 --> 00:16:20,840
也许不是最新的，也许不是糖豆。

240
00:16:20,840 --> 00:16:23,610
也许你想设计主要用于冰淇淋三明治，

241
00:16:23,610 --> 00:16:27,120
虽然他们是几乎相同的设计决策

242
00:16:27,120 --> 00:16:30,550
实际库和API。

243
00:16:30,550 --> 00:16:36,250
但是，而不是让人们

244
00:16:36,250 --> 00:16:40,050
原生Android版本类似甜甜圈回来的路上时，

245
00:16:40,050 --> 00:16:43,420
还有谁碰巧使用，尝试下载您的应用程序，然后说

246
00:16:43,420 --> 00:16:46,160
这是行不通的，我的手机上，你可以设置的最低版本

247
00:16:46,160 --> 00:16:48,620
是姜饼或冰淇淋三明治

248
00:16:48,620 --> 00:16:53,300
或任何你觉得舒服的一起提交的。

249
00:16:53,300 --> 00:16:57,170
这是一个例子的清单。我们可以看看在实际中位。

250
00:16:57,170 --> 00:17:00,900
>> 好吧，我们就前进的演示。

251
00:17:00,900 --> 00:17:08,900
此为演示，如果谷歌Android建立你的第一个应用程序或类似的东西。

252
00:17:08,900 --> 00:17:12,089
我们将通过在那里的一切是怎么回事，

253
00:17:12,089 --> 00:17:17,690
对不起，只是一个参考，谁知道这里Java在任何程度上的？

254
00:17:17,690 --> 00:17:28,310
好吧，所以Java走出CS50对于大多数人来说是新的编码语言。

255
00:17:28,310 --> 00:17:31,850
简单地说，走一遍这里说什么，

256
00:17:31,850 --> 00:17:35,580
我们想要做的是什么，而不是调整这个Hello World应用程序

257
00:17:35,580 --> 00:17:38,620
它是所有它启动，它说，“世界，你好

258
00:17:38,620 --> 00:17:43,580
和它说你好CS50在顶部，因为这是活动名称

259
00:17:43,580 --> 00:17:47,190
我们要试图使一个文本字段和一个按钮

260
00:17:47,190 --> 00:17:50,680
这样，当我们按下此按钮，将采取文字

261
00:17:50,680 --> 00:17:53,660
从文本字段，并推出一个新的活动，它会说

262
00:17:53,660 --> 00:17:58,380
无论该文本在活动中说，这是比较简单的。

263
00:17:58,380 --> 00:18:00,650
这是不是很有趣。你不想要，释放任何这样的应用程序。

264
00:18:00,650 --> 00:18:03,880
但它演示了一些重要的设计的东西。

265
00:18:03,880 --> 00:18:07,030
>> 我们将不得不与清单，布局文件，

266
00:18:07,030 --> 00:18:12,440
的源代码，你可以看到如何启动一个活动，从另一个。

267
00:18:19,740 --> 00:18:23,060
我们将开始与我们的第一个活动的布局，

268
00:18:23,060 --> 00:18:27,320
我知道这是一种小的，

269
00:18:27,320 --> 00:18:32,660
但正如你可以看到，现在，所有这是我们的标志，我们创建，

270
00:18:32,660 --> 00:18:36,310
活动名称，和它说你好世界的中心。

271
00:18:36,310 --> 00:18:40,400
相反，我首先要使它成为一个线性布局，

272
00:18:40,400 --> 00:18:42,350
相对布局，而这些所有的东西

273
00:18:42,350 --> 00:18:45,870
你可以看看值得在一些点在布局方面。

274
00:18:45,870 --> 00:18:47,310
这是一个很像HTML。

275
00:18:47,310 --> 00:18:52,640
我们说，这不是真的值得了解的方面的纲领性意义，

276
00:18:52,640 --> 00:18:55,840
但也有许多不同的布局，你可以控制，

277
00:18:55,840 --> 00:18:57,970
它就像CSS款式。

278
00:18:57,970 --> 00:19:01,590
>> 有很多事情只是在这里的美学，

279
00:19:01,590 --> 00:19:08,930
是啊，这是值得学习的，但它的诸如此类的事情，你应该看看

280
00:19:08,930 --> 00:19:11,810
你去，你觉得你需要一些新的东西。

281
00:19:11,810 --> 00:19:17,030
所以我可以利用的一些ADT工具，至少在这里，开始了与。

282
00:19:17,030 --> 00:19:21,930
我会做出一个文本字段，我会让一个按钮。

283
00:19:21,930 --> 00:19:24,100
把他们的权利，彼此相邻的。

284
00:19:24,100 --> 00:19:28,200
他们已经适当地调整。

285
00:19:28,200 --> 00:19:31,320
我们很抱歉，再次回来线性布局和相对布局之间的差异，

286
00:19:31,320 --> 00:19:34,830
线性布局提供了一些功能

287
00:19:34,830 --> 00:19:38,720
在填充空间并确保

288
00:19:38,720 --> 00:19:42,790
我们的位置水平或垂直的事情。

289
00:19:42,790 --> 00:19:46,130
线性布局和相对布局的最大区别

290
00:19:46,130 --> 00:19:50,250
是布局相对位置的一切相对于其他意见，

291
00:19:50,250 --> 00:19:52,630
它的好处是，它需要较少的时间来绘制

292
00:19:52,630 --> 00:19:56,120
因为作业系统的所有代码和说，这正好

293
00:19:56,120 --> 00:19:58,270
相对于此，在这里。

294
00:19:58,270 --> 00:20:03,170
这意味着它使较少的测量，比一大堆的嵌套的线性布局，

295
00:20:03,170 --> 00:20:06,840
这是我必须做的，如果我想的事情去垂直这里。

296
00:20:06,840 --> 00:20:10,510
>> 我已经有一些事情水平，所以我需要一个不同的线性布局

297
00:20:10,510 --> 00:20:14,560
嵌套它们垂直，但如果我做一个相对的布局，我可以说

298
00:20:14,560 --> 00:20:18,140
保持这个到左侧，右侧和下面这些东西。

299
00:20:18,140 --> 00:20:21,850
但是，因为我希望他们能填权现在我打算使用线性布局，

300
00:20:21,850 --> 00:20:24,510
你可以看到它已经为我们做了很多这些东西。

301
00:20:24,510 --> 00:20:28,890
所有视图需要有一个属性的宽度和高度，

302
00:20:28,890 --> 00:20:33,410
发生这种情况的权重为1，这有一个权重为1的

303
00:20:33,410 --> 00:20:36,050
所以，它充满了整个空间。

304
00:20:36,050 --> 00:20:38,460
但是，宽度和高度是最重要的。

305
00:20:38,460 --> 00:20:45,880
此ID字段在这里并不重要，在实际的布局

306
00:20:45,880 --> 00:20:49,060
除非我们使用相对布局和说，大家可以参考

307
00:20:49,060 --> 00:20:52,990
一种观点认为参考到另一个位置。

308
00:20:52,990 --> 00:20:56,170
如果我们有一个相对布局，我们可以说，低于这个位置

309
00:20:56,170 --> 00:20:59,390
或高于这个ID，但这个ID将是重要的

310
00:20:59,390 --> 00:21:01,660
当我们在我们的代码中使用它，因为大家可以参考一下

311
00:21:01,660 --> 00:21:05,610
这些个人的意见这种方式。

312
00:21:05,610 --> 00:21:10,350
>> 然后你就可以看到标记requestFocus，这是一些你可能看到的pset 7。

313
00:21:10,350 --> 00:21:15,370
有一个自动对焦标记或东西沿着这些线路的领域之一。

314
00:21:15,370 --> 00:21:22,100
还有一件事，当然，我们可以做的，就像在HTML中，

315
00:21:22,100 --> 00:21:25,660
通知关于ADT的好东西之一是，它可以自动在这里。

316
00:21:25,660 --> 00:21:29,930
也许不是很好的，因为它没有在XCode，但它仍然

317
00:21:29,930 --> 00:21:32,860
我们可以说提示，然后给它一些字符串排序

318
00:21:32,860 --> 00:21:37,070
喜欢写一条消息，

319
00:21:37,070 --> 00:21:41,300
如果我给它的时刻，也请注意，我在这里得到一点点的错误

320
00:21:41,300 --> 00:21:44,610
说，我们应该使用一个字符串资源，

321
00:21:44,610 --> 00:21:48,820
所以如果我让它做一些对我的辛勤工作

322
00:21:48,820 --> 00:21:57,320
我可以选择这个字符串，做折射Android和提取物的Andr​​oid串。

323
00:21:57,320 --> 00:22:00,570
它可以给我这个名字，写一个消息，

324
00:22:00,570 --> 00:22:04,180
什么，它现在是没有取代硬编码字符串

325
00:22:04,180 --> 00:22:07,980
与参考字符串的XML文件中的字符串，

326
00:22:07,980 --> 00:22:10,200
这意味着，现在这是在这里。

327
00:22:10,200 --> 00:22:15,560
>> 我知道，在这一点上似乎有点琐碎，像额外的工作，

328
00:22:15,560 --> 00:22:17,840
但是当你有一大堆的事情，一大堆的字符串，

329
00:22:17,840 --> 00:22:20,750
这是非常重要的，特别是对于本地化

330
00:22:20,750 --> 00:22:26,920
因为正如我前面提到的，Android是全球使用的操作系统

331
00:22:26,920 --> 00:22:35,950
你可以简单地做价值观EN或值SP

332
00:22:35,950 --> 00:22:44,320
或英语或西班牙语或其他语言的东西。

333
00:22:44,320 --> 00:22:50,210
然后，你可能还没有过这样的经历还

334
00:22:50,210 --> 00:22:53,030
因为我们并没有做太多的JavaScript网页编程方面，

335
00:22:53,030 --> 00:22:56,850
但我们也可以做这一领域的onClick按钮，

336
00:22:56,850 --> 00:23:02,350
这是一个引用的方式在我们的布局

337
00:23:02,350 --> 00:23:06,570
我们希望在我们的源代码一定要调用的函数。

338
00:23:06,570 --> 00:23:09,420
我要调用的SendMessage，

339
00:23:09,420 --> 00:23:13,390
为了使这项工作，这意味着在这里的主要活动

340
00:23:13,390 --> 00:23:19,180
我将不得不创建一个函数是公共

341
00:23:19,180 --> 00:23:22,250
，这样它可以被访问由布局。

342
00:23:22,250 --> 00:23:25,930
它是无效的，因为你只是不希望它返回什么。

343
00:23:25,930 --> 00:23:37,760
我们叫它的sendMessage，它需要一个视图，

344
00:23:37,760 --> 00:23:43,690
这是一个样的背景下，我们可以巩固这个方法

345
00:23:43,690 --> 00:23:47,160
个别的观点，当我们运行它。

346
00:23:47,160 --> 00:23:50,090
>> 我不知道你是否注意到，你不会注意到，

347
00:23:50,090 --> 00:24:02,370
但在这一点上就在这里

348
00:24:02,370 --> 00:24:06,930
这种观点是一种尚未被列入，

349
00:24:06,930 --> 00:24:10,630
当然，大家都知道从CS50不包括的类型。

350
00:24:10,630 --> 00:24:13,120
关于IDE的Eclipse这样美好的事情是，

351
00:24:13,120 --> 00:24:17,520
如果你忘了，包括类型，它会用小的红色波浪下划线

352
00:24:17,520 --> 00:24:19,680
然后给你选择导入的看法。

353
00:24:19,680 --> 00:24:23,130
这样做，是一个快速的方法控制移位O，以及将导入

354
00:24:23,130 --> 00:24:27,070
它需要的所有文件。

355
00:24:27,070 --> 00:24:33,670
现在，我们有这个函数SendMessage，

356
00:24:33,670 --> 00:24:46,560
这是怎么回事MainActivity消息发送到一个新的活动，

357
00:24:46,560 --> 00:24:55,230
我们将不得不使用从这个意图推出新的活动，

358
00:24:55,230 --> 00:25:02,240
所以我们可能要创建一个全局常量或还特别公开常数

359
00:25:02,240 --> 00:25:06,240
这将帮助我们知道我们要如何来引用字符串

360
00:25:06,240 --> 00:25:09,090
因为当我们创建了一个意图，我们不只是调用一个新的活动，

361
00:25:09,090 --> 00:25:11,520
但我们也可以给它一个信息包。

362
00:25:11,520 --> 00:25:14,720
一个bundle实际上是Android使用的术语，

363
00:25:14,720 --> 00:25:21,470
说给它额外的数据，它不能是一个非常复杂的数据类型的一种方式，

364
00:25:21,470 --> 00:25:24,510
但我们可以肯定包括布尔型或字符串或整数。

365
00:25:24,510 --> 00:25:29,750
诸如此类的事情。

366
00:25:29,750 --> 00:25:34,230
>> 随意询问任何预选赛，

367
00:25:34,230 --> 00:25:36,900
公众，最终，静态的。

368
00:25:36,900 --> 00:25:38,610
公开是最重要的一个。

369
00:25:38,610 --> 00:25:47,090
这意味着我们可以访问此变量从其他源代码文件

370
00:25:47,090 --> 00:25:49,590
比如，当我们创建了一个新的活动。

371
00:25:49,590 --> 00:25:52,190
大家可以参考一下这个文件内的字符串。

372
00:25:52,190 --> 00:25:57,160
如果它是私有的，这意味着它是有限，这个单独的文件。

373
00:25:57,160 --> 00:26:02,430
不过，我们会打电话给这个像额外的消息。

374
00:26:16,260 --> 00:26:23,300
现在，我们已经取得了这个功能，如果我们按一下按钮，这个函数将被调用。

375
00:26:23,300 --> 00:26:27,970
但是我们还没有做任何事情，很明显，与功能。

376
00:26:27,970 --> 00:26:33,130
我们现在要做的是创建一个新的活动，

377
00:26:33,130 --> 00:26:35,350
的活动，实际上将陆续推出。

378
00:26:35,350 --> 00:26:44,330
在Eclipse中，我们可以说新的Andr​​oid活动，空白活动。

379
00:26:44,330 --> 00:26:46,530
我们可以给它一个名字。

380
00:26:46,530 --> 00:26:57,050
让我们叫它结果活动。

381
00:26:57,050 --> 00:27:04,430
然后此层次的父字段指定的方式

382
00:27:04,430 --> 00:27:08,180
的活动如何彼此相关的。

383
00:27:08,180 --> 00:27:11,020
因为这一个从其他活动将陆续推出

384
00:27:11,020 --> 00:27:27,520
我们应指定，它有父的主要活动。

385
00:27:27,520 --> 00:27:31,220
>> 我可以点击下一字段，这将告诉我们

386
00:27:31,220 --> 00:27:33,830
还包括一些可选字段，

387
00:27:33,830 --> 00:27:38,800
但关于ADT，再次，是很好的事情，如果我在这里向下滚动

388
00:27:38,800 --> 00:27:45,740
在清单中，记住，这一切真的被列入默认情况下，

389
00:27:45,740 --> 00:27:48,930
当我们最初创建项目

390
00:27:48,930 --> 00:27:53,090
因为我们现在只是用来创建一个新的活动，而不是

391
00:27:53,090 --> 00:27:58,610
这样做，因为我们经历过他们的GUI添加自己的类文件

392
00:27:58,610 --> 00:28:01,930
它已经增加了这一切为我们的清单，

393
00:28:01,930 --> 00:28:06,020
这意味着，现在的操作系统将不会抱怨

394
00:28:06,020 --> 00:28:09,400
当我们尝试推出这项活动。

395
00:28:09,400 --> 00:28:14,620
当然，也给它的标签，这也说明了在字符串。

396
00:28:14,620 --> 00:28:17,340
它做了很多的事情，我们的后端。

397
00:28:17,340 --> 00:28:20,140
不管怎样，现在，我们有这个结果活动，

398
00:28:20,140 --> 00:28:23,810
实际的源代码在源文件夹中的文件，

399
00:28:23,810 --> 00:28:33,540
你可以看到简单地谈谈这

400
00:28:33,540 --> 00:28:37,790
因为我们告诉它关于这个层次的父母

401
00:28:37,790 --> 00:28:46,640
它给了本场android.r.ide.home此onOption所选的事情。

402
00:28:46,640 --> 00:28:49,020
>> 这基本上是说的是，现在有一个菜单按钮

403
00:28:49,020 --> 00:28:53,110
在屏幕的左上角

404
00:28:53,110 --> 00:29:02,220
如果我回去到PowerPoint，我们第一次谈到行动起来吧

405
00:29:02,220 --> 00:29:05,380
因为父层次，现在有一个小箭头，回到这里

406
00:29:05,380 --> 00:29:10,610
这是可点击的，所以我们应该能够到后，我们运行这个程序

407
00:29:10,610 --> 00:29:15,360
回去了，它是一种拯救我们有一点点的代码。

408
00:29:26,220 --> 00:29:40,180
现在，在这个井，似乎抱怨了一会儿。

409
00:29:40,180 --> 00:29:43,910
我们的意见说出来。

410
00:29:43,910 --> 00:29:48,260
现在，为了真正与这2个活动，

411
00:29:48,260 --> 00:29:55,020
我们要创造的意图，其中包括所有的数据。

412
00:29:55,020 --> 00:29:58,950
的sendMessage现在我要通过一些代码位巡航

413
00:29:58,950 --> 00:30:00,700
，并解释说，因为我去。

414
00:30:00,700 --> 00:30:06,280
一个意图，正如我所说，是从另一种方式来启动一个活动。

415
00:30:06,280 --> 00:30:10,000
意图是类型。我们正在创造一个变量myIntent。

416
00:30:10,000 --> 00:30:13,980
>> 这实际上是一个对象，这就是为什么我们必须调用新。

417
00:30:13,980 --> 00:30:18,500
这是常见的Java使用，这可能需要一点点的时间来适应。

418
00:30:18,500 --> 00:30:23,900
这意味着我们正在使用的活动或类MainActivity，

419
00:30:23,900 --> 00:30:28,630
意图以这种方式需要的活动，它会从

420
00:30:28,630 --> 00:30:36,060
和活动，这是怎么回事，我们称之为ResultActivity，

421
00:30:36,060 --> 00:30:38,170
那就是它自己的类。

422
00:30:38,170 --> 00:30:41,720
中包括这样。

423
00:30:41,720 --> 00:30:47,370
然后，正如我之前提到的，我们给到编辑的文本字段，ID

424
00:30:47,370 --> 00:30:53,710
文本视图，因此，以编程方式捕捉

425
00:30:53,710 --> 00:31:01,860
，存在在EDITTEXT中的文本

426
00:31:01,860 --> 00:31:06,710
我们使用此功能称为findViewByID，

427
00:31:06,710 --> 00:31:13,660
这是类似的东西，你会当试图从DOM领域使用。

428
00:31:13,660 --> 00:31:17,560
也许大卫谈讲座。

429
00:31:17,560 --> 00:31:26,600
但它只是一种让那些这就是为什么我们这些字段标记这些东西。

430
00:31:26,600 --> 00:31:31,110
Id.editText1。

431
00:31:31,110 --> 00:31:35,220
它已经自动完成对我来说。

432
00:31:35,220 --> 00:31:42,010
>> 然后我们会还包括这EDITTEXT现在我们有现场

433
00:31:42,010 --> 00:31:47,640
在我们的程序中，所有的findViewByID基本上没有

434
00:31:47,640 --> 00:31:50,870
你可以把它看作是给大家一个参考，EDITTEXT。

435
00:31:50,870 --> 00:31:54,570
现在，我们想要得到的字符串或消息

436
00:31:54,570 --> 00:32:00,670
，在该EDITTEXT我们可以通过使用-

437
00:32:00,670 --> 00:32:03,360
你能想到的EDITTEXT为结构

438
00:32:03,360 --> 00:32:07,600
在Java对象与一大堆不同的方法，我们把它叫做

439
00:32:07,600 --> 00:32:10,650
或连接到它的字段和属性。

440
00:32:10,650 --> 00:32:15,510
当我说EDITTEXT。它让我有机会访问

441
00:32:15,510 --> 00:32:19,770
方法如gettext的，这将得到当前文本

442
00:32:19,770 --> 00:32:23,990
在该EDITTEXT，然后再转换，明确

443
00:32:23,990 --> 00:32:26,520
一个字符串，我们已经保存了该消息。

444
00:32:26,520 --> 00:32:32,730
现在我们真正想要做一些与这一意图，我们只是瞬间。

445
00:32:32,730 --> 00:32:40,250
我会把多余的，因为它是调用的意图，

446
00:32:40,250 --> 00:32:43,330
再次，就像我之前说的，这是一种方式创建捆绑

447
00:32:43,330 --> 00:32:45,980
一大堆数据。

448
00:32:45,980 --> 00:32:50,920
额外的消息是我们的标签，所以我们知道我们节省下，

449
00:32:50,920 --> 00:32:56,700
然后我消息。

450
00:32:56,700 --> 00:33:04,870
>> 然后我们就可以真正开始活动给​​它的参数myIntent。

451
00:33:04,870 --> 00:33:10,630
这实际上将推出的活动，所以，因为我现在升级到Windows 8

452
00:33:10,630 --> 00:33:15,870
有可能是一些简要的错误，但试图忽略它们。

453
00:33:28,010 --> 00:33:30,310
这是在Android模拟器。

454
00:33:30,310 --> 00:33:33,540
希望的代码实际上将在瞬间弹出。

455
00:33:33,540 --> 00:33:36,680
同样，无视所有那些小东西。

456
00:33:36,680 --> 00:33:42,290
但在Android模拟器可以模拟任何版本的操作系统

457
00:33:42,290 --> 00:33:45,180
从最早的甜甜圈，姜饼。

458
00:33:45,180 --> 00:33:49,640
这是果冻豆4.1。

459
00:33:49,640 --> 00:33:53,150
但是，你现在可以看到，这是我们所做的事情。

460
00:33:53,150 --> 00:33:55,780
这具有的MainActivity，EDITTEXT，按钮。

461
00:33:55,780 --> 00:34:01,550
我可以输入的东西，但是在这一点上我们还缺少什么？

462
00:34:01,550 --> 00:34:05,190
我们作出了场MainActivity发送消息

463
00:34:05,190 --> 00:34:08,570
的其他活动，但在这一点

464
00:34:08,570 --> 00:34:12,330
我们没有做任何其他活动，所以它不会收到任何东西。

465
00:34:12,330 --> 00:34:18,800
让我们完成了这部分在我们继续之前。

466
00:34:18,800 --> 00:34:25,760
>> 这种结果的活动，我们需要做的是什么，我们需要做的是，我们需要到

467
00:34:25,760 --> 00:34:30,070
我们也可以在这个活动中引用的意图，

468
00:34:30,070 --> 00:34:33,580
所以我们要捕获的意图，这是非常简单的。

469
00:34:33,580 --> 00:34:40,780
它是一个函数包含在活动类，

470
00:34:40,780 --> 00:34:47,610
因此，我们可以说“消息的意图。”

471
00:34:47,610 --> 00:34:56,260
“意向书myIntent =的getIntent。”

472
00:34:56,260 --> 00:35:00,030
而这将给我们现在myIntent是一个对象，

473
00:35:00,030 --> 00:35:05,380
这是一个参考的意图，我们这个活动。

474
00:35:05,380 --> 00:35:10,130
MainActivity调用，并提供了额外的信息，导致活动。

475
00:35:10,130 --> 00:35:14,070
结果活动现在看起来，导致这里的意图，

476
00:35:14,070 --> 00:35:23,540
我们可以访问的信息是，我们在中的另一个，

477
00:35:23,540 --> 00:35:26,370
getStringExtra，这会为我自动完成。

478
00:35:26,370 --> 00:35:31,190
然后记得，我们标记的方式，数据位

479
00:35:31,190 --> 00:35:38,400
为给这一领域就在这里，这个公共字符串，

480
00:35:38,400 --> 00:35:42,080
这是我们实际上包括字符串标记。

481
00:35:42,080 --> 00:35:48,450
>> 如果我说MainActivity.Extra_Message，

482
00:35:48,450 --> 00:35:52,200
它就在那里，这是有点像参数名称

483
00:35:52,200 --> 00:35:55,330
当我们通过从控制器的代码模板，

484
00:35:55,330 --> 00:35:57,680
当我们想要说标题箭头的东西。

485
00:35:57,680 --> 00:36:01,140
它的想法是相同的排序。

486
00:36:01,140 --> 00:36:07,130
现在，请记住这一点。

487
00:36:07,130 --> 00:36:12,230
我们也有这个自动创建或自动生成的代码

488
00:36:12,230 --> 00:36:16,410
结果活性，其中包括在中间的文本图

489
00:36:16,410 --> 00:36:19,690
说“世界，你好。

490
00:36:19,690 --> 00:36:27,510
我们可能有更大。

491
00:36:27,510 --> 00:36:33,980
让我们做到这一点。

492
00:36:33,980 --> 00:36:39,550
我们可以使40密度独立像素。

493
00:36:39,550 --> 00:36:42,670
让我们来看看，这是超级巨大的。这将是好的。

494
00:36:42,670 --> 00:36:48,180
然后以引用这个人在我们的代码中的文本视图

495
00:36:48,180 --> 00:36:53,890
我们需要给它一个编号，

496
00:36:53,890 --> 00:36:58,350
为了做到这一点，我们说@ + ID，这意味着我们将它的ID。

497
00:36:58,350 --> 00:37:02,480
如果我们刚才说的@ id，它会假设，我们引用一个ID已经存在，

498
00:37:02,480 --> 00:37:07,760
让调用这个resultTextView。

499
00:37:07,760 --> 00:37:10,570
注意到，在XML中有没有分号或任何需要。

500
00:37:10,570 --> 00:37:12,380
一切都在这些标签。

501
00:37:12,380 --> 00:37:15,530
它非常类似于HTML中大量的感官。

502
00:37:15,530 --> 00:37:22,760
>> 这需要一点点的时间来适应，但最终你会觉得很舒服。

503
00:37:22,760 --> 00:37:31,320
让我们更新我们的结果文本视图的文本，

504
00:37:31,320 --> 00:37:35,650
像我们一样，当我们得到我们的其他活动中，编辑的文本字段

505
00:37:35,650 --> 00:37:46,630
MainActivity在这里，我们也同样会

506
00:37:46,630 --> 00:37:54,890
我们会发现视图的ID。

507
00:37:54,890 --> 00:37:59,640
和R的情况下，我没有提过，是参考我们的资源文件夹，

508
00:37:59,640 --> 00:38:05,350
然后ID是一个参考的资源“文件夹中的一切，所有的ID，

509
00:38:05,350 --> 00:38:10,060
和resultTextView。

510
00:38:10,060 --> 00:38:13,010
像以前一样，resultTextView是一个对象，

511
00:38:13,010 --> 00:38:15,780
这意味着它有与它相关联的所有这些特性。

512
00:38:15,780 --> 00:38:20,610
当我们使用这个文本字段编辑文本或文本视图的getText

513
00:38:20,610 --> 00:38:23,980
实际上，我们可以使用的setText

514
00:38:23,980 --> 00:38:26,960
然后，我们已经找到了该消息的意图，

515
00:38:26,960 --> 00:38:35,760
所以我可以说的消息，这实际上设置消息。

516
00:38:35,760 --> 00:38:41,820
>> 它花点时间来启动，然后我们可以看它是否崩溃，

517
00:38:41,820 --> 00:38:48,670
但这个过程有任何疑问，诸如此类的互动吗？

518
00:38:48,670 --> 00:38:51,490
在许多方面，它的简单。

519
00:38:51,490 --> 00:38:53,960
我之所以要通过相对简单的东西

520
00:38:53,960 --> 00:38:57,330
再次，是因为你能看到的布局之间的相互作用，

521
00:38:57,330 --> 00:38:59,520
的源代码，参考的东西你怎么

522
00:38:59,520 --> 00:39:07,680
也许得到Java的工作方式有一点点暴露。

523
00:39:07,680 --> 00:39:16,500
如果我输入的东西在这里，ohai一样，然后我按一下按钮，

524
00:39:16,500 --> 00:39:22,260
它推出一个新的活动，并，文本视图ohai说。

525
00:39:22,260 --> 00:39:27,640
这是非常简单的，但希望在这个例子中

526
00:39:27,640 --> 00:39:32,310
排序看到这种互动是如何工作的，和现在那些乱七八糟的文件

527
00:39:32,310 --> 00:39:36,870
所有这些项目文件夹的左侧，希望你知道现在去哪里找。

528
00:39:36,870 --> 00:39:38,700
这是你的源代码区域。

529
00:39:38,700 --> 00:39:41,760
>> 布局是真正的唯一的事情，你会处理包括图像，直到你

530
00:39:41,760 --> 00:39:46,370
可绘制或什么的，和值，即包括字符串，

531
00:39:46,370 --> 00:39:51,960
正如我们提到的，风格是有点像CSS。

532
00:39:51,960 --> 00:39:56,410
当你想解决这个问题，但直到你感觉很舒服，增加额外的天赋

533
00:39:56,410 --> 00:40:02,520
您的应用程序就没有必要担心太多。

534
00:40:02,520 --> 00:40:07,410
只是包裹起来的另一件事情，你一定要包括

535
00:40:07,410 --> 00:40:13,010
假设你要很酷的功能集成，并保存自己的一些额外的编码

536
00:40:13,010 --> 00:40:16,460
将包括第三方库。

537
00:40:16,460 --> 00:40:19,840
这里是小的Andr​​oid与福尔摩斯的帽子的家伙。

538
00:40:19,840 --> 00:40:23,040
这是一个行动吧福尔摩斯库，

539
00:40:23,040 --> 00:40:25,390
这基本上意味着，你看到刚才的动作栏，

540
00:40:25,390 --> 00:40:29,590
这是现在的标准配置冰淇淋三明治和糖豆，

541
00:40:29,590 --> 00:40:33,100
如果你想带那种旧版本的用户体验，以用户

542
00:40:33,100 --> 00:40:39,290
并保存自己的担心用户如何去浏览

543
00:40:39,290 --> 00:40:42,490
在旧版本中，当那个东西是不存在，你可以包括库

544
00:40:42,490 --> 00:40:46,770
然后你只需要参考，而不是默认的Andr​​oid

545
00:40:46,770 --> 00:40:50,250
库行动吧，你引用这个支持库。

546
00:40:50,250 --> 00:40:53,090
>> Scoreloop的之类的东西，这是伟大的，如果你要，其中包括游戏。

547
00:40:53,090 --> 00:40:57,280
它可以让你添加游戏排行榜和成就。

548
00:40:57,280 --> 00:41:00,900
Admob的是一种把广告到您的应用程序

549
00:41:00,900 --> 00:41:02,900
的情况下，你想一点点钱。

550
00:41:02,900 --> 00:41:05,730
当然，也有整合有Facebook和Twitter

551
00:41:05,730 --> 00:41:08,170
如果你想分享的东西很容易，等等。

552
00:41:08,170 --> 00:41:15,120
Dropbox的，同样，Google Analytics（分析）是寻找一个有该图表。

553
00:41:15,120 --> 00:41:19,070
这将是非常重要的，如果你真的想看到谁交互

554
00:41:19,070 --> 00:41:25,800
与您的应用程序或者是谁，他们是如何相互作用，等等。

555
00:41:25,800 --> 00:41:30,650
默认情况下，谷歌，告诉你很多已安装您的应用程序的统计信息

556
00:41:30,650 --> 00:41:35,020
他们有什么样的手机，他们有什么样的操作系统版本。

557
00:41:35,020 --> 00:41:38,080
但是，如果你希望看到谁在使用它每天的基础上，以及他们如何使用它

558
00:41:38,080 --> 00:41:42,860
那么你会希望包括某种这样的跟踪系统。

559
00:41:42,860 --> 00:41:44,990
>> 当你准备好分发您的应用程序

560
00:41:44,990 --> 00:41:46,930
我并不需要太多的深度进入，在。

561
00:41:46,930 --> 00:41:49,090
点击这里的链接，谷歌播放。

562
00:41:49,090 --> 00:41:51,080
它使用的是Android市场。

563
00:41:51,080 --> 00:41:53,470
他们更名一切与谷歌的播放，

564
00:41:53,470 --> 00:41:55,230
所以现在你提交。

565
00:41:55,230 --> 00:41:57,140
这是非常简单的。

566
00:41:57,140 --> 00:42:01,070
你必须包括说明，一些截图。

567
00:42:01,070 --> 00:42:05,660
就像我说的，有没有像iOS的审批过程。

568
00:42:05,660 --> 00:42:07,270
和从这里去哪里？

569
00:42:07,270 --> 00:42:09,450
我向您展示了一个非常简单的例子。

570
00:42:09,450 --> 00:42:13,270
我们希望，如果它似乎极其简单

571
00:42:13,270 --> 00:42:15,740
那么这可能是一个好兆头。

572
00:42:15,740 --> 00:42:20,080
如果你感到有点困惑或不确定，正是我打字

573
00:42:20,080 --> 00:42:26,160
这也蛮好的，但是从这里去谷歌指南。

574
00:42:26,160 --> 00:42:28,330
这是一个伟大的地方开始。

575
00:42:28,330 --> 00:42:31,460
它会跟你通过他们所期望的应用程序设计方面，

576
00:42:31,460 --> 00:42:33,380
用户通常是如何与它进行交互。

577
00:42:33,380 --> 00:42:36,450
它更比iOS更自由的形式，我会说，

578
00:42:36,450 --> 00:42:41,330
它似乎像表意见，我不知道，那是他们的面包，黄油。

579
00:42:41,330 --> 00:42:44,690
一切都是表视图，向上和向下滑动。

580
00:42:44,690 --> 00:42:48,160
有了Android，他们肯定鼓励人们看它从

581
00:42:48,160 --> 00:42:51,720
一大堆不同的观点。

582
00:42:51,720 --> 00:42:56,000
>> 当包括软件开发工具包在这个ADT

583
00:42:56,000 --> 00:43:03,010
默认情况下，你在Android有一大堆的样本项目。

584
00:43:03,010 --> 00:43:05,470
就在这里，机器人，机器人示例项目。

585
00:43:05,470 --> 00:43:11,870
如果我点击的话，我可以选择一个版本的样品项目申请。

586
00:43:11,870 --> 00:43:13,300
这里有一个不同的事情一大堆。

587
00:43:13,300 --> 00:43:16,690
开始行动吧兼容性，

588
00:43:16,690 --> 00:43:24,610
加速度播放，备份和恢复，支持蓝牙，手势建设者。

589
00:43:24,610 --> 00:43:28,930
喷气男孩是一个样本，他们给你的游戏，是LunarLander。

590
00:43:28,930 --> 00:43:31,250
这里有一大堆的示例应用程序，

591
00:43:31,250 --> 00:43:35,290
他们都针对Android的API在不同的方面，

592
00:43:35,290 --> 00:43:41,520
的想法是，当你让你的应用程序

593
00:43:41,520 --> 00:43:44,110
你不需要学习一切关于Android的Andr​​oid应用程序。

594
00:43:44,110 --> 00:43:47,300
你只需要了解的部分，其实你要使用。

595
00:43:47,300 --> 00:43:49,340
看看这些样品库。

596
00:43:49,340 --> 00:43:51,510
随意进行复制和粘贴代码，并重新应用它。

597
00:43:51,510 --> 00:43:53,850
这是一个伟大的事情，看起来更困难的代码

598
00:43:53,850 --> 00:43:57,060
并尝试去了解它，这当然是为什么CS50

599
00:43:57,060 --> 00:44:01,510
我们常常给你大量的源代码。

600
00:44:01,510 --> 00:44:04,620
看看其中的一些，如果你要使用类似的库

601
00:44:04,620 --> 00:44:08,630
然后将其应用到自己的代码。

602
00:44:08,630 --> 00:44:10,430
当然，有教程。

603
00:44:10,430 --> 00:44:12,690
搜索教程。

604
00:44:12,690 --> 00:44:17,020
我发现了很多好的网上可以给你带来加快速度

605
00:44:17,020 --> 00:44:20,080
片段真的是什么，以及如何可以使用它们。

606
00:44:20,080 --> 00:44:22,240
>> 这些新设计的东西，有些像碎片一样，

607
00:44:22,240 --> 00:44:26,840
你真的不必担心，除非你正在做一个

608
00:44:26,840 --> 00:44:30,560
在相当大的范围内项目。

609
00:44:30,560 --> 00:44:32,510
他们的事情，谷歌正试图逐步英寸

610
00:44:32,510 --> 00:44:35,570
StackOverflow的当然是你的朋友。

611
00:44:35,570 --> 00:44:37,930
希望我卖给你的Andr​​oid上，

612
00:44:37,930 --> 00:44:41,640
实现它只是编码语言方面更容易接近。

613
00:44:41,640 --> 00:44:45,970
Java是Objective-C的理解比我想说容易得多。

614
00:44:45,970 --> 00:44:50,780
Android正在成长，我觉得比iOS更。

615
00:44:50,780 --> 00:44:54,890
我的意思是，有太多的数据是，除了我在想什么。

616
00:44:54,890 --> 00:44:56,920
这是怎么回事了一段时间，

617
00:44:56,920 --> 00:45:00,880
他们是落后几年在其设计周期

618
00:45:00,880 --> 00:45:04,690
所以它的排序可以理解的，他们还在通过一些

619
00:45:04,690 --> 00:45:09,080
一致性的问题，比如这个动作栏为他们仍然是一个新事物，

620
00:45:09,080 --> 00:45:16,010
排序在所有的应用程序创建类似的用户体验。

621
00:45:16,010 --> 00:45:20,650
希望你可以向前走，现在开放的Eclipse

622
00:45:20,650 --> 00:45:22,870
，使自己的Andr​​oid应用程序。

623
00:45:22,870 --> 00:45:30,240
>> 没有人有任何的问题之前，我们总结什么？

624
00:45:30,240 --> 00:45:34,410
我可以告诉你，答案是42。

625
00:45:34,410 --> 00:45:41,990
嗯，高兴编码大家，祝你好运。

626
00:45:41,990 --> 00:45:44,990
[CS50.TV]