1
00:00:00,000 --> 00:00:09,620

2
00:00:09,620 --> 00:00:11,550
>> FRED聪：好的。

3
00:00:11,550 --> 00:00:12,600
嗨，大家好。

4
00:00:12,600 --> 00:00:19,450
感谢您的欢迎
在这个研讨会上加入了我。

5
00:00:19,450 --> 00:00:23,130
所以今天我们将要谈论
如何开发应用程序为Android，

6
00:00:23,130 --> 00:00:26,870
特别是，我们要
是为了采用Android工作室

7
00:00:26,870 --> 00:00:29,490
发展我们的应用程序。

8
00:00:29,490 --> 00:00:32,150
>> 所以，大家都知道。

9
00:00:32,150 --> 00:00:36,750
Android使用Java的，所以我们会在
经过简单的介绍

10
00:00:36,750 --> 00:00:39,860
在Java本身。

11
00:00:39,860 --> 00:00:45,830
所以我知道你们很多人只有
编程经验的C.所以

12
00:00:45,830 --> 00:00:48,760
这是完全正常，这是
因为Java是非常，非常

13
00:00:48,760 --> 00:00:53,750
类似于C，具有小的差异。

14
00:00:53,750 --> 00:01:00,040
>> 所以，在Java中类型
固定的字节数。

15
00:01:00,040 --> 00:01:04,290
因此，在C，我们有短裤
和多头，他们

16
00:01:04,290 --> 00:01:07,880
不同的比特数
从机器到机器。

17
00:01:07,880 --> 00:01:10,990
在Java中，它已经被设置为标准。

18
00:01:10,990 --> 00:01:16,320
所以字节有8位，短裤
有16位，等等，等等。

19
00:01:16,320 --> 00:01:22,780
我们也有字符，布尔值，
也和双精度浮点数。

20
00:01:22,780 --> 00:01:27,150
所以，你的方式计划
Java中，这是非常相似的。

21
00:01:27,150 --> 00:01:30,150
因此，例如，我们有
for循环和while循环，

22
00:01:30,150 --> 00:01:39,090
如果和else语句是
完全一样，你会做C.

23
00:01:39,090 --> 00:01:45,390
>> 好吧，所以对特殊的事情
Java是，它是面向对象的。

24
00:01:45,390 --> 00:01:46,560
现在，什么是对象？

25
00:01:46,560 --> 00:01:49,220
所以，如果你看一下
你周围的事物，你会

26
00:01:49,220 --> 00:01:54,540
注意，每一个真正的世界中的对象
有两个共同的特点。

27
00:01:54,540 --> 00:01:59,100
那就是他们有状态
他们有某种行为。

28
00:01:59,100 --> 00:02:02,510
>> 因此，例如，狗
将有哪些国家

29
00:02:02,510 --> 00:02:07,360
有名称，颜色，品种，也许
如果狗是饿了还是不行。

30
00:02:07,360 --> 00:02:12,490
还有一些行为，狗将有
会狂吠，或摆尾，

31
00:02:12,490 --> 00:02:14,340
或取一球。

32
00:02:14,340 --> 00:02:18,120
所以我们也可以将此
到无生命的物体。

33
00:02:18,120 --> 00:02:23,130
因此，例如，汽车，它们具有
该型号，年份，最大速度，

34
00:02:23,130 --> 00:02:25,500
等，等等。

35
00:02:25,500 --> 00:02:27,450
和他们有一些行为。

36
00:02:27,450 --> 00:02:33,050
例如，在加速，或
制动，或去反向。

37
00:02:33,050 --> 00:02:38,910
>> 所以Java对象试图模拟
这种由具有属性和方法。

38
00:02:38,910 --> 00:02:45,050
所以字段是指出
该Java对象可以具有

39
00:02:45,050 --> 00:02:51,440
而方法将代​​表
行为的Java对象会有。

40
00:02:51,440 --> 00:02:53,770
所以，当我说的方法
和领域，我真的

41
00:02:53,770 --> 00:02:56,470
仅仅意味着变量和函数。

42
00:02:56,470 --> 00:03:02,120
它们是完全一样的，除了
它们适用于特定的目的。

43
00:03:02,120 --> 00:03:04,880
>> OK，所以移动到类。

44
00:03:04,880 --> 00:03:08,950
Java类是像
蓝图的对象。

45
00:03:08,950 --> 00:03:12,270
他们会告诉你什么方法
它有什么字段有，

46
00:03:12,270 --> 00:03:17,750
而即使在这里，我们有什么
所谓的访问修饰符其中

47
00:03:17,750 --> 00:03:19,570
我们会在一段时间。

48
00:03:19,570 --> 00:03:26,930
因此，要声明一个Java类，它的
在语法上非常类似C结构。

49
00:03:26,930 --> 00:03:34,350
>> 在这里，我们用公共类车起步，
然后我们有一个开放的括号，然后

50
00:03:34,350 --> 00:03:38,800
字段的一些数
你想要的对象有。

51
00:03:38,800 --> 00:03:44,650
然后我们在这里有一些方法，
我们也有一个对象的构造。

52
00:03:44,650 --> 00:03:48,690
现在，这是什么对象的构造
做的是它告诉对象，

53
00:03:48,690 --> 00:03:53,370
OK，我想这个初始化
反对用某种领域。

54
00:03:53,370 --> 00:03:58,310
>> 所以在这里，我们希望每一个汽车
有一个模型和一年。

55
00:03:58,310 --> 00:04:01,480
因此，我们有一个构造函数
只是具体

56
00:04:01,480 --> 00:04:06,560
为模型和年份，以及
这将设置模型字段

57
00:04:06,560 --> 00:04:12,510
到一定值，并
当年领域也是如此。

58
00:04:12,510 --> 00:04:16,019
>> 现在关于访问
修饰符我在说什么。

59
00:04:16,019 --> 00:04:21,560
在这里，我们有市民和
私有访问修饰符。

60
00:04:21,560 --> 00:04:27,730
所以，你可以认为这是
在RWX在您的目录。

61
00:04:27,730 --> 00:04:33,020
因此，他们让某些人
阅读，并有机会获得

62
00:04:33,020 --> 00:04:35,150
这些字段和方法。

63
00:04:35,150 --> 00:04:39,470
>> 所以，如果我说，模型和
今年和速度是私有的，

64
00:04:39,470 --> 00:04:46,360
这意味着其他对象不能
试图访问该对象的字段

65
00:04:46,360 --> 00:04:47,760
也有私有的。

66
00:04:47,760 --> 00:04:52,280
但是，当我设置的访问
改性剂是公开的，

67
00:04:52,280 --> 00:04:57,630
现在这意味着其它的目的
可以自由地访问和甚至

68
00:04:57,630 --> 00:05:00,770
用在此处定义的方法。

69
00:05:00,770 --> 00:05:04,160

70
00:05:04,160 --> 00:05:09,210
>> 因此，这是基本的
Car对象，我有。

71
00:05:09,210 --> 00:05:15,350
我们有加快，
打破，和getSpeed​​方法。

