抽象类及抽象方法、多态（类，接口）、对象转型（自动，强转）、内部类（成员，静态，接口，局部，匿名内部类）--学习JavaEE的day16

news2024/9/30 11:30:52

day16

Day16

抽象类及抽象方法

//抽象类
public abstract class 类名{
    //抽象方法
    public abstract void method();
}

abstract

关键字，用来修饰类和方法

不能与final，static，private一起修饰，不能被重写

抽象类

1.概念：

被abstract修饰的类，包含抽象方法的类就是抽象类

2.抽象类的特征：
  1. 抽象类不能实例化，即不能用new来实例化抽象类
  2. 抽象类中包含有构造方法，但构造方法不能用来new实例，只能用来被子类调用
  3. 抽象类中可以包含成员变量，成员方法，静态方法，构造方法，final 修饰的方法，抽象方法
  4. 抽象类只能用来被继承
3.应用场景：

当一个方法必须在父类中出现，但是这个方法又不好实现，就把该方法变成抽象方法，交给非抽象的子类去实现

抽象方法

1.概念

使用abstract修饰的方法，没有方法体，只有声明，交给非抽象的子类去实现（重写）

理解：

将共性的行为(方法)抽取到父类之后。由于每一个子类执行的内容是不一样的,在父类中不能确定具体的方法体。 即正向实现反向抽取。

2.抽象方法的特征：
  1. 抽象类中可以包含 0 个或多个抽象方法
  2. 抽象方法必须被子类实现
  3. 抽象类中可以有属性、构造方法、成员方法、静态方法、抽象方法
  4. 有抽象方法的类只能定义成抽象类(含有抽象方法的类必须是抽象类)
  5. 只有当子类实现了抽象超类中的所有抽象方法，子类才不是抽象类，才能产生实例
  6. 如果子类中仍有抽象方法未实现，则子类也只能是抽象类

抽象类及抽象方法的使用

需求：

编写人类为父类，编写两个子类(ps:中国人、日本人)，中国人的子类(ps:四川人、广东人)

封装Person类并为抽象类，写一个抽象方法eat()

	public abstract void eat();

Japanese类继承Person类，重写eat()

public class Japanese extends Person{

private String yearNum;

public Japanese() {
}

public Japanese(String name, char sex, int age, String yearNum) {
	super(name, sex, age);
	this.yearNum = yearNum;
}

public String getYearNum() {
	return yearNum;
}

public void setYearNum(String yearNum) {
	this.yearNum = yearNum;
}

@Override
public void eat() {
	System.out.println(super.getName() + "吃生鱼片");
}

}

Chinese类继承Person类，但是并没有实现eat()，所以Chinese类为抽象类，交给他的子类去实现。这里扩展添加了一个抽象方法hobbies()

public abstract class Chinese extends Person{

private String id;

public Chinese() {
}

public Chinese(String name, char sex, int age, String id) {
	super(name, sex, age);
	this.id = id;
}

public String getId() {
	return id;
}

public void setId(String id) {
	this.id = id;
}

public abstract void hobbies();

}

SiChuan类继承Chinese类，去实现了eat()，他可以实例化

public class SiChuan extends Chinese{
	

public SiChuan() {
}

public SiChuan(String name,char sex,int age,String id){
	super(name, sex, age, id);
}

@Override
public void hobbies() {
	System.out.println(super.getName() + "喜欢打麻将、炸金花");
}

@Override
public void eat() {
	System.out.println(super.getName() + "吃火锅、串串香");
}

}

抽象类及抽象方法的深入

面试题：

1.抽象类不能有构造方法？

抽象类可以有构造方法

2.抽象类中只能有抽象方法？

抽象类中有非抽象方法（成员方法和静态方法）

3.抽象类中不可以没有抽象方法？

抽象类中可以没有抽象方法，但是毫无意义

4.如果父类是抽象类，则子类必须实现父类的抽象方法？

不一定，子类如果是抽象类，可以不实现父类的抽象方法

5.可以使用new关键字来创建抽象类对象？

不可以，创建的是匿名内部类的对象

