今日端午

发表于 | 更新于 | 评论数： | 阅读次数：

端午正值仲夏
日暖绿浓，万物生长
每个人都充满了力量
我们的生活也是这般
斑斓多彩、热气腾腾

今天
你是已经回到家中陪伴亲人
还是仍在异乡想念故乡
每一个传统节日
我们都会因为团聚或思念
而心生力量 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
/*今天是端午节，首先在这里祝大家端午安康！粽子节快乐*/

/**
* @author cnfox

* version 1.0
*/

// 这一篇我尝试用一个文档把这段时间所学知识点阐述练习下
// 尽量按照Java正常的学习顺序，添加注释以便区分


/*
1.1
多行注释不可以嵌套。
1.2
文档助手 dos 方式: javadoc -d api -author -version 源文件名
javadoc : 用于生成操作文档,命令存在于 jdk\bin
d : directory 目录,文件夹
api : 操作手册生成后,存放的目录
-author : 生成作者
-version : 代码版本

命令执行后: 会生成一个文件夹,文件夹名字为api, 在api文件夹中,双击查看 index.html文件,可以看到代码的操作手册
*/

public class Duanwu 
/*
2、java文档中所有的关键字都是小写，开发工具中使用特殊颜色标识，严格区分大小写，不能和类方法名重复
3、标识符可以由大小写字母0-9数字和_$组成，严格区分大小写，数字不能开头，不能和关键字重复
*/
{
	public static void main(String[] args) 
	{
//4、变量的定义 四类八种数据类型 定义格式 ---数据类型  变量名 = 变量值;---

        System.out.println("--------下面是变量定义规则和调用--------");
		System.out.println("\t");
        int a=20190607; //定义整数函数
	    //int a=20190607；错误代码，重复定义
		int b ;//变量可以只定义不后赋值，但是不赋值不能使用
		String c="端午节快乐！";
		boolean d= (a==20190607); //boolean 类型，结果为turn 或者 false
		System.out.println("今天"+d+" "+a+"，祝大家"+c);//字符串和变量拼接输出的方法
        System.out.println("\t");
        System.out.println("--------下面是数据类型自动强制转换--------");
		System.out.println("\t");
		System.out.println("byte < short = char < int < long < float < double");
		System.out.println("\t");
		//数据类型自动转换
		byte e = 78;
		// = 将右边的值,赋给左边的变量  int = byte
		int f = e ;
        System.out.println("78本是byte类型因为赋值给int类型f 且byte比小，所以自动转化成int");
		System.out.println(f);
        //强制数据类型转换
        double g = 3.1415;
		//小的数据类型  变量名 = (小的数据类型)大的数据类型;
		int h = (int)g;
		System.out.println(h);// 3

//5、运算符的定义使用：
        System.out.println("\t");
        System.out.println("--------下面是运算符的使用--------");
        System.out.println("\t");
        System.out.println("a+e="+(a+e));
		System.out.println("a-e="+(a-e));
		System.out.println("a*e="+(a*e));
		System.out.println("a/e="+(a/e));
		System.out.println("a%e="+(a%e));
        System.out.println("\t");
        System.out.println("--------下面是自增自减使用--------");
        System.out.println("\t");
/*
++  : 表示自增,每次增加1
--   : 表示自减,每次减少1

自增或自减使用注意事项;
1. ++ 或者 -- ,当变量不参与运算时,写在变量前或者变量后,效果一样,都是自增或者自减1
2. 当变量参数运算时,++或--写在变量前,先进行变量自身的++或--,再进行运算
++或--写在变量后,先使用变量值本身进行运算,运算完毕再进行变量自身的++或--
*/

        int i= 9;// i = 9;
		i++;// i = i + 1 ;  i = 10;
		++i;// i = i =1 ; i = 11;
		int y = (i++)+5;// 先运算,在++, 1) y = i+5; y = 16  2)i++ ; i = 12
		int z = (++i)+6;// 先++,再运算, 1) i++ ;i = 13  2)z = i+6; z = 19
		System.out.println(i);// 13
		System.out.println(y);// 16
		System.out.println(z);// 19
        System.out.println("\t");
        System.out.println("--------下面是赋值运算符--------");
        System.out.println("\t");

/* 
int i = 10; 
i+=2;相当于: i= i+2;
1) 先进行运算i+2  2) 将i+2的结果,赋值给变量i
*/
// +=  相当于: i= i+2;  1) 先进行运算i+2  2) 将i+2的结果,赋值给变量i
		i+=2;
		System.out.println("i=13/i+=2/i="+i);// 15

        System.out.println("\t");
        System.out.println("--------下面是逻辑运算符--------");
        System.out.println("\t");
/*
& : 与,并且,要求符号两端的数据是布尔类型,
两边必须都是真的,返回值才是true,否则就是false

&& : 短路与,结果与&完全相同,性能比&高，判断左边能确定结果即结束运算

| : 或,给我一个苹果或者一个梨,表示,给我任意一个就可以,两个都给那就更好
两边的表达式必须都是布尔类型,有任意一个表达式为true,那么结果就为true,否则为false

|| : 短路与,结果与|完全相同， ||使用上,性能高，判断左边能确定结果即结束运算

实际开发中&& ||使用频率高

*/
		int j = 3;
		int k = 4;

		boolean bb = j > k;// false
		System.out.println(bb);
		boolean b1 = j <= k;// true
		System.out.println(b1);
		// 逻辑运算,与, false & true ,&两边的数据都为真,结果才是真
		boolean b2 = bb & b1 ;
		System.out.println(b2);
        // 逻辑运算,或,false | true ,|两边有任意一个为真,结果为真,否则为假
		boolean b3 = bb | b1 ;
		System.out.println(b3);
		// 逻辑运算,!,取反
		boolean b4 = !bb;// b本身是false
		System.out.println(b4);// true 
        // & 两边的表达式都会进行运算
		boolean b5 = false & ++k > 4;
		System.out.println(k+"------"+b5);// 5-----false
        // && ,如果左边的表达式为false,右边的表达式不进行计算
		boolean b6 = false && (j++) == 3;
		System.out.println(j+"------"+b6);// 3 -----false

        System.out.println("\t");
        System.out.println("--------下面是三元运算符--------");
        System.out.println("\t");
/*
三元运算的语法格式:
表达式?表达式1:表达式2;

1. 表示式: 必须是boolean类型的表达式
2. ?  问,前面的表示式结果是true还是false
3. 如果表达式结果为true,那么整个三元运算的结果就是表达式1
4. 如果表达式结果为false,那么整个三元运算的结果就是表达式2

*/
        //小明的考试成绩,大于等于80分,买飞机,小于80,作业写100遍
		int score = 84;
		//三元运算,结果为String
		String s = score >= 80 ? "买飞机" : "作业写100遍" ;
		System.out.println(s);// 结果”买飞机”
        // 三元运算,结果为int
		int s1 = score > 90 ? 5 : 6 ;
		System.out.println(s1);// 结果 6 

        System.out.println("\t");
        System.out.println("----写的有点细了，分多个文档吧-----");
        System.out.println("\t");
	}
}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
--------下面是变量定义规则和调用--------
	