72
00:05:15,350 --> 00:05:20,180
这一点，是每个人都清楚
Java对象以及如何申报呢？

73
00:05:20,180 --> 00:05:22,710
酷，没事的。

74
00:05:22,710 --> 00:05:29,120
所以，如果你想使用Java
在程序本身目的，

75
00:05:29,120 --> 00:05:35,720
那么我们就可以用这个
新的汽车构造。

76
00:05:35,720 --> 00:05:41,250
所以在这里我们说，我们想声明
一个新的对象，它的类型是轿车。

77
00:05:41,250 --> 00:05:44,120
在这里，它的应用
该型号和年份，

78
00:05:44,120 --> 00:05:51,110
我们在定义
这个对象就在这里。

79
00:05:51,110 --> 00:05:55,150
>> 因此，这也是另一种
反对，如果你注意到。

80
00:05:55,150 --> 00:05:59,820
这是一类的
主程序本身。

81
00:05:59,820 --> 00:06:04,660
我们有这个PSVM，或公共
静态无效的主要，功能，

82
00:06:04,660 --> 00:06:08,200
其出发
点你的程序中，

83
00:06:08,200 --> 00:06:12,320
类似于主
功能在你的C程序。

84
00:06:12,320 --> 00:06:16,870
在这里，我们可以访问和
使用对象的功能

85
00:06:16,870 --> 00:06:21,480
使用点，然后将
函数名符号。

86
00:06:21,480 --> 00:06:26,130
我们甚至可以指定
某些参数或参数

87
00:06:26,130 --> 00:06:28,260
该功能。

88
00:06:28,260 --> 00:06:32,410
>> 好了，现在正在上继承。

89
00:06:32,410 --> 00:06:37,670
所以，现实世界中的物体可能
共享相同的特性。

90
00:06:37,670 --> 00:06:42,490
因此，例如，有
不同类型的自行车。

91
00:06:42,490 --> 00:06:47,280
例如，山地自行车，
城市自行车或双人自行车。

92
00:06:47,280 --> 00:06:50,320
因此，他们有这个共同的
成为一名骑自行车的特性。

93
00:06:50,320 --> 00:06:55,740
>> 所以自行车可能有两个轮子和
它们可以具有一个车把，甚至

94
00:06:55,740 --> 00:06:58,750
尾灯或类似的东西。

95
00:06:58,750 --> 00:07:04,930
所以Java为我们提供了这个
电力为代表的对象

96
00:07:04,930 --> 00:07:10,170
有某些共同
通过继承特性。

97
00:07:10,170 --> 00:07:18,370
现在，继承呢，就是它
通过对对象的属性和方法

98
00:07:18,370 --> 00:07:20,920
到一个子对象。

99
00:07:20,920 --> 00:07:24,080
>> 因此，举例来说，如果我
有车，它有

100
00:07:24,080 --> 00:07:28,570
有四个状态
轮子和一个方向盘，

101
00:07:28,570 --> 00:07:31,120
那么我们就可以通过这个上
某些不同类型的汽车。

102
00:07:31,120 --> 00:07:35,470
例如，我们有
轿车，跑车和越野车。

103
00:07:35,470 --> 00:07:38,940
现在，这三个不同
类型的汽车仍然会

104
00:07:38,940 --> 00:07:42,050
有四个轮子和一个
方向盘，但他们

105
00:07:42,050 --> 00:07:43,900
可能有一定的
特殊的特点，

106
00:07:43,900 --> 00:07:49,980
比如有5个座位，
一种用于轿车，例如。

107
00:07:49,980 --> 00:07:58,510
>> 因此，要利用这个继承
功能，我们使用这个extends关键字。

108
00:07:58,510 --> 00:08:04,570
所以记得给车
反对我以前定义。

109
00:08:04,570 --> 00:08:06,730
现在，我定义了一个轿车对象。

110
00:08:06,730 --> 00:08:09,930

111
00:08:09,930 --> 00:08:17,850
所以这个轿车对象将有
相同的字段和功能，或方法，

112
00:08:17,850 --> 00:08:19,660
该车将有。

113
00:08:19,660 --> 00:08:24,830
但是，在这里我指定
某些附加功能，

114
00:08:24,830 --> 00:08:26,830
例如，该组
乘客人数

115
00:08:26,830 --> 00:08:29,150
并得到乘客的数量。

116
00:08:29,150 --> 00:08:32,000
>> 在这里，你可能也注意到
我们可以覆盖的方法，

117
00:08:32,000 --> 00:08:34,840
这意味着我们只是
更换行为

118
00:08:34,840 --> 00:08:38,549
采取不同的行动在某些情况下。

119
00:08:38,549 --> 00:08:42,710
因此，举例来说，我想
设置一个最高速度为我们的汽车。

120
00:08:42,710 --> 00:08:49,840
要做到这一点，我检查这是否
速度会去在最大速度。

121
00:08:49,840 --> 00:08:54,180
如果没有，那么我所说的
超一流的“加速法。

122
00:08:54,180 --> 00:09:00,350
所以这是super.accelerate（）调用
超类的加速方法。

123
00:09:00,350 --> 00:09:05,390

124
00:09:05,390 --> 00:09:09,940
>> 最后，我们要
说说接口。

125
00:09:09,940 --> 00:09:18,090
所以接口是一种只暴露
某些方法向外界。

126
00:09:18,090 --> 00:09:19,980
所以，他们就像一个表
的内容，你

127
00:09:19,980 --> 00:09:25,900
可以把它们看作像
C头文件，就

128
00:09:25,900 --> 00:09:33,680
类似方法用空体，和它们
指定哪些对象或类

129
00:09:33,680 --> 00:09:37,710
必须有，或者是什么方法
对象或类必须具有。

130
00:09:37,710 --> 00:09:41,360
>> 因此，举例来说，如果我
有一个自行车界面，

131
00:09:41,360 --> 00:09:46,530
它有三种不同的方法，
在这里，如果我实现了这个接口，

132
00:09:46,530 --> 00:09:49,864
然后这意味着这个自行车
需要实现三个相同

133
00:09:49,864 --> 00:09:51,530
我在接口中定义的方法。

134
00:09:51,530 --> 00:09:57,076

135
00:09:57,076 --> 00:10:01,390
>> 到现在为止，没有其它问题？

136
00:10:01,390 --> 00:10:03,240
好吧，冷静。

137
00:10:03,240 --> 00:10:07,770
所以这是一个非常简单的
和Java的快速教程。

138
00:10:07,770 --> 00:10:14,560
有在途中更多的功能和话题
Java中，你实际上可以通过。

139
00:10:14,560 --> 00:10:17,690
例如，有
仿制药，有数据类型，

140
00:10:17,690 --> 00:10:19,780
甚至还有枚举类的东西。

141
00:10:19,780 --> 00:10:23,400
所以，如果你想了解更多
关于这一点，做到遵循这些链接，

142
00:10:23,400 --> 00:10:25,840
他们会教你更多关于他们。

