Java学习笔记
目录
一、前期准备
计算机包括两部分
- 硬件：鼠标、键盘、显示器、主机箱内部的CPU、内存条、硬盘等
注意：计算机只有硬件是无法工作的，需要软件驱动硬件才能工作。
- 软件：系统软件和应用软件
- 系统软件：直接和硬件交互的软件，例如：windows、win8、Linux系统
- 应用软件：应用软件通常运行在系统软件中，例如：QQ
我们通常所说的软件开发是指应用软件开发。
（一）cmd
1、打开cmd
- 01 win+R
- 02 输入cmd
- 03 按下回车键或者点击确定
2、常见cmd命令
- 盘符名称+冒号
- 说明：盘符切换
- 举例：D:回车，表示切换到D盘
- dir
- 说明：查看当前路径下的内容
- cd 目录
- 说明：进入单极目录
- 举例：cd Downloads
注：路径包括绝对路径和相对路径
绝对路径：表示该路径从某个磁盘的盘符下作为出发点的路径
相对路径：表示该路径从当前所在的路径下作 为出发点的路径
- cd..
- 说明：回退到上一级目录
- cd 目录1\目录2\……
- 说明：进入多极目录
- 举例：cd Desktop\crmui
- cd \
- 说明：回退到盘符目录
- cls
- 说明：清屏
- exit
- 说明：退出命令提示符窗口
打开指定的文件夹，在路径栏里输入“cmd”，回车，就进入控制台了。默认路径就是指定文件夹的路径。
（二）环境变量
想要在任意目录下都可以打开指定的软件，可以把软件的路径配置到环境变量中
步骤：右键此电脑→点击属性→点击关于→打开高级系统设置→点击环境变量
（三）JDK
安装路径中不要有中文和空格
所有开发工具最好安装目录统一
1、安装目录：
- bin：该路径下存放了各种工具命令。其中比较重要的有：javac和java
- conf：该路径下存放了相关配置文件
- include：该路径下存放了一些平台特定的头文件
- jmods：该路径下存放了各种模块
- legal：该路径下存放了各模块的授权文档
- lib：该路径下存放了工具的一些补充jar包
（四）配置环境变量
（五）Java的加载与执行
Java程序的运行包括编译阶段和运行阶段
编译阶段主要的任务是检查Java源程序是否符合Java语法，符合java语法则能够生成正常的字节码文件（xxx.class）
javac 路径（绝对路径或相对路径）
java 类名
（六）java三大使用平台
- JavaSE
Java语言的标准版，用于桌面应用的开发，是其他两个版本的基础
桌面应用：用户只要打开程序，程序的界面会让用户在最短的时间内找到他们需要的功能，同时主动带领用户完成他们的工作并得到最好的体验。例如：计算器，坦克大战 - JavaME
Java语言的小型版，用于嵌入式电子设备或者小型移动设备 - JavaEE
Java语言的企业版，用于web方向的网站开发
（七）java的主要特性
- 面向对象
- 安全性
- 多线程
- 简单易用
- 开源
- 跨平台（一次编译，到处运行）
（八）高级语言的编译运行方式
- 编程：java程序员写的是.java代码，c程序员写的是.c代码，python程序员写的是.py代码
- 编译：机器只认识0、1的机器语言，编译是把.java、.c、.py的代码转化让机器认识的过程
- 运行：让机器执行编译后的指令
（九）JRE和JDK
JVM（Java Virtual Machine）：java虚拟机，真正运行java程序的地方
JDK（Java Development kit）：Java开发工具包
JDK=JVM+核心类库（java已经写好的，可以直接用）+开发工具（javac编译工具、java运行工具、jdb调试工具、jhat内存分析工具……）
JRE（Java Runtime Environment）：java的运行环境
JRE=JVM+核心类库+运行工具
二、java基础语法
（一）注释
- 单行注释
//注释信息 - 多行注释
/*注释信息*/ - 文档注释
/** *注释信息 */
注释内容不会参与编译和运行，仅仅是对代码的解释说明
（二）关键字
被java赋予特定含义的英文单词
- 关键字的字母全部小写
- 常用的代码编辑器，针对关键字有特殊的颜色标记
class：用于创建/定义一个类，后面跟随类名，类是Java最基本的组成单元
（三）字面量
告诉程序员数据在程序中的书写格式
字面量的分类
| 字面量类型 | 说明 |
| 整数类型 | 不带小数点的数字 |
| 小数类型 | 带小数点的数字 |
| 字符串类型 | 用双引号括起来的内容 |
| 字符类型 | 用单引号括起来的，内容只有一个 |
| 布尔类型 | 布尔值表示真假，只有两个值：true，false |
| 空类型 | 空值，值是：null |
null不能直接打印，要打印null，只能通过字符串的形式进行打印
特殊字符
- 转义字符 \
转义字符出现在特殊字符之前，会将特殊字符转换成普通字符
- \n 换行符
- \t 制表符
在打印时，把前面字符串的长度补齐到8或者8的整数倍。最少补一个空格，最多补8个空格
（四）变量
在程序执行过程中，其值可能发生改变的量
变量的定义格式：
数据类型 变量名 = 数据值;
等号：赋值，把右边的数据赋值给左边的变量
变量的注意事项：
- 变量只能存一个值
- 变量名不允许重复定义
- 一条语句可以定义多个变量
int a = 10, b = 2, c = 1; - 变量使用前一定要进行赋值
- 变量的适用范围
变量分类：
- 局部变量：在方法体中声明的变量
- 成员变量：在方法体外【类体之内】声明的变量
成员变量没有手动赋值系统会默认赋值(局部变量不会)
（五）计算机的存储规则
在计算机中，任意数据都是以二进制的形式来存储的
1、文本数据：
数字——转二进制
字母——查询码表
汉字——查询码表
常见的进制：
- 二进制：由0和1组成，代码中以0b开头
- 八进制：由0~7组成，代码中以0开头
- 十进制：由0~9组成，前面不加任何前缀
- 十六进制：由09和af组成，代码中以0x开头
任意进制转十进制
公式：系数*技术的权次幂相加
系数：每一位上的数
基数：当前进制数
权：从右往左，依次为0,1,2,3,4……
十进制转其他进制
除基取余法
不断的除以基数得到余数，直到商为0，再将余数倒着拼接
计算机最初只支持英文，最先出现的字符编码是：ASCII码
'a' --> 97 [01100001]
'A' --> 65
'0' --> 48
GB2312编码：1981年5月1日发表的简体中文汉字编码国家标准。收录7445个图形文字，其中包括6763个汉字
BIG5编码：台湾地区繁体中文标准字符集，共收录13053个中文字，1984年实施
GBK编码：2000年3月17日发布，收录21003个汉字，包含国家标准GB13000-1中的全部中日韩汉字，和BIG5编码中的所有汉字
Unicode编码：国际标准字符集，她将世界各种语言的每个字符定义一个唯一的编码，以满足跨语言、跨平台的文本信息转换
反斜杠u后面的一串数字是某文字的unicode编码
通过native2ascii查看unicode编码
2、图片数据：
- 黑白图
- 灰度图（用0~255表示灰度数据）
- 彩色图（光学三原色：红、绿、蓝，可称为RGB）
3、声音数据
（六）数据类型
作用：指导JVM在运行程序的时候给该数据分配多大的内存空间。
1、基本数据类型
| 数据类型 | 关键词 | 取值范围 | 内存占用 |
| 整数 | byte | -128~127 | 1 |
| short | -32768~32767 | 2 | |
| int（默认） | -2147483648~2147483647 | 4 | |
| long | -263~263-1 | 8 | |
| 浮点数 | float | 4 | |
| double（默认） | 8 | ||
| 字符 | char | 0~65535 | 2 |
| 布尔 | boolean | true, false | 1 |
整数和小数取值范围大小关系：
double>float>long>int>short>byte
如果要定义long类型的变量，在数据值后面需要加一个L作为后缀，可以大写，也可以小写，建议大写
定义float类型变量时，数据值也需要加一个F作为后缀
八种数据类型的默认值是一切向0看齐
2、引用数据类型：类，接口，数组，字符串……
字符串使用"",字符使用''
（七）标识符
在java源程序当中凡是程序员有权利自己命名的单词都是标识符
包括：类名；方法名；变量名；接口名；常量名等
1、标识符的命名规则（必须遵守）
- 只能由"数字，字母，下划线_，美元符号$"组成，不能含有其他符号，
- 不能用数字开头
- 严格区分大小写
- 关键字不能做标识符
- 理论上无上限，但最好不要太长
2、标识符的命名规范
- 最好见名知意 例：username
- 遵守驼峰命名方式 例：UserService
- 类名、接口名：首字母大写，后面每个单词首字母大写。
- 变量名、方法名：首字母小写，后面每个单词首字母大写。
- 常量名：全部大写
（七）键盘录入
- 步骤一：导包
import java.util.Scanner; //导包的动作必须出现在类定义的上边
- 步骤二：创建对象
Scanner sc = new Scanner(System.in); //只有sc是变量名，可以变
- 步骤三：接收数据
int i = sc.nextInt(); //只有i是变量名
System.out.println(); 负责向控制台输出【从内存到控制台，输出的过程，这是从内存中出来了】
System.out.println()和System.out.print()的区别：
println输出之后换行，print表示输出，但是不换行
另一种方法：
- 第一步：创建键盘扫描对象
java.util.Scanner s = new java.util.Scanner(System.in);
- 第二步：调用Scanner对象的next()方法开始接收用户键盘输入
程序执行到这里会停下来，等待用户的输入
当用户输入，并且最终敲回车的时候，输入的信息会自动赋值给userInputContent
接收文本【以字符串的形式接收】
String userInputContent = s.next();
接收数字【以整数型int的形式来接收】
int num = s.nextInt();
（八）IDEA
IDEA项目结构介绍
- project 项目
- module 模块
- package 包
- class 类、
快速生成main方法：psvm+回车
输出语句：sout+回车
IDEA的项目和模块操作
IDEA中类相关操作：
- 新建类
- 删除类
- 修改类名
IDEA中模块相关操作：
- 新建模块
- 删除模块
- 修改模块
- 导入模块
IDEA中项目相关操作：
- 关闭项目
- 新建项目
- 打开项目
- 修改项目
三、运算符
（一）算术运算符
| 符号 | 作用 |
| + | 求和 |
| - | 求差 |
| * | 乘积 |
| / | 商 |
| % | 取模、取余 |
在代码中，整数参与计算，结果只能得到整数。如果有小数参与计算，结果有可能不精确
练习：
键盘录入一个三位数，将其个位、十位、百位分别打印
package com.test; import java.util.Scanner; public class test1 { public static void main(String[] args) { //键盘录入一个三位数，将其个位、十位、百位分别打印 //键盘录入 Scanner sc = new Scanner(System.in); System.out.println("请输入一个三位数："); int number = sc.nextInt(); int ge = number%10;//个位 int shi = number/10%10;//十位 int bai = number/100;//百位 System.out.println("个位数字为"+ge); System.out.println("十位数字为"+shi); System.out.println("百位数字为"+bai); } }
"+"操作的三种情况：
- 数字相加
数字进行运算时，数据类型不一样不能运算，需要转成一样的，才能运算- 隐式转换（自动类型提升）
取值范围小的→取值范围大的 - 强制转换
取值范围大的→取值范围小的
- 隐式转换（自动类型提升）
转换规则：
1，除布尔类型外其他7中类型之间都可以相互转换
2，小容量向大容量转换，称为自动类型转换
byte < short(char) < int < long < float < double
注：任何浮点类型不管占用多少字节，都比整数型容量大。
char和short可表示的种类数量相同，但是char可以取更大的正整数。
3，大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，但可能会损失精度。
格式：目标数据类型 变量名 = (目标数据类型)被强制的数据;
4，当整数字面值没有超出byte,short,char的取值范围，可以直接赋值给byte,short,char类型的变量。
5，byte,short,char运算的时候，都先转换成int类型再进行运算。
6，多种数据类型混合运算，先转换成容量最大的那种类型再做运算。
- 字符串相加
当"+"操作中出现字符串时，这个"+"是字符串连接符，而不是算术运算符了。会将前后的数据进行拼接，并产生一个新的字符串 - 字符相加
当字符+字符或字符+数字时，会把字符通过ASCII码表查询到对应的数字再进行计算
（二）自增自减运算符
| 符号 | 作用 | 说明 |
| ++ | 加 | 变量的值加1 |
| - | 减 | 变量的值减1 |
++和--即可以放在变量的前边，也可以放在变量的后面
用法：
单独使用：++和--无论是放在变量前边还是后边，单独写一行结果是一样的
参与计算：
当++或--在后时，先用后加减
当++或--在前时，先加减再用
（三）赋值运算符
| 符号 | 作用 | 说明 |
| = | 赋值 | int a = 1，将1赋值给变量a |
| += | 加后赋值 | a+=b，将a+b的值给a |
| -= | 减后赋值 | a-=b，将a-b的值给a |
| *= | 乘后赋值 | a*=b，将a × b的积给a |
| /= | 除后赋值 | a/=b，将a ÷ b的商给a |
| %= | 取余后赋值 | a%=b，将a ÷ b的余数给a |
+=、-=、*=、/=底层都隐藏了一个强制类型转换
（四）关系运算符（比较运算符）
| 符号 | 说明 |
| == | a == b，判断a和b的值是否相等，成立为true，不成立为false |
| != | a != b，判断a和b的值是否不相等，成立为true，不成立为false |
| > | a > b，判断a是否大于b，成立为true，不成立为false |
| >= | a >= b，判断a是否大于等于b，成立为true，不成立为false |
| < | a < b，判断a是否小于b，成立为true，不成立为false |
| <= | a <= b，判断a是否小于等于b，成立为true，不成立为false |
关系运算符的结果都是boolean类型，要么是true，要么是false
练习：
你和你的约会对象在餐厅里面正在约会。
键盘录入两个整数，表示你和你约会对象衣服的时髦度。（手动录入0~10之间的整数，不能录其他）
如果你的时髦度大于你对象的时髦度，相亲就成功，输出true，否则输出false
package com.test; import java.util.Scanner; public class test2 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入您的时髦度："); int number1 = scanner.nextInt(); System.out.println("请输入对方的时髦度："); int number2 = scanner.nextInt(); boolean result = number1 > number2; System.out.println(result); } }
（五）逻辑运算符
| 符号 | 作用 | 说明 |
| & | 逻辑与（且） | 并且，两边都为真，结果才是真 |
| | | 逻辑或 | 或者，两边都为假，结果才是假 |
| ^ | 逻辑异或 | 相同为false，不同为true |
| ! | 逻辑非 | 取反 |
短路逻辑运算符
| 符号 | 作用 | 说明 |
| && | 短路与 | 结果和&相同，但是有短路效果 |
| || | 短路或 | 结果和|相同，但是有短路效果 |
&、|，无论左边true，false，右边都要执行
&&、||，如果左边能确定整个表达式的结果，则右边不执行
（六）三元运算符
格式：关系表达式?表达式1:表达式2;
计算规则：
- 首先计算关系表达式的值
- 如果值为true，运算结果就是表达式1的值
- 如果值为false，运算结果就是表达式2的值
练习：
判断两只老虎体重是否相同
public class test3 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入第一只老虎的体重："); int weight1 = scanner.nextInt(); System.out.println("请输入第二只老虎的体重："); int weight2 = scanner.nextInt(); String result = weight1==weight2?"相同":"不同"; System.out.println(result); } }
（七）其他运算符
| 运算符 | 含义 | 运算规则 |
| & | 逻辑与 | 0为false 1为true |
| | | 逻辑或 | 0为false 1为true |
| << | 左移 | 向左移动，低位补0 |
| >> | 右移 | 向右移动，高位补0或1 |
| >>> | 无符号右移移 | 向右移动，高位补0 |
四、原码、反码、补码
（一）原码
十进制数据的二进制表现形式，最左边是符号位，0为正，1为负
弊端：利用原码进行计算的时候，如果是正数完全没有问题，但如果是负数计算，结果就出错，实际运算的方向跟正确的运算方向是相反的
（二）反码
正数的反码是其本身，负数的反码是符号位保持不变，其余位取反
弊端：负数运算的时候，如果结果不跨0，是没有任何问题的，但是如果结果跨0，跟实际结果会有1的偏差
（三）补码
正数的补码是其本身，负数的补码是在其反码的基础上+1
计算机中的存储和计算都是以补码的形式进行的
字节{byte}：
1 byte = 8 bit 【1个字节 = 8个比特位】1个比特位表示一个二进制位：1/0
1 KB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
五、判断与循环
（一）流程控制语句
1、顺序结构
默认的执行流程，按照代码的先后顺序，从上到下依次执行
2、分支结构（选择结构）
if，if...else，switch
if语句又被称为分支语句/条件控制语句：
- 1,if语句的语法结构：
第一种：
if(布尔表达式){ java语句 ... }
第二种：
if(布尔表达式){ java语句 ... }else{ java语句 ... }
第三种：
if(布尔表达式){ java语句 ... }else if(布尔表达式){ java语句 ... }...
第四种：
if(布尔表达式){ java语句 ... }else if(布尔表达式){ java语句 ... }...else{ java语句 ... }
- 2、对于java中的if语句来说，只要有一个分支执行，整个if语句全部结束
- 3、可以嵌套使用
switch语句：
语法结构：
switch(int或String类型的字面值或变量){
case int或String类型的字面值或变量:
java语句;
...
break;
case int或String类型的字面值或变量:
java语句;
...
break;
...
default:
java语句;
...
}
switch语句执行原理：
switch后面的小括号当中的“数据”和case后面的“数据”进行一一匹配，匹配成功的分支执行。
按照自上而下的顺序依次匹配。
匹配成功的分支执行，分支当中最后有“break”语句的话，整个switch语句终止。
匹配成功的分支执行，分支当中没有“break”语句的话，直接进入下一个分支执行（不进行匹配），
这种现象被称为case穿透现象。【提供break；语句可以避免穿透】
所有分支都没有匹配成功，当有default的语句，会执行default分支当中的程序。
switch和case后面只能是int或String类型的数据。
byte,short,char也可以直接写到switch和case后面，因为它们可以自动类型转换，转换为int类型。
case可以合并。
3、循环结构
1、for循环的语法结构：
for(初始表达式;布尔表达式;更新表达式){
需要重复执行的代码片段【循环体：由Java语句构成】
}
注：初始表达式，布尔表达式，更新表达式都不是必须的，但是两个分号是必须的
需求：
键盘输入两个数，表示一个区间，在该区间内求有多少个被3整除同时被5整除的数
public class test4 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int number1 = scanner.nextInt();
System.out.println("请输入第二个数字：");
int number2 = scanner.nextInt();
int count = 0;
for(int i = ((number1<number2)?number1:number2); i <= ((number1<number2)?number2:number1); i++){
if (i%3==0 && i%5==0){
count += 1;
}
}
System.out.println(number1+"与"+number2+"之间有"+count+"个");
}
}
2、while循环的语法结构：
while(布尔表达式){
循环体;
}
注：循环体可以不执行。
需求：判断是否为回文数
public class test5 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个整数：");
int number = scanner.nextInt();
int temp = number;
int num = 0;
while (temp != 0){
int x = temp % 10;
temp = temp / 10;
num = num*10+x;
}
System.out.println(num == number);
}
}
需求：求商和余数，不使用/与%
public class test6 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入被除数：");
int x = scanner.nextInt();
System.out.println("请输入除数：");
int y = scanner.nextInt();
int temp = x;
int count = 0;
while(x-y>=0){
x=x-y;
count++;
}
System.out.println(temp+"与"+y+"的商为："+count+"，余数为："+x);
}
}
3、do...while循环的语法结构：
do{
循环体;
}while(布尔表达式);
注：循环体至少执行1次。
无限循环
for(;;){
System.out.println("无限循环");
}
while(true){
System.out.println("无限循环");
}
do{
System.out.println("无限循环");
}while(true)
跳转控制语句
continue：结束本次循环，继续下次循环
break：结束整个循环
需求：打印1到100之间满足逢七过的数据
public class test7 {
public static void main(String[] args) {
for(int i=1;i<=100;i++){
if(i%7==0 || i%10==7 || i/10==7){
System.out.println("过");
continue;
}
System.out.println(i);
}
}
}
需求：求x的平方根，只保留整数部分
public class test8 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个整数：");
int number = scanner.nextInt();
int i=1;
while (i*i<number){
if((i+1)*(i+1)>number)break;
i++;
}
System.out.println(i);
}
}
public class test8 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个整数：");
int number = scanner.nextInt();
for(int i=1;i<=number;i++){
if(i*i==number){
System.out.println(i+"就是"+number+"的平方根");
break;
} else if (i*i>number) {
System.out.println((i-1)+"是"+number+"平方根的整数部分");
break;
}
}
}
}
需求：判断一个数是否为质数
public class test9 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个正整数：");
int number = scanner.nextInt();
boolean flag = true;
if(number == 1) flag = false;
// Math.sqrt()表示平方根
for (int i=2;i<=Math.sqrt(number);i++){
if(number % i == 0){
flag = false;
break;
}
}
if(flag){
System.out.println(number+"是质数");
}else{
System.out.println(number+"不是质数");
}
}
}
获取随机数
1、导包：import java.util.Random;
2、创建对象：Random r = new Random();
3、生成随机数：int number = r.nextInt(随机数的范围);
取值范围从0到n-1
需求：猜数字
public class test10 {
public static void main(String[] args) {
Random random = new Random();
//数字范围为1-100
int number1 = random.nextInt(100)+1;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入所猜数字：");
int number2 = scanner.nextInt();
while (number2 != number1){
if(number2 > number1){
System.out.println("猜大了");
}else if (number2 < number1){
System.out.println("猜小了");
}
System.out.println("请输入所猜数字：");
number2 = scanner.nextInt();
}
if (number2 == number1) System.out.println("猜对了");
}
}
public class test10 {
public static void main(String[] args) {
Random random = new Random();
//数字范围为1-100
int number1 = random.nextInt(100)+1;
while (true){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入所猜数字：");
int number2 = scanner.nextInt();
if(number2 > number1){
System.out.println("猜大了");
}else if (number2 < number1){
System.out.println("猜小了");
}else{
System.out.println("猜对了");
break;
}
}
}
}
需求：猜数字，猜错5次后失败
public class test10 {
public static void main(String[] args) {
Random random = new Random();
//数字范围为1-100
int number1 = random.nextInt(100)+1;
int count = 0;
while (true){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入所猜数字：");
int number2 = scanner.nextInt();
if(number2 > number1){
System.out.println("猜大了");
}else if (number2 < number1){
System.out.println("猜小了");
}else{
System.out.println("猜对了");
break;
}
count++;
if(count == 5){
System.out.println("失败");
break;
}
}
}
}
六、数组
存储同种数据类型的多个值（隐式转换）
（一）数组定义
格式一：数组类型 [] 数组名 eg：int [] array
格式二：数组类型 数组名[] eg：int array[]
（二）数组初始化
1、静态初始化
完整格式：
数据类型[] 数据名 = new 数据类型[]{元素1, 元素2, 元素3...};
eg: int[] array = new int[]{1,2,3};
简化格式：
数据类型[] 数据名 = {元素1, 元素2, 元素3...};
eg: double[] array = {1.0,2,3.1};
创建完毕后长度不会变
打印时打印的是地址值
2、动态初始化
初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 数组名 = new 数据类型[数组长度];
默认初始化规律：
整数数据类型：默认初始化值0
小数类型：默认初始化值0.0
字符类型：默认初始化值'\u0000' 空格
布尔类型：默认初始化值false
引用数据类型：默认初始化值null
（三）数组元素访问
格式：数组名[索引];
索引：也叫下标，角标，从0开始，逐个+1增长，连续不间断
把数据存储到数组当中
格式：数组名[索引] = 具体数据/变量
一旦覆盖后，原来的数据就不存在了
（四）数组遍历
将数组中所有的内容取出来，打印、求和、判断...
数组长度属性：数组名.length
idea中快速生成数组遍历：数组名.fori
需求：遍历数组并求和
public class test11 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum += array[i];
}
System.out.println(sum);
}
}
需求：统计数组中能被3整除的个数
public class test12 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6,7,8,9,10};
int count = 0;
for (int i = 0; i < array.length; i++) {
if(array[i] % 3 == 0)count++;
}
System.out.println(count);
}
}
需求：遍历数组，如果是奇数，则将当前数字扩大两倍；如果是偶数，则将当前数字变为原来的二分之一
public class test13 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6,7,8,9,10};
for (int i = 0; i < array.length; i++) {
if(array[i] % 2 == 1){
array[i] = array[i]*2;
}else array[i] = array[i]/2;
System.out.print(array[i]+" ");
}
}
}
（五）数组常见操作
1、求最值
public class test14 {
public static void main(String[] args) {
int[] array = {6,29,36,26,83,37};
int max = array[0];
for (int i = 1; i < array.length; i++) {
if(array[i] > max)max = array[i];
}
System.out.println(max);
}
}
2、求和
需求：生成10个1-100之间的随机数存入数组
（1）求出所有数据的和
（2）求所有数据的平均数
（3）统计有多少个数据比平均值小
public class test15 {
public static void main(String[] args) {
Random random = new Random();
int[] array = new int[10];
int sum = 0;
int avg = 0;
int count = 0;
for (int i = 0; i < array.length; i++) {
int number = random.nextInt(100)+1;
array[i] = number;
sum += array[i];
}
avg = sum/ array.length;
System.out.print("数组为：");
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
if(avg > array[i])count++;
}
System.out.println();
System.out.println("数组中数据和为："+sum+"，平均数为："+avg+"，共有"+count+"个数据小于平均数");
}
}
3、交换数据
需求：将数组中数据首尾对调
public class test16 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
int temp = array[0];
array[0] = array[4];
array[4] = temp;
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
}
}
需求：将数组中数据进行倒序
public class test16 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6,7,8};
int length = array.length;
for (int i = 0; i <= array.length/2; i++) {
int temp = array[length-i-1];
array[length-i-1] = array[i];
array[i] = temp;
}
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
}
}
public class test16 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6,7};
for (int i = 0,j = array.length-1; i < j; i++,j--) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
}
}
4、打乱数据
需求：打乱数组中所有数据的顺序
public class test17 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
Random random = new Random();
for (int i = 0; i < array.length; i++) {
int randomIndex = random.nextInt(array.length);
int temp = array[i];
array[i] = array[randomIndex];
array[randomIndex] = temp;
}
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
}
}
七、java内存分配
- 栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行
- 堆：存储对象或者数组，new来创建的，都存储在堆内存
- 方法区：存储可以运行的class文件
- 本地方法栈：JVM在使用操作系统功能的时候使用，和开发无关
- 寄存器：给CPU使用，和开发无关
八、方法
方法(method)是程序中最小的执行单元。
重复的代码、具有独立功能的代码可以抽取到方法中。
方法的好处：
- 可以提高代码的复用性
- 可以提高代码的可维护性
（一）方法的格式
把一些代码打包在一起，该过程称为方法定义。
1、最简单的方法定义
public static void 方法名(){ 方法体; }
需求：求和
public class test18 {
public static void main(String[] args) {
sum();
}
public static void sum(){
int a = 1;
int b = 2;
System.out.println(a+b);
}
}
2、带参数的方法定义
单个参数
public static void 方法名(参数){……}
调用
方法名(参数);
多个参数
public static void 方法名(参数1, 参数2, ……){……}
调用
方法名(参数1, 参数2, ……);
public class test18 {
public static void main(String[] args) {
sum(10,20);
}
public static void sum(int number1, int number2){
System.out.println(number1+number2);
}
}
形参：方法定义中的参数
实参：方法调用中的参数
3、带返回值方法的定义
public static 返回值类型 方法名(参数){ 方法体; return 返回值; }
调用：
- 直接调用
方法名(实参); - 赋值调用
变量名 = 方法名(实参); - 输出调用
System.out.println(方法名(实参));
public class test18 {
public static void main(String[] args) {
//直接调用
getSum(10,30,50);
//赋值调用
int sum = getSum(20, 39,28);
System.out.println(sum);
//输出调用
System.out.println(getSum(39,49,29));
}
public static int getSum(int number1, int number2, int number3){
int result = number1 + number2 + number3;
return result;
}
}
需求：比较两个长方形的面积
public class test19 {
public static void main(String[] args) {
double rectangle1 = getSize(4, 58);
double rectangle2 = getSize(6.2, 16);
if(rectangle1 > rectangle2){
System.out.println("第一个矩形面积大");
}else if (rectangle1 < rectangle2){
System.out.println("第二个矩形面积大");
}else{
System.out.println("两个矩形面积相等");
}
}
public static double getSize(double length, double width){
double size = length * width;
return size;
}
}
方法注意事项：
方法不调用就不执行
方法与方法之间是平级关系，不能互相嵌套定义
方法的编写顺序和执行顺序无关
方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句，如果要编写return，后面不能有具体数据
return语句下面，不能编写代码，因为永远执行不到，属于无效代码
return关键字
- 方法没有返回值：可以省略不写，如果书写，表示结束方法
- 方法有返回值：必须要写。表示结束方法和返回结果
（二）方法的重载
在同一个类中，定义了多个同名的方法，这些同名的方法具有同种功能
每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系
需求：打印数组
public class test20 {
public static void main(String[] args) {
int[] array = {38, 75, 93, 2994,29};
printArray(array);
}
public static void printArray(int[] array){
System.out.print("{");
for (int i = 0; i < array.length; i++) {
if (i == array.length-1){
System.out.print(array[i]);
}else {
System.out.print(array[i] + ", ");
}
}
System.out.println("}");
}
}
需求：返回数组最大值
public class test21 {
public static void main(String[] args) {
int[] array = {38, 928,38,33,12};
int max =maxArray(array);
System.out.println(max);
}
public static int maxArray(int[] array){
int max = array[0];
for (int i = 1; i < array.length; i++) {
if(max < array[i]) max = array[i];
}
return max;
}
}
需求：判断一个数字是否在数组里
public class test22 {
public static void main(String[] args) {
int[] array = {29, 49,28, 38, 26};
int number = 26;
boolean flag = contains(array, number);
if(flag){
System.out.println(number + "在数组中");
}else {
System.out.println(number + "不在数组中");
}
}
public static boolean contains(int[] array, int number){
boolean is = false;
for (int i = 0; i < array.length; i++) {
if(number == array[i]){
is = true;
break;
}
}
return is;
}
}
public class test22 {
public static void main(String[] args) {
int[] array = {29, 49,28, 38, 26};
int number = 30;
boolean flag = contains(array, number);
if(flag){
System.out.println(number + "在数组中");
}else {
System.out.println(number + "不在数组中");
}
}
public static boolean contains(int[] array, int number){
for (int i = 0; i < array.length; i++) {
if(number == array[i]){
return true;
}
}
return false;
}
}
需求：复制数组
public class test23 {
public static void main(String[] args) {
int[] array = {24, 63, 64, 29, 19};
int from = 1;
int to = array.length-1;
copyOfRange(array, from, to);
}
public static void copyOfRange(int[] arr, int from, int to){
int[] newArr = new int[to - from];
int index = 0;
for (int i = from; i < to; i++){
newArr[index] = arr[i];
index++;
}
System.out.print("新数组为：{");
for (int i = 0; i < newArr.length; i++) {
if(i == newArr.length-1){
System.out.print(newArr[i]);
}else {
System.out.print(newArr[i] + ", ");
}
}
System.out.println("}");
}
}
public class test23 {
public static void main(String[] args) {
int[] array = {24, 63, 64, 29, 19};
int from = 1;
int to = array.length;
int[] copyarray = copyOfRange(array, from, to);
System.out.print("新数组为：{");
for (int i = 0; i < copyarray.length; i++) {
if(i == copyarray.length-1){
System.out.print(copyarray[i]);
}else {
System.out.print(copyarray[i] + ", ");
}
}
System.out.println("}");
}
public static int[] copyOfRange(int[] arr, int from, int to){
int[] newArr = new int[to - from];
int index = 0;
for (int i = from; i < to; i++){
newArr[index] = arr[i];
index++;
}
return newArr;
}
}
飞机票
需求：
- 机票价格按照淡季旺季、头等舱和经济舱、输入机票原价、月份、和头等舱或经济舱
- 按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8折，淡季（11月到来年4月）头等舱7折，经济舱6折
public class test24 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入机票原价：");
double price = scanner.nextDouble();
System.out.println("请输入购买月份：");
int month = scanner.nextInt();
if(month > 0 && month < 13){
System.out.println("请输入购买舱位（头等舱/经济舱）:");
String accommodation = scanner.next();
if (accommodation.equals("头等舱") || accommodation.equals("经济舱")){
switch (month){
case 5: case 6: case 7: case 8: case 9: case 10:
if (accommodation.equals("头等舱")){
price = price*0.9;
break;
}
else{
price = price*0.8;
break;
}
default:
if (accommodation.equals("头等舱")){
price = price*0.7;
break;
}
else{
price = price*0.6;
break;
}
}
System.out.println("您需要支付" + price + "元");
}else System.out.println("输入舱位有误！");
}else System.out.println("输入月份有误！");
}
}
public class test24 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入机票原价：");
int price = scanner.nextInt();
System.out.println("请输入购买月份：");
int month = scanner.nextInt();
if(month > 0 && month < 13){
System.out.println("请输入购买舱位（1表示头等舱/0表示经济舱）:");
int accommodation = scanner.nextInt();
if (accommodation == 1 || accommodation == 0){
if(month >= 5 && month <= 10){
price = getPrice(price, accommodation, 0.9, 0.8);
}else {
price = getPrice(price, accommodation, 0.7, 0.6);
}
System.out.println("您需要支付" + price + "元");
}else System.out.println("输入舱位有误！");
}else System.out.println("输入月份有误！");
}
public static int getPrice(int ticket, int seat, double v0, double v1){
if(seat == 1) ticket = (int)(ticket*v0);
else ticket = (int)(ticket*v1);
return ticket;
}
}
Ctrl+alt+M：自动抽取方法
需求：找出一个范围内有多少质数：
public class test25 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入起点：");
int from = scanner.nextInt();
System.out.println("请输入终点：");
int to = scanner.nextInt();
int count = 0;
for (int i = from; i <= to; i++){
boolean flag = true;
if(i == 1)flag = false;
else {
for(int j = 2; j <= Math.sqrt(i); j++){
if(i % j == 0) {
flag = false;
//跳出单层循环
break;
}
}
}
if (flag)count++;
}
System.out.println(from+"与"+to+"之间共有"+count+"个质数");
}
}
需求：定义方法实现随机产生一个5位的验证码
验证码格式：前四位是大写字母或者小写字母，最后一位是数字
public class test26 {
public static void main(String[] args) {
String captcha = getCaptcha();
System.out.println(captcha);
}
public static String getCaptcha(){
String captcha ="";
char[] array = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t',
'u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','G','K','L','M','N','O','P','Q','R','S',
'T','U','V','W','X','Y','Z'};
Random random = new Random();
for (int i = 0; i < 4; i++){
captcha += array[random.nextInt(array.length)];
}
captcha = captcha + random.nextInt(10);
return captcha;
}
}
public class test26 {
public static void main(String[] args) {
String captcha = getCaptcha();
System.out.println(captcha);
}
public static String getCaptcha(){
String captcha ="";
char[] array = new char[52];
for (int i = 0; i < array.length; i++) {
if(i < 26){
array[i] = (char)(97 + i);
}else {
array[i] = (char)(65 + i - 26);
}
}
Random random = new Random();
for (int i = 0; i < 4; i++){
captcha += array[random.nextInt(array.length)];
}
captcha = captcha + random.nextInt(10);
return captcha;
}
}
需求：评委打分，去掉最高分和最低分，求平均值
public class test27 {
public static void main(String[] args) {
int[] scoreArray = getScore();
int max = getMax(scoreArray);
int min = getMin(scoreArray);
int sum = getSum(scoreArray);
int getScore = (sum - max - min)/(scoreArray.length-2);
System.out.println("获得的分数为" + getScore);
}
public static int getMax(int[] score){
int max = score[0];
for (int i = 0; i < score.length; i++) {
if(max < score[i]) max = score[i];
}
return max;
}
public static int getMin(int[] score){
int min = score[0];
for (int i = 0; i < score.length; i++) {
if(min > score[i]) min = score[i];
}
return min;
}
public static int getSum(int[] score){
int sum = 0;
for (int i = 0; i < score.length; i++) {
sum += score[i];
}
return sum;
}
public static int[] getScore(){
int[] array = new int[6];
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < array.length; ) {
System.out.println("请输入评委成绩：");
int score = scanner.nextInt();
if(score >= 0 && score <=100){
array[i] = score;
i++;
}else {
System.out.println("请重新第" + (i+1) + "个输入成绩：");
}
}
return array;
}
}
shift+F6：批量修改
需求：数字加密
规则：将输入数字每位加5，在对10取余，最后将数字取反
public class test28 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要加密的数字：");
int number = scanner.nextInt();
int temp = number;
int length = 1;
while (true){
if (temp / 10 == 0)break;
else {
temp = temp / 10;
length++;
}
}
int[] array = getArray(number,length);
int[] newArray = getNewArray(getArray(array));
int newNumber = 0;
for (int i = 0; i < newArray.length; i++) {
newNumber = newNumber * 10 + newArray[i];
}
System.out.print("加密后的数字为：" + newNumber);
}
//将数字每一位装到数组中
public static int[] getArray(int number, int length){
int[] array = new int[length];
for (int i = 0; i < length; i++){
array[length-i-1] = number % 10;
number = number / 10;
}
return array;
}
//将数组中每一位加5并对10取余
public static int[] getArray(int[] array){
for (int i = 0; i < array.length; i++) {
array[i] = (array[i] + 5) % 10;
}
return array;
}
//将数组中的数进行倒转
public static int[] getNewArray(int[] array){
int temp;
for (int i = 0, j = array.length-1; i < j; i++, j--){
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
return array;
}
}
需求：将之前加密的数据进行解密
public class test29 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入需要解密的数字：");
int number = scanner.nextInt();
int temp = number;
int count = 1;
while (true){
if(temp / 10 == 0)break;
else {
temp = temp/10;
count++;
}
}
int[] array = getArray(number, count);
int[] newArray = getNewArray(array);
int newNumber = 0;
for (int i = 0; i < newArray.length; i++) {
newNumber = newNumber * 10 + newArray[i];
}
System.out.println("解密后的数字为" + newNumber);
}
//将数字的每一位倒序装到数组中
public static int[] getArray(int number, int length){
int[] array = new int[length];
for (int i = 0; i < array.length; i++) {
array[i] = number % 10;
number = number / 10;
}
return array;
}
//将数组中每个数字加5并对10取余
public static int[] getNewArray(int[] array){
for (int i = 0; i < array.length; i++) {
array[i] = (array[i] + 5) % 10;
}
return array;
}
}
需求：抽奖，奖项随机求不重复
public class test30 {
public static void main(String[] args) {
int[] array = {100,200,500,1000,5000};
int[] newArray = getArray(array);
printArray(newArray);
}
public static int[] getArray(int[] array){
int[] newArray = new int[array.length];
Random random = new Random();
for (int i = 0; i < array.length; ) {
int number = random.nextInt(array.length);
boolean flag = true;
for (int j = 0; j <= i; j++) {
if(newArray[j] == array[number]){
flag = false;
break;
}
}
if(flag){
newArray[i] = array[number];
i++;
}
}
return newArray;
}
public static void printArray(int[] array){
System.out.print("{");
for (int i = 0; i < array.length; i++) {
if(i == array.length-1) System.out.print(array[i]);
else System.out.print(array[i] + ", ");
}
System.out.print("}");
}
}
public class test30 {
public static void main(String[] args) {
int[] array = {100,200,500,1000,5000};
int[] newArray = getArray(array);
printArray(newArray);
}
// 将数组中排序打乱
public static int[] getArray(int[] array){
Random random = new Random();
int temp;
for (int i = 0; i < array.length; i++) {
int number = random.nextInt(array.length);
temp = array[i];
array[i] = array[number];
array[number] = temp;
}
return array;
}
public static void printArray(int[] array){
System.out.print("{");
for (int i = 0; i < array.length; i++) {
if(i == array.length-1) System.out.print(array[i]);
else System.out.print(array[i] + ", ");
}
System.out.print("}");
}
}
需求：双色球
public class test31 {
public static void main(String[] args) {
int[] ticket = new int[7];
int[] buyTicket = getBuyTicket(ticket);
System.out.print("所购买的彩票为：");
printTicket(buyTicket);
int[] realTicket = getRealTicket(ticket);
System.out.print("中奖彩票为：");
printTicket(realTicket);
System.out.print("所获奖项：");
String prize =prize(buyTicket, realTicket);
System.out.println(prize);
}
// 保存购买彩票号码
public static int[] getBuyTicket(int[] ticket){
int[] buyTicket = new int[ticket.length];
Scanner scanner = new Scanner(System.in);
int number;
boolean flag;
System.out.println("请输入购买彩票的第1个号码：");
for (int i = 0; i < ticket.length-1; ) {
number = scanner.nextInt();
if(number >= 1 && number <= 33){
flag = ball(buyTicket, number, i);
if(flag){
buyTicket[i] = number;
i++;
if (i < ticket.length-1){
System.out.println("请输入购买彩票的第" + (i+1) + "个号码：");
}
}else System.out.println("该球号已存在，请重新输入购买彩票的第"+ (i+1) + "个号码：");
}else {
System.out.println("输入有误，请重新输入购买彩票的第" + (i+1) + "个号码：");
}
}
System.out.println("请输入购买彩票的第7个号码：");
while (true){
number = scanner.nextInt();
if (number >= 1 && number <= 16) {
buyTicket[ticket.length-1] = number;
break;
}
else System.out.println("输入有误，请重新输入购买彩票的第7个号码：");
}
return buyTicket;
}
// 打印彩票号码
public static void printTicket(int[] ticket){
System.out.print("{");
for (int i = 0; i < ticket.length; i++) {
if(i == ticket.length-1) System.out.print(ticket[i]);
else System.out.print(ticket[i] + ", ");
}
System.out.println("}");
}
// 随机生成彩票号码
public static int[] getRealTicket(int[] tickct){
int[] realTicket = new int[tickct.length];
Random random = new Random();
boolean flag;
int number;
for (int i = 0; i < tickct.length-1; ) {
number = random.nextInt(33) + 1;
flag = ball(realTicket, number, i);
if(flag) {
realTicket[i] = number;
i++;
}
}
realTicket[tickct.length-1] = random.nextInt(16) + 1;
return realTicket;
}
// 判断球是否重复
public static boolean ball(int[] ticket, int number, int i){
for(int j = 0; j <= i; j++){
if(ticket[j] == number) return false;
}
return true;
}
public static String prize(int[] buyTicket, int[] realTicket){
int red = 0;
int blue = 0;
for (int i = 0; i < buyTicket.length-1; i++) {
if(buyTicket[i] == realTicket[i]) red++;
}
if(buyTicket[buyTicket.length-1] == realTicket[realTicket.length-1]) blue++;
if(red == 6 && blue == 1) {
return "一等奖";
}
if(red == 6 && blue == 0) {
return "二等奖";
}
if(red == 5) {
return "三等奖";
}
if(red == 4) {
return "四等奖";
}
if((red == 3 || red == 2) && blue ==1) {
return "五等奖";
}
if((red == 1 || red == 0) && blue ==1) {
return "六等奖";
}
else {
return "未获奖";
}
}
}
拓展：二维数组
静态初始化
格式：数据类型[][] 数组名 = new 数据类型[][] {{元素1,元素2},{元素1,元素2}};
一维数组可以不等长
动态初始化：
格式：数据类型[][] 数组名 = new 数据类型[m][n];
需求：
某商场每个季度的营业额如下：
第一季度：22，66，44
第二季度：77，33，88
第三季度：25，45，65
第四季度：11，66，99
计算出每个季度的总营业额和全年营业额
public class test32 {
public static void main(String[] args) {
int[][] array = {
{22, 66, 44},
{77, 33, 88},
{25, 45, 65},
{11, 66, 99}
};
System.out.println(getSum(array[0]));
System.out.println(getSum(array[1]));
System.out.println(getSum(array[2]));
System.out.println(getSum(array[3]));
System.out.println(getSum(array));
}
public static int getSum(int[] array){
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum += array[i];
}
return sum;
}
public static int getSum(int[][] array){
int sum = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
sum += array[i][j];
}
}
return sum;
}
}
八、面向对象
（一）类和对象
- 类：是对象共同特征的描述
- 对象：是真实存在的具体实例
类的定义
public class 类名 {
1、成员变量（代表属性，一般是名词）
2、成员方法（代表行为，一般是动词）
3、构造器
4、代码块
5、内部类
}
如何得到类的对象：
类名 对象名 = new 类名();
如何使用对象：
- 访问属性：
对象名.成员变量 - 访问行为：
对象名.方法名(...)
注意：
用来描述一类事物的类，专业叫做Javabean类，是不写main方法的
编写main方法的类叫做测试类，在测试类中创建javabean类的对象并进行赋值调用
类名首字母建议大写，驼峰模式
一个java文件可以定义多个class类，只能一个类名是public修饰，且public修饰的类名必须和代码文件名一致
成员变量完整定义格式：修饰符 数据类型 变量名称 = 初始化值;一般无需指定初始化值，存在默认值
面向对象三大特征：封装、继承、多态
（二）封装
对象代表什么，就得封装对应的数据，并提供数据对应的行为
1、private关键字
- 是一个权限修饰符
- 可以修饰成员（成员变量和成员方法）
- 被private修饰的成员只能在本类中才能访问
就近原则
2、this关键字
区分成员变量与局部变量
3、构造方法
也叫构造器、构造函数
作用：在创建对象的时候给成员变量进行初始化
格式：
public class 类名 {
修饰符 方法名(参数) {
方法体;
}
}
1、方法名与类名相同，大小写一致
2、没有返回值类型，void也没有
3、没有具体返回值（不能有return带回结果数据）
创建对象的时候有虚拟机调用，不能手动调用构造方法
每创建一次对象，就调用一次构造方法
如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法
带参构造方法和无参数构造方法，两者方法名相同，但是参数不同，这叫做构造方法的重载
建议：无论是否使用，都手动书写无参数构造方法和带全部参数的构造方法
public class User {
// 属性
private String username;
private String password;
private String emall;
private String sex;
private int age;
// 空参
public User(){}
// 带全部参数的构造
public User(String username, String password, String emall, String sex, int age){
this.username = username;
this.password = password;
this.emall = emall;
this.sex = sex;
this.age = age;
}
// get和set方法
public void setUsername(String username){
this.username = username;
}
public String getUsername(String username){
return username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmall() {
return emall;
}
public void setEmall(String emall) {
this.emall = emall;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
快捷键：alt+insert
需求：文字版格斗游戏
package com.object;
import java.util.Random;
public class Role {
private String name;
private int blood;
public Role() {
}
public Role(String name, int blood) {
this.name = name;
this.blood = blood;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getBlood() {
return blood;
}
public void setBlood(int blood) {
this.blood = blood;
}
public void attack(Role role) {
Random random = new Random();
int hurt = random.nextInt(20) + 1;
//剩余血量
int remainBlood = role.getBlood() - hurt;
remainBlood = remainBlood < 0 ? 0 : remainBlood;
role.setBlood(remainBlood);
//this表示方法的调用
System.out.println(this.getName() + "攻击" + role.getName() +
"造成" + hurt + "点伤害，" + role.getName() + "还剩" +
remainBlood + "点血");
}
}
package com.object;
public class GameTest {
public static void main(String[] args) {
Role r1 = new Role("孙悟空", 100);
Role r2 = new Role("贝吉塔", 100);
while (true) {
r1.attack(r2);
if(r2.getBlood() == 0){
System.out.println(r1.getName() + "KO了" + r2.getName() + "!");
break;
}
r2.attack(r1);
if(r1.getBlood() == 0){
System.out.println(r2.getName() + "KO了" + r1.getName() + "!");
break;
}
}
}
}
System.out.printf();
两部分参数：第一部分：要输入的内容%s（占位），第二部分：填充的数据
有几个占位符就要有几个填充的数据
需求：定义数组存储对象
package com.object;
public class Goods {
private String id;
private String name;
private double price;
private int count;
public Goods() {
}
public Goods(String id, String name, double price, int count) {
this.id = id;
this.name = name;
this.price = price;
this.count = count;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}
package com.object;
public class GoodsTest {
public static void main(String[] args) {
Goods[] arr = new Goods[3];
Goods g1 = new Goods("001","皮卡丘",500,50);
Goods g2 = new Goods("002","喵喵",300,80);
Goods g3 = new Goods("003","小火龙",100,200);
arr[0] = g1;
arr[1] = g2;
arr[2] = g3;
for (int i = 0; i < arr.length; i++) {
Goods goods = arr[i];
System.out.println(goods.getId() + ", " + goods.getName() + ", "
+ goods.getPrice() + ", " + goods.getCount());
}
}
}
键盘录入：
第一种体系：遇到空格、制表符、回车就停止接收
nextInt(); 接收整数
nextDouble(); 接收小数
next(); 接收字符串
第二种体系：可以接收空格、制表符，遇到回车才停止接收数据
nextLine(); 接收字符串
九、API与字符串
API：应用程序编程接口
例：Scanner、Random
字符串(String)的内容是不会改变的，对象在创建后不能被更改
创建String对象的两种方式：
1、直接赋值
2、new
| 构造方法 | 说明 |
| public String() | 创建空白字符串，不含任何内容 |
| public String(String original) | 根据传入的字符串，创建字符串对象 |
| public String(char[] chs) | 根据字符数组，创建字符串对象 |
| public String(byte[] chs) | 根据字节数组，创建字符串对象 |
字符串比较：
- boolean equals方法(要比较的字符串) 完全一样结果才是true，否则为false
- boolean equalsIgnoreCase(要比较的字符串) 忽略大小写的比较
public char charAt(int index); 根据索引返回字符
public int length(); 返回此字符串的长度
数组的长度：数组名.length
字符串的长度：字符串对象.length()
需求：键盘录入一个字符串，统计该字符串中大写字母字符、小写字母字符与数字字符出现的次数
public class test33 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String str = scanner.next();
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if(c >= 'a' && c <= 'z') smallCount++;
else if(c >= 'A' && c <= 'Z') bigCount++;
else if(c >= '0' && c <= '9') numberCount++;
}
System.out.println("该字符中有" + bigCount + "个大写字母, " + smallCount + "个小写字母, " + numberCount + "个数字");
}
}
需求：定义一个方法，把int数组中的数据按照指定格式输出。
public class test34 {
public static void main(String[] args) {
int[] arr = {76,0,35};
String str = getString(arr);
printString(str);
}
public static String getString(int[] array){
if(array == null) return "";
if(array.length == 0) return "{}";
String result = "{";
for (int i = 0; i < array.length; i++) {
if(i == array.length-1) result += array[i];
else result = result + array[i] + ", ";
}
result += "}";
return result;
}
public static void printString(String string){
for (int i = 0; i < string.length(); i++) {
char c = string.charAt(i);
System.out.print(c);
}
}
}
需求：定义一个方法，实现字符串的反转
public class test35 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一组字符串：");
String str = scanner.next();
String string = reverser(str);
System.out.println(string);
}
public static String reverser(String string){
String result = "";
for (int length = string.length(); length > 0; length--) {
char c = string.charAt(length-1);
result += c;
}
return result;
}
}
金额转换
public class test36 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int money;
while (true) {
System.out.println("请输入金额：");
money = scanner.nextInt();
if (money >= 0 && money <= 9999999){
break;
}else {
System.out.println("输入金额有误！");
}
}
String moneyStr = "";
while (true) {
int ge = money % 10;
String capitalNumber = getCapitalNumber(ge);
moneyStr = capitalNumber + moneyStr;
money = money / 10;
if (money == 0) break;
}
int count = 7 - moneyStr.length();
for (int i = 0; i < count; i++) {
moneyStr = "零" + moneyStr;
}
String[] arr = {"百","十","万","千","百","十","元"};
String newMoneyStr = "";
for (int i = 0; i < arr.length; i++) {
char c = moneyStr.charAt(i);
newMoneyStr = newMoneyStr + c + arr[i];
}
System.out.println(newMoneyStr);
}
public static String getCapitalNumber(int number){
String[] arr = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
return arr[number];
}
}
String substring(int beginindex, int endindex) 截取
包头不包尾，包左不包右
只有返回值才是截取的小段
String substring(int beginingex) 截取到末尾
需求：手机号码加密
public class test37 {
public static void main(String[] args) {
String phoneNumber = "19394829495";
String newPhonrNumber = phoneNumber.substring(0,3) + "****" + phoneNumber.substring(7);
System.out.println(newPhonrNumber);
}
}
需求：根据身份证号输出出生年月及性别
public class test38 {
public static void main(String[] args) {
String id = "220182200303193840";
String year = id.substring(6,10);
String month = id.substring(10,12);
String day = id.substring(12,14);
System.out.println("出生年月为：" + year + "年" + month + "月" + day + "日");
char sex = id.charAt(16);
int num = sex - 48;
System.out.print("性别为：");
if (num % 2 ==0) System.out.println("女");
else System.out.println("男");
}
}
String replace(旧值,新值) 替换
只有返回值才是替换之后的结果
需求：屏蔽敏感词
public class test39 {
public static void main(String[] args) {
String talk = "cnm，会不会玩啊，sb";
String[] arr = {"cnm","sb","tmd"};
for (int i = 0; i < arr.length; i++) {
talk = talk.replace(arr[i],"***");
}
System.out.println(talk);
}
}
StringBuilder
StringBuilder可以看做一个容器，创建后里面的内容是可变的
作用：提高字符串的操作效率
StringBulider构造方法
| 方法名 | 说明 |
| public StringBuilder() | 创建一个空白可变字符串对象，不含有任何内容 |
| public StringBulider(String str) | 根据字符串的内容，来创建可变字符串对象 |
| 方法名 | 说明 |
| public StringBuilder append(任意类型) | 添加数据，并返回对象本身 |
| public StringBulider reverse() | 反转容器中的内容 |
| public int length() | 返回长度（字符出现的个数） |
| public String toString() | 通过toString()就可以实现把StringBuilder转换为String |
public class test40 {
public static void main(String[] args) {
// 创建
StringBuilder sb = new StringBuilder("123");
// 添加
sb.append("sjdi");
sb.append(12);
sb.append(true);
// 反转
sb.reverse();
// 获取长度
int len = sb.length();
System.out.println(sb);
System.out.println(len);
// 变回字符串
String str = sb.toString();
System.out.println(str);
}
}
需求：判断对称字符串
public class test41 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s = scanner.next();
String result = new StringBuilder().append(s).reverse().toString();
System.out.println((result.equals(s))?"是":"否");
}
}
需求：拼接字符串
public class test42 {
public static void main(String[] args) {
int[] arr = {1,2,3};
System.out.println(arrToString(arr));
}
public static String arrToString(int[] array){
StringBuilder sb = new StringBuilder();
sb.append("{");
for (int i = 0; i < array.length; i++) {
if(i == array.length-1) sb.append(array[i]);
else sb.append(array[i]).append(", ");
}
String s =sb.append("}").toString();
return s;
}
}
StringJoiner跟StringBuilder一样，也可以看做一个容器，创建后里面的内容是可变的
作用：提高字符串的操作效率，代码编写简洁
StringJoiner构造方法
| 方法名 | 说明 |
| public StringJoiner(间隔符号) | 创建一个StringJoiner对象，指定拼接时的间隔符号 |
| public StringJoiner(间隔符号, 开始符号, 结束符号) | 创建一个StringJoiner对象，指定拼接时的间隔符号、开始符号、结束符号 |
| 方法名 | 说明 |
| public StringJoiner add(添加的内容) | 添加数据，并返回对象本身 |
| public int length() | 返回长度（字符出现的个数） |
| public String toString() | 返回一个字符串（该字符串就是拼接之后的结果） |
public class test43 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String str;
while (true){
System.out.println("请输入需要转换的数字：");
str = scanner.next();
boolean flag = checkStr(str);
if(flag){
System.out.println(changeString(str));
break;
}
else System.out.println("转换数字有误");
}
}
public static boolean checkStr(String string){
if (string.length() > 9) return false;
for (int i = 0; i < string.length(); i++) {
char c = string.charAt(i);
if(c <= '0' || c > '9') return false;
}
return true;
}
public static String changeString(String string){
String[] arr = {"I","II","III","IV","V","VI","VII","VIII","IX"};
StringBuilder sb = new StringBuilder();
for (int i = 0; i < string.length(); i++) {
char c = string.charAt(i);
int number = c - '0';
sb.append(arr[number - 1]).append(" ");
}
String result = sb.toString();
return result;
}
}
需求：将字符串中最左侧的字符移动到最右边，给定两个字符串，判断经过若干次变换时是否相同。
public class test44 {
public static void main(String[] args) {
String A = "2iwi";
String B = "wi2i";
int count = 0;
int len = A.length();
boolean flag = false;
do{
if(A.equals(B)){
flag = true;
break;
}
A = rotate(A);
count++;
}while (count < len);
if(flag){
System.out.println(flag);
System.out.println("需要经过" + count + "次变换");
}else {
System.out.println(flag);
}
}
public static String rotate(String s){
char first = s.charAt(0);
String end = s.substring(1);
String result = end + first;
return result;
}
}
需求：输入一个字符串，打乱其内容
public class test45 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入字符串：");
String str = scanner.next();
char[] arr = str.toCharArray();
Random random = new Random();
for (int i = 0; i < arr.length; i++) {
char temp = arr[i];
int rand = random.nextInt(arr.length);
arr[i] = arr[rand];
arr[rand] = temp;
}
String result = new String(arr);
System.out.println(result);
}
}
需求：返回字符串中最后一个单词的位数
public class test46 {
public static void main(String[] args) {
String str = "hello world";
int count = 0;
String newStr= "";
char[] arr = str.toCharArray();
for (int num = str.length(); num > 0; num--) {
if(arr[num-1] == ' ')break;
newStr = arr[num-1] + newStr;
count++;
}
System.out.println("最后一个单词为：" + newStr + "，共有" + count + "位");
}
}
十、集合
集合与数组对比
- 长度
数组长度固定
集合长度可变 - 存储类型
数组可以存基本数据类型与引用数据类型
集合可以存引用数据类型，存基本数据类型时需要先转换为对应的包装类
（一）ArrayList
| 方法名 | 说明 |
| boolean add(E e) | 添加元素，返回值表示添加成功 |
| boolean remove(E e) | 删除指定元素，返回值表示删除成功 |
| E remove(int index) | 删除指定索引的元素，返回被删除元素 |
| E set(int index,E e) | 修改指定索引的元素，返回原来的元素 |
| E get(int index) | 获取指定索引的元素 |
| int size() | 集合的长度，也就是集合中元素的个数 |
public class test47 {
public static void main(String[] args) {
// 泛式，限定集合中存储的数据类型
ArrayList<String> list = new ArrayList<>();
// 添加元素
boolean result = list.add("92e");
list.add("jjw");
list.add("9rjf");
list.add("93u");
list.add("3ii9e");
System.out.println(result);
System.out.println(list);
// 删除元素
System.out.println(list.remove("jjw"));
System.out.println(list.remove(0));
System.out.println(list);
// 修改元素
System.out.println(list.set(0,"abc"));
System.out.println(list);
// 查询元素
System.out.println(list.get(0));
// 获取长度
System.out.println(list.size());
// 遍历
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
}
}
基本数据类型对应的包装类
| byte | Byte |
| short | Short |
| char | Character |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
需求：添加数字并进行遍历
public class test48 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(123);
list.add(4567);
list.add(89);
System.out.print("[");
for (int i = 0; i < list.size(); i++) {
if(i == list.size()-1) System.out.print(list.get(i));
else System.out.print(list.get(i) + ", ");
}
System.out.println("]");
}
}
需求：定义一个集合，添加学生对象并进行遍历
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class test49 {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Student s1 = new Student();
s1.setName("张三");
s1.setAge(18);
Student s2 = new Student("李四", 19);
list.add(s1);
list.add(s2);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).getName() + list.get(i).getAge());
}
}
}
需求：对象的数据来自键盘录入
public class test50 {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
Student s = new Student();
System.out.println("请输入学生姓名：");
s.setName(scanner.next());
System.out.println("请输入学生年龄：");
s.setAge(scanner.nextInt());
list.add(s);
}
for (int i = 0; i < list.size(); i++) {
Student stu = list.get(i);
System.out.println(stu.getName() + ", " + stu.getAge());
}
}
}
需求：定义一个集合，存入3个用户对象，属性为id,username,password
根据ID判断用户是否存在
public class test51 {
public static void main(String[] args) {
ArrayList<User> list = new ArrayList<>();
User u1 = new User("li001","张三", "123456");
User u2 = new User("li002","李四", "123456");
User u3 = new User("li003","王五", "123456");
list.add(u1);
list.add(u2);
list.add(u3);
System.out.println(contains(list,"li003"));
}
public static boolean contains(ArrayList<User> list, String id){
for (int i = 0; i < list.size(); i++) {
if(id.equals(list.get(i).getId())) return true;
}
return false;
}
}
十一、学生管理系统
package test;
public class Student {
private int id;
private String name;
private int age;
private String address;
public Student() {
}
public Student(int id, String name, int age, String address) {
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
package test;
import java.util.ArrayList;
import java.util.Scanner;
public class StudentSyetem {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
ArrayList<Student> list = new ArrayList<>();
loop:
while (true) {
System.out.println("-----欢迎来到学生管理系统-----");
System.out.println("1:添加学生");
System.out.println("2:删除学生");
System.out.println("3:修改学生");
System.out.println("4:查询学生");
System.out.println("5:查询单个学生信息");
System.out.println("6:退出");
System.out.println("请输入要进行的操作：");
int choose = scanner.nextInt();
int id;
switch (choose) {
case 1:
System.out.println("添加学生");
addStudent(list);
break;
case 2:
System.out.println("删除学生");
deleteStudent(list);
break;
case 3:
System.out.println("修改学生");
updateStudent(list);
break;
case 4:
System.out.println("查询学生");
queryStudent(list);
break;
case 5:
System.out.println("查询单个学生信息");
inQueryStudent(list);
break;
default:
System.out.println("退出");
break loop;
// 停止虚拟机运行
//System.exit(0);
}
}
}
public static void addStudent(ArrayList<Student> list){
Scanner scanner = new Scanner(System.in);
Student s = new Student();
System.out.println("请输入学生学号：");
int id = scanner.nextInt();
boolean flag = contain(list,id);
while (!flag){
System.out.println("当前学号已存在，请重新输入");
id = scanner.nextInt();
flag = contain(list,id);
}
s.setId(id);
System.out.println("请输入学生姓名：");
s.setName(scanner.next());
System.out.println("请输入学生年龄：");
s.setAge(scanner.nextInt());
System.out.println("请输入学生住址：");
s.setAddress(scanner.next());
list.add(s);
System.out.println("添加成功");
}
public static void deleteStudent(ArrayList<Student> list){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入学生学号：");
int id = scanner.nextInt();
int index = getIndex(list,id);
if(index <0) System.out.println("该生不存在");
else {
list.remove(index);
System.out.println("删除成功");
}
}
public static void updateStudent(ArrayList<Student> list){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入需要更改的学生学号：");
int id = scanner.nextInt();
int index = getIndex(list,id);
if(index < 0) {
System.out.println("该生不存在");
return;
}
Student s = list.get(index);
System.out.println("请输入需要更改的学生姓名：");
String newName = scanner.next();
s.setName(newName);
System.out.println("请输入需要更改的学生年龄：");
int newAge = scanner.nextInt();
s.setAge(newAge);
System.out.println("请输入需要更改的学生地址：");
String newAddress = scanner.next();
s.setAddress(newAddress);
System.out.println("学生信息修改成功");
}
public static void queryStudent(ArrayList<Student> list){
if (list.size() == 0){
System.out.println("当前无学生信息，请添加后查询");
}else {
System.out.println("id\t姓名\t年龄\t家庭住址");
for (int i = 0; i < list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getId() + "\t" + s.getName() + "\t" + s.getAge() + "\t" + s.getAddress());
}
}
}
public static void inQueryStudent(ArrayList<Student> list){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入需要查询的学生学号：");
int id = scanner.nextInt();
int index = getIndex(list,id);
if(index < 0) System.out.println("该生不存在");
else {
System.out.println("id\t姓名\t年龄\t家庭住址");
Student s = list.get(index);
System.out.println(s.getId() + "\t" + s.getName() + "\t" + s.getAge() + "\t" + s.getAddress());
}
}
public static boolean contain(ArrayList<Student> list,int id){
/*for (int i = 0; i < list.size(); i++) {
if(id == list.get(i).getId()) return false;
}
return true;*/
return getIndex(list,id) < 0;
}
public static int getIndex(ArrayList<Student> list,int id){
for (int i = 0; i < list.size(); i++) {
if(id == list.get(i).getId()) return i;
}
return -1;
}
}
改善后
public class Student {
private int id;
private String name;
private int age;
private String address;
public Student() {
}
public Student(int id, String name, int age, String address) {
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
public class StudentSystem {
public static void startStudentSystem() {
Scanner scanner = new Scanner(System.in);
ArrayList<Student> list = new ArrayList<>();
loop:
while (true) {
System.out.println("-----欢迎来到学生管理系统-----");
System.out.println("1:添加学生");
System.out.println("2:删除学生");
System.out.println("3:修改学生");
System.out.println("4:查询学生");
System.out.println("5:查询单个学生信息");
System.out.println("6:退出");
System.out.println("请输入要进行的操作：");
int choose = scanner.nextInt();
int id;
switch (choose) {
case 1:
System.out.println("添加学生");
addStudent(list);
break;
case 2:
System.out.println("删除学生");
deleteStudent(list);
break;
case 3:
System.out.println("修改学生");
updateStudent(list);
break;
case 4:
System.out.println("查询学生");
queryStudent(list);
break;
case 5:
System.out.println("查询单个学生信息");
inQueryStudent(list);
break;
default:
System.out.println("退出");
break loop;
// 停止虚拟机运行
//System.exit(0);
}
}
}
public static void addStudent(ArrayList<Student> list){
Scanner scanner = new Scanner(System.in);
Student s = new Student();
System.out.println("请输入学生学号：");
int id = scanner.nextInt();
boolean flag = contain(list,id);
while (!flag){
System.out.println("当前学号已存在，请重新输入");
id = scanner.nextInt();
flag = contain(list,id);
}
s.setId(id);
System.out.println("请输入学生姓名：");
s.setName(scanner.next());
System.out.println("请输入学生年龄：");
s.setAge(scanner.nextInt());
System.out.println("请输入学生住址：");
s.setAddress(scanner.next());
list.add(s);
System.out.println("添加成功");
}
public static void deleteStudent(ArrayList<Student> list){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入学生学号：");
int id = scanner.nextInt();
int index = getIndex(list,id);
if(index <0) System.out.println("该生不存在");
else {
list.remove(index);
System.out.println("删除成功");
}
}
public static void updateStudent(ArrayList<Student> list){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入需要更改的学生学号：");
int id = scanner.nextInt();
int index = getIndex(list,id);
if(index < 0) {
System.out.println("该生不存在");
return;
}
Student s = list.get(index);
System.out.println("请输入需要更改的学生姓名：");
String newName = scanner.next();
s.setName(newName);
System.out.println("请输入需要更改的学生年龄：");
int newAge = scanner.nextInt();
s.setAge(newAge);
System.out.println("请输入需要更改的学生地址：");
String newAddress = scanner.next();
s.setAddress(newAddress);
System.out.println("学生信息修改成功");
}
public static void queryStudent(ArrayList<Student> list){
if (list.size() == 0){
System.out.println("当前无学生信息，请添加后查询");
}else {
System.out.println("id\t姓名\t年龄\t家庭住址");
for (int i = 0; i < list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getId() + "\t" + s.getName() + "\t" + s.getAge() + "\t" + s.getAddress());
}
}
}
public static void inQueryStudent(ArrayList<Student> list){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入需要查询的学生学号：");
int id = scanner.nextInt();
int index = getIndex(list,id);
if(index < 0) System.out.println("该生不存在");
else {
System.out.println("id\t姓名\t年龄\t家庭住址");
Student s = list.get(index);
System.out.println(s.getId() + "\t" + s.getName() + "\t" + s.getAge() + "\t" + s.getAddress());
}
}
public static boolean contain(ArrayList<Student> list,int id){
/*for (int i = 0; i < list.size(); i++) {
if(id == list.get(i).getId()) return false;
}
return true;*/
return getIndex(list,id) < 0;
}
public static int getIndex(ArrayList<Student> list,int id){
for (int i = 0; i < list.size(); i++) {
if(id == list.get(i).getId()) return i;
}
return -1;
}
}
public class User {
private String username;
private String password;
private String personId;
private String phoneNumber;
public User() {
}
public User(String username, String password, String personId, String phoneNumber) {
this.username = username;
this.password = password;
this.personId = personId;
this.phoneNumber = phoneNumber;
}
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 getPersonId() {
return personId;
}
public void setPersonId(String personId) {
this.personId = personId;
}
public String getPhoneNumber() {
return phoneNumber;
}
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
}
public class App {
public static void main(String[] args) {
ArrayList<User> list = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("欢迎来到学生管理系统");
System.out.println("请选择操作：1.登录 2.注册 3.忘记密码");
String choose = scanner.next();
switch (choose) {
case "1":
login(list);
break;
case "2":
register(list);
break;
case "3":
forgetPassword(list);
break;
default:
System.out.println("谢谢使用，再见");
System.exit(0);
}
}
}
private static void forgetPassword(ArrayList<User> list) {
System.out.println("忘记密码");
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名");
String username = scanner.next();
boolean flag = contains(list, username);
if (!flag){
System.out.println("用户" + username + "不存在，请先注册");
return;
}
System.out.println("请输入身份证");
String personId = scanner.next();
System.out.println("请输入电话号码");
String phoneNumber = scanner.next();
int index = findIndex(list, username);
User user = list.get(index);
if(!(personId.equalsIgnoreCase(user.getPersonId()) && phoneNumber.equals(user.getPhoneNumber()))){
System.out.println("身份号或者手机号输入有误，不能修改密码");
return;
}
String password;
while (true) {
System.out.println("请输入新的密码");
password = scanner.next();
System.out.println("请再次输入新的密码");
String againPassword = scanner.next();
if (password.equals(againPassword)){
System.out.println("两次密码输入一致");
break;
}else {
System.out.println("两次密码输入不一致，请重新输入");
}
}
user.setPassword(password);
System.out.println("修改成功");
}
private static int findIndex(ArrayList<User> list, String username) {
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
if(username.equals(user.getUsername())) return i;
}
return -1;
}
private static void register(ArrayList<User> list) {
Scanner scanner = new Scanner(System.in);
System.out.println("注册");
User u = new User();
while (true){
System.out.println("请输入用户名");
String username = scanner.next();
boolean flag1 = checkUsername(username);
if (!flag1) {
System.out.println("用户名格式有误，请重新输入");
continue;
}
boolean flag2 = contains(list,username);
if(flag2){
System.out.println("当前用户已存在，请重新输入");
}else {
System.out.println("用户名可用");
u.setUsername(username);
break;
}
}
while (true){
System.out.println("请输入密码");
String password = scanner.next();
System.out.println("请再次输入密码");
String againPassword = scanner.next();
if (password.equals(againPassword)){
u.setPassword(password);
break;
}else {
System.out.println("两次密码输入不一致，请再次输入密码");
}
}
while (true){
System.out.println("请输入身份证号");
String personId = scanner.next();
boolean flag = checkPersonId(personId);
if(flag){
System.out.println("身份号码通过");
u.setPersonId(personId);
break;
}else {
System.out.println("身份号码有误");
}
}
while (true){
System.out.println("请输入手机号");
String phoneNumber = scanner.next();
boolean flag = checkPhoneNumber(phoneNumber);
if(flag){
System.out.println("手机号通过");
u.setPhoneNumber(phoneNumber);
break;
}else {
System.out.println("手机号有误，请重新输入");
}
}
list.add(u);
System.out.println("注册成功");
printList(list);
}
private static void printList(ArrayList<User> list) {
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
System.out.println(user.getUsername() + user.getPassword() + user.getPersonId() + user.getPhoneNumber());
}
}
private static boolean checkPhoneNumber(String phoneNumber) {
if(phoneNumber.length() != 11) return false;
if (phoneNumber.startsWith("0")) return false;
for (int i = 0; i < phoneNumber.length(); i++) {
char c = phoneNumber.charAt(i);
if (c < '0' || c > '9') return false;
}
return true;
}
private static boolean checkPersonId(String personId) {
if (personId.length() != 18) return false;
if (personId.startsWith("0")) return false;
for (int i = 0; i < personId.length() - 1; i++) {
char c = personId.charAt(i);
if (c < '0' || c > '9') return false;
}
char endChar = personId.charAt(personId.length() - 1);
if (!((endChar >= '0' && endChar <= '9') || endChar == 'x' || endChar == 'X')) return false;
return true;
}
// 判断用户名是否存在
private static boolean contains(ArrayList<User> list, String username) {
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
String rightUsername = user.getUsername();
if (rightUsername.equals(username)) return true;
}
return false;
}
private static boolean checkUsername(String username) {
int len = username.length();
if(len < 3 || len > 15){
return false;
}
for (int i = 0; i < username.length(); i++) {
char c = username.charAt(i);
if(!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))){
return false;
}
}
int count = 0;
for (int i = 0; i < username.length(); i++) {
char c = username.charAt(i);
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')){
count++;
break;
}
}
return count > 0;
}
private static void login(ArrayList<User> list){
System.out.println("登录");
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.println("请输入用户名");
String username = scanner.next();
boolean flag = contains(list, username);
if(!flag){
System.out.println("用户名" + username + "未注册，请先注册再登录");
return;
}
System.out.println("请输入密码");
String password = scanner.next();
while (true) {
String rightCode = getCode();
System.out.println("验证码为" + rightCode);
System.out.println("请输入验证码");
String code = scanner.next();
// 不区分大小写
if (code.equalsIgnoreCase(rightCode)){
System.out.println("验证码正确");
break;
}else {
System.out.println("验证码有误，请重新输入");
}
}
User userInfo = new User(username, password, null, null);
boolean result = checkUserInfo(list, userInfo);
if (result){
System.out.println("登录成功，可以开始使用学生系统");
StudentSystem ss = new StudentSystem();
ss.startStudentSystem();
}else {
System.out.println("登录失败，用户名或者密码错误");
if(i == 2){
System.out.println("当前用户" + username + "已被锁定，请联系管理员");
} else {
System.out.println("还剩下" + (2-i) + "次机会");
}
}
}
}
private static boolean checkUserInfo(ArrayList<User> list, User userInfo) {
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
if(user.getUsername().equals(userInfo.getUsername()) && user.getPassword().equals(userInfo.getPassword())){
return true;
}
}
return false;
}
// 生成验证码
public static String getCode(){
ArrayList<Character> list = new ArrayList<>();
for (int i = 0; i < 26; i++) {
list.add((char)('a' + i));
list.add((char)('A' + i));
}
StringBuilder sb = new StringBuilder();
Random random = new Random();
for (int i = 0; i < 4; i++) {
int index = random.nextInt(list.size());
char c = list.get(index);
sb.append(c);
}
int number = random.nextInt(10);
sb.append(number);
char[] arr = sb.toString().toCharArray();
int randomIndex = random.nextInt(arr.length);
char temp = arr[randomIndex];
arr[randomIndex] = arr[arr.length - 1];
arr[arr.length - 1] = temp;
return new String(arr);
}
}
十二、static
static表示静态，是Java中的一个修饰符，可以修饰成员方法，成员变量
被static修饰的成员变量，叫做静态变量
特点：
- 被该类所有对象共享
- 不属于对象，属于类
- 随着类的加载而加载，优先于对象存在
调用方式
- 类名调用
- 对象名调用
被static修饰的成员方法，叫做静态方法
特点：
- 多用在测试类和工具类中
- Javabean类中很少使用
调用方式：
- 类名调用
- 对象名调用
javabean类：用来描述一类事物的类。比如，Student，Teacher，Dog，Cat等
测试类：用来检查其他类是否书写正确，带有main方法的类，是程序的入口
工具类：不是用来描述一类事物的，而是帮我们做一些事情的类
public class ArrayUtil {
// 私有化变量方法
// 不让外界创建它的对象
private ArrayUtil(){}
//需要定义为静态的，方便调用
public static String printArr(int[] arr){
StringJoiner sj = new StringJoiner(", ", "[", "]");
for (int i = 0; i < arr.length; i++) {
sj.add(arr[i] + "");
}
return sj.toString();
}
public static double getAverage(double[] arr){
double sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum / arr.length;
}
}
public class TestDemo {
public static void main(String[] args) {
// 测试工具类中方法是否正确
int[] arr1 = {84,29,394,29};
String str = ArrayUtil.printArr(arr1);
System.out.println(str);
double[] arr2 = {89, 90, 93, 96};
double avg = ArrayUtil.getAverage(arr2);
System.out.println(avg);
}
}
需求：定义学生工具类，获取集合中最大学生的年龄
public class Student {
private String name;
private int age;
private String gender;
public Student() {
}
public Student(String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
public class StudentUtil {
private StudentUtil(){}
public static int getMaxAge(ArrayList<Student> list){
int maxAge = list.get(0).getAge();
for (int i = 1; i < list.size(); i++) {
int tempAge = list.get(i).getAge();
if(maxAge <= tempAge) maxAge = tempAge;
}
return maxAge;
}
}
public class TestDemo {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Student sd1 = new Student("张三", 20 , "男");
list.add(sd1);
Student sd2 = new Student("李四", 23 , "男");
list.add(sd2);
Student sd3 = new Student("王五", 21 , "女");
list.add(sd3);
int maxAge = StudentUtil.getMaxAge(list);
System.out.println(maxAge);
}
}
static的注意事项
- 静态方法只能访问静态变量和静态方法
- 非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法
- 静态方法中是没有this关键字
十三、继承
当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承，优化代码
继承的格式：
public class 子类 extends 父类 {}
子类可以得到父类的属性和行为，子类可以使用
子类可以在父类的基础上新增其他功能
（一）继承的特点
java只支持单继承，不支持多继承，但支持多层继承
一个子类只能继承一个父类，不能同时继承多个父类
java中所有的类都直接或者间接继承与Object类
子类只能访问父类中非私有的成员
需求：现有四种动物：布偶猫、中国狸花猫、哈士奇、泰迪
四种动物分别有以下的行为：
布偶猫：吃饭、喝水、抓老鼠
中国狸花猫：吃饭、喝水、抓老鼠
哈士奇：吃饭、喝水、看家、拆家
泰迪：吃饭、喝水、看家、蹭一蹭
public class Animal {
public void eat(){
System.out.println("吃东西");
}
public void drink(){
System.out.println("喝水");
}
}
public class Cat extends Animal{
public void catchMouse(){
System.out.println("猫在抓老鼠");
}
}
public class Dog extends Animal{
public void lookHome(){
System.out.println("看家");
}
}
public class Ragdoll extends Cat{
}
public class LiHua extends Cat{
}
public class Husky extends Dog{
public void breakHome(){
System.out.println("哈士奇在拆家");
}
}
public class Teddy extends Dog{
public void touch(){
System.out.println("泰迪在蹭一蹭");
}
}