抽象类及抽象方法的使用的扩展

匿名内部类

匿名内部类理解图见文件画图

  I1 i1 = new Person() {
  	          @Override
  	          public void i1Method() {
  		            System.out.println("用良心做教育");
  	           }
  };

在需要创建一个临时对象来实现特定抽象类的情况下，可以直接通过匿名内部类来完成。这样不必单独编写一个新的类文件，节省了开发工作量。

public class Test02 {
	public static void main(String[] args) {
		Person p = new Person("弗罗兹·甘地",'男',23) {//继承父类属性
			
			@Override
			public void eat() {
				System.out.println(super.getName() + "吃咖喱");
			}
		};
		p.eat();
	}
}

接口

1.概念：

Java中一种引用类型，是方法的集合

特殊的抽象类

关键字interface

理解：

  1. 特殊的抽象类
  2. JDK1.7时，接口中只能有静态常量和抽象方法
  3. JDK1.8开始，接口中添加了静态方法和默认方法

注意：

​ 1.接口中的抽象方法默认添加public abstract（经验：一般把abstract去掉）

​ 2.接口中的属性默认添加public static final

​ 3.接口中的默认方法默认添加public

2.应用场景：

接口相当于是制定规则(标准)，再让实现类去实现

抽象类 vs 接口

抽象类：成员变量、静态变量、静态常量、成员方法、静态方法

接口：静态常量、静态方法(JDK1.8)、默认方法(JDK1.8)

3.类 - 接口的关系：

​ 类 - 类：单继承（一个类只能继承另一个类，不能继承多个类）

​ 类 - 接口：多实现（一个类可以实现多个接口）

​ 接口 - 接口：多继承（一个接口可以继承多个接口）

做代码实验验证

4.实现

关键字implements，子类实现接口

需求：设计学生管理系统项目的接口
分析：
学生管理系统管理一个一个的学生对象
管理 - 数据的操作：增、删、改、查

(1)封装一个学生类，里面重写toString()

(2)写一个学生管理系统的接口

public interface IStudentManagerSystem {	

//静态常量
//默认使用public static final修饰
int NAME = 1;
int SEX = 2;
int AGE = 3;
int CLASS_ID = 4;
int ID = 5;

//抽象方法
//默认使用public abstract修饰
public void add(Student stu);

public void delete(String classId,String id);

public void update(String classId,String id,int type,Object val);

public Student getStu(String classId,String id);

//静态方法
public static void method01(){
	System.out.println("IStudentManagerSystem接口中的静态方法");
}

//默认方法
//默认使用public修饰
default void method02(){
	System.out.println("IStudentManagerSystem接口中的默认方法");
}
}

(3)写学生管理系统的实现类实现接口生管理系统，当写完类名时就会报红提示实现接口里的抽象方法，点击就会自动需要实现的方法，之后去完善就可以了

public class StudentManagerSystemImpl implements IStudentManagerSystem{

@Override
public void add(Student stu) {
}

@Override
public void delete(String classId, String id) {
}

@Override
public void update(String classId, String id, int type, Object val) {
}

@Override
public Student getStu(String classId, String id) {
	return null;
}

}

(4)测试类调用方法

	StudentManagerSystemImpl sms = new StudentManagerSystemImpl();
	
	//调用实现类实现的方法
	sms.add(new Student());
	//调用默认方法
	sms.method02();
	//调用静态方法，类名调用
	IStudentManagerSystem.method01();
}
5.面试题：

1.一个类可以实现多个接口？

可以
2.一个接口可以实现多个接口？

不可以，接口与接口的关系是多继承
3.接口里面的方法不一定都是抽象的？

是的，因为JDK1.7时接口里只能有抽象方法，JDK1.8时接口可以有抽象方法和默认方法
4.接口解决了类的单继承问题？

是的，因为类与类是单继承，类与接口是多实现
5.一个类是否可以继承一个类并同时实现多个接口？

可以
6.接口可以new对象？

不可以，因为接口是特殊的抽象类，但是本质还是抽象类，抽象类是不可以new对象的，接口也是不能new对象，new出来的匿名类内部类的对象