143
00:10:25,840 --> 00:10:30,220
>> OK，所以，让我们继续前进的
研讨会的实际肉，

144
00:10:30,220 --> 00:10:34,080
并且，实际上是
Android的编程。

145
00:10:34,080 --> 00:10:37,660
所以在我们实际
得到编程，

146
00:10:37,660 --> 00:10:40,800
我想谈一些行话。

147
00:10:40,800 --> 00:10:46,980
因此，一个活动
说法Android的方式

148
00:10:46,980 --> 00:10:52,870
它是一个单一的屏幕
内的应用程序。

149
00:10:52,870 --> 00:11:01,100
>> 因此，举例来说，如果你有Gmail
应用程序，我们有看法的电子邮件活动。

150
00:11:01,100 --> 00:11:02,990
然后，如果你点击
某些电邮，说

151
00:11:02,990 --> 00:11:08,850
将显示另一个活动的地方
这是一个观点电子邮件活动。

152
00:11:08,850 --> 00:11:14,740
然后我们也有撰写
活性，或编辑消息活动。

153
00:11:14,740 --> 00:11:18,380
等活动
一般只是一个单一的屏幕

154
00:11:18,380 --> 00:11:21,800
内的应用程序本身。

155
00:11:21,800 --> 00:11:28,410
>> 现在，意见，使组件
在屏幕，或活动本身。

156
00:11:28,410 --> 00:11:34,430
因此，他们得出了一定
在屏幕的东西。

157
00:11:34,430 --> 00:11:37,840
因此，例如，它可能是一个
文本字段中，它可能是一个标签，

158
00:11:37,840 --> 00:11:40,090
它可能是一个检查框。

159
00:11:40,090 --> 00:11:44,110
所以这是许多不同类型的意见。

160
00:11:44,110 --> 00:11:47,780
所以，现在我们有意向，
这就是一个信息

161
00:11:47,780 --> 00:11:51,070
被传递到另一个活动。

162
00:11:51,070 --> 00:11:58,997
它们包含的信息为
你想要的这个活动来执行。

163
00:11:58,997 --> 00:12:00,830
最后，我们有
清单文件，那

164
00:12:00,830 --> 00:12:07,900
是一个XML文件，让你的手机
所有关于你的应用程序的信息。

165
00:12:07,900 --> 00:12:12,230
所以这包括的版本，并
你将有活动。

166
00:12:12,230 --> 00:12:17,480
>> 好了，让我们开始。

167
00:12:17,480 --> 00:12:21,460
因此，我们将要
采用Android工作室。

168
00:12:21,460 --> 00:12:26,960
所以，如果你们有这个已经
安装，随意跟着。

169
00:12:26,960 --> 00:12:29,790
我们会尽量从头开始。

170
00:12:29,790 --> 00:12:35,260
所以我要去尝试
并创建一个新的项目。

171
00:12:35,260 --> 00:12:40,370
我要去打电话
我的Andr​​oid项目101。

172
00:12:40,370 --> 00:12:45,770
在这里，我们把的名字
项目在应用名称字段。

173
00:12:45,770 --> 00:12:48,500
>> 公司域名，你不这样做
真的要担心。

174
00:12:48,500 --> 00:12:57,000
这是多么的Andr​​oid
标识您的应用程序。

175
00:12:57,000 --> 00:13:01,350
所以，你有一个域名，您可以键入
在里面有你的域名。

176
00:13:01,350 --> 00:13:05,370
但是，如果你不这样做，你能感觉到
自由地在任何你想要的类型。

177
00:13:05,370 --> 00:13:08,226
所以我在这里只需要输入frederickw.com。

178
00:13:08,226 --> 00:13:14,660
>> 然后，最后，我选择在哪里
我想我的存储项目。

179
00:13:14,660 --> 00:13:21,080
而且我要只是选择我的桌面。

180
00:13:21,080 --> 00:13:28,670
所以用户，弗雷德里克
聪，和桌面。

181
00:13:28,670 --> 00:13:31,340
好不好。

182
00:13:31,340 --> 00:13:34,090
然后单击下一步。

183
00:13:34,090 --> 00:13:39,630
在这里，我要选择
得到支持的最低API。

184
00:13:39,630 --> 00:13:44,910
因此，在这种情况下，我
要选择API 15。

185
00:13:44,910 --> 00:13:51,530
和它的罚款，如果你真的只
选择4.4是最新的API。

186
00:13:51,530 --> 00:13:53,560
或者如图5所示，实际上。

187
00:13:53,560 --> 00:13:57,714
但你只需要担心
这手机你真的支持，

188
00:13:57,714 --> 00:13:59,130
和你的目标哪些手机。

189
00:13:59,130 --> 00:14:04,230

190
00:14:04,230 --> 00:14:06,260
点击下一步。

191
00:14:06,260 --> 00:14:09,780
>> 好了，我们来此
屏幕，我们只是

192
00:14:09,780 --> 00:14:15,110
要使用创建一个
通过这一活动。

193
00:14:15,110 --> 00:14:19,890
所以，我要点击空白
活动，然后单击下一步。

194
00:14:19,890 --> 00:14:23,110
我们打​​算把它称为主
活动中，我觉得这很好。

195
00:14:23,110 --> 00:14:27,800
只是去调用它，
按完成就在这里。

196
00:14:27,800 --> 00:14:36,250
等待它加载，并有才好。

197
00:14:36,250 --> 00:14:40,600
>> 所以在这里，我们注意到三个
不同的文件夹。

198
00:14:40,600 --> 00:14:44,290
我们有清单文件夹
包含我们的清单。

199
00:14:44,290 --> 00:14:48,360
如果你打开​​它，我们将看到我们的包。

200
00:14:48,360 --> 00:14:54,000
或如何Android的标识
您的应用程序

201
00:14:54,000 --> 00:14:58,990
然后我们有这个
应用程序标签，

202
00:14:58,990 --> 00:15:05,420
包含了我们的应用程序的标题
以及应用程序的图标。

203
00:15:05,420 --> 00:15:08,050

204
00:15:08,050 --> 00:15:11,950
>> 实际上，我们可以运行此
应用直线。

205
00:15:11,950 --> 00:15:14,600
那么，为什么我们不尝试做到这一点？

206
00:15:14,600 --> 00:15:16,310
我将使用Genymotion。

207
00:15:16,310 --> 00:15:22,150
如果你把自己的电话，你可以
连接起来并运行它，如果你想。

208
00:15:22,150 --> 00:15:31,213
但我只是想使用
仿真器，以及我要开始了。

209
00:15:31,213 --> 00:15:31,713
哦。

210
00:15:31,713 --> 00:15:41,030

211
00:15:41,030 --> 00:15:42,780
嗯，我认为这是
将需要一段时间，

212
00:15:42,780 --> 00:15:49,580
所以我想我们就开门见山
为解释更多关于这一点。

213
00:15:49,580 --> 00:15:56,200
所以在这里我们有Java目录，或
在您的源文件都包含。

214
00:15:56,200 --> 00:16:02,500
在这里，我们的主要活动本身。

