面向对象
类和对象
类:是对象共同特征的描述
对象:是真实存在的具体东西
在java中,必须先设计类,才能获得对象.
定义类
public class 类名{
1.成员变量(代表属性,一般是名词)
2.成员方法(代表行为,一般是动词)
3.构造器
4.代码块
5.内部类
}得到类的对象
类名 对象名 = new 类名();使用对象
访问属性: 对象名.成员变量
访问行为: 对象名.方法名(...)
类名首字母建议大写,需要见名知意
一个java文件中可以定义多个class类,且只能是一个类是public修饰,而且public修饰的类名必须成为代码文件名,实际开发中建议还是一个文件定义一个class类
成员变量的完善定义格式是:修饰符 数据类型 变量名称 = 初始化值; 一般无需指定初始化值,存在默认值
封装
对象代表什么,就得封装对应的数据,并提供数据对应的行为
private关键字
是一个权限修饰符
可以修饰成员(成员变量和成员方法)
被private修饰的成员只能在本类中才能访问
public class GirlFriend{
private int age;
//set赋值 //调用:类名.setAge(参数);
public void setAge(int a){
if(a >= 18 && a <= 50){
age = a ;
}else{
System.out.println("非法数据");
}
}
//get获取 //调用:类名.getAge();
public int getAge(){
return age;
}
}set和get方法
针对每一个私有化的成员变量,都要提供get和set方法
set方法:给成员变量赋值,"setXXX(参数)",方法用public修饰
get方法:对外提供成员变量的值,"getXXX(参数)",方法用public修饰
this关键字
代表方法调用者的地址值
成员变量和局部变量
成员变量: 类中方法外的变量
局部变量: 方法中的变量
区别 | 成员变量 | 局部变量 |
类中位置不同 | 类中,方法外 | 方法内,方法申明上 |
初始化值不同 | 有默认初始化 | 没有,使用之前需要完成赋值 |
内存位置不同 | 堆内存 | 栈内存 |
生命周期不同 | 随着对象的创建而存在,随着对象的消失而消失 | 随着方法的调用而存在,随着方法的运行结束而消失 |
作用域 | 整个类中有效 | 当前方法中有效 |
就近原则
成员变量在类里面
局部变量在方法里面
this可以区别成员变量和局部变量
public class GirlFriend{
//属性
private int age; //0 // 成员变量
//方法
public void method(){
int age = 10; //10 //局部变量
System.out.println(age);//就近原则 //10
System.out.println(this.age); //0
}
}构造方法
构造方法也叫作构造器、构造函数
作用:在创建对象的时候给成员变量进行赋值
构造方法格式
public class Student{
修饰符 类名(参数){ //修饰符例如public
方法体;
}
}1.方法名与类名相同,大小写也要一致
2.没有返回值类型,连void都没有
3.没有具体的返回值(不能由retrun带回结果数据)
调用
类名 对象名 = new 类名(参数);注意事项
1.如果没有定义构造方法,系统将给出一个默认的无参数构造方法
2.如果定义了构造方法,系统将不再提供默认的构造方法
3.手动书写无参数构造方法,和带全部参数的构造方法
标准的JavaBean类
1.类名需要见名知意
2.成员变量使用private修饰
3.提供至少两个构造方法: 无参构造方法和带参数构造方法
4.成员方法: 提供每一个成员变量对应的setXxx()/getSxx() ;如果还有其他行为,也需要写上
Java内存分配
栈
堆
方法区
本地方法栈
寄存器
方法区: 字节码文件加载时进入的内存
栈内存: 方法运行时所进入的内存,变量也是在这里
堆内存: new 出来的东西会在这块内存中开辟空间并产生地址
一个对象的内存图
Students s = new Students(); //s局部变量
加载class文件
申明局部变量
在堆内存中开辟一个空间
默认初始化
显示初始化
构造方法初始化
将堆内存中的地址值赋值给左边的局部变量
%s 占位
第一部分参数: 要输出的内容%s(占位)
第二部分参数: 填充的数据
System.out.println("你好呀,%s","张三") //你好呀,张三
键盘录入
第一套体系
nextInt(); //接收整数
nextDouble(); //接收小数
next(); //接收字符串遇到空格,制表符,回车就停止接收,这些符号后面的数据就不会接受了.
import java.util.Scanner;
public class Test13 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");//abc bcd
String str1 = sc.next();
System.out.println(str1);//abc
System.out.println("请输入第二个字符串");
String str2 = sc.next();
System.out.println(str2);//bcd
}
}第二套体系
nextLine(); //接收字符串import java.util.Scanner;
public class Test13 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");//abc bcd
String str3 = sc.nextLine();
System.out.println(str3);//abc bcd
System.out.println("请输入第二个字符串");
String str4 = sc.nextLine();
System.out.println(str4);//
}
}键盘录入的两套体系不能混用
对象数组
定义
动态初始化
类名称[] 对象 数组名 = new 类名称[长度];静态初始化
类名称[] 对象数组名 = new 类名称[] {对象，对象......};API
应用程序编程接口
java api : 指的就是JDK中提供的各种功能的java类
这些类将底层的实现封装了起来,不需要关心这些类如何实现,只需要学习如何使用这些类
例如:
Scanner 键盘录入
Random 随机数
查阅帮助文档
String类
String类概述
String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！
String类的特点
字符串不可变，它们的值在创建后不能被更改
虽然 String 的值是不可变的，但是它们可以被共享
字符串效果上相当于字符数组( char[] )，但是底层原理是字节数组( byte[] )
String类的构造方法
常用的构造方法
方法名 | 说明 |
public String() | 创建一个空白字符串对象，不含有任何内容 |
public String(char[] chs) | 根据字符数组的内容，来创建字符串对象 |
public String(byte[] bys) | 根据字节数组的内容，来创建字符串对象 |
String s = “abc”; | 直接赋值的方式创建字符串对象，内容就是abc |
示例代码
public class StringDemo01 {
public static void main(String[] args) {
//public String()：创建一个空白字符串对象，不含有任何内容
String s1 = new String();
System.out.println("s1:" + s1);
//传递一个字符数组，根据传递的字符串内容再创建一个新的字符串对象
String s5 = new String("你好");
System.out.println("s5:" + s5);
//public String(char[] chs)：根据字符数组的内容，来创建字符串对象
char[] chs = {'a', 'b', 'c'};
String s2 = new String(chs);
System.out.println("s2:" + s2);
//public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
byte[] bys = {97, 98, 99};
String s3 = new String(bys);
System.out.println("s3:" + s3);
//String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc
String s4 = "abc";
System.out.println("s4:" + s4);
}
}创建字符串对象两种方式的区别
通过构造方法创建
通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
直接赋值方式创建
以“”方式给出的字符串，系统会检查该字符串在串池中是否存在,只要字符序列相同(顺序和大小写,复用,无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在**字符串池(StringTable)**中维护
字符串的比较
键盘录入的字符串是通过new方法创建的字符串对象
==号的作用
比较基本数据类型：比较的是具体的值
比较引用数据类型：比较的是对象地址值
equals方法的作用
方法介绍
boolean equals方法(要比较的字符串) //完全一样结果才是true,否则为false (看大小写)
boolean equalsIgnoreCase(要比较的字符串) //忽略大小写比较//调用格式 boolean result = 第一个字符串.equals(要比较的字符串)
示例代码
public class StringDemo02 {
public static void main(String[] args) {
//构造方法的方式得到对象
char[] chs = {'a', 'b', 'c'};
String s1 = new String(chs);
String s2 = new String(chs);
//直接赋值的方式得到对象
String s3 = "abc";
String s4 = "abc";
//比较字符串对象地址是否相同
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s3 == s4);
System.out.println("--------");
//比较字符串内容是否相同
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s3.equals(s4));
}
}用户登录案例
案例需求
已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示
代码实现
public class Test1登录案例 {
public static void main(String[] args) {
//1.定义两个变量用来记录正确的用户名和密码
String rightUsername = "itheima";
String rightPassword = "1234qwer";
//2.键盘录入用户名和密码
//ctrl + alt + T 选择包裹方式
for (int i = 0; i < 3; i++) {//0 1 2
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名");
String username = sc.next();
System.out.println("请输入密码");
String password = sc.next();
//3.判断比较
if (username.equals(rightUsername) && password.equals(rightPassword)) {
System.out.println("登录成功");
//如果正确，循环结束
break;
} else {
//最后一次机会
if(i == 2){
System.out.println("账户" + username + "被锁定");
}else{
//不是最后一次机会
System.out.println("用户名或密码错误，登录失败,还剩下" + (2 - i) + "次机会");//2 1 0
}
}
}
}
}遍历字符串案例
public char charAt(int index) //根据索引返回字符 //调用方法: char c = 字符串对象.charAt(int index)
public int length() //返回字符串的长度
数组的长度: 数组名.length
字符串的长度: 字符串对象.length案例需求
键盘录入一个字符串，使用程序实现在控制台遍历该字符串
直接遍历字符串
public class Test2字符串直接遍历 {
public static void main(String[] args) {
//两个方法：
//charAt()：会根据索引获取对应的字符
//length(): 会返回字符串的长度
//1.键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入字符串");
String str = sc.next();
System.out.println(str);
//2.遍历
for (int i = 0; i < str.length(); i++) {
//i 依次表示字符串的每一个索引
//索引的范围：0 ~ 长度-1
//根据索引获取字符串里面的每一个字符
//ctrl + alt + V 自动生成左边的接受变量
char c = str.charAt(i);
System.out.println(c);
}
}
}统计字符次数案例
案例需求
键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
代码实现
public class Test4统计个数 {
public static void main(String[] args) {
//键盘录入一个字符串，统计大写，小写，数字出现的次数
//1.键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
//2.统计 --- 计数器count
//此时我要统计的有3样东西，所以要定义3个计数器分别进行统计
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
//得到这个字符串里面每一个字符
for (int i = 0; i < str.length(); i++) {
//i 表示字符串中的索引
//c 表示字符串中的每一个字符
char c = str.charAt(i);
//对c进行判断
if (c >= 'a' && c <= 'z') {
smallCount++;
}else if(c >= 'A' && c <= 'Z'){
bigCount++;
}else if(c >= '0' && c <= '9'){
numberCount++;
}
}
//3.当循环结束之后，三个变量记录的就是对应的个数
System.out.println("大写字符有:" + bigCount + "个");
System.out.println("小写字符有:" + smallCount + "个");
System.out.println("数字字符有:" + numberCount + "个");
}
}字符串拼接案例
案例需求
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
并在控制台输出结果。例如，数组为 int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
代码实现
public class Test5数组拼接成字符串 {
public static void main(String[] args) {
//定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
//并在控制台输出结果。例如，数组为 int[] arr = {1,2,3};
//执行方法后的输出结果为：[1, 2, 3]
int[] arr = {1, 2, 3, 4, 5};
String str = arrToString(arr);
System.out.println(str);
}
//作用：把一个数组变成字符串
public static String arrToString(int[] arr) {
String s = "";
//拼接左括号
s = s + "["; //此时是拿着长度为0的字符串，跟[进行拼接，产生一个新的字符串。
//把新的字符串再赋值给s，此时变量s记录的就是新的字符串"["的地址值
//下面我想得到数组里面的每一个元素并进行拼接
//那么就需要遍历数组，得到每一个元素才行
for (int i = 0; i < arr.length; i++) {
//假设第一次循环:i = 0 获取的就是0索引上的元素
//在拼接的时候："[" + 1 + ", " 拼接完毕之后产生一个新的字符串 "[1, "
//第二次循环：i = 1 获取的就是1索引上的元素
//在拼接的时候： 此时s就是第一次循环结束后拼接完毕的结果："[1, "
//在拼接的时候："[1, " + 2 + ", " 拼接完毕之后产生一个新的字符串 "[1, 2, "
//...
if(i == arr.length - 1){
//如果是最后一个元素，那么不需要拼接逗号空格
s = s + arr[i];
}else{
//如果不是最后一个元素，需要拼接元素和逗号空格
s = s + arr[i] + ", ";
}
}
//等循环结束之后，再拼接最后一个右括号
s = s + "]";
return s;
}
//用来遍历数组
public static void printArr(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i]);
} else {
System.out.print(arr[i] + ", ");
}
}
System.out.println("]");
//[1, 2, 3, 4, 5]
//我们现在要知道，这个最终结果是怎么来的？
//从到右依次打印得来的。
}
}字符串反转案例
案例需求
定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
例如，键盘录入 abc，输出结果 cba
代码实现
public class Test6反转字符串 {
public static void main(String[] args) {
/*定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
例如，键盘录入 abc，输出结果 cba*/
//1.定义一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
//2.定义一个方法，反转字符串
//abc ---> cba
//可以把字符串倒着遍历，再拼接
String result = reverse(str);
System.out.println(result);
}
//注释：方法的作用就是反转字符串
//把传递进来的字符串进行反转
public static String reverse(String str){//abc
//核心思想：倒着遍历并进行拼接就可以了
//fori :正着遍历 forr：倒着遍历
String s = "";
for (int i = str.length() - 1; i >= 0; i--) {
//i 依次表示字符串里面的每一个索引（倒着的）
//我们就可以拿到里面的每一个字符并拼接
s = s + str.charAt(i);
}
//把倒着拼接之后的结果返回即可
return s;
}
}金额转换
案例需求
把2135变成：零佰零拾零万贰仟壹佰叁拾伍元
把789变成：零佰零拾零万零仟柒佰捌拾玖元
代码实现
package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo9 {
public static void main(String[] args) {
//1.键盘录入一个金额
Scanner sc = new Scanner(System.in);
int money;
while (true) {
System.out.println("请录入一个金额");
money = sc.nextInt();
if (money >= 0 && money <= 9999999) {
break;
} else {
System.out.println("金额无效");
}
}
//定义一个变量用来表示钱的大写
String moneyStr = "";
//2.得到money里面的每一位数字,再转成中文
while (true) {//2135
//从右往左获取数据，因为右侧是数据的个位
int ge = money % 10;
String capitalNumber = getCapitalNumber(ge);
//把转换之后的大写拼接到moneyStr当中
moneyStr = capitalNumber + moneyStr;
//第一次循环 ： "伍" + "" = "伍"
//第二次循环 ： "叁" + "伍" = "叁伍"
//去掉刚刚获取的数据
money = money / 10;
//如果数字上的每一位全部获取到了，那么money记录的就是0，此时循环结束
if (money == 0) {
break;
}
}
//3.在前面补0，补齐7位
int count = 7 - moneyStr.length();
for (int i = 0; i < count; i++) {
moneyStr = "零" + moneyStr;
}
System.out.println(moneyStr);//零零零贰壹叁伍
//4.插入单位
//定义一个数组表示单位
String[] arr = {"佰","拾","万","仟","佰","拾","元"};
// 零 零 零 贰 壹 叁 伍
//遍历moneyStr，依次得到 零 零 零 贰 壹 叁 伍
//然后把arr的单位插入进去
String result = "";
for (int i = 0; i < moneyStr.length(); i++) {
char c = moneyStr.charAt(i);
//把大写数字和单位拼接到result当中
result = result + c + arr[i];
}
//5.打印最终结果
System.out.println(result);
}
//定义一个方法把数字变成大写的中文
//1 -- 壹
public static String getCapitalNumber(int number) {
//定义数组，让数字跟大写的中文产生一个对应关系
String[] arr = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
//返回结果
return arr[number];
}
}手机号屏蔽
字符串截取
String substring(int beginindex , int endindex);
//注意:包头不包尾,包左不包右.
String substring(int beginindex);
//截取到末尾需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
最终效果为：131****9468
代码实现：
public class Test8手机号屏蔽 {
public static void main(String[] args) {
/*以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
最终效果为：131****9468*/
//1.键盘录入一个手机号码
Scanner sc = new Scanner(System.in);
System.out.println("请输入手机号码");
String phoneNumber = sc.next();//13112349408
//2.截取手机号码中的前三位
String star = phoneNumber.substring(0, 3);
//3.截取手机号码中的最后四位
//此时我用substring方法，是用1个参数的，还是两个参数的？1个参数的会更好
//因为现在我要截取到最后，所以建议使用1个参数的。
String end = phoneNumber.substring(7);
//4.拼接
String result = star + "****" + end;
System.out.println(result);
}
}敏感词替换
需求1：键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换
public class Test9敏感词替换 {
public static void main(String[] args) {
//1.定义一个变量表示骂人的话
String talk = "后裔你玩什么啊，TMD";
//2.把这句话中的敏感词进行替换
String result = talk.replace("TMD", "***");
//3.打印
System.out.println(talk);
System.out.println(result);
}
}需求2：如果要替换的敏感词比较多怎么办？
public class Test10多个敏感词替换 {
public static void main(String[] args) {
//实际开发中，敏感词会有很多很多
//1.先键盘录入要说的话
Scanner sc = new Scanner(System.in);
System.out.println("请输入要说的话");
String talk = sc.next();//后裔你玩什么啊，TMD,GDX,ctmd,ZZ
//2.定义一个数组用来存多个敏感词
String[] arr = {"TMD","GDX","ctmd","ZZ","lj","FW","nt"};
//3.把说的话中所有的敏感词都替换为***
for (int i = 0; i < arr.length; i++) {
//i 索引
//arr[i] 元素 --- 敏感词
talk = talk.replace(arr[i],"***");
}
//4.打印结果
System.out.println(talk);//后裔你玩什么啊，***,***,***,***
}
}身份证信息查看
身份证的每一位都是有固定的含义：
1、2位：省份
3、4位：城市
5、6位：区县
7-14位：出生年、月、日
15、16位：所在地派出所
17位：性别（奇数男性，偶数女性）
18位：个人信息码（随机产生）
要求打印内容方式如下：
人物信息为：
出生年月日：XXXX年X月X日
性别为：男/女
package com.itheima.stringdemo;
public class StringDemo11 {
public static void main(String[] args) {
//1.定义一个字符串记录身份证号码
String id = "321281202001011234";
//2.获取出生年月日
String year = id.substring(6, 10);
String month = id.substring(10, 12);
String day = id.substring(12, 14);
System.out.println("人物信息为：");
System.out.println("出生年月日:" + year + "年" + month + "月" + day + "日");
//3.获取性别
char gender = id.charAt(16);//'3' ---> 3
//利用ASCII码表进行转换
//'0' ---> 48
//'1' ---> 49
//'2' ---> 50
//'3' ---> 51
//'4' ---> 52
//'5' ---> 53
//'6' ---> 54
//'7' ---> 55
//'8' ---> 56
//'9' ---> 57
int num = gender - 48;
if(num % 2 == 0){
System.out.println("性别为:女");
}else{
System.out.println("性别为:男");
}
}
}StringBuilder
StringBuilder 可以看成是一个容器，创建之后里面的内容是可变的。
当我们在拼接字符串和反转字符串的时候会使用到
//因为StringBuilder是Java已经写好的类
//java在底层对他做了一些特殊处理。
//打印对象不是地址值而是属性值。构造方法
方法名 | 说明 |
public StringBuilder() | 创建一个空白可变字符对象,不含有任何内容 |
public StringBuilder(String str) | 根据字符串的内容,来创建可变字符对象 |
StringBuilder sb = new StringBuilder("abc");成员方法
方法名 | 说明 |
public StringBuilder append(任意类型) | 添加数据,并返回对象本身 |
public StringBuilder reverse() | 反转容器中的内容 |
public int length() | 返回长度(字符出现的个数) |
public String toString() | 通过toString()就可以实现StringBuilder转换为String |
基本使用
public class StringBuilderDemo3 {
public static void main(String[] args) {
//1.创建对象
StringBuilder sb = new StringBuilder("abc");
//2.添加元素
/*sb.append(1);
sb.append(2.3);
sb.append(true);*/
//反转
sb.reverse();
//获取长度
int len = sb.length();
System.out.println(len);
//打印
//普及：
//因为StringBuilder是Java已经写好的类
//java在底层对他做了一些特殊处理。
//打印对象不是地址值而是属性值。
System.out.println(sb);
}
}链式编程
当我们在调用一个方法的时候,不需要用变量接收他的结果,可以继续调用其他方法
public class StringBuilderDemo4 {
public static void main(String[] args) {
//1.创建对象
StringBuilder sb = new StringBuilder();
//2.添加字符串
sb.append("aaa").append("bbb").append("ccc").append("ddd"); //链式编程
System.out.println(sb);//aaabbbcccddd
//3.再把StringBuilder变回字符串
String str = sb.toString();
System.out.println(str);//aaabbbcccddd
}
}练习1：对称字符串
需求：
键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是
对称字符串：123321、111
非对称字符串：123123
代码示例：
public class StringBuilderDemo6 {
//使用StringBuilder的场景：
//1.字符串的拼接
//2.字符串的反转
public static void main(String[] args) {
//1.键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
//2.反转键盘录入的字符串
String result = new StringBuilder().append(str).reverse().toString();
//3.比较
if(str.equals(result)){
System.out.println("当前字符串是对称字符串");
}else{
System.out.println("当前字符串不是对称字符串");
}
}
}练习2：拼接字符串
需求：定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回。
调用该方法，并在控制台输出结果。
例如：数组为int[] arr = {1,2,3};
执行方法后的输出结果为：[1, 2, 3]
代码示例:
package com.itheima.stringbuilderdemo;
public class StringBuilderDemo7 {
public static void main(String[] args) {
//1.定义数组
int[] arr = {1,2,3};
//2.调用方法把数组变成字符串
String str = arrToString(arr);
System.out.println(str);
}
public static String arrToString(int[] arr){
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if(i == arr.length - 1){
sb.append(arr[i]);
}else{
sb.append(arr[i]).append(", ");
}
}
sb.append("]");
return sb.toString();
}
}StringJoiner
StringJoiner跟StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的。
作用：提高字符串的操作效率，而且代码编写特别简洁，但是目前市场上很少有人用。
JDK8出现的
构造方法
方法名 | 说明 |
public StringJoiner(间隔符号) | 创建一个StringJoiner对象,指定拼接时的间隔符号 |
public StringJoiner(间隔符号,开始符号,结束符号) | 创建一个StringJoiner对象,指定拼接时的间隔符号,开始符号,结束符号 |
成员方法
方法名 | 说明 |
public StringJoiner add(添加的内容) | 添加数据,并返回对象本身 |
public int length() | 返回长度(字符出现的个数) |
public String toString() | 返回一个字符串(改字符串就是拼接之后的结果) |
基本使用
//1.创建一个对象，并指定中间的间隔符号
StringJoiner sj = new StringJoiner("---");
//2.添加元素
sj.add("aaa").add("bbb").add("ccc");
//3.打印结果
System.out.println(sj);//aaa---bbb---ccc//1.创建对象
StringJoiner sj = new StringJoiner(", ","[","]");
//2.添加元素
sj.add("aaa").add("bbb").add("ccc");
int len = sj.length();
System.out.println(len);//15
//3.打印
System.out.println(sj);//[aaa, bbb, ccc]
String str = sj.toString();
System.out.println(str);//[aaa, bbb, ccc]关于字符串的扩展
字符串存储的内存原理
String s = “abc”；直接赋值
特点：
此时字符串abc是存在字符串常量池中的。
先检查字符串常量池中有没有字符串abc，如果有，不会创建新的，而是直接复用。如果没有abc，才会创建一个新的。
所以，直接赋值的方式，代码简单，而且节约内存。
new出来的字符串
看到new关键字，一定是在堆里面开辟了一个小空间。
String s1 = new String（“abc”）；
String s2 = “abc”；
s1记录的是new出来的，在堆里面的地址值。
s2是直接赋值的，所以记录的是字符串常量池中的地址值。
==号比较的到底是什么？
如果比较的是基本数据类型：比的是具体的数值是否相等。
如果比较的是引用数据类型：比的是地址值是否相等。
结论：==只能用于比较基本数据类型。不能比较引用数据类型。
字符串拼接的底层原理
拼接的时候没有变量,都是字符串
触发字符串的优化机制
在编译的时候就已经是最终的结果了
集合
集合长度可变
可以存引用数据类型,基本数据类型需要包装类
包装类
byte | Byte |
short | Short |
char | Character |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
ArrayList
泛型: 限定集合中存储数据的类型
<>中写入需要存储的数据类型,不能是基本数据类型
打印对象不是地址值,而是集合中存储的数据内容
在展示的时候会拿两个[]把所有的数据进行包裹展示
import java.util.ArrayList;
public class ArrayDemo1 {
public static void main(String[] args) {
//1.创建集合对象
ArrayList<String> list = new 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() | 集合的长度,也就是集合中元素的个数 |
import java.util.ArrayList;
public class ArrayDemo1 {
public static void main(String[] args) {
//1.创建集合对象
ArrayList<String> list = new ArrayList<>();
System.out.println(list);
//2.添加数据
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("eee");
System.out.println("---增---");
System.out.println(list); //[aaa, bbb, ccc, eee]
//2.删除数据
System.out.println("---删---");
boolean result = list.remove("ccc");
System.out.println(result); //true
System.out.println(list); //[aaa, bbb, eee]
boolean result1 = list.remove("ddd");
System.out.println(result1); //false
System.out.println(list);// [aaa, bbb, eee]
String result2 = list.remove(1);
System.out.println(result2); //bbb
System.out.println(list); //[aaa, eee]
//3.修改数据
System.out.println("---改---");
list.set(0,"我喜欢你");
System.out.println(list);// [我喜欢你, eee]
//4.查找数据
String result3 = list.get(0);
System.out.println(result3); //我喜欢你
//5.集合长度
int result4 = list.size();
System.out.println(result4); //2
}
}练习
1.定义一个集合,添加字符串,并进行遍历,遍历格式参照: [元素1,元素2,元素3]
import java.util.ArrayList;
public class ArrayListDemo1 {
//定义一个集合,添加字符串,并进行遍历,遍历格式参照: [元素1,元素2,元素3]
public static void main(String[] args) {
//1.定义一个集合
ArrayList<String> list = new ArrayList<>();
//2.添加元素
list.add("你好");
list.add("我喜欢你");
list.add("就是你");
//3.遍历元素
String result = "[";
for (int i = 0; i < list.size(); i++) {
if (i == list.size() -1){
result = result + list.get(i) + "]";
}else {
result = result + list.get(i) + ",";
}
}
//4.打印
System.out.println(result);
}
}2.定义一个集合,并添加数字,并进行遍历,遍历格式参照: [元素1,元素2,元素3]
import java.util.ArrayList;
public class ArrayListDemo2 {
//定义一个集合,并添加数字,并进行遍历,遍历格式参照: [元素1,元素2,元素3]
public static void main(String[] args) {
//1.定义一个集合
ArrayList<Integer> list = new ArrayList<>();
//2.添加元素
list.add(5);
list.add(2);
list.add(1);
//3.遍历元素
String result = "[";
for (int i = 0; i < list.size(); i++) {
if (i == list.size() -1){
result = result + list.get(i) + "]";
}else {
result = result + list.get(i) + ",";
}
}
//4.打印
System.out.println(result);
}
}3.创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
import java.util.ArrayList;
public class ArrayListDemo3 {
public static void main(String[] args) {
//创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
//1.创建集合
ArrayList<Student> list = new ArrayList<>();
//2.创建学生对象
Student stu1 = new Student("zhangsan",19);
Student stu2 = new Student("lisi",18);
Student stu3 = new Student("wangsu",16);
//3.向集合添加元素
list.add(stu1);
list.add(stu2);
list.add(stu3);
//4.遍历集合
for (int i = 0; i < list.size(); i++) {
//i索引list.get(i) 元素/学生对象
Student stu = list.get(i);
System.out.println(stu.getName()+","+stu.getAge());
}
}
}4.需求：
1，main方法中定义一个集合，存入三个用户对象。
用户属性为：id，username，password
2，要求：定义一个方法，根据id查找对应的学生信息。
如果存在，返回索引
如果不存在，返回-1
import java.util.ArrayList;
import java.util.Scanner;
public class ArrayListDemo4 {
/*
* 需求：
1，main方法中定义一个集合，存入三个用户对象。
用户属性为：id，username，password
2，要求：定义一个方法，根据id查找对应的学生信息。
如果存在，返回索引
如果不存在，返回-1
* */
public static void main(String[] args) {
//1.定义一个集合
ArrayList<User> list = new ArrayList<>();
//2.创建用户对象
User us1 = new User("wql","Wangqianlong",123);
User us2 = new User("hx","hanxin",456);
User us3 = new User("xz","xingzhen",789);
//3.向集合中存储对象
list.add(us1);
list.add(us2);
list.add(us3);
//4.键盘输入查询id
Scanner sc = new Scanner(System.in);
System.out.print("请输入id：");
String id = sc.next();
int result = checkid(list,id);
System.out.print("查询结果:"+result);
}
//4.定义方法，通过id查找对应学生信息
public static int checkid(ArrayList<User> list,String id){
//遍历获取每个id
for (int i = 0; i < list.size(); i++) {
User user = list.get(i); //获取集合每一个元素
if (user.getId().equals(id)){
return i;
}
}
return -1;
}
}学生管理系统
需求：
采取控制台的方式去书写学生管理系统。
分析：
初始菜单：
"-------------欢迎来到学生管理系统----------------"
"1：添加学生"
"2：删除学生"
"3：修改学生"
"4：查询学生"
"5：退出"
"请输入您的选择:"学生类：
属性：id、姓名、年龄、家庭住址
添加功能：
键盘录入每一个学生信息并添加，需要满足以下要求：
id唯一
删除功能：
键盘录入要删除的学生id，需要满足以下要求：
id存在删除
id不存在，需要提示不存在，并回到初始菜单
修改功能：
键盘录入要修改的学生id，需要满足以下要求
id存在，继续录入其他信息
id不存在，需要提示不存在，并回到初始菜单
查询功能：
打印所有的学生信息，需要满足以下要求
如果没有学生信息，提示：当前无学生信息，请添加后再查询
如果有学生信息，需要按照以下格式输出。（不用过于纠结对齐的问题）
id 姓名 年龄 家庭住址
ha001 张三 23 南京
ha002 李四 24 北京
ha003 王五 25 广州
ha004 赵六 26 深圳案例需求
完成一个综合案例：学生管理系统。该系统主要功能如下：
添加学生：通过键盘录入学生信息，添加到集合中
删除学生：通过键盘录入要删除学生的学号，将该学生对象从集合中删除
修改学生：通过键盘录入要修改学生的学号，将该学生对象其他信息进行修改
查看学生：将集合中的学生对象信息进行展示
退出系统：结束程序
实现步骤
定义学生类，包含以下成员变量
private String sid // 学生id
private String name // 学生姓名
private String age // 学生年龄
private String address // 学生所在地
学生管理系统主界面的搭建步骤
2.1 用输出语句完成主界面的编写
2.2 用Scanner实现键盘输入
2.3 用switch语句完成选择的功能
2.4 用循环完成功能结束后再次回到主界面
学生管理系统的添加学生功能实现步骤
3.1 定义一个方法，接收ArrayList 集合
3.2 方法内完成添加学生的功能
①键盘录入学生信息
②根据录入的信息创建学生对象
③将学生对象添加到集合中
④提示添加成功信息
3.3 在添加学生的选项里调用添加学生的方法
学生管理系统的查看学生功能实现步骤
4.1 定义一个方法，接收ArrayList 集合
4.2 方法内遍历集合，将学生信息进行输出
4.3 在查看所有学生选项里调用查看学生方法
学生管理系统的删除学生功能实现步骤
5.1 定义一个方法，接收ArrayList 集合
5.2 方法中接收要删除学生的学号
5.3 遍历集合，获取每个学生对象
5.4 使用学生对象的学号和录入的要删除的学号进行比较,如果相同，则将当前学生对象从集合中删除
5.5 在删除学生选项里调用删除学生的方法
学生管理系统的修改学生功能实现步骤
6.1 定义一个方法，接收ArrayList 集合
6.2 方法中接收要修改学生的学号
6.3 通过键盘录入学生对象所需的信息，并创建对象
6.4 遍历集合，获取每一个学生对象。并和录入的修改学生学号进行比较.如果相同，则使用新学生对象替换当前学生对象
6.5 在修改学生选项里调用修改学生的方法
退出系统
使用System.exit(0);退出JVM
import java.util.ArrayList;
import java.util.Scanner;
public class StudentSystem {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
loop: while (true) { //给循环起个标识符，让break跳出while循环
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.print("请输入您的选择:");
Scanner sc = new Scanner(System.in);
String choose = sc.next();
switch (choose){
case "1" -> addStudent(list);
case "2" -> deleteStudent(list);
case "3" -> updateStudent(list);
case "4" -> queryStudent(list);
case "5" -> {
System.out.println("退出");
break loop; //单个break只会跳出switc循环，break+标识符可以跳出指定循环
//System.exit(0); 停止虚拟机运行
}
default -> System.out.println("没有这个选项");
}
}
}
//添加学生
public static void addStudent(ArrayList<Student> list){
Scanner sc = new Scanner(System.in);
String id;
while (true) {
System.out.print("请输入学生id:");
id = sc.next();
int result = checkId(list,id);
if (result >= 0){
//表示存在，需要重新需入
System.out.println("id已经存在，请重新录入");
}else {
//id不存在,表示可以继续使用
break;
}
}
System.out.print("请输入学生姓名:");
String name = sc.next();
System.out.print("请输入学生年龄:");
int age = sc.nextInt();
System.out.print("请输入学生家庭住址:");
String adress = sc.next();
//创建学生对象
Student student = new Student(id,name,age,adress);
//向集合中添加学生对象
list.add(student);
System.out.println("添加成功");
}
//删除学生
public static void deleteStudent(ArrayList<Student> list){
Scanner sc = new Scanner(System.in);
System.out.print("请输入要删除学生的id:");
String deleteId = sc.next();
int result = checkId(list,deleteId);
if (result >= 0){
list.remove(result);
System.out.println("删除成功");
}else{
System.out.println("没有要删除人的信息");
}
}
//修改学生
public static void updateStudent(ArrayList<Student> list){
Scanner sc = new Scanner(System.in);
System.out.print("请输入要修改学生的id:");
String updateId = sc.next();
int resultindex = checkId(list,updateId);
if (resultindex == -1){
//表示修改人不在集合中
System.out.println("要修改的id:"+updateId+"不存在，请重新输入");
return;
}
//修改人在集合中
//获取要修改的学生对象
Student student = list.get(resultindex);
//输入信息进行修改
System.out.print("请输入修改后的学生姓名:");
String newName = sc.next();
student.setName(newName);
System.out.print("请输入修改后的学生年龄:");
int newAge = sc.nextInt();
student.setAge(newAge);
System.out.print("请输入修改后的学生家庭住址:");
String newAdress = sc.next();
student.setAdress(newAdress);
System.out.println("修改成功");
}
//查询学生
public static void queryStudent(ArrayList<Student> list){
if (list.size() == 0){
System.out.println("当前无学生信息，请添加后再查询");
return; //结束本方法
}
//有学生信息，按照以下格式输出
System.out.println("id\t\t姓名\t年龄\t家庭住址");
for (int i = 0; i < list.size(); i++) {
Student student = list.get(i);
System.out.println(student.getId()+"\t"+student.getName()+"\t"+student.getAge()+"\t"+student.getAdress());
}
}
//通过id查询是否在集合中
public static int checkId(ArrayList<Student> list,String id){
for (int i = 0; i < list.size(); i++) {
Student student = list.get(i);
if (student.getId().equals(id)){
return i;
}
}
//不存在
return -1;
}
}学生管理系统升级
需求：
为学生管理系统书写一个登陆、注册、忘记密码的功能。
只有用户登录成功之后，才能进入到学生管理系统中进行增删改查操作。
分析：
登录界面：
System.out.println("欢迎来到学生管理系统");
System.out.println("请选择操作1登录 2注册 3忘记密码");用户类：
属性：用户名、密码、身份证号码、手机号码
注册功能：
1，用户名需要满足以下要求：
验证要求：
用户名唯一
用户名长度必须在3~15位之间
只能是字母加数字的组合，但是不能是纯数字
2，密码键盘输入两次，两次一致才可以进行注册。
3，身份证号码需要验证。
验证要求：
长度为18位
不能以0为开头
前17位，必须都是数字
最为一位可以是数字，也可以是大写X或小写x
4，手机号验证。
验证要求：
长度为11位
不能以0为开头
必须都是数字
登录功能：
1，键盘录入用户名
2，键盘录入密码
3，键盘录入验证码
验证要求：
用户名如果未注册，直接结束方法，并提示：用户名未注册，请先注册
判断验证码是否正确，如不正确，重新输入
再判断用户名和密码是否正确，有3次机会
忘记密码：
1，键盘录入用户名，判断当前用户名是否存在，如不存在，直接结束方法，并提示：未注册
2，键盘录入身份证号码和手机号码
3，判断当前用户的身份证号码和手机号码是否一致，
如果一致，则提示输入密码，进行修改。
如果不一致，则提示：账号信息不匹配，修改失败。
验证码规则：
长度为5
由4位大写或者小写字母和1位数字组成，同一个字母可重复
数字可以出现在任意位置
比如：
aQa1K
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
public class App {
public static void main(String[] args) {
ArrayList<User> list = new ArrayList<>();
while (true){
System.out.println("---------欢迎来到学生管理系统升级版---------");
System.out.println("请选择操作：1登陆，2注册，3忘记密码");
Scanner sc = new Scanner(System.in);
System.out.print("请输入选择:");
String choose = sc.next();
switch (choose){
case "1" -> Login(list);
case "2" -> register(list);
case "3" -> forgetPassword(list);
case "4" -> {
System.out.println("谢谢使用，再见！");
System.exit(0);
}
default -> System.out.println("没有这个选项");
}
}
}
//登陆
public static void Login(ArrayList<User> list){
//1.键盘录入用户名
Scanner sc =new Scanner(System.in);
for (int i = 0; true; i++) {
System.out.print("请输入用户名:");
String username = sc.next();
int checkIndex = checkIndex(list,username);
if (checkIndex == -1){
System.out.println("用户名"+username+"没有注册，请先注册再登陆");
return;
}
//2.键盘输入密码
System.out.println("请输入密码:");
String password = sc.next();
//3.键盘输入验证码
String rightCode = GetCode();
System.out.println("当前正确验证码:"+rightCode);
while (true) {
System.out.print("请输入验证码:");
String code = sc.next();
if (code.equalsIgnoreCase(rightCode)){
System.out.println("验证码正确");
break;
}else {
System.out.println("验证码错误，请重新输入");
}
}
//验证用户名和密码是否正确
//将上面输入的数据封装为一个对象
User InfoUser = new User(username,password,null,null);
boolean Result = checkInfo(list,InfoUser);
if (Result){
System.out.println("登陆成功");
break;
}else {
System.out.println("登陆失败,用户名或密码错误");
if (i == 2){
System.out.println("当前账号"+username+"被锁定");
return;
}else {
System.out.println("用户名或密码错误，还剩"+(2-i)+"次");
}
}
}
}
//注册
public static void register(ArrayList<User> list){
//1.键盘录入用于名
//用户名需要满足以下要求：
//验证要求：
//先验证格式是否正确，再验证是否唯一
//用户名长度必须在3~15位之间
//只能是字母加数字的组合，但是不能是纯数字
//用户名唯一
Scanner sc = new Scanner(System.in);
String name;
while (true) {
System.out.print("请输入用户名:");
name = sc.next();
boolean result = checkUsernmae(name);
if (!result){
System.out.println("用户名格式不满足条件，请重新输入!");
continue;
}
//判断用户名是否唯一
int resultIndex = checkIndex(list,name);
if (resultIndex >= 0){
//用户名存在
System.out.println("用户名"+name+"存在"+"，请重新输入。");
}else {
//用户名不存在，可以继续录入
System.out.println("用户名"+name+"可以使用。");
break;
}
}
//2.键盘输入密码
//密码键盘输入两次，两次一致才可以进行注册。
String password;
while (true) {
System.out.print("请输入要注册的密码:");
password = sc.next();
System.out.print("请再次输入要注册的密码:");
String againPassword = sc.next();
if (!password.equals(againPassword)){
System.out.println("两次密码输入不一致，请重新输入！");
}else{
System.out.println("两次密码输入一致，继续录入其他数据");
break;
}
}
//3.键盘输入身份证号
//验证要求：
//长度为18位
//不能以0为开头
//前17位，必须都是数字
//最为一位可以是数字，也可以是大写X或小写x
String personId;
while (true) {
System.out.print("请输入身份证号:");
personId = sc.next();
boolean result = checkpersonID(personId);
if (!result){
System.out.println("身份证格式不正确，请重新输入!");
}else {
System.out.println("身份证格式正确，请继续输入其他信息");
break;
}
}
//4.键盘输入手机号码
//验证要求：
//长度为11位
//不能以0为开头
//必须都是数字
String userPhone;
while (true) {
System.out.print("请输入注册手机号:");
userPhone = sc.next();
boolean resultnumber = checkPhoneNumber(userPhone);
if (!resultnumber){
System.out.println("手机号格式错误，请重新输入");
}else {
System.out.println("手机号正确");
break;
}
}
//创建用户对象
User user = new User(name,password,personId,userPhone);
//把用户对象添加到集合中
list.add(user);
System.out.println("注册成功");
pringList(list);
}
//打印集合的学生对象
public static void pringList(ArrayList<User> list){
for (User user : list) {
System.out.println(user.getUsername() + user.getPassword() + user.getPersonId() + user.getPhoneNumber());
}
}
//忘记密码
public static void forgetPassword(ArrayList<User> list){
Scanner sc = new Scanner(System.in);
System.out.print("请输入用户名:");
String name =sc.next();
int Index = checkIndex(list,name);
if (Index == -1){
System.out.println("用户不存在，请先注册");
return;
}
//键盘录入身份证号和手机号码
System.out.print("请输入身份证号:");
String personID = sc.next();
System.out.print("请输入手机号码:");
String Phone = sc.next();
//判断当前用户的身份证号码和手机号码是否一致，
//封装用户的身份证号码和手机号码
User InfoUser = new User(null,null,personID,Phone);
boolean result = CheckInfo(list,InfoUser,Index);
if (!result){
System.out.println("账号信息不匹配");
return;
}
System.out.println("身份确认，可以修改密码");
String newPassword;
while (true) {
System.out.print("请输入修改后的密码:");
newPassword = sc.next();
System.out.print("请再次输入密码:");
String AgainNewPassword = sc.next();
if (newPassword.equals(AgainNewPassword)){
System.out.println("两次密码输入一致");
break;
}else{
System.out.println("两次密码不一致，请重新输入");
continue;
}
}
//修改数据
changeDate(list,Index,newPassword);
}
//判断用户名格式
public static boolean checkUsernmae(String username){
//将字符串变为字符数组
char[] arr = username.toCharArray();
//计数器
int small = 0;
int big = 0;
int number = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] <= 'z' && arr[i] >= 'a'){
small++;
} else if (arr[i] <= 'Z' && arr[i] >= 'A') {
big++;
} else if (arr[i] <= '9' && arr[i] >= '0') {
number++;
}
}
//用户名长度必须在3~15位之间
//只能是字母加数字的组合，但是不能是纯数字
if ((small+big+number) >= 3 && (small+big+number) <=15){
if (small > 0 || big > 0){
return number != 0;
}else {
return false;
}
}else {
return false;
}
}
//判断用户名是否唯一
public static int checkIndex(ArrayList<User> list,String name){
for (int i = 0; i < list.size(); i++) {
User user = list.get(i);
if (user.getUsername().equals(name)){
return i;
}
}
//不存在,唯一
return -1;
}
//判断身份证号码
public static boolean checkpersonID(String personId){
//长度为18位
if (personId.length() != 18){
return false;
}
//不能以0为开头
if (personId.startsWith("0")){
return false;
}
//前17位，必须都是数字
for (int i = 0; i < personId.length(); i++) {
char c = personId.charAt(i);
if (!(c >= '0' && c <= '9')){
return false;
}
}
//最为一位可以是数字，也可以是大写X或小写x
char endChar = personId.charAt(personId.length()-1);
if ((endChar >= '0' && endChar <= '9') || (endChar == 'X') || (endChar == 'x')){
return true;
}else {
return false;
}
}
//判断手机号码
public static boolean checkPhoneNumber(String phonenumber){
//验证要求：
//长度为11位
if (phonenumber.length() != 11){
return false;
}
//不能以0为开头
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;
}
//生成一个验证码
//长度为5
//由4位大写或者小写字母和1位数字组成，同一个字母可重复
//数字可以出现在任意位置
private static String GetCode(){
//1.创建一个集合添加所有的大写和小写字母
ArrayList<Character> list = new ArrayList<>();
for (int i = 0; i < 26; i++) {
list.add((char)('a' + i));
list.add((char)('A' + i));
}
//2.随机抽取4个字符
StringBuilder sb =new StringBuilder();
Random r = new Random();
for (int i = 0; i < 4; i++) {
//获取随机索引
int index = r.nextInt(list.size());
//利用随机索引获取字符
sb.append(list.get(index));
}
//3.把一个随机数字放到末尾
int number = r.nextInt(10);
sb.append(number);
//4.把字符串变成字符数组，在数组中修改，然后再穿件一个新的字符串
char[] arr = sb.toString().toCharArray();
//拿着最后一个索引，跟随机索引交换
int Index = r.nextInt(arr.length);
//交换索引指向的元素交换
char temp = arr[Index];
arr[Index] = arr[arr.length-1];
arr[arr.length-1] = temp;
//重新变为字符串并且返回
return new String(arr);
}
//校验用户名和密码
public static boolean checkInfo(ArrayList<User> list,User InfoUser){
//遍历集合，判断用户名是否存在
int Index = checkIndex(list,InfoUser.getUsername());
if (Index == -1){
//用户名不存在
return false;
}else {
User user = list.get(Index);
return InfoUser.getPassword().equals(user.getPassword());
}
}
//校验用户的身份证号码和手机号码
public static boolean CheckInfo(ArrayList<User> list,User InfoUser,int index){
User user = list.get(index);
if (user.getPersonId().equals(InfoUser.getPersonId())){
return user.getPhoneNumber().equals(InfoUser.getPhoneNumber());
}else {
return false;
}
}
//修改密码
public static void changeDate(ArrayList<User> list,int index,String change){
User user = list.get(index);
user.setPassword(change);
System.out.println("修改数据成功");
}
}static 静态变量
static表示静态,是java中的一个修饰符,可以修饰成员方法,成员变量
静态变量
被static修饰的成员变量,叫做静态变量
特点:
被该类所有对象共享
不属于对象,属于类
静态变量是随着类的加载而加载,放于堆内存中的静态区,优先于对象出现的
调用方式:
类名调用(推荐)
对象名调用
定义格式
修饰符 static 数据类型 变量名 = 初始值； 举例
public class Student {
public static String schoolName = "常州大学"； // 属于类，只有一份。
// .....
}静态成员变量的访问:
格式：类名.静态变量
public static void main(String[] args){
System.out.println(Student.schoolName); // 常州大学
Student.schoolName = "程序员";
System.out.println(Student.schoolName); // 程序员
}实例变量及其访问
无static修饰的成员变量属于每个对象的， 这个成员变量叫实例变量，之前我们写成员变量就是实例成员变量。
需要注意的是：实例成员变量属于每个对象，必须创建类的对象才可以访问。
格式：对象.实例成员变量
静态方法
被static修饰的成员方法,叫做静态方法
静态方法的生命周期与类相同，在类定义的时候静态方法就被分配和装载入内存中，当本进程结束时，才会随之销毁。
非静态方法的生命周期和类的实例化对象相同，只有当类实例化了一个对象，非静态方法才会被创建，而当这个对象被销毁时，非静态方法也马上被销毁。
特点:
多用在测试类和工具类中
javabean类中很少会用
调用方式:
类名调用(推荐)
对象名调用
举例
public class Student{
private Student(){} //私有化构造方法 目的:不让外界创建他的对象
public static String schoolName = "常州大学"； // 属于类，只有一份。
// .....
public static void study(){
System.out.println("我们都是程序员");
}
}静态成员变量的访问:
格式：类名.静态方法
public static void main(String[] args){
Student.study();
}Javabean类,测试类,工具类
Javabean类: 用来描述一类事物的类,比如,Student,Teacher等
测试类: 用来检查其他类是否书写正确,带有main方法的类,是程序的入口
工具类: 不是用来描述一类事物的,而是帮我们做一些事情的类
工具类:
类名见名知意
私有化构造方法 目的:不让外界创建他的对象
方法定义为静态
练习:
编写一个数组的工具类:ArrayUtil
提供一个工具类方法printArr,用于放回整数数组的内容 ,返回的字符串格式如下[10,20,50] (只考虑整数数组,且只考虑一维数组)
提供一个工具类getAerage,用于返回平均分.(只考虑浮点型数组,且只考虑一维数组)
public class ArrayUtil { private ArrayUtil(){} //私有化构造方法 目的:不让外界创建他的对象 //提供一个工具类方法printArr,用于放回整数数组的内容 ,返回的字符串格式如下[10,20,50] (只考虑整数数组,且只考虑一维数组) //需要定义为静态，方便调用 public static String printArr(int[] arr){ StringBuilder sb = new StringBuilder(); sb.append("["); for (int i = 0; i < arr.length; i++) { if(i == arr.length - 1){ sb.append(arr[i]); }else{ sb.append(arr[i]).append(", "); } } sb.append("]"); return sb.toString(); } //提供一个工具类getAerage,用于返回平均分.(只考虑浮点型数组,且只考虑一维数组) public static double getAerage(double[] arr){ double sum = 0; for (int i = 0; i < arr.length; i++) { sum += arr[i]; } return sum/arr.length; } }
实例方法及其访问
无static修饰的成员方法属于每个对象的，这个成员方法也叫做实例方法。
需要注意的是：实例方法是属于每个对象，必须创建类的对象才可以访问。
格式：对象.实例方法
示例：
public class Student {
// 实例变量
private String name ;
// 2.方法：行为
// 无 static修饰，实例方法。属于每个对象，必须创建对象调用
public void run(){
System.out.println("学生可以跑步");
}
// 无 static修饰，实例方法
public void sleep(){
System.out.println("学生睡觉");
}
public static void study(){
}
}public static void main(String[] args){
// 创建对象
Student stu = new Student ;
stu.name = "张三";
// Student.sleep();// 报错，必须用对象访问。
stu.sleep();
stu.run();
}注意事项
静态方法只能访问静态变量和静态方法,不能调用非静态变量和非静态方法
非静态方法可以访问静态变量或者静态方法,也可以访问非静态的成员变量和非静态的成员方法
静态方法中没有this关键字
main方法
public : 被JVM调用,访问权限足够大
static : 被JVM调用,不用创建对象,直接类名访问,因为main方法是静态的,所以测试类中的其他方法也需要是静态的
void : 被JVM调用,不需要给JVM返回值
main : 一个通用的名称,虽然不是关键字,但是被JVM识别
String[] args : 以前用于键盘录入数据,现在没有作用
扫一扫
3244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