6.接口的使用扩展

(匿名内部类)匿名实现类

匿名内部类理解图见文件画图

  I1 i1 = new I1() {
  	          @Override
  	          public void i1Method() {
  		           System.out.println("用良心做教育");
  	          }
  };

二、多态

概念

多态性是指同一操作或方法可以在不同的对象上具有不同的行为。它允许我们通过使用基类或接口类型的引用变量来调用子类或实现类的方法。

理解：多种形态

分类：

​ 类的多态：子类对象指向父类引用（父类引用中存储的是子类对象在堆中开辟的地址）

​ 接口的多态：实现类对象指向接口的引用（接口的引用中存储的是实现类对象在堆中开辟的地址）

设计

设计原则：前人总结的经验，告诉我们什么不该做

设计模式：前人总结的经验，告诉我们一步一步的怎么做

ps：OCP原则：

​ O - Open - 在需求升级时，对于创建类是欢迎的

​ (因为创建类对于原来代码的影响几乎为0)

​ C - Close - 在需求升级时，对于改动原有类是拒绝的

​ (因为原有类之间的关系是趋于稳定状态，如果改动原有类，

​ 很有可能打破这种平衡，导致bug的出现)

​ P - Principle - 原则

优缺点：

​ 优点：提高程序的维护性，在需求升级/迭代时，不违反OCP原则

​ 缺点：不能调用子类独有的属性和方法

类的多态：

1.概念：

子类对象指向父类引用
理解：父类引用中存储的是子类对象在堆中开辟的内存地址

2.需求

需求：使用代码描述出老师骑着自行车上班
分析：老师类、自行车类

步骤：

​ 1.创建Bick类，编写open、close

​ 2.创建Teacher，编写start、stop

Teacher类start、stop方法里面调用Bick类的start、stop方法，操作具体的车

需求升级：自行车 -> 小汽车
步骤：
1.创建Car类，编写open、close
2.改动原来的Teacher，编写start、stop

同理Teacher类重载start、stop方法

需求升级：自行车 -> 小汽车 -> 飞机

步骤：

​ 1.创建Vehicles类，编写抽象方法open、close

​ 2.创建Plane类，改动Bick、Car类继承Vehicles，重写open、close

​ 3.改动原来的Teacher，改动start、stop操作交通工具

测试类：

	Teacher t = new Teacher();
	
	//类的多态：子类对象指向父类引用
	//理解：父类引用中存储的是子类对象在堆中开辟的内存地址
	Vehicles v = new Plane();
	
	t.start(v);
	System.out.println("欣赏沿途的风景");
	t.stop(v);

接口的多态

1.概念

实现类对象指向接口的引用
理解：接口的引用存储的是实现类对象在堆中开辟的地址

2.需求：

使用代码描述出电脑连接外部设备

分析：电脑类、USB接口、鼠标类、硬盘类、键盘类

步骤：

​ 1.创建IUSB接口，抽象方法use

​ 2.创建鼠标类Mouse、硬盘类Disk、键盘类KeyBoard、都实现接口，并且都重写抽象方法use；

​ 3.电脑类Computer写一个连接方法connection操作接口

测试类：

	Computer computer = new Computer();
	
	//接口的多态：实现类对象指向接口的引用
	//理解：接口的引用存储的是实现类对象在堆中开辟的地址
	IUSB usb = new KeyBoard();
	
	computer.connection(usb);
}

三、对象转型

前提：有继承关系

自动转型 - 向上转型：

子类类型 转 父类类型

注意：

  1. 向上转型就是多态！！！

       2. 向上转型后，可以调用父类属性、方法 
   3. 向上转型后，不可以调用子类独有的属性、方法 
   4. 向上转型后，可以调用子类重写父类的方法

需求：父类，子类

写一个Father类、一个Son类继承Father

测试类进行验证

	//向上转型
	Father father = new Son();
	
	System.out.println(father.fatherAttr);
	father.fatherMethod();

强制转型 - 向下转型：

父类类型 转 子类类型