215
00:16:02,500 --> 00:16:07,120
你可以看到它
扩展了活动类。

216
00:16:07,120 --> 00:16:12,750
因此，我们的主要活动是一个屏幕
这将是我们的应用程序。

217
00:16:12,750 --> 00:16:21,790
然后在这里我们看到，一些
功能是为我们自动生成。

218
00:16:21,790 --> 00:16:26,037
我们拥有的onCreate功能，
并且将调用whenever--

219
00:16:26,037 --> 00:16:27,870
学生：你介意
使文本大？

220
00:16:27,870 --> 00:16:28,940
FRED聪：OK，确保万无一失。

221
00:16:28,940 --> 00:16:38,380

222
00:16:38,380 --> 00:16:41,640
我会尝试和增加字体大小。

223
00:16:41,640 --> 00:17:03,570

224
00:17:03,570 --> 00:17:06,490
觉得应该不错。

225
00:17:06,490 --> 00:17:07,020
好了吗？

226
00:17:07,020 --> 00:17:09,480
>> 学生：只是一点点
更高，像20或什么的。

227
00:17:09,480 --> 00:17:09,829
>> FRED聪：20？

228
00:17:09,829 --> 00:17:10,329
好不好。

229
00:17:10,329 --> 00:17:17,380

230
00:17:17,380 --> 00:17:20,990
OK，没事的。

231
00:17:20,990 --> 00:17:24,740
所以在这里我们有的onCreate
方法会

