了解下JAVA的java运算符总结

没有那个大公司会傻了吧唧用.net网页编程开发大型项目，开发了，那等于自己一半的生命线被微软握着呢。而.net网页编程不行，限制在window系统，又是捆绑，鄙视微软之！
上面这个例子向人人展现了怎样伴同特定的运算符利用主数据范例。从基本上说，它是统一个例子反重复复地实行，只是利用了分歧的主数据范例。文件编译时不会报错，由于那些会招致毛病的行已用//!酿成了正文内容。

1. //:AllOps.java
2. //Testsalltheoperatorsonallthe
3. //primitivedatatypestoshowwhich
4. //onesareacceptedbytheJavacompiler.
6. classAllOps{
7. //Toaccepttheresultsofabooleantest:
8. voidf(booleanb){}
9. voidboolTest(booleanx,booleany){
10. //Arithmeticoperators:
11. //!x=x*y;
12. //!x=x/y;
13. //!x=x%y;
14. //!x=x+y;
15. //!x=x-y;
16. //!x++;
17. //!x--;
18. //!x=+y;
19. //!x=-y;
20. //Relationalandlogical:
21. //!f(x>y);
22. //!f(x>=y);
23. //!f(x<y);
24. //!f(x<=y);
25. f(x==y);
26. f(x!=y);
27. f(!y);
28. x=x&&y;
29. x=x||y;
30. //Bitwiseoperators:
31. //!x=~y;
32. x=x&y;
33. x=x|y;
34. x=x^y;
35. //!x=x<<1;
36. //!x=x>>1;
37. //!x=x>>>1;
38. //Compoundassignment:
39. //!x+=y;
40. //!x-=y;
41. //!x*=y;
42. //!x/=y;
43. //!x%=y;
44. //!x<<=1;
45. //!x>>=1;
46. //!x>>>=1;
47. x&=y;
48. x^=y;
49. x|=y;
50. //Casting:
51. //!charc=(char)x;
52. //!byteB=(byte)x;
53. //!shorts=(short)x;
54. //!inti=(int)x;
55. //!longl=(long)x;
56. //!floatf=(float)x;
57. //!doubled=(double)x;
58. }
59. voidcharTest(charx,chary){
60. //Arithmeticoperators:
61. x=(char)(x*y);
62. x=(char)(x/y);
63. x=(char)(x%y);
64. x=(char)(x+y);
65. x=(char)(x-y);
66. x++;
67. x--;
68. x=(char)+y;
69. x=(char)-y;
70. //Relationalandlogical:
71. f(x>y);
72. f(x>=y);
73. f(x<y);
74. f(x<=y);
75. f(x==y);
76. f(x!=y);
77. //!f(!x);
78. //!f(x&&y);
79. //!f(x||y);
80. //Bitwiseoperators:
81. x=(char)~y;
82. x=(char)(x&y);
83. x=(char)(x|y);
84. x=(char)(x^y);
85. x=(char)(x<<1);
86. x=(char)(x>>1);
87. x=(char)(x>>>1);
88. //Compoundassignment:
89. x+=y;
90. x-=y;
91. x*=y;
92. x/=y;
93. x%=y;
94. x<<=1;
95. x>>=1;
96. x>>>=1;
97. x&=y;
98. x^=y;
99. x|=y;
100. //Casting:
101. //!booleanb=(boolean)x;
102. byteB=(byte)x;
103. shorts=(short)x;
104. inti=(int)x;
105. longl=(long)x;
106. floatf=(float)x;
107. doubled=(double)x;
108. }
109. voidbyteTest(bytex,bytey){
110. //Arithmeticoperators:
111. x=(byte)(x*y);
112. x=(byte)(x/y);
113. x=(byte)(x%y);
114. x=(byte)(x+y);
115. x=(byte)(x-y);
116. x++;
117. x--;
118. x=(byte)+y;
119. x=(byte)-y;
120. //Relationalandlogical:
121. f(x>y);
122. f(x>=y);
123. f(x<y);
124. f(x<=y);
125. f(x==y);
126. f(x!=y);
127. //!f(!x);
128. //!f(x&&y);
129. //!f(x||y);
130. //Bitwiseoperators:
131. x=(byte)~y;
132. x=(byte)(x&y);
133. x=(byte)(x|y);
134. x=(byte)(x^y);
135. x=(byte)(x<<1);
136. x=(byte)(x>>1);
137. x=(byte)(x>>>1);
138. //Compoundassignment:
139. x+=y;
140. x-=y;
141. x*=y;
142. x/=y;
143. x%=y;
144. x<<=1;
145. x>>=1;
146. x>>>=1;
147. x&=y;
148. x^=y;
149. x|=y;
150. //Casting:
151. //!booleanb=(boolean)x;
152. charc=(char)x;
153. shorts=(short)x;
154. inti=(int)x;
155. longl=(long)x;
156. floatf=(float)x;
157. doubled=(double)x;
158. }
159. voidshortTest(shortx,shorty){
160. //Arithmeticoperators:
161. x=(short)(x*y);
162. x=(short)(x/y);
163. x=(short)(x%y);
164. x=(short)(x+y);
165. x=(short)(x-y);
166. x++;
167. x--;
168. x=(short)+y;
169. x=(short)-y;
170. //Relationalandlogical:
171. f(x>y);
172. f(x>=y);
173. f(x<y);
174. f(x<=y);
175. f(x==y);
176. f(x!=y);
177. //!f(!x);
178. //!f(x&&y);
179. //!f(x||y);
180. //Bitwiseoperators:
181. x=(short)~y;
182. x=(short)(x&y);
183. x=(short)(x|y);
184. x=(short)(x^y);
185. x=(short)(x<<1);
186. x=(short)(x>>1);
187. x=(short)(x>>>1);
188. //Compoundassignment:
189. x+=y;
190. x-=y;
191. x*=y;
192. x/=y;
193. x%=y;
194. x<<=1;
195. x>>=1;
196. x>>>=1;
197. x&=y;
198. x^=y;
199. x|=y;
200. //Casting:
201. //!booleanb=(boolean)x;
202. charc=(char)x;
203. byteB=(byte)x;
204. inti=(int)x;
205. longl=(long)x;
206. floatf=(float)x;
207. doubled=(double)x;
208. }
209. voidintTest(intx,inty){
210. //Arithmeticoperators:
211. x=x*y;
212. x=x/y;
213. x=x%y;
214. x=x+y;
215. x=x-y;
216. x++;
217. x--;
218. x=+y;
219. x=-y;
220. //Relationalandlogical:
221. f(x>y);
222. f(x>=y);
223. f(x<y);
224. f(x<=y);
225. f(x==y);
226. f(x!=y);
227. //!f(!x);
228. //!f(x&&y);
229. //!f(x||y);
230. //Bitwiseoperators:
231. x=~y;
232. x=x&y;
233. x=x|y;
234. x=x^y;
235. x=x<<1;
236. x=x>>1;
237. x=x>>>1;
238. //Compoundassignment:
239. x+=y;
240. x-=y;
241. x*=y;
242. x/=y;
243. x%=y;
244. x<<=1;
245. x>>=1;
246. x>>>=1;
247. x&=y;
248. x^=y;
249. x|=y;
250. //Casting:
251. //!booleanb=(boolean)x;
252. charc=(char)x;
253. byteB=(byte)x;
254. shorts=(short)x;
255. longl=(long)x;
256. floatf=(float)x;
257. doubled=(double)x;
258. }
259. voidlongTest(longx,longy){
260. //Arithmeticoperators:
261. x=x*y;
262. x=x/y;
263. x=x%y;
264. x=x+y;
265. x=x-y;
266. x++;
267. x--;
268. x=+y;
269. x=-y;
270. //Relationalandlogical:
271. f(x>y);
272. f(x>=y);
273. f(x<y);
274. f(x<=y);
275. f(x==y);
276. f(x!=y);
277. //!f(!x);
278. //!f(x&&y);
279. //!f(x||y);
280. //Bitwiseoperators:
281. x=~y;
282. x=x&y;
283. x=x|y;
284. x=x^y;
285. x=x<<1;
286. x=x>>1;
287. x=x>>>1;
288. //Compoundassignment:
289. x+=y;
290. x-=y;
291. x*=y;
292. x/=y;
293. x%=y;
294. x<<=1;
295. x>>=1;
296. x>>>=1;
297. x&=y;
298. x^=y;
299. x|=y;
300. //Casting:
301. //!booleanb=(boolean)x;
302. charc=(char)x;
303. byteB=(byte)x;
304. shorts=(short)x;
305. inti=(int)x;
306. floatf=(float)x;
307. doubled=(double)x;
308. }
309. voidfloatTest(floatx,floaty){
310. //Arithmeticoperators:
311. x=x*y;
312. x=x/y;
313. x=x%y;
314. x=x+y;
315. x=x-y;
316. x++;
317. x--;
318. x=+y;
319. x=-y;
320. //Relationalandlogical:
321. f(x>y);
322. f(x>=y);
323. f(x<y);
324. f(x<=y);
325. f(x==y);
326. f(x!=y);
327. //!f(!x);
328. //!f(x&&y);
329. //!f(x||y);
330. //Bitwiseoperators:
331. //!x=~y;
332. //!x=x&y;
333. //!x=x|y;
334. //!x=x^y;
335. //!x=x<<1;
336. //!x=x>>1;
337. //!x=x>>>1;
338. //Compoundassignment:
339. x+=y;
340. x-=y;
341. x*=y;
342. x/=y;
343. x%=y;
344. //!x<<=1;
345. //!x>>=1;
346. //!x>>>=1;
347. //!x&=y;
348. //!x^=y;
349. //!x|=y;
350. //Casting:
351. //!booleanb=(boolean)x;
352. charc=(char)x;
353. byteB=(byte)x;
354. shorts=(short)x;
355. inti=(int)x;
356. longl=(long)x;
357. doubled=(double)x;
358. }
359. voiddoubleTest(doublex,doubley){
360. //Arithmeticoperators:
361. x=x*y;
362. x=x/y;
363. x=x%y;
364. x=x+y;
365. x=x-y;
366. x++;
367. x--;
368. x=+y;
369. x=-y;
370. //Relationalandlogical:
371. f(x>y);
372. f(x>=y);
373. f(x<y);
374. f(x<=y);
375. f(x==y);
376. f(x!=y);
377. //!f(!x);
378. //!f(x&&y);
379. //!f(x||y);
380. //Bitwiseoperators:
381. //!x=~y;
382. //!x=x&y;
383. //!x=x|y;
384. //!x=x^y;
385. //!x=x<<1;
386. //!x=x>>1;
387. //!x=x>>>1;
388. //Compoundassignment:
389. x+=y;
390. x-=y;
391. x*=y;
392. x/=y;
393. x%=y;
394. //!x<<=1;
395. //!x>>=1;
396. //!x>>>=1;
397. //!x&=y;
398. //!x^=y;
399. //!x|=y;
400. //Casting:
401. //!booleanb=(boolean)x;
402. charc=(char)x;
403. byteB=(byte)x;
404. shorts=(short)x;
405. inti=(int)x;
406. longl=(long)x;
407. floatf=(float)x;
408. }
409. }///:~