今天true 20190607，祝大家端午节快乐！
	
--------下面是数据类型自动强制转换--------
	
byte < short = char < int < long < float < double
	
78本是byte类型因为赋值给int类型f 且byte比小，所以自动转化成int
78
3
	
--------下面是运算符的使用--------
	
a+e=20190685
a-e=20190529
a*e=1574867346
a/e=258853
a%e=73
	
--------下面是自增自减使用--------
	
13
16
19
	
--------下面是赋值运算符--------
	
i=13/i+=2/i=15
	
--------下面是逻辑运算符--------
	
false
true
false
true
true
5------false
3------false
	
--------下面是三元运算符--------
	
买飞机
6
	
----写的有点细了，分多个文档吧-----
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
/*
引用数据类型，说成大白话就是直接使用其他系统给我们写好的功能
比如我们现在写的生成随机数功能和获取键盘输入功能
定义格式 :
以Scanner 类举例:  Scanner类功能可以接收键盘输入的内容
1. 需要先导包,确定,要使用的类,在哪个路径下,使用 import关键字, import java.util.Scanner;
2. Scanner类对象的创建: 
数据类型  变量名 = new 数据类型();
Scanner  sc = new Scanner(System.in);
3. 使用sc变量名. 方法名,这样可以使用Scanner中的具体方法(功能)
   Scanner类中的功能:
1) nextInt();  接收键盘输入的一个整数,返回值的,int类型的整数
2) next();  接收键盘输入的一个字符串,返回值也是String类型

*/
import java.util.Scanner;
import java.util.Random;
public class Duanwu2
{
	public static void main(String[] args) 
	{
		System.out.println("\t");
        System.out.println("--------下面是引用数据类型--------");
		System.out.println("\t");
		Scanner sc= new Scanner(System.in);
        System.out.println("请输入一个想生成随机数的最大数");
		int x =sc.nextInt();
		Random ran= new Random();
		int y= ran.nextInt(x)+1;
		System.out.println("生成的随机数是："+y);
        System.out.println("\t");
        System.out.println("--------下面是流程控制语句if--------");
		System.out.println("\t");
/*
if语句的三种表达形式：
-----------------------
 if(表达式){

     执行的任何的语句;
}
------------------------
if(表达式){
   if的执行语句;
}else{
   else的执行语句;
}
-----------------------
if(表达式1){
   语句1;
}else if(表达式2){
语句2;

}else if(表达式3){
语句3;
}...
else{
else语句;
}
----------------------

*/
          System.out.println("--------下面是流程控制语句if1--------");
           int score = 80;
		   if(score >= 80){
			System.out.println("买飞机去");
		}
        System.out.println("--------下面是流程控制语句if2--------");
		int age = 20;
		// if else 语法结构
		if(age >= 18){
			System.out.println("独立");
		}else{
			System.out.println("和妈妈一起住");
		}

        System.out.println("--------下面是流程控制语句if--------");
        System.out.println("键盘输入任意一个整数,需要告知我,这个数是: 正数/负数/0");
		Scanner sc2= new Scanner(System.in);
		System.out.println("请输入一个整数");
		int z = sc2.nextInt();
		if( z < 0){
				System.out.println("负数");

		}else if ( z > 0 ){
			System.out.println("正数");
		}else if( z == 0){
		    System.out.println("0");
		}else{
		    System.out.println("不是数"); 
		}

        System.out.println("\t");
        System.out.println("--------下面是流程控制语句swich case--------");
		System.out.println("\t");
/*
switch case语句的表达形式：
-----------------------
switch...case语法结构:

switch(表达式){
  case 常量1:
  语句1;
  break;
  case 常量2:
语句2;
break;
   ...
 default:
  default语句;
break;
}

----------------------

*/
        //需求: 键盘输入一个整数(1-7),判断这是星期几
		System.out.println("请输入一个代表星期的整数:");
		int xq = sc.nextInt();
        /*
		   switch中的表达式xq与下面的case匹配,匹配成功,执行对应case的内容,
		   匹配不成功,执行default中的内容
		*/
		switch(xq){// xq的类型可以是: byte short char int String 
		   case 1:
			 System.out.println("星期一");  
		     break;//break输入不是必须的,switch case具有穿透性,即如果case 1没有break,如果xq为1.执行结果即为星期一/t星期二
		   case 2:
			 System.out.println("星期二");  
		     break;
		   case 3:
			 System.out.println("星期三");  
		     break;
		   case 4:
			 System.out.println("星期四");  
		     break;
		   case 5:
			 System.out.println("星期五");  
		     break;
		   case 6:
			 System.out.println("星期六");  
		     break;
		   case 7:
			 System.out.println("星期七");  
		     break;
		   default:
			 System.out.println("输入错误");
			 break;
          }

        System.out.println("\t");
        System.out.println("--------下面是循环语句for--------");
		System.out.println("\t");

/*
for语句的表达形式：
-----------------------
for的语法格式:
for( 初始化值(定义变量); 判断语句;  变量值的变化(自增或自减)){
      多次执行的语句;

}

说明: 
1. 初始化值 int i = 0;
2. 判断语句,必须是boolean类型的逻辑,i < 10
3. 变量值的变化i++
for(int i = 0; i < 10;i++){// 功能: 能将0-9的整数打印出来
  System.out.println(i);
}
4. 只要判断语句为true,那么for循环中的语句就会执行
*/
// for 起始值 5 ,判断条件 >=1 , 变化 --
		// for循环内部定义的变量  int i = 5; 只能在循环的大括号中使用
		for(int i = 5 ; i >= 1 ; i --){
		    System.out.println(i);
		}
		// System.out.println("-----------"+i);


        System.out.println("\t");
        System.out.println("--------下面是循环语句while--------");
		System.out.println("\t");
/*
while语句的表达形式：
-----------------------
while循环语法结构:
while(表达式){
   while语句;
}

说明: 
1. 表达式必须是boolean类型
2. 表达式为true,那么执行大括号中的while语句
3. 表达式为false,那么while大括号中的语句不执行,while结束
*/
            int ww = 5;
         while(ww >=1){// 判断条件 ww只要大于等于1,那么while内的逻辑就执行
			System.out.println(ww);
			ww--; 
		}
        System.out.println("\t");
        System.out.println("--------下面是循环语句do  while--------");
		System.out.println("\t");
/*
while语句的表达形式：
-----------------------
do{
  循环执行的语句;
}while(表达式);
*/

      int dd = 0;
        // do...while语句,不管while中的表达式为true或者false,都先执行一次循环
		do
		{
			System.out.println("+++++++++" + dd);
		}
		while ( dd > 6);

        // while判断条件为false,while一次都不执行
		while( dd > 6){
		    System.out.println("----"+dd);
		}
        System.out.println("\t");
        System.out.println("--------下面是嵌套循环语句--------");
		System.out.println("\t");


for(int qq = 1 ; qq <= 5 ; qq++){// 外层循环表示循环次数,一共打印5行星星,因此外层循环5次
       /*
每次打印星星时,星星变化规律从5个依次减少,最后变成1个
怎么由5变到1,让j=qq
*/
       for(int tt = qq ; tt <=5; tt++){
			      System.out.print("*");
			}
			System.out.println();
		}

        System.out.println("\t");
        System.out.println("----写的有点细了，分多个文档吧-----");
        System.out.println("\t");

	}
}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
--------下面是变量定义规则和调用--------
	