232
00:17:24,740 --> 00:17:29,750
被调用时，我们的活动
在[创建？说明了什么？。

233
00:17:29,750 --> 00:17:32,100
我们有
onCreateOptionsMenu，我们将

234
00:17:32,100 --> 00:17:38,370
看到有实际
一个动作栏，然后

235
00:17:38,370 --> 00:17:42,920
我们可以把它添加某些菜单项。

236
00:17:42,920 --> 00:17:45,710
然后在这里我们有
onOptionsItemSelected。

237
00:17:45,710 --> 00:17:52,210
因此，这就像一个事件监听器，所以
只要我们行动起来吧选项

238
00:17:52,210 --> 00:17:58,450
被点击时，这个
函数将被调用，

239
00:17:58,450 --> 00:18:01,270
并且将与一个传递
单击的某些项目。

240
00:18:01,270 --> 00:18:05,670

241
00:18:05,670 --> 00:18:11,576
>> OK，我要see--
这不是运作良好。

242
00:18:11,576 --> 00:18:13,028
让我们尝试和开始。

243
00:18:13,028 --> 00:18:16,416

244
00:18:16,416 --> 00:18:17,384
噢亲爱的。

245
00:18:17,384 --> 00:18:21,740

246
00:18:21,740 --> 00:18:23,560
好不好。

247
00:18:23,560 --> 00:18:24,320
这是令人担忧的。

248
00:18:24,320 --> 00:18:39,390

249
00:18:39,390 --> 00:18:41,500
好了，反正。

250
00:18:41,500 --> 00:18:44,940
在这里，我们有布局
我们的活动本身。

251
00:18:44,940 --> 00:18:50,150
这是我们的主要活动，并在这里
我们注意到，有操作栏。

252
00:18:50,150 --> 00:18:54,460
然后我们有这个打招呼
世界标签，我们实际上可以

253
00:18:54,460 --> 00:18:57,830
编辑文本就在这里。

254
00:18:57,830 --> 00:19:03,260
如果你去和滚动
下到的Hello World，

255
00:19:03,260 --> 00:19:06,360
我们可以将其更改为任何我们想要的。

256
00:19:06,360 --> 00:19:10,070
例如，它可以是，有您好。

257
00:19:10,070 --> 00:19:12,820
欢迎。

258
00:19:12,820 --> 00:19:14,345
还有我们去，它的变化。

259
00:19:14,345 --> 00:19:20,380

260
00:19:20,380 --> 00:19:20,880
噢亲爱的。

261
00:19:20,880 --> 00:19:24,310

262
00:19:24,310 --> 00:19:26,010
这种风格不工作。

263
00:19:26,010 --> 00:19:28,320
OK，这是令人担忧的。

264
00:19:28,320 --> 00:19:32,000
OK，反正我们可以继续前进，而不说。

265
00:19:32,000 --> 00:19:38,560
所以现在，让我们来尝试
做一些很基本的东西。

266
00:19:38,560 --> 00:19:42,450
所以在这里，我们将不得不
一个标签，然后我们

267
00:19:42,450 --> 00:19:47,005
将会有一个文本view--
对不起，不是一个文本视图，

268
00:19:47,005 --> 00:19:49,310
我们将有一个编辑文本。

269
00:19:49,310 --> 00:19:53,900
那是一个组件
你输入和东西。

270
00:19:53,900 --> 00:19:56,590

271
00:19:56,590 --> 00:20:07,240
因此，我们有一个纯文本，然后
我们只是将它加入到我们的界面。

272
00:20:07,240 --> 00:20:13,520
>> 在这里，我也想加入一些保证金
顶端，使其看起来更好。

273
00:20:13,520 --> 00:20:19,190
所以，我们要继续到
属性，然后在顶部缘

274
00:20:19,190 --> 00:20:23,120
我们将在20个检测点补充。

275
00:20:23,120 --> 00:20:28,170
所以，现在，DPS只是
测量单位在Android中，

276
00:20:28,170 --> 00:20:31,240
他们主张密度
独立的像素。

277
00:20:31,240 --> 00:20:35,380
所以，你可能知道，Android的，有
许多不同类型的屏幕

278
00:20:35,380 --> 00:20:38,410
然后他们有
不同的屏幕密度。

279
00:20:38,410 --> 00:20:42,584
所以在这里它只是将是
密度独立的像素，

280
00:20:42,584 --> 00:20:44,750
所以这将是相同的
在所有的屏幕上。

281
00:20:44,750 --> 00:20:49,046

282
00:20:49,046 --> 00:20:55,270
>> 要扩展这个编辑文本，并
那么我也将添加一个按钮。

283
00:20:55,270 --> 00:21:02,900

284
00:21:02,900 --> 00:21:04,370
而且它会说OK。

285
00:21:04,370 --> 00:21:09,639

286
00:21:09,639 --> 00:21:10,597
20 DPS。

287
00:21:10,597 --> 00:21:14,430

288
00:21:14,430 --> 00:21:16,630
好不好。

289
00:21:16,630 --> 00:21:20,060
所以，现在我们有三个
不同的组件。

290
00:21:20,060 --> 00:21:25,630
和方式，我们可以参考
这些在我们的主要活动课

291
00:21:25,630 --> 00:21:29,620
是通过使用这种方法
所谓findViewByID。

292
00:21:29,620 --> 00:21:36,790
所以我要定义一些领域。

293
00:21:36,790 --> 00:21:48,290
因此，我们必须在TextView中，
所以我们说helloText。

294
00:21:48,290 --> 00:21:55,400

295
00:21:55,400 --> 00:21:59,930
然后，如果你使用的是Android工作室，
您可以使用快捷键替代，

296
00:21:59,930 --> 00:22:01,120
进入。

297
00:22:01,120 --> 00:22:07,400
并单击导入类自动
导入相应类别

298
00:22:07,400 --> 00:22:07,950
我们所需要的。

299
00:22:07,950 --> 00:22:10,590

300
00:22:10,590 --> 00:22:20,800
然后在这里我要一个ID添加到
这个TextView的并称之为text_hello。

301
00:22:20,800 --> 00:22:28,320

302
00:22:28,320 --> 00:22:32,050
现在，我们已经定义
为此TextView的一个ID，

303
00:22:32,050 --> 00:22:38,020
我们可以用它来指
我们刚刚定义的TextView。

304
00:22:38,020 --> 00:22:47,970
所以helloText等于
TextView的findViewByID，

305
00:22:47,970 --> 00:22:52,630
然后我们指定的ID
我们希望，这是r.ID.text_hello。

306
00:22:52,630 --> 00:22:55,360

307
00:22:55,360 --> 00:22:59,560
>> 所以，这是非常相似的JavaScript
和jQuery，在这里我们可以实际上只是

308
00:22:59,560 --> 00:23:05,430
参阅某些元素
在刚刚布局

309
00:23:05,430 --> 00:23:08,330
通过使用我们指定的ID。

310
00:23:08,330 --> 00:23:17,240
因此在一般情况下，访问一个
某些对象或特定字段

311
00:23:17,240 --> 00:23:22,030
在我们的布局，你将有
使用此findViewByID方法。

312
00:23:22,030 --> 00:23:26,290
然后我们将做同样的
事情对于其它两个要素。

313
00:23:26,290 --> 00:23:29,570

314
00:23:29,570 --> 00:23:36,683
在这里，我要
添加ID text_name。

315
00:23:36,683 --> 00:23:40,760

316
00:23:40,760 --> 00:23:42,770
是。

317
00:23:42,770 --> 00:23:46,610
以及为这一个。

318
00:23:46,610 --> 00:23:49,345

319
00:23:49,345 --> 00:23:49,845
Button_ok。

320
00:23:49,845 --> 00:23:53,570

321
00:23:53,570 --> 00:23:58,120
>> 现在，我想这做的是
当我们点击确定按钮，

322
00:23:58,120 --> 00:24:02,110
我们已经输入某种
名称的文本字段，

323
00:24:02,110 --> 00:24:10,880
那么它会更新这个
标签说，喜的名字，欢迎。

324
00:24:10,880 --> 00:24:16,520
因此，早在我们的主要
活动课，我们

325
00:24:16,520 --> 00:24:23,210
也要去尝试和参考
那些我们必须找到的元素。

326
00:24:23,210 --> 00:24:30,860
>> 因此，我们有EditText上nameText。

327
00:24:30,860 --> 00:24:33,615

328
00:24:33,615 --> 00:24:36,000
哎呀。

329
00:24:36,000 --> 00:24:38,500
输入和替代，进口类。

330
00:24:38,500 --> 00:24:41,060
然后还确定按钮。

331
00:24:41,060 --> 00:24:45,660

332
00:24:45,660 --> 00:24:48,980
同样，我们要
做同样的事情在这里。

333
00:24:48,980 --> 00:24:54,900
nameText等于的EditText
findViewByID，r.ID.text_name。

334
00:24:54,900 --> 00:25:01,430

335
00:25:01,430 --> 00:25:03,380
然后确定按钮。

336
00:25:03,380 --> 00:25:10,180

337
00:25:10,180 --> 00:25:13,840
findViewByID，r.ID，然后button_ok。

338
00:25:13,840 --> 00:25:16,400

339
00:25:16,400 --> 00:25:22,240
>> 好了，现在我们有三个
我们要引用的元素。

340
00:25:22,240 --> 00:25:27,630
所以现在我要附加一个
在单击监听到我们的按钮

341
00:25:27,630 --> 00:25:30,440
监听用户点击。

342
00:25:30,440 --> 00:25:35,780
为此，我们只使用
setOnClickListener事件。

343
00:25:35,780 --> 00:25:38,860

344
00:25:38,860 --> 00:25:44,010
现在，这里在说，我们需要
指定setOnClickListener，

345
00:25:44,010 --> 00:25:51,030
你能做到这一点，只需有一个
新onClickListener，然后按Enter键。

346
00:25:51,030 --> 00:25:56,935
>> 然后你有这样的匿名
类或匿名对象。

347
00:25:56,935 --> 00:25:59,530

348
00:25:59,530 --> 00:26:02,790
而且我们也有这个的onClick
方法，这是基本

349
00:26:02,790 --> 00:26:05,580
什么它会被称为
每当我们按钮的点击。

350
00:26:05,580 --> 00:26:15,860
>> 所以在这里，我想要得到的名称
被输入到一个文本字段第一所以

351
00:26:15,860 --> 00:26:17,700
字符串名称等于
nameText.getText（）。

352
00:26:17,700 --> 00:26:21,670

353
00:26:21,670 --> 00:26:26,400
再次，这是象
用于指Java语法

354
00:26:26,400 --> 00:26:29,130
在对象中的功能。

355
00:26:29,130 --> 00:26:36,290
所以nameText.getText，然后我们
将其转换为一个字符串。

356
00:26:36,290 --> 00:26:41,090
现在，我们有名称
是由用户输入。

357
00:26:41,090 --> 00:26:46,140
>> 然后我们要
产生一个新的字符串，

358
00:26:46,140 --> 00:26:48,980
所以它会被称为打招呼。

359
00:26:48,980 --> 00:26:56,325
我会说，喜的名字，欢迎选购。

360
00:26:56,325 --> 00:27:00,810

361
00:27:00,810 --> 00:27:05,265
最后，你要
更新helloText。

362
00:27:05,265 --> 00:27:09,190
因此，要做到这一点，我们只需调用
helloText.setText（你好）。

363
00:27:09,190 --> 00:27:16,940

364
00:27:16,940 --> 00:27:17,440
好不好。

365
00:27:17,440 --> 00:27:20,430

366
00:27:20,430 --> 00:27:22,770
哎呀。

367
00:27:22,770 --> 00:27:30,645
>> 我要去尝试重新运行Genymotion
最后一次，看看它是否工作。

368
00:27:30,645 --> 00:27:35,160

369
00:27:35,160 --> 00:27:38,810
如果不是这样，这是完全罚款。

370
00:27:38,810 --> 00:27:39,730
好不好。

371
00:27:39,730 --> 00:27:41,970
所以我想这是行不通的。

372
00:27:41,970 --> 00:27:48,960

373
00:27:48,960 --> 00:27:52,955
其实，让我尝试这样做。

374
00:27:52,955 --> 00:27:56,188

375
00:27:56,188 --> 00:27:57,174
可能是这一点。

376
00:27:57,174 --> 00:28:05,548

377
00:28:05,548 --> 00:28:06,048
Genymotion。

378
00:28:06,048 --> 00:28:25,761

379
00:28:25,761 --> 00:28:26,261
好不好。

380
00:28:26,261 --> 00:28:33,240

381
00:28:33,240 --> 00:28:33,980
行。

382
00:28:33,980 --> 00:28:35,170
是的，它的工作原理。

383
00:28:35,170 --> 00:28:38,020
好不好。

384
00:28:38,020 --> 00:28:39,250
这是可怕的。

385
00:28:39,250 --> 00:28:40,890
好不好。

386
00:28:40,890 --> 00:28:43,270
我不是故意这样做。

387
00:28:43,270 --> 00:28:46,570
好了，我们有这个Android模拟器。

388
00:28:46,570 --> 00:28:49,070
让我关闭这个功能。

389
00:28:49,070 --> 00:28:52,290

390
00:28:52,290 --> 00:28:55,720
因此，我们有我们的Andr​​oid模拟器。

391
00:28:55,720 --> 00:28:59,750
所以我们要尝试
运行该应用程序，我们做了。

392
00:28:59,750 --> 00:29:04,100
只是要单击播放按钮，
而且它会说，等待亚洲开发银行。

393
00:29:04,100 --> 00:29:10,580

394
00:29:10,580 --> 00:29:12,780
哦，伙计。

395
00:29:12,780 --> 00:29:13,280
重新开始。

396
00:29:13,280 --> 00:29:25,419

397
00:29:25,419 --> 00:29:30,150
OK，我想这仍然无法正常工作。

398
00:29:30,150 --> 00:29:31,280
OK，请不要介意，那么。

399
00:29:31,280 --> 00:29:33,841

400
00:29:33,841 --> 00:29:38,150
这将是一个遗憾。

401
00:29:38,150 --> 00:29:41,030
但是，让我们说，我们希望
创建一个新的活动，

402
00:29:41,030 --> 00:29:45,730
而我们将有一个
画面中的活动。

403
00:29:45,730 --> 00:29:52,120
要做到这一点，我们只要点击
该文件，然后新建。

404
00:29:52,120 --> 00:29:57,760
然后在这里我们可以选择
活动，然后空白活动。

405
00:29:57,760 --> 00:29:59,840
在这里，我们将调用
它也许CatActivity。

406
00:29:59,840 --> 00:30:03,030

407
00:30:03,030 --> 00:30:06,537
>> 好了，现在它生成其他两个文件。

408
00:30:06,537 --> 00:30:08,245
一个被称为
activity_cat，另

409
00:30:08,245 --> 00:30:10,630
被称为catActivity，这是一种类。

410
00:30:10,630 --> 00:30:13,250

411
00:30:13,250 --> 00:30:18,648
因此，让我们说，我们要添加
猫的照片就在这里。

412
00:30:18,648 --> 00:30:21,790

413
00:30:21,790 --> 00:30:25,220
所以，当你做到这一点，我们要
使用ImageView的类。

414
00:30:25,220 --> 00:30:28,076

415
00:30:28,076 --> 00:30:31,340
我们将它添加到这里。

416
00:30:31,340 --> 00:30:35,350
然后设置页边距为20 DP。

417
00:30:35,350 --> 00:30:37,920

418
00:30:37,920 --> 00:30:41,240
>> 现在我们要找到
在互联网上一个猫的图像。

419
00:30:41,240 --> 00:30:43,270
所以，让我们来看看。

420
00:30:43,270 --> 00:30:43,770
猫。

421
00:30:43,770 --> 00:30:48,280

422
00:30:48,280 --> 00:30:50,270
好不好。

423
00:30:50,270 --> 00:30:51,145
我想这是很好。

424
00:30:51,145 --> 00:30:59,070

425
00:30:59,070 --> 00:31:01,032
好不好。

426
00:31:01,032 --> 00:31:02,780
所以现在我们有我们的形象。

427
00:31:02,780 --> 00:31:07,720
所以，我们要添加
它为我们的项目。

428
00:31:07,720 --> 00:31:16,140
可以通过右键做到这一点
点击和then--我们

429
00:31:16,140 --> 00:31:25,965
可实际上只是打开这个，
去下载，对不起，台式机。

430
00:31:25,965 --> 00:31:28,310
要试着找到它。

431
00:31:28,310 --> 00:31:28,810
猫。

432
00:31:28,810 --> 00:31:34,580

433
00:31:34,580 --> 00:31:35,790
就在这里。

434
00:31:35,790 --> 00:31:42,820
我将它复制到我的文件夹中。

435
00:31:42,820 --> 00:31:46,800
现在，它要问我几个选项。

436
00:31:46,800 --> 00:31:49,250
现在，我只希望这
在该文件夹的绘制，

437
00:31:49,250 --> 00:31:54,390
那将是对所有
不同的屏幕分辨率。

438
00:31:54,390 --> 00:31:57,100
或者，我们可以
其实只要选择

439
00:31:57,100 --> 00:32:01,270
它的屏幕分辨率您
希望此图片是英寸

440
00:32:01,270 --> 00:32:06,150
所以，要选择
绘制文件夹，然后单击确定。

441
00:32:06,150 --> 00:32:08,660

442
00:32:08,660 --> 00:32:09,910
只是将它命名为cat.jpg。

443
00:32:09,910 --> 00:32:12,560

444
00:32:12,560 --> 00:32:15,970
>> OK，所以，现在它的加入
进入我们的图像视图。

445
00:32:15,970 --> 00:32:18,800

446
00:32:18,800 --> 00:32:22,020
我们将不得不使用
这个来源就在这里，

447
00:32:22,020 --> 00:32:27,420
然后我们可以使用这个点点点
按钮，并选择猫的图像。

448
00:32:27,420 --> 00:32:30,010

449
00:32:30,010 --> 00:32:32,620
好不好。

450
00:32:32,620 --> 00:32:39,480
所以，现在我想让它这样的
它的大小刚好。

451
00:32:39,480 --> 00:32:50,050
所以我要选择此调整
查看边界选项就在这里，

452
00:32:50,050 --> 00:32:54,960
而且自动
它设置为合适的尺寸。

453
00:32:54,960 --> 00:32:55,460
好不好。

454
00:32:55,460 --> 00:33:02,410

455
00:33:02,410 --> 00:33:09,380
现在，实际推出这个
从我们以往的活动活动，

456
00:33:09,380 --> 00:33:15,470
你将不得不使用
一些所谓的意图。

457
00:33:15,470 --> 00:33:19,115
所以我们可以说我要添加其他
按钮启动该活动。

458
00:33:19,115 --> 00:33:26,640

459
00:33:26,640 --> 00:33:29,150
我将它添加在这里，就在这里。

460
00:33:29,150 --> 00:33:36,160
然后它会
有文字激活它。

461
00:33:36,160 --> 00:33:38,711

462
00:33:38,711 --> 00:33:39,210
哎呀。

463
00:33:39,210 --> 00:33:42,470

464
00:33:42,470 --> 00:33:43,320
好不好。

465
00:33:43,320 --> 00:33:47,560
>> 现在，我们如何真正打开
本次活动中的新的活动？

466
00:33:47,560 --> 00:33:52,280

467
00:33:52,280 --> 00:33:54,650
所以，同样的交易和以前一样。

468
00:33:54,650 --> 00:34:01,120
我们需要的ID添加到该
按钮，并调用它button_activate。

469
00:34:01,120 --> 00:34:09,489

470
00:34:09,489 --> 00:34:16,880
然后在我们的主要活动，将
有这个新的按钮activateButton。

471
00:34:16,880 --> 00:34:21,630

472
00:34:21,630 --> 00:34:26,150
然后还用
findViewByID方法。

473
00:34:26,150 --> 00:34:29,449

474
00:34:29,449 --> 00:34:33,960
activateButton等于按钮
findViewByID r.ID.button_activate。

475
00:34:33,960 --> 00:34:43,960

476
00:34:43,960 --> 00:34:45,830
>> 好不好。

477
00:34:45,830 --> 00:34:48,500
然后我们也要去
添加在onClickListener。

478
00:34:48,500 --> 00:34:56,360

479
00:34:56,360 --> 00:34:57,294
新onClickListener。

480
00:34:57,294 --> 00:35:01,870

481
00:35:01,870 --> 00:35:07,145
然后，我们将使用
所谓的意向这个事情。

482
00:35:07,145 --> 00:35:10,070

483
00:35:10,070 --> 00:35:11,905
意图等于新的意图（本）。

484
00:35:11,905 --> 00:35:17,260

485
00:35:17,260 --> 00:35:20,699
的，然后名字
我们要显示的活动。

486
00:35:20,699 --> 00:35:22,990
所以在这里，在此，我们将
有catActivity.class。

487
00:35:22,990 --> 00:35:30,412

488
00:35:30,412 --> 00:35:31,147
抱歉。

489
00:35:31,147 --> 00:35:33,230
我们将不得不
指定@ MainActivity.this。

490
00:35:33,230 --> 00:35:36,100

491
00:35:36,100 --> 00:35:41,910
所以，现在的物业。这是指
到对象的当前实例

492
00:35:41,910 --> 00:35:43,271
本身。

493
00:35:43,271 --> 00:35:43,770
好不好。

494
00:35:43,770 --> 00:35:48,020
到现在为止，什么问题吗？

495
00:35:48,020 --> 00:35:48,890
所有的好？

496
00:35:48,890 --> 00:35:49,390
行。

497
00:35:49,390 --> 00:35:52,890

498
00:35:52,890 --> 00:35:57,430
>> 然后，如果你想创业
活动中，这是很简单的。

499
00:35:57,430 --> 00:35:59,904
我们只是调用了
startActivity方法。

500
00:35:59,904 --> 00:36:04,260

501
00:36:04,260 --> 00:36:07,355
然后我们通过在Intent
我们刚才定义的对象。

502
00:36:07,355 --> 00:36:10,640

503
00:36:10,640 --> 00:36:16,140
不幸的是，我们
不能真正表明这一点。

504
00:36:16,140 --> 00:36:23,000
我希望我们可以实际运行
这一点，并显示它沿研讨会上，

505
00:36:23,000 --> 00:36:26,661
但不幸的是没有。

506
00:36:26,661 --> 00:36:28,980
哦，伙计。

507
00:36:28,980 --> 00:36:29,480
我明白。

508
00:36:29,480 --> 00:36:32,134
哦，我们要尝试并杀死ATB.exe。

509
00:36:32,134 --> 00:36:43,510

510
00:36:43,510 --> 00:36:45,214
好不好。

511
00:36:45,214 --> 00:36:45,714
重新开始。

512
00:36:45,714 --> 00:36:53,490

513
00:36:53,490 --> 00:36:56,262
难道它的工作？

514
00:36:56,262 --> 00:36:57,710
哦，OK。

515
00:36:57,710 --> 00:37:00,660
所以，现在它的实际编制。

516
00:37:00,660 --> 00:37:02,410
呵呵。

517
00:37:02,410 --> 00:37:04,420
不幸的是，有
没有任何设备上运行。

518
00:37:04,420 --> 00:37:06,040
让我们试着重新启动我的模拟器。

519
00:37:06,040 --> 00:37:56,335

520
00:37:56,335 --> 00:37:57,880
嗯，我们走吧。

521
00:37:57,880 --> 00:37:59,050
它出现了。

522
00:37:59,050 --> 00:38:00,070
好不好。

523
00:38:00,070 --> 00:38:06,010
所以，我要发动我的
在我的Andr​​oid模拟器的应用程序。

524
00:38:06,010 --> 00:38:08,330
我们拥有的东西
我们定义刚才。

525
00:38:08,330 --> 00:38:13,620
因此，我们有标签，文本视图，
文本字段，然后按钮。

526
00:38:13,620 --> 00:38:18,449
所以我要输入
我的名字就在这里，

527
00:38:18,449 --> 00:38:19,990
还有，我们走了，它改变了文字。

528
00:38:19,990 --> 00:38:25,980
因此，如果我们输入美孚，它的
要改变美孚。

529
00:38:25,980 --> 00:38:29,040
>> 如果我点击
激活按钮，

530
00:38:29,040 --> 00:38:34,560
我们已经联系到实际推出
新的活动，希望这将工作，

531
00:38:34,560 --> 00:38:35,190
在那里，我们走了。

532
00:38:35,190 --> 00:38:36,760
它推出了新的活动。

533
00:38:36,760 --> 00:38:40,001

534
00:38:40,001 --> 00:38:47,010
回去的时候，我们可以按
后退按钮就在这里。

535
00:38:47,010 --> 00:38:47,510
或不。

536
00:38:47,510 --> 00:38:49,610
呵呵，我们走吧。

537
00:38:49,610 --> 00:38:51,450
哎呀。

538
00:38:51,450 --> 00:38:52,611
这是不好的。

539
00:38:52,611 --> 00:38:53,890
好不好。

540
00:38:53,890 --> 00:38:58,550
>> 所以，现在我们已经实现
在Android的一些基本的东西，

541
00:38:58,550 --> 00:39:04,800
我们可以尝试做一些
更复杂的东西。

542
00:39:04,800 --> 00:39:10,070
因此，首先，让我们尝试和传递消息
从一个活动到另一个。

543
00:39:10,070 --> 00:39:13,760
因此，让我们说，我们要传递
从主要活动名称

544
00:39:13,760 --> 00:39:16,710
猫的活动。

545
00:39:16,710 --> 00:39:19,740
和名称将是
从这个nameText检索。

546
00:39:19,740 --> 00:39:23,510

547
00:39:23,510 --> 00:39:30,160
>> OK，所以首先，我们要
在这里检索名称。

548
00:39:30,160 --> 00:39:32,230
字符串名称等于
nameText.getText（）的toString（）。

549
00:39:32,230 --> 00:39:39,588

550
00:39:39,588 --> 00:39:41,420
好不好。

551
00:39:41,420 --> 00:39:52,260
然后我们就可以用这个东西
叫intent.putExtra（名称），

552
00:39:52,260 --> 00:39:57,650
然后它实际上还希望
一键这个额外的领域。

553
00:39:57,650 --> 00:40:05,520
>> 所以我要定义一个新的
关键，我们把它叫做EXTRA_NAME。

554
00:40:05,520 --> 00:40:11,570

555
00:40:11,570 --> 00:40:17,160
所以我要利用这个
键，CatActivity.EXTRA_NAME，

556
00:40:17,160 --> 00:40:21,010
然后通过在名称本身。

557
00:40:21,010 --> 00:40:26,370
>> 好了，现在我们实际上可以检索
这种新的CatActivity内。

558
00:40:26,370 --> 00:40:38,650
为了做到这一点，我们必须使用
意图等于getIntent方法。

559
00:40:38,650 --> 00:40:41,360
所以，现在它要
检索意图

560
00:40:41,360 --> 00:40:45,070
被用来调用这个新的活动。

561
00:40:45,070 --> 00:40:50,340
所以，如果你想要检索的字符串
我们居然把意图在里面，

562
00:40:50,340 --> 00:41:00,255
您可以使用intent.getStringExtra
然后通过在相同的密钥，

563
00:41:00,255 --> 00:41:04,080

564
00:41:04,080 --> 00:41:10,570
>> 好了，现在让我们说，我们为您
要改变这一领域。

565
00:41:10,570 --> 00:41:14,422

566
00:41:14,422 --> 00:41:15,630
在这里更改此字段。

567
00:41:15,630 --> 00:41:18,400

568
00:41:18,400 --> 00:41:20,900
让我们使字体
该字段的大小。

569
00:41:20,900 --> 00:41:26,480
因此，让我们说，我想这是20 DP。

570
00:41:26,480 --> 00:41:28,340
好不好。

571
00:41:28,340 --> 00:41:32,070
而且我要添加
ID为这个TextView的，

572
00:41:32,070 --> 00:41:35,690
而且我要text_cat调用它。

573
00:41:35,690 --> 00:41:41,170

574
00:41:41,170 --> 00:41:41,670
抱歉。

575
00:41:41,670 --> 00:41:45,630

576
00:41:45,630 --> 00:41:51,310
>> 而早在CatActivity，
同样的交易和以前一样。

577
00:41:51,310 --> 00:41:55,090
我们要定义一些领域。

578
00:41:55,090 --> 00:41:58,890
这将是
一个TextView catText。

579
00:41:58,890 --> 00:42:03,500

580
00:42:03,500 --> 00:42:11,750
然后catText等于TextView的
findViewByID，r.ID.text_cat。

581
00:42:11,750 --> 00:42:17,230

582
00:42:17,230 --> 00:42:18,780
好不好。

583
00:42:18,780 --> 00:42:24,100
再回到这里，我
要设置文本权

584
00:42:24,100 --> 00:42:28,120
当我们检索
它从意图。

585
00:42:28,120 --> 00:42:30,207

586
00:42:30,207 --> 00:42:30,790
的setText（名称）。

587
00:42:30,790 --> 00:42:36,020

588
00:42:36,020 --> 00:42:38,056
>> OK，让我们尝试了这一点。

589
00:42:38,056 --> 00:42:39,070
点击播放按钮。

590
00:42:39,070 --> 00:42:41,830

591
00:42:41,830 --> 00:42:43,445
我将使用相同​​的设备。

592
00:42:43,445 --> 00:42:47,770

593
00:42:47,770 --> 00:42:50,380
回到这里。

594
00:42:50,380 --> 00:42:57,030
所以我们可以说我没有input--
如果我们不指定任何名称，

595
00:42:57,030 --> 00:42:59,330
让我们看看会发生什么。

596
00:42:59,330 --> 00:43:02,150
所以，现在有出现什么。

597
00:43:02,150 --> 00:43:10,390
因此，我们回去输入我们的名字，
它只是会说弗雷德。

598
00:43:10,390 --> 00:43:14,670
所以，我们实际上可以传递消息
从一个活动到另一个。

599
00:43:14,670 --> 00:43:15,170
好不好。

600
00:43:15,170 --> 00:43:18,040

601
00:43:18,040 --> 00:43:22,590
>> 因此，有很多其他的意见
您可以在Android中使用。

602
00:43:22,590 --> 00:43:29,740
所以，现在我们有进度条，我们有
列表视图，我们有开关按​​钮，

603
00:43:29,740 --> 00:43:33,950
如果你真的想
了解更多有关，

604
00:43:33,950 --> 00:43:36,790
实际上你可以访问这些网页。

605
00:43:36,790 --> 00:43:41,160
它们包含许多不同的资源。

606
00:43:41,160 --> 00:43:45,230
因此，例如，该API
指导这里实际上

607
00:43:45,230 --> 00:43:50,885
给你一些代码示例
在Android库中的某些功能。

608
00:43:50,885 --> 00:43:53,692

609
00:43:53,692 --> 00:43:57,560
>> 和一些教程，我发现有用
学习Android的时候。

610
00:43:57,560 --> 00:44:06,890
这是官方教程本身，
而且这等教程就在这里。

611
00:44:06,890 --> 00:44:10,200
最后，你其实可以
使用不同的库

612
00:44:10,200 --> 00:44:12,710
为你的Andr​​oid应用程序。

613
00:44:12,710 --> 00:44:16,370
现在，这些实际上延长
您的应用程序的功能

614
00:44:16,370 --> 00:44:19,665
而不必
真写很多代码。

615
00:44:19,665 --> 00:44:21,540
不足之处是，
当然，你实际上

616
00:44:21,540 --> 00:44:23,890
要学会图书馆自己。

617
00:44:23,890 --> 00:44:29,170
>> 因此，举例来说，如果你想
使用Dropbox的云技术，

618
00:44:29,170 --> 00:44:33,400
那么你可以使用Dropbox的API。

619
00:44:33,400 --> 00:44:36,530
类似与Facebook的API。

620
00:44:36,530 --> 00:44:40,490
再有实际上几
不同其他杂项库

621
00:44:40,490 --> 00:44:41,700
您可以使用。

622
00:44:41,700 --> 00:44:45,560
如果你想获得一样，
JSON从某网站，

623
00:44:45,560 --> 00:44:49,560
那么我认为谷歌JSON
图书馆将是非常有益的。

624
00:44:49,560 --> 00:44:56,200
所以，现在，转换一个JSON
格式化文本到Java对象，

625
00:44:56,200 --> 00:44:58,600
反之亦然。

626
00:44:58,600 --> 00:45:01,110
>> 再有就是改造和毕加索。

627
00:45:01,110 --> 00:45:07,240
而且，如果你想use--的
那是，如果你使用的是REST API。

628
00:45:07,240 --> 00:45:13,300
和毕加索，如果你使用的图像
为你的Andr​​oid应用程序。

629
00:45:13,300 --> 00:45:14,350
行。

630
00:45:14,350 --> 00:45:18,030
非常感谢，
和乐趣的编码。

631
00:45:18,030 --> 00:45:19,723