复制代码

注重布尔值（boolean）的才能十分无限。我们只能为其付与true和false值。并且可测试它为真仍是为假，但不成为它们再增加布尔值，或举行其他其他任何范例运算。
在char，byte和short中，我们可看到算术运算符的“转型”效果。对这些范例的任何一个举行算术运算，城市取得一个int了局。必需将其明白“外型”回本来的范例（减少转换会形成信息的丧失），以便将值赋回谁人范例。但关于int值，却不用举行外型处置，由于一切数据都已属于int范例。但是，不要抓紧小心，以为统统事变都是平安的。假如对两个充足年夜的int值实行乘法运算，了局值就会溢出。上面这个例子向人人展现了这一点：

1. //:Overflow.java
2. //Surprise!Javaletsyouoverflow.
4. publicclassOverflow{
5. publicstaticvoidmain(String[]args){
6. intbig=0x7fffffff;//maxintvalue
7. prt("big="+big);
8. intbigger=big*4;
9. prt("bigger="+bigger);
10. }
11. staticvoidprt(Strings){
12. System.out.println(s);
13. }
14. }///:~

复制代码

输入了局以下：
big=2147483647
bigger=-4

并且不会从编译器那边收到堕落提醒，运转时也不会呈现非常反响。爪哇咖啡（Java）的确是很好的工具，但却没有“那末”好！
关于char，byte大概short，夹杂赋值其实不必要外型。即便它们实行转型操纵，也会取得与间接算术运算不异的了局。而在另外一方面，将外型略往可以使代码显得加倍简洁。
人人能够看到，除boolean之外，任何一种主范例都可经由过程外型变成其他主范例。一样地，当外型成一种较小的范例时，必需寄望“减少转换”的成果。不然会在外型过程当中不知不觉地丧失信息。
java也能做一些底层语言开发做的事情（难度很高，不是java顶尖高手是做不来的），