注意：

  1. 向下转型是不安全的 – ClassCastException类型转换异常
  2. 出现ClassCastException，一定要看错误信息
  3. 父类对象不能赋值给子类引用 – Dog dog = (Dog) new Animal();
  4. 向下转型之前必须先向上转型
  5. 向下转型之前，使用instanceof判断类型

ps：MyString

	if(obj instanceof MyString){
		MyString my = (MyString) obj;
	}

需求:动物类，猫类，狗类

创建动物类Animal；创建猫类Cat、狗Dog继承Animal

测试类验证：

  //前提：向上转型
  Animal an = new Cat();
  
  //向下转型
  if(an instanceof Dog){//判断引用an中指向的对象是否是Dog类型
  	Dog dog = (Dog) an;
  	dog.shout();
  }else if(an instanceof Cat){//判断引用an中指向的对象是否是Cat类型
  	Cat cat = (Cat) an;
  	cat.eat();
  }

应用场景

对象转型的应用包括但不限于以下几个方面:
1.多态性的实现:Java中的多态性是通过对象转型来实现的。通过向上转型，将子类对象赋值给父类类型的变量，可以实现对多个子类对象的统一处理，从而实现多态性。
2.接口的实现:接口是Java中重要的面向对象编程概念，对象转型可以用于实现接口。将一个实现了某个接口的类类型对象转换为该接口类型，就可以通过接口类型调用实现类中实现的方法。
3.继承关系的处理:Java中的继承关系是通过对象转型来实现的。将一个子类类型的对象转换为一个父类类型的对象，就可以实现父类和子类之间的继承关系。
总之，Java中的对象转型是java面向对象编程的重要特性之一，可以帮助程序员更好地实现面向对象编程的思想，提高代码的可复用性和可维护性。

案例：MyString(参考day15)