今天true 20190607，祝大家端午节快乐！
	
--------下面是数据类型自动强制转换--------
	
byte < short = char < int < long < float < double
	
78本是byte类型因为赋值给int类型f 且byte比小，所以自动转化成int
78
3
	
--------下面是运算符的使用--------
	
a+e=20190685
a-e=20190529
a*e=1574867346
a/e=258853
a%e=73
	
--------下面是自增自减使用--------
	
13
16
19
	
--------下面是赋值运算符--------
	
i=13/i+=2/i=15
	
--------下面是逻辑运算符--------
	
false
true
false
true
true
5------false
3------false
	
--------下面是三元运算符--------
	
买飞机
6
	
----写的有点细了，分多个文档吧-----
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
public class Duanwu3 
{
	public static void main(String[] args) 
	{
		System.out.println("\t");
        System.out.println("--------下面是方法的定义以及调用--------");

/*
方法定义格式:
修饰符 返回值类型 方法名(参数列表){
     功能逻辑;
}

public static void main(String[] args){
   逻辑;
}
*/
		System.out.println("\t");
		int y = duanwu4 (3,4);
		System.out.println("周长是:"+y);
		System.out.println("\t");
        System.out.println("--------下面是方法的定义以及调用--------");		
        System.out.println("\t");
		System.out.println("方法的重载就是相同方法名,但是参数的个数类型和排列顺序不一样");		
		System.out.println("这边我就不演示了");		
	    System.out.println("\t");
        System.out.println("--------下面是数组的定义以及调用--------");		
        System.out.println("\t");
/*
 动态定义
  定义格式: 
  数据类型[]  数组名 = new 数据类型[数组的长度];
  int[]  arr = new int[3];

  数组定义格式分析:
 数据类型 : 当前数组容器中,可以存放什么类型的数据
[] : 表示是一个数组,一维数组
数组名: 名字,符合标识符的规范
new : 新建,给数组在内存中开辟一块空间,用于存储数据
数据类型: 与前面的数据类型保持一致
 [数组长度]: 数组长度必须给出,确定在内存中给数组开辟的空间是多大

  举例: int[]  arr = new int[3];
[I@15db9742 : arr数组变量打印出的结果

*/
// 定义一个int类型的数组,数组的长度为3,动态定义
        int[] arr = new int[3];
		System.out.println(arr);//[I@15db9742


		// 静态的定义
		int[] arr1 = {1,2,4,5,-9,77};
		System.out.println(arr1);//[I@6d06d69c
		System.out.println(arr1[4]);// -9 

		// 动静结合

		int[] arr2 = new int[]{1,2,4,5,-9,77};
		int arrr = arr2[2];
		if(arr2 != null&&arr.length!=0)//解决空指针异常的问题,数组不为空
{
		System.out.println(arrr);//数组索引2指向'4'
		System.out.println(arr2);//[I@7852e922
		System.out.println(arr2[5]);// 77 
}
	  System.out.println("\t");
        System.out.println("--------下面是数组的遍历--------");		
        System.out.println("\t");
	int[] a = new int[3];
        // arr.length= 数组的长度
		/*for( int i = 0 ;i <= a.length-1 ; i ++ ){// 代表数组中索引的起始值 0-- a.length-1

		}*/
        // 数组的遍历
		if( a != null ){
			for( int i = 0 ;i < a.length ; i ++ ){// 代表数组中索引的起始值 0
			// 赋值
			a[i] = 3;
            // 打印数组中元素
		    System.out.println(a[i]);
		    }
		}	
 System.out.println("\t");
        System.out.println("--------下面是数组的最值--------");		
        System.out.println("\t");
	 int[] arrt= new int [] {1,9,6,7,2,12,-9,666} ;
		 int max =0;
		 if(arrt!=null&&arrt.length!=0)
		{
			for (int i=0;i<arrt.length ;i++ )
			{
				if(max<arrt[i])
					max=arrt[i];
			}
		}
		System.out.println(max);//输出666
	}


//方法的定义,在Java中  方法就表示打包好的功能 ,可以在main主函数中调用,简化了main函数
public static int duanwu4(int w, int h){
		int z=(w+h)*2;
		return z;
/*
--返回值类型: 指方法应该是有什么样的结果,返回值类型可以是任意的数据类型,
如果没有返回值,那么写成void(例如main方法,就没有返回值)
--参数列表: 表示,我要做一个功能,需要提供给我哪些数据,写在方法名后的小括号中
            参数可以没有,不写;
--方法的返回: 关键字return ,表示返回,将这个方法的结果,返回到方法的调用者处
	        如果方法有返回值,return 必须写, return后面的数据必须与返回值类型一致;
		    如果方法没有返回值,return 可以省略,可以写(return ;  没意义)
		    方法如果没有返回值,那么在定义上,返回值类型处必须写成void
*/

        
	}
}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
--------下面是变量定义规则和调用--------
	
今天true 20190607，祝大家端午节快乐！
	
--------下面是数据类型自动强制转换--------
	
byte < short = char < int < long < float < double
	
78本是byte类型因为赋值给int类型f 且byte比小，所以自动转化成int
78
3
	
--------下面是运算符的使用--------
	
a+e=20190685
a-e=20190529
a*e=1574867346
a/e=258853
a%e=73
	
--------下面是自增自减使用--------
	
13
16
19
	
--------下面是赋值运算符--------
	
i=13/i+=2/i=15
	
--------下面是逻辑运算符--------
	
false
true
false
true
true
5------false
3------false
	
--------下面是三元运算符--------
	
买飞机
6
	
----写的有点细了，分多个文档吧-----

“端”有开头、初始之意

愿你尽享端午小长假的悠闲轻松

在假日后抖擞精神

再出发!

-------------本文结束感谢您的阅读-------------
0%