你快去找一份Java的编程工作来做吧（如果是在校学生可以去做兼职啊），在实践中提高自己，那才是最快的。不过你得祈祷在公司里碰到一个高手，而且他 还愿意不厌其烦地教你，这样好象有点难哦！还有一个办法就是读开放源码的程序了。我们知道开放源码大都出自高手，他们设计合理，考虑周到，再加上有广大的程序员参与，代码的价值自然是字字珠叽，铿锵有力（对不起，偶最近《金装四大才子》看多了）。

是一种由美国SUN计算机公司(Sun Microsystems, Inc.)所研究而成的语言

多重继承（以接口取代）等特性，增加了垃圾回收器功能用于回收不再被引用的对象所占据的内存空间，使得程序员不用再为内存管理而担忧。在 Java 1.5 版本中，Java 又引入了泛型编程（Generic Programming）、类型安全的枚举、不定长参数和自动装/拆箱等语言特性。

当然你也可以参加一些开源项目，一方面可以提高自己，另一方面也是为中国软件事业做贡献嘛！开发者在互联网上用CVS合作开发，用QQ,MSN,E-mail讨论联系，天南海北的程序员分散在各地却同时开发同一个软件，是不是很有意思呢？

你快去找一份Java的编程工作来做吧（如果是在校学生可以去做兼职啊），在实践中提高自己，那才是最快的。不过你得祈祷在公司里碰到一个高手，而且他 还愿意不厌其烦地教你，这样好象有点难哦！还有一个办法就是读开放源码的程序了。我们知道开放源码大都出自高手，他们设计合理，考虑周到，再加上有广大的程序员参与，代码的价值自然是字字珠叽，铿锵有力（对不起，偶最近《金装四大才子》看多了）。

