yuqi的学习日志
/2026-4-28
equals方法的用法
与== 的区别
用于判断 int 等类型是否相等
判断 引用类型时是判断两者的内存地址是否相等
equals 只能判断引用类型，且判断的是引用的内容
用法
例
str1.equals(ste2)
this关键字
使用变量有就近原则（局部变量，成员变量，谁近用谁）
用于当局部变量和成员变量重名时进行区分
用法：
this.成员变量
构造方法
作用：在创建对象的时候给成员进行初始化
特点:
方法名与类名相同,大小写也要一致
没有返回值类型,连void都没有
没有具体的返回值(不能由retrun带回结果数据)
执行时机:
4. 创建对象的时候由虚拟机调用,不能手动调用构造方法
5. 每创建一次对象,就会调用一次构造方法
习惯:无论是否使用,都手动书写无参数构造方法,和带全部参数的构造方法
public class Student {
private String name;
private int age;
//构造空参方法
public Student() {
···
}
//
带全部参数构造方法
public Student(String name, int age) {
···
}
Student s1 = new Student();
Student s2 = new Student("3₭E", 23);
英雄VS怪兽
import java.util.Random;
public class fightgame {
//设置角色属性
public static void main(String[] args) {
int heroblood = 500 ;
int monsterblood = 300 ;
Random r = new Random();
int heroattack = r.nextInt(101);
int monsterttack = r.nextInt(151);
while (true){
//怪兽先攻击
if (heroblood!= 0){
heroblood= Math.max(heroblood - monsterttack, 0);//英雄剩余血量=原来血量-怪兽攻击力，最小值为0
System.out.println("怪兽攻击英雄"+monsterttack+"点伤害"+",英雄剩余"+heroblood+"点血");
}
else {
System.out.println("英雄被打败");
break; }
if (monsterblood != 0 ){
monsterblood= Math.max(monsterblood - heroattack, 0);//怪兽剩余血量=原来血量-英雄攻击力，最小值为0
System.out.println("英雄攻击怪兽"+monsterttack+"点伤害"+",怪兽剩余"+heroblood+"点血");
}
else {
System.out.println("怪兽被打败");
break; }
}
}
}
图书馆借还书
1.定义图书的属性
//定义图书类
public class Book {
//属性
private String title ;
private String author ;
private boolean isBrowwered;//是否被借走
//构造方法
public Book(String title, String author) {
this.title = title;
this.author = author;
this.isBrowwered = false;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public boolean isBrowwered() {
return isBrowwered;
}
public void setBrowwered(boolean browwered) {
isBrowwered = browwered;
}
}
2.定义显示图书状态，借书，还书的方法
import java.util.Scanner;
public class Browwer {//借书
private static Book [] books ;
static {
//静态变量初始化
books = new Book[10]; //10, null
for (int i = 0; i <books.length ; i++) {
books[i] = new Book("图书" + (i+1), "作者"+(i+1));
}
}
//定义展示图书状态的方法
public void displayBooks(){
System.out.println("编号\t图书名称\t作者\t状态\t");
for (int i = 0; i < books.length; i++) {
Book book = books[i];
System.out.println((i+1) + book.getTitle() + "\t" + book.getAuthor()+ "\t" + (book.isBrowwered() ? "已借" : "未借"));
}
}
Scanner scanner = new Scanner(System.in);
//借书的方法
public void dorrowBook (){
System.out.println("请输入你要借书的名称");
String title = scanner.next();
for (Book book : books){
if (book.getTitle().equals(title) ) {
if (!book.isBrowwered()) {
book.setBrowwered(true);
System.out.println("借书成功");
} else {
System.out.println("书已经被接走，你不能借了");
}
return;
}
}
}
//还书的方法
public void returnBook(){
System.out.println("请输入你要还的书");
String title = scanner.next();
for (Book book : books){
if (book.getTitle().equals(title)){
if (book.isBrowwered()){
book.setBrowwered(false);
System.out.println("还书成功");
}else {
System.out.println("书未被借走，你不能还");
}
}
}
}
}
3.main方法
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Browwer browwer = new Browwer();
while (true){
System.out.println("本系统的功能为："+"1.成列所有图书"+"2.借阅图书"+"3.归还图书"+ "4.退出系统");
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你要的功能");
int no = scanner.nextInt();
switch (no){
case 1 :
browwer.displayBooks();
break; case 2 :
browwer.dorrowBook();
break; case 3 :
browwer.returnBook();
break; default:
System.out.println("结束系统");
break ; }
if (no == 4) break;
}
}
}
2026-4-29
Generate tab*2+enter 简历空参方法
对象在内存中的样子
Student stu=new Student();创建对象的七步:
1 加载class字节码文件
2 申明等号左边的局部变量
3 在堆里面开辟一个空间(对象)
4 给对象中的属性进行默认初始化
5 给对象中的属性进行显示初始化
6 给对象中的属性利用构造方法进行初识化
7 把对象的内存地址赋值给等号左边的变量
方法出栈之后,方法里面的变量全部消失//
如果没有任何地方使用堆里面的对象,那么对象也会从堆里面消失
方法区里面字节码信息一般不会消失,除非关闭虚拟机
把一个对象传递给方法,实际传递的是什么?
传递的是对象的内存地址
当多个变量指向同一个对象的时候,会发生什么?
只要有一个变量修改了对象中的属性
其他变量再次访问就是修改之后的结果了
2026-4-30
static 关键字
static:表示静态,是Java的修饰符,用来修饰(成员变量/成员
static修饰成员变量，叫做静态变量，被该类的所有对象共享
关于static需要重点掌握的内容:
静态变量,被当前类所有的对象共享
共享:
赋值只要赋值一次
只要有一个对象修改了静态变量,其他对象再次访问的时候就是修改之后的结果
调用方法：类加方法名
静态对象是在堆内存中单独开辟了一片空间
静态变量是随着类的加载而加载的,优先于对象出现的
public class test {
public static void main(String[] args) {
Student s2 = new Student();
s2.name = "小王";
s2.age = 18;
Student.teachername = "罗翔"; //两个对象共享
Student s1 = new Student();
s1.name = "小厉";
s1.age = 17;
System.out.println(s1.name + " " + s1.age + " " + Student.teachername);
System.out.println(s2.name + " " + s2.age + " " + Student.teachername);
}
}
2026-5-1
定义静态方法
与静态对象相似，
可以被类中的所有对象调用，
调用的方法:类名+方法名or对象名+方法名
工具类的书写方式
不是用来描述一类事物的,也没有main方法,而是帮我们做一些事情的类
01：类名见名知意
02：私有化构造方法
03：方法定义为静态
屏幕截图 2026-05-01 211222.png
静态的注意事项
1.静态方法只能访问静态变量和其他的静态方法
2.非静态方法可以访问静态变量或者静态方法,也可以访问非静态的成员变量和非静态的成员方法
3.静态方法中是没有this关键字
总结:静态只能调用静态,非静态可以调用所有,静态方法无this（原因：静态的变量和方法是随着类建立的，此时对象可能还没有被创建，所以不能访问，非静态是随着对象被建立）
fanal关键字
final:表示最终,不可变。可以修饰变量、类、方法
特点1:只能赋值一次,数据不可变
特点2:名字大写,多个单词下划线隔开
fanal 修饰基本变量，变量变成常量，内容不能修改
fanal修饰引用变量，内存地址不能改变，其中的内容可以改变
2025-5-2
枚举
什么是枚举：枚举是一个特殊的Javabean类,这个类的对象是有限个
所以的枚举项都默认使用 pubilc static fanal 修饰
使用场景:订单的状态、月份、星期、游戏角色职业、会议室预约状态、设备状态 ...
枚举使用的注意事项
1.每一个枚举项,都是该枚举类的对象，每一个对象都是通过构造方法创建出来的
2.枚举项在底层其实就是常量,默认用public static final修饰
3.枚举类的第一行上必须是枚举项,枚举项之间用逗号隔开,以分号作为结尾
4.枚举类的构造方法必须是private修饰,不让外界创建本类的对象
5.编译器会给枚举类新增两个默认存在的方法:values(),valueOf()
values():表示获取本类所有的枚举项
valueOf():表示获取一个指定的枚举项
继承
继承 是类与类之间的一种父子关系,Java中提供关键字extends,用于建立类与类之间的关系
继承的好处
1.可以把多个子类中重复的代码抽取到父类中了,提高代码的复用性
2.子类可以在父类的基础上,增加其他的功能,使子类更强大
2026-5-3
**继承
什么是继承?
面向对象三大特征之一,可以让类跟类之间产生父子的关系。继承的作用是什么?
操作:多个子类中重复的代码抽取到父类,子类可以直接使用。
好处:减少代码冗余,提高代码复用性。继承的格式?
public class 子类 extends 父类{}继承后子类的好处?
好处一:子类可以得到父类的属性和行为,子类可以使用。
好处二:子类可以在父类的基础上新增其他功能,子类更强大。
设计类的继承结构时，采取从下往上的顺序，提取类中相同的属性和行为
Java只支持单继承,不支持多继承,但支持多层继承
细节一:直接父类和间接父类
细节二:顶级父类Object
继承中成员的特点
找本类：this
找父类：super
继承中成员方法的特点
同样是抽取共性
同样的就近原则
构造方法
方法的重写
方法的重写：在子类中，把父类的方法再写一遍，方法申明保持一致
使用场景:如果父类的方法不能满足子类的要求了，子类中可以把该方法再重写一遍
方法重写的要注意:
1.如果父类里面的代码，我一行都不想用，此时把子类中的方法体重新完整写一遍即
2.如果父类里面的代码我还想用，此时我只是在父类的基础上再加其他的逻辑，则可以用super调用父类得到一个结果，再去处理
final修饰类为最终类,里面所有的方法不能被重写，也不能被调用
private私有方法、static静态方法、final最终方法不能被重写
final修饰变量、修饰类、修饰方法
final修饰类:这个类现在就是最终类，不能被继承。
2026-5-4
继承结构当中构造方法的小细节:
1.子类构造方法第一行，有一个默认的super()，如果我们没有书写，JVM也会自动加上
2.如果想要访问父类的带参构造，super(参数)必须手动写上，不能省略
3.在创建对象的时候，先执行父类的构造方法，再执行子类的构造方法
public class person {
//属性
String name;
int age;
//构造方法
public person() {
System.out.println("父类的空参构造方法被调用");
}
public person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("父类的有参构造方法被调用");
}
}
this(...); //访问本类中的构造方法
public class student extends person{
int grade;
//构造方法
public student(){
//在老版本this()要放在第一行，用于设定一个初始值，空参和有参构造不能互相调用，要留给super调用父类
this(1,"同学",18);
System.out.println("子类的空参构造方法被调用");
}
2026-5-6
构造方法:不能被子类继承,可以利用super关键字调用
成员变量:可以被子类继承,private私有的也可以,但是私有的无法直接调用
class fu {
String name;
}
class zi extends fu {
String name;
public void show() {
System.out.println(name+" "+super.name);
}
}
public class test {
public static void main(String[] args) {
zi z1 = new zi();
z1.name = "张三";
z1.show();
}
}//结果是张三 null
成员方法:
1 .虚方法可以被继承（虚方法:就是普通的成员方法,非final、非static、非private修饰的方法。）
2 .final修饰的最终方法不能被继承,可以被调用
3 .static修饰的静态方法不能被继承,可以被调用
4 .private修饰的私有方法不能被继承,不能被调用
方法重写:替换虚方法中的地址
权限修饰符
作用范围由小到大
(private<空着不写<protected<public)
2026-5-7
多态：事物的多种状态
多态的表现形式 父类类型 对象名称 = 子类对象;
多态的前提：
1.有继承/实现关系（？）
2.有父类的引用指向子类的对象
3.有方法的重写 (可选的)
public class StudentManager {
//建立一个方法来注册
public void register(Person person){
System.out.println("姓名为" + person.getName() + "的用户注册成功,账号" + person.getUsername() + ",密码" + person.getPassword());
person.work();
}
}
多态的好处
好处一:方法中使用父类型作为参数,可接收父类对象+所有子类对象
好处二:如果进行方法重写,利用多态调用方法,
可以调用不同子类中重写的方法
多态调用成员的特点
变量调用: 编译看左边,运行也看左边
方法调用: 编译看左边,运行看右边
多态的弊端：多态下不能使用子类独有的功能
解决这种弊端的方法
类型转换
自动类型转换(从子到父):子类对象赋值给父类类型的变量
强制类型转换(从父到子):子类 对象变量=(子类)父类类型的变量
Person p = new Student();
Student s = (Student)p;
// 注意点:
// 爷爷 爸爸
// 创建了爸爸的对象,赋值给了爷爷类型
//在进行强制类型转换的时候,只能转到爸爸类型,不能转成儿子类型
Ye y = new Fu();
// 判断一下,y是不是父类类型的
if(y instanceof Fu){
Fu ff = (Fu)y;
ff.fuShow();
ff.show();
}else{
System.out.println("请确定好类型,再进行转换”);
}
2026-5-8
多态的练习题
// 行为:行驶交通工具(能使用所有交通工具)
public void drive( @NotNull Vehicle vehicle){ no usages
// 表示当前的交通工具正在行驶
vehicle.move();
// 响铃,鸣笛
// 判断一下传递过来是不是自行车
if(vehicle instanceof Bicycle){
Bicycle b = (Bicycle)vehicle;
b.ringBell();
}else if(vehicle instanceof Car){
Car c = (Car)vehicle;
c.honk();
}else{
System.out.println("没有这个类型”);
}
什么是多态?
事物的多种形态多态的好处?
好处一:方法中,使用父类型作为参数,可以接收所有子类对象
好处二:根据传递不同的对象,调用子类不同的方法多态的弊端是什么?
不能使用子类的特有功能引用数据类型的类型转换,有几种方式?
自动类型转换、强制类型转换强制类型转换能解决什么问题?强制类型转换需要注意什么?
● 可以转换成真正的子类类型,从而调用子类独有功能
● 转换类型与真实对象类型不一致会报错
● 转换的时候用instanceof关键字进行判断
抽象类和抽象方法
抽象方法:
将共性的行为(方法)抽取到父类之后。因为每一个子类的方法体是不一样,所以,在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。
public abstract 返回值类型 方法名(参数列表);
抽象类: 如果一个类中存在抽象方法,那么该类就必须声明为抽象类
public abstract class 类名{ .. }
public abstract class Animal {
//属性
private String name;
private String color;
//抽象方法
public abstract void eat();
//行为
public void drink(){
System.out.println("喝水");
}
注意点:1. 抽象类不能实例化
2. 抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类
3. 抽象类中可以有构造方法
4. 抽象类的子类，要么重写抽象类中的所有抽象方法，要么子类也是抽象类
2026-5-9
接口
接口就是一个规则,而且是独立于继承体系以外的规则。(可以理解为干爹)
格式:关键字interface来定义
使用:接口和类之间的是实现关系,通过implements关键字表示
public class 类名implements 接口{ .. }
public interface 接口名{ .. }
注意点1:接口不能实例化
注意点2:接口的子类(实现类),要么重写接口中所有的抽象方法,要么实现类是一个抽象类
注意点3：一个类可以实现多个接口，也可以在继承一个类的同时，实现多个接口
public class 类名implements接口1,接口2{ ... }
public class 类名extends 父类implements 接口1,接口2{ .. }
接口中成员的特点
成员变量:只能是常量。默认修饰符:public static final
构造方法:没有
成员方法:只能是抽象方法。默认修饰符:public abstract
JDK7以前:接口中只能定义抽象方法
JDK8的新特性:接口中可以定义有方法体的方法
JDK9的新特性:接口中可以定义私有方法
接口与类的关系
类和类的关系
继承关系,只能单继承,不能多继承,但是可以多层继承
类和接口的关系
实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口
接口和接口的关系
继承关系,可以单继承,也可以多继承
如果一个类实现了多个接口,那么就要重写多个接口中所有的抽象方法
注意点:
1.如果父类Person也是一个抽象类的话,那么在子类当中,需要把所有的抽象方向进行抽象,要么子类本身也是一个抽象类
2.如果多个接口中出现了重复的抽象方法,此时我们只要重写一次就可以了
接口和接口的关系
继承关系,可以单继承,也可以多继承
注意点:
如果有一个接口A继承了多个挖口,此时相当于是把多个接口中的抽象方法全部继承下来了，在以后,实现类实现接口A的时候,就要把所有的抽象方法进行重写
2026-5-10
JDK7及以前:
接口中只能定义抽象方法
JDK8新特性:
为了接口升级时向下兼容,接口中可以定义有方法体的方法(默认、静态)
● 允许在接口中定义默认方法,需要使用关键字default修饰
作用:为了接口升级时,代码不报错
接口中默认方法的定义格式:
● 格式:public default 返回值类型 方法名(参数列表){}
● 范例:public default void show(){ }
// 新增默认的方法
// public default 返回值类型 方法名(形参){方法体
public default void function(){ no usages
System.out.println(“接口中新增的默认方法~”);
}
接口中默认方法的注意事项:
● 默认方法不是抽象方法,所以不强制被重写。但是如果被重写,重写的时候去掉default关键字
@Override no usages
public void method2() {
System.out.println("实现类重写的method2方法~”);
}
● public可以省略,default不能省略
● 如果实现了多个接口,多个接口中存在相同名字的默认方法,子类就必须对该方法进行重写
接口中静态方法的定义格式:
● 格式:public static 返回值类型 方法名(参数列表){}
● 范例:public static void show(){ }
接口中静态方法的注意事项:
虚方法表
非static 非final 非private
只有虚方法表里面的方法才能够被重写,方法重写的实际意义就是替换了虚方法表中记录方法的内存地址
● 静态方法只能通过接口名调用,不能通过实现类名或者对象名调用，
● public可以省略,static不能省略
JDK9新特性:
为了抽取默认方法和静态方法中重复代码而出现的
● 格式1:private返回值类型 方法名(参数列表){
● 范例1 :private void show(){ }
}
● 格式2:private static 返回值类型 方法名(参数列表){}
● 范例2:private static void method(){
}
2026-5-11
什么是内部类?
写在一个类里面的类就叫做内部类什么时候用到内部类?
一个类表示的事物是另一个类的一部分,且单独存在没有意义
比如:汽车的发动机,人的心脑等等内部类的分类?
成员内部类,静态内部类,局部内部类,匿名内部类。
public class Carr{
String carBrand;//汽车的品牌
int carAge; // 车龄
String carColor;// 颜色
class Engine{ no usages
String engineBrand;// 发动机的品牌
nt engineAge;// 使用年限
}
}
成员内部类（了解）
写在成员位置的,属于外部类的成员
成员内部类可以被一些修饰符所修饰,比如:private,默认,protected,public,static等
在成员内部类里面,JDK16之前不能定义静态变量,JDK16开始才可以定义静态变量
获取成员内部类对象的两种方式?
方式一:当成员内部类被private修饰时。
在外部类编写方法,对外提供内部类对象
public class Outer {
String name;
private class Inner{
static int a = 10;
}
public Inner getInstance(){
return new Inner();
}
方式二:当成员内部类被非私有修饰时,直接创建对象。
格式:外部类名.内部类名 对象名=外部类对象.内部类对象;
范例:Outer.Inner oi = new Outer().new Inner();
当外部类和内部类重名的时候怎么办
public class Outer {
private int a = 10;
class Inner {
private int a = 20;
public void show() {
int a = 30;
System.out.println(a); //30
System.out.println(this.a); //20
//Outher.this 获取了外部类对象的地址值
System.out.println(Outer.this.a);//10
}
}
}
屏幕截图 2026-05-11 174546.png
静态内部类
一种特殊的成员内部类
静态内部类只能访问外部类中的静态变量和静态方法
如果在静态内部类中,想要访问外部类非静态的内容,需要创建外部类的对象
创建静态内部类的对象:
外部类名.内部类名 对象名=new 外部类名.内部类名();
Outer. Inner oi = new Outer. Inner();
调用静态内部类中非静态方法的格式:
先创建对象,用对象调用
调用静态内部类中静态方法的格式:
外部类名.内部类名.方法名();
局部内部类
将内部类定义在方法里面就叫做局部内部类,类似于方法里面的局部变量。
外界是无法直接使用,需要在方法内部创建对象并使用。
该类可以直接访问外部类的成员,也可以访问方法内的局部变量。
匿名内部类
隐藏了名字的内部类,可以写在成员位置,也可以写在局部位置
作用:在继承一个类或者实现一个接口的时候少写一个文件,也是lambda的前置知识点
使用场景
如果实现类只要使用一次,就可以用匿名内部类简化代码
匿名内部类的定义格式=没有名字的java类+继承/实现+重写方法+创建对象
最终格式可以理解为:是一个没有名字的java类的对象
//new 类名或者接口名(){
//重写方法;
//};
new Inter() {
public void show() { ... };
};
public static void main(String[] args) {
//在测试类中调用
Swim s = new Swim(){
@Override
public void swim() {
System.out.println("匿名内部类实现接口");
}
};
goswimming(s);
}
2026-5-12
{
public static void main(String[] args) {
CheckOrder order1 = new CheckOrder(0001,"待派送");
CheckOrder order2 = new CheckOrder(0002,"待派送");
CheckOrder order3 = new CheckOrder(0003,"待派送");
CheckOrder [] orders = {order1,order2,order3} ;
Deliver delivery1 = new Deliver("丽水","外卖员") ;
Deliver delivery2 = new Deliver("装三","外卖员") ;
Waiter waiter1 = new Waiter("王五","服务员");
Scanner scanner = new Scanner(System.in);
System.out.println("----外卖配送系统-------");
System.out.println("1.查询订单");
System.out.println("2.配送订单");
int count = orders.length;
while (true){
System.out.println("请输入你要的功能");
int input = scanner.nextInt();
switch (input){
case 1 :
for (int i = 0 ; i < orders.length ; i++){
CheckOrder order = orders[i];//获取订单
order.show();
if (order.getState().equals("配送中")){
System.out.println("配送员信息：");
// 调用配送员信息
order.getPerson().show();
}
}
break;
case 2 :
if (count == 0){
System.out.println("没有订单了");
}
else {
delivery1.deliver(orders[0]);//调用配送
count--;
delivery2.deliver(orders[1]);
count--;
waiter1.deliver(orders[2]);
count--;
break; }
case 3 :
System.out.println("退出系统");
System.exit(0);
break;
default:
System.out.println("输入错误");
break; }
}
}
}
public class Waiter extends Person implements Delverable{
public Waiter() {
}
public Waiter(String name, String job) {
super(name, job);
}
@Override
public void deliver(CheckOrder order){
order.setState("配送中");
order.setPerson(this);
System.out.println(getJob()+getName()+ "正在配送订单编号为："+ order.getId()+"的订单");
}
@Override
public void show() {
System.out.println(getJob()+ getName());
}
}
2026-5-13
API:就是JDK提供的各种功能的Java类，即应用程序编程接口
API帮助文档:帮助开发人员更好的使用API和查询API的一个工具。
如何使用API帮助文档
1 打开API帮助文档
2 点击显示,并找到索引下面的输入
3 在输入框中输入类名并点击显示
4 查看类所在的包
5 查看类的描述
6 查看构造方法
7 查看成员方法
package APIdemo;
//引入Random类，导包
//扩展:在什么情况下,我不需要导包?
//情况一:如果使用本包中的类
//情况二:如果使用java.lang(核心)包下的类
import java.util.Random;
public class Test {
public static void main(String[] args) {
//查看api帮助文档，使用Random类获取随机小数的方法
Random random = new Random();
Double d = random.nextDouble();
}
}
2026-5-14
String类,定义在java.lang包下,无需导包。Java中的所有字符串文字(例如“abc")都为此类的对象
注意点：
字符串的内容是不可变的,它的对象在创建后不能被更改
创建String对象的方法
//第一种:直接赋值
//第二种:new关键字
//public String() //空白字符串,不含任何内容
// //public String(String original) //根据传入的字符串,创建新的字符串对象
// //public String(char[] chs) //根据字符数组,创建字符串对象
// //public String(byte[] chs) //根据字节数组,创建字符串对象
//第一种:直接赋值
String s1 = "hello";
System.out.println(s1);
//第二种:new + 空参数构造
String s2 = new String();
System.out.println("--"+ s2 + "@@");
//第三种:new + 字符数组参数构造
char[] chs = {'a', 'b', 'c'};
String s3 = new String(chs);
System.out.println(s3);
//第四种:new + 字节数组参数构造
byte[] bytes = {97, 98, 99};
String s4 = new String(bytes);
//Ascii码表 97--a 98--b 99--cSystem.out.println(s4);
2025-5-15
字符串比较
● boolean equals方法(要比较的字符串)
完全一样结果才是true,否则为false，比较的是内容
// 字符串比较的两个方法
// 第一个方法:equals方法完全一致
String username = "zhangsan";
String rightUsername = "Zhangsan";
boolean b1 = username.equals(rightUsername);
System.out.print1n(b1);
● boolean equalsIgnoreCase(要比较的字符串)
忽略大小写的比较
// 字符串比较的两个方法
// 第二个方法:equalsIgnoreCase忽略大小写的比较
String username = "zhangsan";
String rightUsername = "Zhangsan";//改变了大小写
boolean b1 = username.equalsIgnoreCase(rightUsername);
System.out.print1n(b1);
== 对引用类型比较的是其内存地址
//已知正确的用户名和密码
String rightName = "张三";
String rightPwd = "123456";
Scanner sc = new Scanner(System.in);
//总共给三次机会
for (int i = 1; i <= 3; i++) {
//用程序实现模拟用户登录
System.out.println("请输入用户名");
String name = sc.next();
System.out.println("请输入密码");
String pwd = sc.next();
//判断用户输入的用户名和密码是否正确
boolean flag = rightName.equals(name)&&rightPwd.equals(pwd);
if (flag){
System.out.println("登录成功");
break; }
else{
if (i <= 2){
System.out.println("登录失败,还剩"+ (3-i)+"次机会");
}
else{
System.out.println("登录失败,已无登录机会");
}
}
遍历字符串
● public char charAt(int index):根据索引返回字符
// 1. charAt
String str ="你好你好123";
char c = str.charAt(7);
System.out.println(c);
● public int length():返回此字符串的长度
● 数组的长度:数组名.length
● 字符串的长度:字符串对象.length()
// 2. length
int len = str.length();
System.out.println(len);
练习
Scanner sc = new Scanner(System. in);
System.out.println("请输入一个字符串:”);
String s = sc.next();
// 字符串遍历中循环的快速生成方式 s.length().fori
for (int i = 0; i < s.length(); i++) {
char cc = s.charAt(i);
System.out.println(cc);
}
2026-5-16
String substring(int beginIndex, int endIndex)
注意点:包头不包尾,包左不包右
只有返回值才是截取的小串
//定义一个字符串
String str = "abcdefg";
// 截取
// 第一个参数:截取的开始索引
// 第二个参数:截取的末尾索引
// 包头不包尾,包左不包右 ---- >包含1索引,但是不包含5索引 1234
// 字符串本身一旦创建之后,是无法发现改变的,截取的时候不会影响调用者的字符串,切记:只有返回值才是截取之后的结果
String res = str.substring(1,5);
System.out.println(res);// bcde
String substring(int beginlndex)
截取到末尾
// 参数:截取的开始索引,默认是截取到字符串的末尾
// 字符串本身一旦创建之后,是无法发现改变的,截取的时候不会影响调用者的字符串,切记:只有返回值才是截取之后的结果
String res2 = str.substring( beginlndex: 1);
System.out.println(res2);// bcdefg
//练习：保留用户名的第一个字符，剩余字符用*代替
String name = "张三丰";
//charAt(int index)
char fristchar = name.charAt(0) ;
String newName = fristchar + "***" ;
System.out.println(newName);
//substring(int start,int end)
String substring = name.substring(0, 1);
String newName2 = substring + "***" ;
System.out.println(newName2);
敏感词过滤
● String replace(旧值,新值)替换
注意点:只有返回值才是替换之后的结果
● subString截取:截取固定位置的数据
●replac替换:位置不确定,替换指定内容
// 定义字符串
String str=“你玩的好菜呀,TMD";
// 替换
// 第一个参数:被替换的数据
// 第二个参数:用来替换的数据
//只有返回值才会替换之后的结果
String res = str.replace( target: "TMD", replacement: " *** ");
System.out.println(res);
练习
//1. 定义一个敏感词库
String[] arr = {"TMD", "SB", "NMD","LJ"};
//2. 键盘录入你说的话
System.out.println(“请输入你想说的话:”);
String msg = sc.next();
// 3. 替换敏感词
for (int i = 0; i < arr.length; i++) {
// arr[i]:依次表示数组当中每一个敏感词
msg = msg.replace(arr[i], replacement: " *** ");
}
Svstem.out.println(msg)
其他常用Sting API
String str = "abcdefg";
//是否包含
boolean b = str.contains("abd");
System.out.println(b);
// 判断开头、结尾
// 判断文件的后缀名
// 判断str是否以bc作为开头
boolean b2 = str.startsWith("bc");
// 判断str从1索引开始,是否以bc开头
boolean b3 = str.startsWith( prefix: "bc", toffset: 1);
System.out.print1n(b2);
boolean b4 = str.endsWith(".txt");
System.out.println(b4);
lastIndexOf(int ch)
//查找当前字符/字符串 第一次出现的索引,如果当前要查找的内容不存在,方法会返回-1
int i1 = str.index0f(97);
System.out.println(i1);// 0
int i2 = str.lastIndexOf( ch: 97);
System.out.print1n(i2);// 4
int i3 = str.indexOf("A");
System.out.print1n(i3);// -1
// 判断是否为空
boolean empty1 = str.isEmpty();
System.out.print1n(empty1);// false
String str2 = "";
boolean empty2 = str2.isEmpty();
System.out.print1n(empty2); //ture
lastIndexOf(int ch)
//查找当前字符/字符串 第一次出现的索引,如果当前要查找的内容不存在,方法会返回-1
int i1 = str.index0f(97);
System.out.println(i1);// 0
int i2 = str.lastIndexOf( ch: 97);
System.out.print1n(i2);// 4
int i3 = str.indexOf("A");
System.out.print1n(i3);// -1
// 判断是否为空
boolean empty1 = str.isEmpty();
System.out.print1n(empty1);// false
String str2 = "";
boolean empty2 = str2.isEmpty();
System.out.print1n(empty2); //
// 转字符数组 toCharArray()
//"abc" -- >0索引 改为A
// "abcdaefg" ---- > ['a', 'b', 'c','d','a','e','f','g']
char[] array = str. toCharArray();
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
//大小写转换 toUpperCase(),toLowerCase()
// abcde ...
String upperCase = str.toUpperCase();
System.out.println(upperCase); // ABCDAEFG
//去除头尾空格 tim()
// 登录注册
String str3 = " a b c ";
String trim = str3.trim();
System.out.println(trim);//a b c
/2026-5-17
StringBuilder：是字符串的一个工具类,可以让我们拼接字符串的时候效率更高
//正常方式，需要的实践太长了，大概要三分钟
String s = "";
for (int i = 0; i < 1000000 i++) {
s = s + "abc";
System.out.println(s);
//StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000000; i++) {
sb.append("abc");
System.out.println(sb);
}
StringBuilder的构造方法:
public StringBuilder() 空参构造
public StringBuilder(String str) 带参构造
// 1. 创建 StringBuilder的对象(容器)空参构造
StringBuilder sb1 = new StringBuilder();
System.out.println(" --- " + sb1 + "@e@");
int len = sb1.length();//获取长度
System.out.println(len);
//2. 创建 StringBuilder的对象(容器) 带参构造
StringBuilder sp2 = new StringBuilder("abc");
System.out.println(sb2);
StringBuilder的常见成员方法:
append(任意类型) 添加数据
reverse() 反转
int length() 获取长度
toString 变回字符串
StringBuilder sb2 = new StringBuilder("abc");
sb2.reverse();//反转
sb2.append("aaa");//添加
String res = sb2.toString();//变回String
System.out.println(res);
2025-5-18
数据库多表查询
join 内查询
join + 表名 on 表名.字段名 = 表名.字段名
left join 左查询
left join + 表名 on 表名.字段名 = 表名.字段名
cross join 交叉查询 用的不多
2025-5-19
字符串反转
Scanner sc = new Scanner(System. in);
while (true) {
// 1.键盘录入字符串
System.out.println("请输入一个字符串:”);
String str = sc.next(); // 123
// 2.判断
if(str.equals("拜拜")){
// 程序停止运行
System.out.println("欢迎使用本系统,期待与您的下次见面~”);
break;
}else{
// 反转
StringBuilder sb = new StringBuilder(str);
sb.reverse();
String res = sb.toString();
System.out.println(res);
截取
// 1. 键盘录入任意字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入任意字符串:”);
String str = sc.next();
// 2. 直接在str的后面补0
// abcdabcda
// 计算最后一行有多少个字符
int lastLineCount = str.length() % 8; // 9 % 8 = 1
// 计算最后一行补多少个0
int count = 8 - lastLineCount; // 8 - 1 = 7
// 补0
if(count != 0){
// 获取最后一行补的0
String line = "00000000".substring(0, count);
// 把最后一行补的0拼接到字符串的后面
str = std + line;
}
// System.out.println(str);
// 3. 每8个打印一行
// abcdabcd
// i+=8:第一行:0索引开始
第二行:8索引开始
for (int i = 0; i < str.length(); i += 8) {
// 每8个截取一次
String res = str.substring(i, i + 8);
// 打印
System.out.println(res);
}
打乱字符串
//1.定义一个字符串
String str = "abcd";
// 2.把字符串str变成字符数组
char[] arr = str. toCharArray();
// 3.打乱字符数组arr中的内容
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
// 获取一个随机的索引
int index = r.nextInt(arr.length);
// 依次得到数组中的每一个字符,跟随机索引上的字符进行位置交换
char temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
// 4.把打乱之后的字符数组转回字符串
String result = new String(arr);
System.out.println(result);