更新MyString(代码，向下转型之前，使用instanceof判断类型

	if(obj instanceof MyString){
		MyString my = (MyString) obj;

测试类：测试MyString达到要求

	String str1 = new String("abc");
	System.out.println(str1.equals(new Student()));//false	
    
	System.out.println("-------------------------------");
	
	MyString m1 = new MyString("abc");
	System.out.println(m1.equals(new Student()));//false

四、内部类

理解：

一个类中再声明另外一个类

应用场景：

  1. B类的对象只在A类中使用，并且B类对象使用到了A类所有的属性，就可以将B类作为A类的成员内部类
  2. B类的对象只在A类中使用，并且B类对象使用到了A类静态的属性，就可以将B类作为A类的静态内部类
  3. 抽象类的子类只创建一次对象，就没必要创建子类，直接使用匿名内部类（new 抽象类）
  4. 接口的实现类只创建一次对象，就没必要创建实现类，直接使用匿名内部类（new 接口）

分类：

  1. 成员内部类

  2. 静态内部类

  3. 接口内部类

  4. 局部内部类

  5. 匿名内部类

//外部类
public class Outter {
	//成员内部类
	class Inner01{
	}
	
	//静态内部类
	static class Inner02{
	}
	
	public void method(){
		//局部内部类
		class Inner03{
		}	
	}
}
//接口
public interface I1 {
	//接口内部类
	class Inner{
	}
}

成员内部类

需求：创建成员内部类的对象，操作对象的方法

注意：

  1. 创建成员内部类对象之前，必须创建外部类对象

  2. 成员内部类可以调用外部类所有的属性

  3. 在成员内部类中调用指定的外部类属性：外部类.this.属性

ps：测试类

	//创建成员内部类的对象
	Inner inner = new Outter().new Inner();
	//调用方法
	inner.innerMethod();

//外部类
public class Outter {

private 		String str1 = "外部类属性1";
				String str2 = "外部类属性2";
protected 		String str3 = "外部类属性3";
public 			String str4 = "外部类属性4";
final 			String str5 = "外部类属性5";
static 			String str6 = "外部类属性6";
static final 	String str7 = "外部类属性7";

//成员内部类
class Inner{
	
	String str1 = "内部类属性";
	
	public void innerMethod(){
		System.out.println("成员内部类的方法");
		System.out.println(str1);//this.str1，就近原则,调内部类属性
		System.out.println(Outter.this.str1);//调外部类属性
		System.out.println(str2);//Outter.this.str2
		System.out.println(str3);//Outter.this.str3
		System.out.println(str4);//Outter.this.str4
		System.out.println(str5);//Outter.this.str5
		System.out.println(str6);//Outter.str6,调外部类静态属性，外部类名调用
		System.out.println(str7);//Outter.str7
	}
}
}

静态内部类

需求：创建静态内部类的对象，操作对象的方法

注意：

  1. 创建静态内部类对象，不用创建外部类对象
  2. 静态内部类只能调用外部类静态的属性

测试类

//创建静态内部类的对象
	 Inner inner = new Outter.Inner();
	//调用方法
	inner.innerMethod();

//外部类
public class Outter {	

static 			String str1 = "外部类属性1";
static final 	String str2 = "外部类属性2";

//静态内部类
static class Inner{

	public void innerMethod(){
		System.out.println("静态内部类的方法");
		System.out.println(str1);//Outter.str1
		System.out.println(str2);//Outter.str2
	}
}
}

接口内部类

需求：创建接口内部类的对象，操作对象的方法

注意：

  1. 接口内部类默认使用public static修饰
  2. 接口内部类的使用方式和静态内部类一致

测试类

  //创建静态内部类的对象
   Inner inner = new Outter.Inner();
  
  //调用方法
  inner.innerMethod();

//外部接口
public interface Outter {

	//接口内部类
	//默认使用public static修饰
	class Inner{
		public void innerMethod(){
			System.out.println("接口内部类的方法");
		}
	}

}

局部内部类

1.使用

需求：调用局部内部类的方法

注意：

  1. 局部内部类不能使用访问修饰符
  2. 局部内部类的作用域就在外部类方法中
  3. 常量：存放在常量池中，项目销毁时，常量才会被回收；局部变量：调用方法，方法在栈中开辟空间，用于存放局部变量，方法执行完毕，该空间会立刻回收

测试类：

  Outter outter = new Outter();
  outter.method();

//外部类
public class Outter {	
	public void method(){	
		//局部内部类
		class Inner{
			public void innerMethod(){
				System.out.println("局部内部类的方法");
			}
		}
	
		//创建局部内部类对象
		Inner inner = new Inner();
		//调用方法
		inner.innerMethod();	
	}
}
2.局部内部类理解图

局部内部类理解图

3.面试题：

局部内部类使用到外部类的局部变量时，为什么局部变量会变为常量？

答：局部变量变成常量，是让该变量的生命周期变长，是让方法以外还能找的到该数据，如果该变量是局部变量，方法执行完毕就直接被回收，在方法就不能使用该数据

匿名内部类

匿名内部类理解图

匿名内部类理解图(类)匿名内部类理解图01
匿名实现类理解图（接口）匿名内部类理解图02

应用场景：

作为接口或者抽象类的实现类：在需要创建一个临时对象来实现特定接口或者抽象类的情况下，可以直接通过匿名内部类来完成。这样不必单独编写一个新的类文件，节省了开发工作量。

创建匿名内部类的对象

（匿名子类，父类）

  1. 底层创建一个匿名类(Test01$1.class)，继承A类，重写method方法
  2. 创建匿名子类的对象
  3. 赋值给父类的引用（类的多态）

【Test01$1.class是系统默认命名，通过查看class文件就可以看到；eclipse里查看：的工具栏---->window—>showview---->Navigator—显示bin目录的class文件】

（匿名子类实现类，父类接口）

  1. 底层创建一个匿名类(Test01$1.class)，实现I1接口，重写method方法
  2. 创建匿名实现类的对象
  3. 赋值给接口的引用（接口的多态）

总结

1.抽象类及抽象方法

2.接口

3.思考题：抽象类与接口的区别

4.多态 – 重要！！！

5.对象转型（向上转型、向下转型）

6.内部类（成员内部类，静态内部类，接口内部类，局部内部类，匿名内部类）
1.注重使用
2.注重局部内部类的面试题
3.注重匿名内部类的内存图

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1485238.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

2024最新AI系统ChatGPT网站源码, AI绘画系统

2024最新AI系统ChatGPT网站源码, AI绘画系统

一、前言说明 SparkAi创作系统是基于ChatGPT进行开发的Ai智能问答系统和Midjourney绘画系统，支持OpenAI-GPT全模型国内AI全模型。本期针对源码系统整体测试下来非常完美，那么如何搭建部署AI创作ChatGPT？小编这里写一个详细图文教程吧。已支持…
阅读更多...
C# aes加密解密byte数组

C# aes加密解密byte数组

using System.Security.Cryptography; using System.Text;namespace AESStu01;public class AesHelper {// AES加密密钥和向量（需要保密） private static readonly string Key "";//16长度字符串数字混合private static readonly string IV …
阅读更多...
web漏洞与规避

web漏洞与规避

文章目录 一、XSS 跨站脚本攻击1.1 XSS攻击的主要类型反射型XSS存储型XSSDOM型XSS 1.2 前端开发如何应对XSS 二、CSRF 跨站请求伪造2.1 CSRF例子2.2 前端开发如何应对CSRF 三、SQL 注入3.1 前端如何防御SQL注入 四、前端如何使用CSP 一、XSS 跨站脚本攻击 攻击者通过在受害者的…
阅读更多...
Kubernetes 学习总结（46）—— Pod 不停重启问题分析与解决

Kubernetes 学习总结（46）—— Pod 不停重启问题分析与解决

我们在做性能测试的时候，往往会发现我们的pod服务，频繁重启，通过kubectl get pods 命令，我们来逐步定位问题。 现象:running的pod，短时间内重启次数太多。 定位问题方法:查看pod日志 kubectl get event …
阅读更多...
寻找峰值[中等]

寻找峰值[中等]

优质博文IT-BLOG-CN 一、题目 峰值元素是指其值严格大于左右相邻值的元素。给你一个整数数组nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。 你可以假设nums[-1] nums[n] -∞。 你…
阅读更多...
解决：Information:java: javacTask: 源发行版 8 需要目标发行版 1.8

解决：Information:java: javacTask: 源发行版 8 需要目标发行版 1.8

解决：Information:java: javacTask: 源发行版 8 需要目标发行版 1.8 先点击 Project Structure 查看jdk是否为1.8版本 我这jdk版本为1.8版本的，但还是运行还是报错 据以上错误显示以及上述配置，我选择的编译器是jdk1.8的，但是在i…
阅读更多...
Git LFS Github 提交大文件

Git LFS Github 提交大文件

问题背景 2024-03-03 一篇微服务系统测试工具的论文，事后发现自己一开始的理解有问题，导致自己算的预期值和论文中正确的值不一样。 测试工具原型的依赖定义有缺失，默认可能会用当前最新版，但时过境迁”最新版“变化会导致不兼容…
阅读更多...
4款塞纸条盲盒交友源码，可以对接公众号

4款塞纸条盲盒交友源码，可以对接公众号

一元盲盒交友源码/脱单盲盒源码/交友盲盒/恋爱盲盒公众号版 可以对接自己支付，全部自定义 没有任何bug版本，已经测试完全可以 免费源码，不包搭建指导 源码下载地址专业知识分享社区-专业知识笔记免费分享 (chaobiji.cn)
阅读更多...
springcloud：3.3测试重试机制

springcloud：3.3测试重试机制

服务提供者【test-provider8001】 Openfeign远程调用服务提供者搭建 文章地址http://t.csdnimg.cn/06iz8 相关接口 测试远程调用：http://localhost:8001/payment/index 服务消费者【test-consumer-resilience4j8004】 Openfeign远程调用消费者搭建 文章地址http:/…
阅读更多...
Git与GitHub：解锁版本控制的魔法盒子

Git与GitHub：解锁版本控制的魔法盒子

✨✨ 欢迎大家来访Srlua的博文（づ￣3￣）づ╭❤～✨✨ 🌟🌟 欢迎各位亲爱的读者，感谢你们抽出宝贵的时间来阅读我的文章。 我是Srlua，在这里我会分享我的知识和经验。&#x…
阅读更多...
计算机设计大赛 深度学习机器视觉车道线识别与检测 -自动驾驶

计算机设计大赛 深度学习机器视觉车道线识别与检测 -自动驾驶

文章目录 1 前言2 先上成果3 车道线4 问题抽象(建立模型)5 帧掩码(Frame Mask)6 车道检测的图像预处理7 图像阈值化8 霍夫线变换9 实现车道检测9.1 帧掩码创建9.2 图像预处理9.2.1 图像阈值化9.2.2 霍夫线变换 最后 1 前言 🔥 优质竞赛项目系列，今天要分…
阅读更多...
MyBatis 学习（七）之 缓存

MyBatis 学习（七）之 缓存

目录 1 MyBatis 缓存介绍 2 一级缓存 3 二级缓存 3.1 二级缓存介绍 3.2 二级缓存配置 3.3 二级缓存测试 4 参考文档 1 MyBatis 缓存介绍 MyBatis 缓存是 MyBatis 中的一个重要特性，用于提高数据库查询的性能。MyBatis 提供了一级缓存和二级缓存两种类型的缓存…
阅读更多...
数据结构：栈和队列的实现附上源代码（C语言版）

数据结构：栈和队列的实现附上源代码（C语言版）

目录 前言 1.栈 1.1 栈的概念及结构 1.2 栈的底层数据结构选择 1.2 数据结构设计代码（栈的实现） 1.3 接口函数实现代码 （1）初始化栈 （2）销毁栈 （3）压栈 （4&…
阅读更多...
求最短路径之BF算法

求最短路径之BF算法

介绍 全称Bellman-Ford算法，目的是求解有负权边的最短路径问题。 考虑环，根据环中边的边权之和的正负，将环分为零环、正环、负环。其中零环、正环不会影响最短路径的求解，而负环会影响最短路径的求解。 可用BF算法返回一个bool值…
阅读更多...
java开发环境配置一指禅

java开发环境配置一指禅

IDEA下载与安装 IDEA 全称 IntelliJ IDEA，是java编程语言的集成开发环境。 idea下载地址 。 JDK安装配置 JDK是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个java开发的核心，它包含了JAVA的运行环…
阅读更多...
vue项目获取拼音首字母

vue项目获取拼音首字母

工具包 pinyin-pro npm install pinyin-pro 官方地址 pinyin-pro | pinyin-pro性能优异、转换准确的 js 中文转拼音工具https://pinyin-pro.cn/示例代码(获取每个汉字的拼音首字母) import {pinyin} from pinyin-pro;function getPinyinInitial(name){if (name) {let py p…
阅读更多...
aop监控spring cloud接口超时，并记录到数据库

aop监控spring cloud接口超时，并记录到数据库

引入pom <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.apache.org/POM/4.0.0" xmlns:xsi"http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation"http://maven.apache.org/POM/4.0.0…
阅读更多...
PlantUML简介

PlantUML简介

PlantUML简介 plantUML是一款开源的UML图绘制工具&#xff0c;支持通过文本来生成图形&#xff0c;使用起来非常高效。可以支持时序图、类图、对象图、活动图、思维导图等图形的绘制。你可以在IDEA中安装插件来使用PlantUML, 或者在Visual Studio Code中安装插件。 也可以在dra…
阅读更多...
2024免费mac苹果电脑的清理和维护软件CleanMyMac X

2024免费mac苹果电脑的清理和维护软件CleanMyMac X

对于 Mac 用户来说&#xff0c;电脑的清理和维护是一件让人头疼的事情。但是&#xff0c;有了 CleanMyMac X&#xff0c;这一切都将变得轻松愉快。CleanMyMac X 是一款专为 Mac 设计的电脑清理软件&#xff0c;它以其强大的功能和简单的操作&#xff0c;让无数用户为之倾倒。 C…
阅读更多...
C语言学习DAY22

C语言学习DAY22

内存泄漏&#xff1a;开辟的内存空间不使用了&#xff0c;但不释放该内存空间。
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023