Java语言程序设计笔记
- bin目录：存放可执行文件
- lib目录：存放Java的类库文件
- include目录：存放用于本地方法的文件
- demo目录：用于存放演示程序（此目录可自行创建）
- jre：存放Java运行环境文件
解读Hello World文件：
1
2
3
4
5
| public class HelloWorld{
public static void main(String[] args){
System.out.println("hello world");
}
}
|
- class 类
- HelloWorld 类名，自定义
- main 程序入口
- String[] args 字符串数组，命令参数
- static 静态的
- println => print line 打印换行
- java 执行命令
- javac 编译命令
Java程序基本内容：
- 类
- 方法
- 打印语句
- 注释
注释: 提高代码的可读性，程序条理清晰，方便维护和交流
文档注释：/ * * * / @功能 可自行定义
多行注释：以/*开始 以*/结束
单行注释：以//开始
- Java是一种既面向对象又可跨平台的语言（平台无关性）
java源代码->编译(javac)命令->java字节码文件(.class文件)->运行->java虚拟机->windows/Linux/Solaris
变量与数据类型
- 变量：计算机中一块特定的内存空间，由一个或多个连续的字节组成
- 数据类型(8 + 1):
数值
整型: int 32位 short 16位 long 64位 byte 字节型 8位
浮点型： float 32位 double 64位
非数值
boolean 布尔 8位 char 16位无符号整数 String(常用类型，非基本类型，特点双引号)
超过64位：BigInteger或BigDecimal类型
- 声明变量： 数据类型 变量名；
变量名 = 值；
数据类型 变量名 = 值；
- 变量的命名：首字母、其他字母、关键字(不能是关键字)、(字母、下划线、￥)
- %s %d %f 占位符
- 字符串拼接：String str = String.format(“%f”,price);
- 类型转换：
long number = 21474836481;
double num =5 / 2d;
条件：1.两种类型兼容 2.目标类型大于原类型(自动类型)1
2
3
4
5
6
7
8
9
10
11
12
13
14
| double num = 90.0;
int num1 = (int)num;//强制类型转换
int num1 = 5,num2 = 2;
int result1 = num1++;//难点：区分前置和后置
// int result1 = num1;
// num1++;
int result2 = ++num2;
//++num2;
//int result2 = num2;
int num = 9527 / 100;//除10——>去掉个位 去尾
//求模：取余数、
//与10求模，取尾，几个0取几位，最终结果的符号跟第一个操作数一致
|
- ASCII码：32–空格 65
90–AZ 97122–az
- “()”优先级别最高，超脱运算符
单目运算符:!,~,++,–运算符中运算级别最高
- 条件结构:
1.可以省略大括号
2.省略大括号后if结构只能影响到下一行
- 多重if结构:
常用来进行区间判断
- switch结构注意点:
1.switch后的表达式可以是整型、字符型、String型
2.case后常量表达式的值不能相同
3.case后允许许多条语句，不需要大括号
4.如果不添加break语句，需要特别注意执行顺序
5.case和default子句的先后顺序可以自行变动
6.default子句可以省略
- while循环
1
2
3
4
5
| int i = 0 循环变量初始化
while(i < 10){ 循环变量判断
System.out.println("第" + (i + 1) + "遍");
i++; 循环变量更新
}
|
1.循环变量的初值
2.循环变量的判断
3.循环变量的更新
循环的特点：
先判断，再执行
循环控制中，不要使用浮点型来比较数值是否相等
- 随机数生成
1.随机类 1
2
| Random rand = new Random();
int attack1 = rand.nextInt(start - end + 1) + start;
|
1
| int attack2 = (int)(System.currentTimemillis()%(start - end + 1) + start);
|
1
| int attack3 = ((int)(Math.random() * 1000)) % (start - end + 1) + start;
|
- 随机数数字公式(a - b)范围:
1
| ((int)(Math.random() * 1000)) % (b - a + 1) + a;
|
- 播放音乐代码
1
2
3
4
5
6
| File sound1 = new File("sounds / 。。。。.wav");
AudioClip sound_choose = Applet.newAudioClip(sound1.touRL());
sound_choose.play(); //播放音乐
System.out.println("请输入任意键继续:");
input.nextLine();
Thread.sleep(3000); //延迟300毫秒(3秒);延迟音乐时间
|
- do-while循环
特点：先判断，再执行 注意死循环
- Debug调试
1.设置断点
2.开启调试/单步调试
3.观察变量的变化1
2
3
4
5
6
7
8
9
| for 循环
for(表达式1(循环变量赋初值);表达式2(循环条件判断);表达式3(更新循环变量))
{ //循环三要素
语句;
}
死循环for(; ;)
一个for循环执行完，循环变量被回收(或者销毁)
|
continue语句1
2
3
4
5
6
7
8
| while(循环条件)<- { do{ for(;循环条件;变量更新)<- {
..... | ..... ..... |
..... | ..... ..... |
..... | ..... ..... |
continue;--- continue;-------- continue;-----------
..... ..... | .....
..... ..... | .....
} }while(循环条件);<- }
|
- break和continue对比：
break可用于switch结构和循环结构中
continue只能用于循环结构中
作用：
break语句终止某个循环，程序跳转到循环块外的下一条语句。
continue跳出本次循环，进入下一个循环
数组
一维数组的定义
1
2
| datatype[] arrayName = new datatype[ size ];
数据类型 数组名 数组大小
|
数组名就是新分配内存空间的首地址
- 初始化一维数组
声明并初始化数组是不需要指定数组的大小； 1
| int days[] = {1,15}; // int[] days = {1,15};
|
2.基本数据类型数组的默认值为0
3.char型数组元素默认值为\u0000
4.布尔类型数组的默认值是false
- 动态赋值及访问数组元素
1
| scores[i] = input.nextDouble;//加循环录入
|
- 冒泡排序
1.一共会比较数组元素个数-1轮
2.每一轮比较的次数比上一轮少1
3.如果前面的数字大于/小于后面的一个数字，那么交换
- 选择排序
每次循环交换i和minIndex的值
- 快速排序
1
2
| Arrays.sort(nums);
Collections.reverse(list); 逆序排序
|
- 二分查找法
使用前提:数组按升序排序
- 数组的删除
1.找到要删除的元素的下标delIndex
2.从要删除的下标开始，后面的元素赋值给前面一个元素—–覆盖
3.数组的总长度-1
- 数组的插入
1.找到要插入元素的位置下标
2.从最后一个元素开始，前面一个元素赋值给后面一个元素
3.总个数+1
二维数组
1
2
3
4
5
6
7
8
9
| int[][] animates;
animates = new int[4][4];
double[][] scores = new double[5][3];//5可以省略，3不能省，行可以省略，列不能省
时间获取
Calendar cal = Calendar.getInstance(); //日历类
cal.get(Calendar.YEAR), //年
cal.get(Calendar.MONTH) + 1, //月
cal.get(Calendar.DATE), //日
currDay //天
|
使用方法实现月历的打印
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
| import java.util.Scanner;
public class printCalendar {
public static int year = Integer.MIN_VALUE;
public static int month = Integer.MIN_VALUE;
private static int[] dayOfMonth = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
public static void main(String[] args) {
PrintCalendar();
}
private static void PrintCalendar() {
InputYearAndMonth();
int sum = getSumDayOfYears();
sum += getSumDayOfMonth();
sum++;
System.out.println(sum % 7);
PrintMonthTitlre();
PrintCalendarContent(sum % 7);
}
private static void PrintCalendarContent(int dayOfWeek) {
int sepCount = dayOfWeek - 1;
if(dayOfWeek == 0) {
sepCount = 6;
}else {
sepCount = dayOfWeek - 1;
}
for (int i = 0; i < dayOfWeek - 1; i++) {
System.out.print("\t");
}
for(int i = 0; i < dayOfMonth[month - 1]; i++) {
System.out.print(i + 1);
if((dayOfWeek + i) % 7 == 0){
System.out.println();
}else{
System.out.print("\t");
}
}
}
private static void PrintMonthTitlre() {
String[] monthNames = {"一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月",
"九月", "十月", "十一月", "十二月"};
System.out.println("\t\t" + year + '\t' + monthNames[month - 1]);
String[] weekdays = {"月曜日", "火曜日", "水曜日", "木曜日", "金曜日", "土曜日", "日曜日"};
for (int i = 0; i < weekdays.length; i++) {
System.out.print(weekdays[i] + "\t");
}
System.out.println();
}
private static int getSumDayOfYears() {
if(year == Integer.MIN_VALUE) {
System.out.println("年份错误！请重新输入年份和月份！");
InputYearAndMonth();
}
int sum = 0;
for(int i = 1900; i < year; i++) {
sum += 365;
if(isLeapYear(i)) {
sum++;
}
}
return sum;
}
private static int getSumDayOfMonth() {
int sum = 0;
for(int i = 0; i < month - 1; i++) {
sum += dayOfMonth[i];
}
if(isLeapYear(year) && month >= 3) {
sum++;
}
return sum;
}
private static boolean isLeapYear(int year) {
return year % 400 == 0 || year % 4 == 0 && year % 100 != 0;
}
private static void InputYearAndMonth() {
Scanner input = new Scanner(System.in);
System.out.print("请输入年份：");
year = input.nextInt();
System.out.print("请输入月份：");
month = input.nextInt();
input.close();
input = null;
}
}
|
使用方法将星期转化为文字输出
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
| import java.util.Scanner;
public class WeekDayDemo {
public static void main(String[] args) {
System.out.print("请输入今天是星期几：");
int dayOfWeek = new Scanner(System.in).nextInt();
ShowWeekDayByChinese(dayOfWeek - 1);
ShowWeekDayByJpanese(dayOfWeek - 1);
ShowWeekDayByEnglish(dayOfWeek - 1);
}
private static boolean isWeekValidate(int dayOfWeek){
if(dayOfWeek < 1 || dayOfWeek > 7) {
System.out.println("必须输入1-7之间的数字");
return false;
}
return true;
}
public static void ShowWeekDayByChinese(int dayOfWeek) {
if(!isWeekValidate(dayOfWeek)) {
System.out.println("必须输入1-7之间的数字");
return;
}
String[] weekdays = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
System.out.println(weekdays[dayOfWeek]);
}
static void ShowWeekDayByJpanese(int dayOfWeek) {
if(!isWeekValidate(dayOfWeek)) {
System.out.println("必须输入1-7之间的数字");
return;
}
String[] weekdays = {"月曜日", "火曜日", "水曜日", "木曜日", "金曜日", "土曜日", "日曜日"};
System.out.println(weekdays[dayOfWeek]);
}
static void ShowWeekDayByEnglish(int dayOfWeek) {
if(!isWeekValidate(dayOfWeek)) {
System.out.println("必须输入1-7之间的数字");
return;
}
String[] weekdays = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"};
System.out.println(weekdays[dayOfWeek]);
}
}
|
用户注册
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| import java.util.Scanner;
public class UserMain {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入密码：");
String password = input.next();
System.out.println(StringUtil.validatePassword(password));
}
}
|
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
| package javabase.chapter9.userdemo;
import java.util.Scanner;
public class User {
private String userName;
private String password;
private String email;
public User(String userName, String password, String email) {
setUserName(userName);
setPassword(password);
setEmail(email);
}
public User() {
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
class StringUtil{
public static boolean isCorrectUserName(String userName) {
boolean isCorrect = true;
if(userName ==null) return false;
if(userName.length() > 25) return false;
char[] unValidChar = {' ', '\'', '"', '?', '<', '>', ','};
for(char ch :unValidChar) {
if(userName.contains(Character.toString(ch))) {
isCorrect = false;
break;
}
}
return isCorrect;
}
public static String validatePassword(String password) {
String power = "";
if(password == null) return power;
if(password.length() < 6 || password.length() > 18) return power;
String part = "_@#$!";
for (int i = 0; i < password.length(); i++) {
if(!Character.isLetterOrDigit(password.charAt(i))) {
if(!part.contains(Character.toString(password.charAt(i)))){
return power;
}
}
}
if(isDigit(password) || isLetter(password)) {
power = "**";
}else if(isDigitAndLetter(password)) {
power = "****";
}else if(isContainsSymble(password)) {
power = "*****";
}
return power;
}
private static boolean isDigitAndLetterAndSymble(String value) {
for (int i = 0; i < value.length(); i++) {
if(!(Character.isDigit(value.charAt(i)) ||
Character.isLetter(value.charAt(i)) ||
"_@#$!".contains(Character.toString(value.charAt(i))))) {
return false;
}
}
return true;
}
private static boolean isDigitAndLetter(String value) {
for (int i = 0; i < value.length(); i++) {
if(!Character.isLetterOrDigit(value.charAt(i))) {
return false;
}
}
return true;
}
private static boolean isDigit(String value) {
for (int i = 0; i < value.length(); i++) {
if(!Character.isDigit(value.charAt(i))) {
return false;
}
}
return true;
}
private static boolean isLetter(String value) {
for (int i = 0; i < value.length(); i++) {
if(!Character.isLetter(value.charAt(i))) {
return false;
}
}
return true;
}
private static boolean isContainsSymble(String value) {
String part = "_@#$!";
for (int i = 0; i < value.length(); i++) {
if(part.contains(Character.toString(value.charAt(i)))) {
return true;
}
}
return false;
}
}
|
