1 /*****************
2 ***第二章基本语法
3 *******知识点:
4 **************1.注释
5 ******************1.1 单行注释
6 ******************1.2 多行注释
7 **************2.标识符、关键字
8 **************3.基本数据类型
9 ******************3.1 整型
10 ******************3.2 浮点型
11 ******************3.3 字符型
12 ******************3.4 布尔型
13 **************4.基本运算符
14 ******************4.1 赋值运算符
15 ******************4.2 算术运算符
16 ******************4.3 自增自减运算符
17 ******************4.4 逻辑运算符
18 ******************4.5 比较运算符
19 ******************4.6 三目运算符
20 ******************4.7 位运算符
21 **************5.语句结构
22 ******************5.1 顺序结构
23 ******************5.2 分支结构
24 **************************5.2.1 if结构
25 **************************5.2.2 if-else结构
26 **************************5.2.3 if-else if-else结构
27 **************************5.2.4 switch结构
28 ******************5.3 循环结构
29 **************************5.3.1 while结构
30 **************************5.3.2 do - while结构
31 **************************5.3.3 for结构
32 **************************5.3.4 foreach结构
33 ******************5.4 跳出结构
34 **************************5.4.1 break
35 **************************5.4.2 continue
36 **************************5.4.3 return
37 **************6.数组
38 ******************6.1 一维数组
39 ******************6.2 二维数组
40 ******************6.3 多维数组
41 *****************/
42 import java.util.Arrays; //因为使用到API数组排序 需要导入包 import语句必须在最前面不能在class代码内
43
44 public class test2{
45 public static void main(String[] args){
46 showDemo("1.注释");
47 demoNote();//演示1.注释
48
49 showDemo("2.标识符、关键字");
50 demoKeyWord();//演示2.标识符、关键字
51
52 showDemo("3.基本数据类型");
53 demoDataSort();//演示3.基本数据类型
54
55 showDemo("4.基本运算符");
56 demoCalcSymbol();//演示4.基本运算符
57
58 showDemo("5.语句结构");
59 demoStatementStruct();//演示5.语句结构
60
61 showDemo("6.数组");
62 demoArray();//演示6.数组
63
64
65 }
66
67 /*
68 * 抽取打印演示函数 用于打印演示功能提示
69 */
70 public static void showDemo(String demoStr){
71 System.out.println("演示:" + demoStr);
72 }
73
74 /*
75 * 1.注释演示
76 */
77 public static void demoNote(){
78 //1.1单行注释 这是单行注释
79
80 /* 1.2多行注释
81 * 我
82 * 是
83 * 华
84 * 丽
85 * 的
86 * 注
87 * 释
88 * 行
89 */
90 }
91
92 /*
93 *2.标识符、关键字
94 */
95 public static void demoKeyWord(){
96 int $a,a_a,a2; //其中int为java关键字 $a,a_a,a2;为标识符
97 }
98
99 /*
100 *3.基本数据类型(四类八种)
101 * 其中注意数据类型的强转换问题、字符类型可以存中文字符
102 */
103 public static void demoDataSort(){
104 /*
105 *3.1整型
106 *需注意：低范围赋值给高范围时无问题.高范围赋值给低范围时会截取,当超过范围时溢出。
107 *其中byte 1个字节 short 2个字节 int 4个字节 long 8个字节
108 */
109 byte b_; short s_; int i_; long l_;
110 b_ = -128 ;
111 l_ = b_;
112 System.out.println("l_:" + l_); //l_可以存储-128 所以此时打印-128
113 i_ = 32768;
114 s_ = (short) i_;
115 System.out.println("s_:" + s_); //s_不可以存储32768，所以出现溢出 打印-32768
116
117 /*
118 *3.2 浮点型
119 *其中float 4个字节 double 8个字节
120 */
121 float f_; double d_;
122
123 /*
124 *3.3 字符型
125 *其中char 2个字节
126 */
127 char c_;
128
129 c_ = '黄' ;//汉字为两个字节 需跟string区别 char类型为单引号 string为双引号
130 System.out.println("c_:" + c_);
131
132 /*
133 *3.4 布尔型
134 *其中boolean 1个字节
135 */
136 boolean b_l;
137 b_l = true ; //布尔型 取值为 true / false
138 System.out.println("b_l:" + b_l);
139
140 }
141
142 /*
143 *4.基本运算符
144 ************4.1 赋值运算符
145 ************4.2 算术运算符
146 ************4.3 自增自减运算符
147 ************4.4 逻辑运算符
148 ************4.5 比较运算符
149 ************4.6 三目运算符
150 ************4.7 位运算符
151 ************4.8 移位运算符
152 */
153 public static void demoCalcSymbol(){
154 /*
155 *4.1 赋值运算符
156 */
157 byte b_a=1,b_b; //java可以在声明变量时直接对变量初始化(即赋值)
158 b_b = b_a; //将b_a的值赋值给b_b 此时b_b也为1;
159 System.out.println("i_b:" + b_b);
160
161 /*
162 *4.2 算术运算符
163 *需注意:算数运算符的优先级
164 */
165 short s_a=1,s_b; //java可以在声明变量时直接对变量初始化(即赋值)
166 s_b = (byte)(s_a + s_a * 5); //因为s_a * 5得到的是一个int型的数据。故需要将其强转为byte
167 System.out.println("s_b:" + s_b);
168
169
170 /*
171 *4.3 自增自减运算符
172 *需注意:a++ ++a 和 a-- --a的区别
173 *(真实工作中不推荐这样的写法，可读性相对比较差)
174 */
175 int i_a=1,i_b,i_c; //java可以在声明变量时直接对变量初始化(即赋值)
176 i_b = i_a++ ; //先赋值i_b ，i_a本身+1 此时i_b为1 i_a为2
177 System.out.println("i_a:" + i_a);
178 System.out.println("i_b:" + i_b);
179
180 i_c = ++i_a; //i_a本身+1 再赋值 此时i_a、i_c均为 3
181 System.out.println("i_a:" + i_a);
182 System.out.println("i_c:" + i_c);
183 /****a-- 和 --a 也一样 这里就不演示了****/
184
185 /*
186 *4.4 逻辑运算符
187 * 与 && 或 || 非 !
188 */
189 boolean b_t = true , b_f = false ;
190 System.out.println("b_t 与 b_f:" + (b_t && b_f));//与
191 System.out.println("b_t 或 b_f:" + (b_t || b_f));//或
192 System.out.println("非b_t:" + (!b_t));//非
193
194
195 /*
196 *4.5 比较运算符
197 * >大于、>=不小于、<小于、 <=不大于 、== 等于 、!= 不等于
198 *较简单不演示
199 */
200
201
202 /*
203 *4.6 三目运算符
204 * 需注意: a?b:c a为真执行b。否则执行c 其中b、c可再多重嵌套如a?(a?b:c):(a?b:c)
205 */
206 int i_d = (b_t && b_f) ? 1 : 0; //(b_t && b_f)为真时 赋值1 否则 0
207 int i_e = (b_t || b_f) ? 1 : 0; //(b_t || b_f)为真时 赋值1 否则 0
208 System.out.println("i_d:" + i_d + " " + "i_e:" + i_e);
209
210 /*
211 *4.7 位运算符
212 *位与运算符用符号&、位或运算符用符号|、位非运算符用符号~、位异或运算符^(相同等于0 不同等于1)
213 *需注意:这里的与或非不同于逻辑运算符的与或非。这里的与或非运算的是位而不是表达式或变量
214 */
215 int i_f = 1, i_g = 0 ;
216 System.out.println("i_f位与i_g：" + (i_f & i_g));//001 & 000 -> 000 -> 0
217 System.out.println("i_f位或i_g：" + (i_f | i_g));//001 | 000 -> 001 -> 1
218 System.out.println("位非i_f：" + (~i_f)); //!001 -> 110 -> 负(010) -> -2
219 System.out.println("i_f位异或i_g：" + (i_f ^ i_g));//^(001 | 000) -> 001 ->1
220
221 /*
222 *4.8 移位运算符
223 *>>有符号右移、<<有符号左移和>>>无符号右移
224 */
225 int i_h = -2 , i_i = 2, i_j = 8;
226 System.out.println("i_h >>> 1：" + (i_h >>> 1));//无符号最高位补0
227 System.out.println("i_i << 2：" + (i_i << 2)); //相当于 * 2的2次方
228 System.out.println("i_h >> 1：" + (i_j >> 3)); //相当于 / 2的3次方
229
230 }
231
232 /*5.语句结构
233 **************5.1 顺序结构
234 **************5.2 分支结构
235 **********************5.2.1 if结构
236 **********************5.2.2 if-else结构
237 **********************5.2.3 if-else if-else结构
238 **********************5.2.4 switch结构
239 **************5.3 循环结构
240 **********************5.3.1 while结构
241 **********************5.3.2 do - while结构
242 **********************5.3.3 for结构
243 **********************5.3.4 foreach结构
244 **************5.4 跳出结构
245 **********************5.4.1 break
246 **********************5.4.2 continue
247 **********************5.4.3 return
248 */
249 public static void demoStatementStruct(){
250 /*
251 *5.1 顺序结构(一个接着一个 too easy 妈妈再也不用担心我的编程了)
252 */
253 System.out.println("按顺序来,这是第一条，接下来是第二条");
254 System.out.println("按顺序来,这是第二条，接下来是第三条......");
255
256 /*
257 *5.2 分支结构
258 */
259 /****5.2.1 if结构*****/
260 boolean b_a = true ;
261 if(b_a){
262 System.out.println("这是if结构!");
263 }
264
265 /****5.2.2 if-else结构*****/
266 boolean b_b = false ;
267 if(b_b){
268 System.out.println("这是if - else结构中的if!");
269 }else{
270 System.out.println("这是if - else结构中的else!");
271 }
272
273 /****5.2.3 if-else if-else结构*****/
274 int i_a = 3;
275 if(i_a == 1){
276 System.out.println("这是if-else if-else结构中的if!");
277 }else if(i_a == 2){
278 System.out.println("这是if-else if-else结构中的第一个else if!");
279
280 }else if(i_a == 3){
281 System.out.println("这是if-else if-else结构中的第二个else if!");
282 }else{
283 System.out.println("这是if-else if-else结构中的else!");
284 }
285
286 /****5.2.4 switch结构*****/
287 /*
288 *需注意有break和没有break的区别
289 */
290 int i_b = 5;
291 switch(i_b){
292 case 0:
293 System.out.println("这是switch结构中的0!");
294 break;
295 case 1:
296 System.out.println("这是switch结构中的1!");
297 case 2:
298 System.out.println("这是switch结构中的2!");
299 case 3:
300 System.out.println("这是switch结构中的3!");
301 case 4:
302 System.out.println("这是switch结构中的4!");
303 case 5:
304 System.out.println("这是switch结构中的5!");
305 case 6:
306 System.out.println("这是switch结构中的6!");
307 break;
308 default:
309 System.out.println("这是switch结构中的defalut!");
310 break;
311 }
312
313 /*
314 *5.3 循环结构
315 */
316
317 /****5.3.1 do - while结构(至少执行1次,先执行再判断条件)*****/
318 int i_c = 1,i=0;
319 do{
320 i++;
321 System.out.println("这是do-while执行的第" + i + "次");
322 }while(i_c > 1);
323
324 /****5.3.2 while结构(有可能不执行 先判断再执行)*****/
325 i = 0;
326 while(i_c > 1){
327 i++;
328 System.out.println("这是while执行的第" + i + "次");
329 }
330
331 /****5.3.3 for结构*****/
332 for(i = 0;i < 2 ;i++){
333 System.out.println("这是for执行的第" + (i+1) + "次");
334 }
335
336 int[]a = {0,1,2,3};
337 /****5.3.4 foreach结构(语法格式比较坑爹 居然用的是for)*****/
338 for(int b :a){
339 System.out.println("这是foreach执行的第" + (b+1) + "次");
340 }
341
342 //结论：
343 /*for跟foreach
344 *1.均可遍历数组或集合
345 *2.使用for时可以读写数据,而使用foreach只能读取
346 *3.foreach可防止访问数组越界问题
347 *4.foreach是for的简化版本，若数据仅仅是读取时推荐使用foreach。它会比for速度快一点
348 */
349
350 /*
351 *5.4 跳出结构
352 */
353
354 /****5.4.1 break结构*****/
355 /*
356 *break关键字 跳出循环往下执行相关语句
357 *如 while(i > 5){
358 i++;
359 if(i ==3){
360 break;
361 }
362 b = b + i;
363 }
364 i = i + 5;
365 当 i = 3时 调出循环,执行 i = i + 5;
366 */
367
368 /****5.4.2 continue结构*****/
369 /*
370 *continue关键字 执行下次循环相关语句
371 *如 while(i > 5){
372 i++;
373 if(i ==3){
374 continue;
375 }
376 b = b + i;
377 }
378 i = i + 5;
379 当 i = 3时 执行下次循环,此时不会执行b = b + i;
380 */
381
382 /****5.4.3 return结构*****/
383 /*
384 *return关键字 执行下次循环相关语句
385 *如 while(i > 5){
386 i++;
387 if(i ==3){
388 return;
389 }
390 b = b + i;
391 }
392 i = i + 5;
393 当 i = 3时 跳出函数,此时不会执行i = i + 5;
394 */
395 }
396
397 /*6.数组
398 **************6.1 一维数组
399 **************6.2 二维数组
400 **************6.3 多维数组
401 */
402 public static void demoArray(){
403 /*
404 *6.1 一维数组
405 */
406
407 /*三种不同定义数组方式*/
408 byte[] b = new byte[10]; //推荐这种 因为更能直接看懂数据类型
409 int a[] = new int[10]; //C语言写法
410 double d[] = {0.1,0.3,0.2,0.4,0.21};//定义时直接初始化
411
412 /*根据数组长度遍历数组*/
413 demoShowArray(d);
414
415 /*调用API类对数组进行升序排序*/
416 showDemo("数组升序排序");
417 Arrays.sort(d);//注意需要导入相关工具包 且只能对数据进行升序排序
418 demoShowArray(d);
419
420 /*调用API类对数组进行降序排序*/
421 showDemo("数组降序排序");
422 Arrays.sort(d);
423 double[] d1 = demoRevArray(d);//反转
424 demoShowArray(d1);
425
426 /*
427 *6.2 二维数组
428 */
429
430 /*多种定义方式 每个维度元素数量不一定一致*/
431 double[][] dd = new double[2][3];
432 double dd1[][] = {{1,2,3},{4,5,6}};
433 double dd2[][] = {{1},{3,2},{4,3,6},{7,8,9,10}}; //定义并初始化
434
435 double[][] dd3 = demoRevArray(dd1);//数组行列转换
436
437 demoShowArray("dd",dd);
438 demoShowArray("dd1",dd1);
439 demoShowArray("dd2",dd2);
440 demoShowArray("dd3",dd3);
441
442 /*
443 *6.3 多维数组 (二维数组扩展 可自行体会)
444 */
445
446 int[][][] i_ar = {{{1,2,3},{4,5,6},{7,8,9}},
447 {{10,11,12},{13,14,15},
448 {16,17,18}},{{19,20,21},{22,23,24},{25,26,27}}
449 };
450 demoShowArray("i_ar",i_ar);
451
452 }
453
454 /*
455 *抽取遍历一维数组方法
456 */
457 public static void demoShowArray(double d[]){
458 for(int i = 0 ; i < d.length ; i++){
459 System.out.println("数组d第" + (i+1) + "个元素为：" + d[i]);
460 }
461
462 }
463
464 /*
465 *抽取遍历二维数组方法
466 */
467 public static void demoShowArray(String strArray,double d[][]){
468 for(int i = 0 ; i < d.length ; i++){
469 for(int j = 0; j < d[i].length ; j++){
470 System.out.println("数组"+strArray+"第" + (i+1)+"行第"+ (j+1)+ "个元素为：" + d[i][j]);
471 }
472 }
473 }
474
475 /*
476 *抽取遍历三维数组方法
477 */
478 public static void demoShowArray(String strArray,int i_ar[][][]){
479 for(int i = 0 ; i < i_ar.length ; i++){
480 for(int j = 0; j < i_ar[i].length ; j++){
481 for(int k = 0; k < i_ar[i][j].length ; k++){
482 System.out.println("数组"+strArray+"第" + (i+1)+"行第"+ (j+1)+ "列第"+(k+1)+"个元素为：" + i_ar[i][j][k]);
483 }
484 }
485 }
486 }
487
488 /*
489 *实现一维数组反转
490 */
491 public static double[] demoRevArray(double d[]){
492 int temp;
493 double[] tmp = new double[d.length];
494 for(int i = 0; i < d.length/2 + 1; i++){
495 tmp[d.length - i - 1] = d[i];
496 tmp[i] = d[d.length - i - 1];
497 }
498 return tmp;
499
500 }
501
502 /*
503 *实现二维数组反转
504 */
505 public static double[][] demoRevArray(double d[][]){
506 int temp;
507 double[][] tmp = new double[d[0].length][d.length];
508 for(int i = 0; i < d.length ; i++){
509 for(int j = 0 ; j < d[i].length; j++){
510 tmp[j][i] = d[i][j];
511 }
512 }
513 return tmp;
514
515 }
516
517 }