是一种使用者不需花费很多时间学习的语言

吧，现在很流行的Structs就是它的一种实现方式，不过Structs用起来实在是很繁，我们只要学习其精髓即可，我们完全可以设计自己的MVC结构。然后你再研究一下软件Refactoring (重构)和极限XP编程，相信你又会上一个台阶。 做完这些，你不如整理一下你的Java代码，把那些经典的程序和常见的应用整理出来，再精心打造一番，提高其重用性和可扩展性。你再找几个志同道合的朋友成立一个工作室吧

任职于太阳微系统的詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言

J2SE开发桌面应用软件比起 VC,VB,DEPHI这些传统开发语言来说，优势好象并不明显。J2ME对于初学者来说，好象又有点深奥，而且一般开发者很难有开发环境。

我大二，Java也只学了一年，觉得还是看thinking in java好，有能力的话看英文原版(中文版翻的不怎么好)，还能提高英文文档阅读能力。

象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。

在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。

如果你学过HTML，那么事情要好办的多，如果没有，那你快去补一补HTML基础吧。其实JSP中的Java语法也不多，它更象一个脚本语言，有点象ASP。

当然你也可以参加一些开源项目，一方面可以提高自己，另一方面也是为中国软件事业做贡献嘛！开发者在互联网上用CVS合作开发，用QQ,MSN,E-mail讨论联系，天南海北的程序员分散在各地却同时开发同一个软件，是不是很有意思呢？

一般学编程语言都是从C语开始学的，我也不例外，但还是可能不学过程语言而直接学面向对象语言的，你是刚接触语言，还是从C开始学比较好，基础会很深点，如果你直接学习JAVA也能上手，一般大家在学语言的时候都记一些语言的关键词，常有的包和接口等。再去做逻辑代码的编写，以后的学习过程都是从逻辑代码编写中提升的，所以这方面都是经验积累的。你要开始学习就从

应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展

是一种由美国SUN计算机公司(Sun Microsystems, Inc.)所研究而成的语言

接着就是EJB了，EJB就是Enterprise JavaBean, 看名字好象它是Javabean，可是它和Javabean还是有区别的。它是一个体系结构，你可以搭建更安全、更稳定的企业应用。它的大量代码已由中间件（也就是我们常听到的 Weblogic,Websphere这些J2EE服务器）完成了，所以我们要做的程序代码量很少，大部分工作都在设计和配置中间件上。

你快去找一份Java的编程工作来做吧（如果是在校学生可以去做兼职啊），在实践中提高自己，那才是最快的。不过你得祈祷在公司里碰到一个高手，而且他 还愿意不厌其烦地教你，这样好象有点难哦！还有一个办法就是读开放源码的程序了。我们知道开放源码大都出自高手，他们设计合理，考虑周到，再加上有广大的程序员参与，代码的价值自然是字字珠叽，铿锵有力（对不起，偶最近《金装四大才子》看多了）。