Java-day07(面向对象-3,4)

news2024/9/23 11:13:59

继承

  1. 将多个类中共有的属性，方法剥离出来单独创建一个共有类，当需要使用共有的属性与方法时，就可以通过继承(extends)来调用共有的属性与方法。
  2. 通过"class A extends B" 来实现类的继承（子类：A 父类（或基类SuperClass）：B)
  3. 子类继承父类，父类中声明的属性，方法，子类就可以获取得到（父类中的私有方法，属性，子类可以获得，但由于封装性的设计，子类不可以直接调用）
  4. 子类除了通过继承父类的属性与方法，还可以自己定义特有的成分
  5. 在继承中，子类是父类功能的"扩展"，即子类不是父类的子集。
  6. Java类的继承只支持单继承（一个子类只能继承一个父类，一个父类可以有多个子类）
  7. 子类父类是相对的概念（子类可以用直接父类（1个），间接父类（0~多个））

事例

//这些类可以写在不同的文件里
public class Test3 {                                                  
    public static void main(String[] args) {
		Student s = new Student("学生",17);
		s.info();

		Worker w = new Worker("打工人",32);
		w.info();

	}
}

class Student extends Person{    
	// private String name; 
	// private int age; 
	private String school = "明德完小"; 
	public Student(String name,int age){ 
		// this.name = name; 
		// this.age = age; 
		this.setAge(age); 
		this.setName(name); 

	}
	// public void setName(String name){ 
	// 	this.name = name; 
	// }
	// public void setAge(int age){ 
	// 	this.age = age; 
	// }
	// public String getName( ){ 
	// 	return name; 
	// }
	// public String getAame( ){ 
	// 	return age; 
	// }
	public String getSchool( ){ 
		return school; 
	 }
	// public void info(){ 
	// 	System.out.println("name: " + this.name + "age: " + this.age); 
	// }

}

class Worker extends Person{//继承Person类
	// private String name;
	// private int age;
	public Worker(String name,int age){
		// this.name = name;
		// this.age = age;
		this.setAge(age);
		this.setName(name);
	}
	// public void setName(String name){
	// 	this.name = name;
	// }
	// public void setAge(int age){
	// 	this.age = age;
	// }
	// public String getName( ){
	// 	return name;
	// }
	// public String getAame( ){
	// 	return age;
	// }
	// public void info(){
	// 	System.out.println("name: " + this.name + "age: " + this.age);
	// }
}
class Person{//将上面相同的部分，合成一个类
	private String name;
	private int age;
	
	public void setName(String name){
		this.name = name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public String getName( ){
		return name;
	}
	public String getAame( ){
		return age;
	}
	public void info(){
		System.out.println("name: " + this.name + "  " + "age: " + this.age);
	}

}

练习
题一
在这里插入图片描述

// 父类
class ManKind{
	private int salary; 
	private int sex;

	public  int getSex() {
		return sex;
	}
	public  int getSalary() {
		return salary;
	}		
	public  void setSex(int sex) {
		this.sex = sex;
	}	
	public void setSalary(int salary){
		this.salary = salary;
	}

	public void manOrWorman(){
		if(sex == 1){
			System.out.println("man");
		}
		if(sex == 0){
			System.out.println("woman");
		}
	}
	public void employeed(){
		if(salary == 0){
			System.out.println("no job");
		}
		if(sex != 0){
			System.out.println("job");
		}

	}
}
//子类
 class Kids extends ManKind{
	private int yearOld;
	public void yearOld(int yearOld){
		this.yearOld = yearOld;
	}
	public void printAge(){
		System.out.println("yearOld: " + yearOld);
	}
}

public class Test3{
	public static void main(String[] args) {
		Kids somekid = new Kids();

		somekid.setSalary(0);
		somekid.setSex(0);
		somekid.yearOld(14);

		somekid.employeed();
		somekid.manOrWorman();
		somekid.printAge();
	}
}

题二
在这里插入图片描述

//这些类可以写在不同的文件里
public class Person{     
	private String name;
	private int age;
	private char sex;

	public void setName(String name){
		this.name = name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public void setSex(char sex){
		this.sex = sex;
	}
	public String getName( ){
		return name;
	}
	public int getAge( ){
		return age;
	}
	public char getSex(){
		return sex;
	}
	public Person(String name,char sex,int age){
		this.age = age;
		this.name = name;
		this .sex = sex;
	}
	public String toString(){
		return 0;

	}
	
}

class Student extends Person{
	private long number;
	private int math;
	private int english;
	private int computer;

	public Student(String n,char s,int a,long k,int m,int e,int c){
		// this.setName(n);
		// this.setAge(a);
		// this.setSex(s);
		super(n, s, e);//调用父类的构造器
		this.number = k;
		this.computer = c;
		this.math = m;
		this.english = e;	
	}
	public double aver(){
		return 0;
	}
	public int max(){
		return 0;
	}
	public String toString(){
		return 0;
	}
}

重写

修饰符  返回值类型 方法名(参数列表){}

前提：有子类继承父类
对父类同名方法的重写（覆盖），即子类继承父类后，父类的方法不适合子类，则可以选择重写来对父类的方法进行覆盖。
注意区分重写与重载的区别

重写规则

  1. 子类的方法的"返回值 方法名（参数列表）" 与父类的方法一致
  2. 子类的方法的修饰符不能小于父类方法的修饰符
  3. 若父类方法抛异常，那么子类方法抛的异常类型不能大于父类的异常类型
  4. 子父类的方法必须同为static或非static的

事例

public class Person{                                      
	private String name;
	private int age;
	private char sex;

	public void setName(String name){
		this.name = name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public void setSex(char sex){
		this.sex = sex;
	}
	public String getName( ){
		return name;
	}
	public int getAge( ){
		return age;
	}
	public char getSex(){
		return sex;
	}
	// public Person(String name,char sex,int age){
	// 	this.age = age;
	// 	this.name = name;
	// 	this .sex = sex;
	// }
	public void sleep(){
		System.out.println("我是人，我要要睡觉！");
	}
}

class Student extends Person{ 
	// public Student(String name, char sex, int age) {
	// 	super(name, sex, age);
	// 	//TODO Auto-generated constructor stub
	// }
               //对父类sleep()方法重写
	public void sleep(){
		System.out.println("我是学生，我要睡觉！");
	}

}

多态

一个事务的多种表达形态

  1. 表现：
    方法的重载和重写。
    子类对象的多态性–直接应用在抽象类和接口上。
  2. Java引用变量有两个类型：编译时类型（”看左边“由声明该变量时使用的类型决定）和运行时类型（”看右边“由实际赋给该变量的对象决定）
  3. 虚拟方法调用：通过父类的引用指向子类的对象实体，调用方法时，实际执行的是子类重写父类的方法
  4. 子类对象的多态性使用的前提：
    有类的继承
    有子类对父类方法的重写
    子类对象的多态性并不适用于属性

instanceof

（判断某个对象是否属于莫类的实例）

格式：对象a instanceof 类A
判断对象a是否为类A的实例，是就返回true,不是就返回false;
如果对象a是类A的一个实例，那对象a一定是类A的父类的实例
事例

//父类
class Person{                  
	private int age;
	private String name;
	
	public Person(){
		super();
	}
	public Person(String name,int age){
		super();
		this.age = age;
		this.name =name;
	}

	public  int 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 void ren(){
		System.out.println("我是人类");
	}
}
//子类
class Man extends Person{
	private boolean smoking;
	
	public Man(){
		super();
	}
	public Man(boolean smoking){
		super();
		this.smoking = smoking;
	}

	public  boolean getSmoking() {
		return smoking;
	}
	
	public  void setSmoking(boolean smoking) {
		this.smoking = smoking;
	}	
	public void ren(){
		System.out.println("我是男人");
	}
	public void game(){
		System.out.println("我要打游戏");
	}
}

class Woman extends Person{
	private boolean beauty;
	
	public Woman(){
		super();
	}
	public Woman(boolean beauty){
		super();
		this.beauty = beauty;
	}

	public  boolean getBeauty() {
		return beauty;
	}
	
	public  void setBeauty(boolean beauty) {
		this.beauty = beauty;
	}	
	public void ren(){
		System.out.println("我是女人");
	}
	public void shopping(){
		System.out.println("我要购物");
	}
}
//测试
public class Test4{ 
	public static void main(String[] args) {
		//子类对象的多态性: 父类的引用指向子类的对象
		Person p = new Man();//向上转型（子-->父）
		//虚拟方法调用
		p.ren();//Man的方法
		// p.game();此时的对象为Person类型，Person中无game()方法

		Person p1 = new Woman();
		p1.ren();//Woman的方法
		Woman w = (Woman)p1;//向下转型(使用强转符：父--->子）
		w.shopping();

		//instanceof判断某个对象是否属于某类的实例
		if(p instanceof Woman){
			Woman w1 = (Woman)p;
			w1.shopping();
		}
		if(p instanceof Man){
			Man m1 = (Man)p;
			m1.game();
		}
		if(p instanceof Person){
			System.out.println("carry!");
		}
	}
}

案例：

//父类
class Person{       
	private int age;
	private String name;
	
	public Person(){
		super();
	}
	public Person(String name,int age){
		super();
		this.age = age;
		this.name =name;
	}

	public  int 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 void ren(){
		System.out.println("我是人类");
	}
}
//子类
class Man extends Person{ 
	private boolean smoking;
	
	public Man(){
		super();
	}
	public Man(boolean smoking){
		super();
		this.smoking = smoking;
	}

	public  boolean getSmoking() {
		return smoking;
	}
	
	public  void setSmoking(boolean smoking) {
		this.smoking = smoking;
	}	
	public void ren(){
		System.out.println("我是男人");
	}
	public void game(){
		System.out.println("我要打游戏");
	}
}

class Woman extends Person{
	private boolean beauty;
	
	public Woman(){
		super();
	}
	public Woman(boolean beauty){
		super();
		this.beauty = beauty;
	}

	public  boolean getBeauty() {
		return beauty;
	}
	
	public  void setBeauty(boolean beauty) {
		this.beauty = beauty;
	}	
	public void ren(){
		System.out.println("我是女人");
	}
	public void shopping(){
		System.out.println("我要购物");
	}
}
//测试
public class Test4{
	public static void main(String[] args) {
		Test4 t = new Test4();
		t.fun(new Person());
		t.fun(new Man());
	}

	public void fun(Person p){
		p.ren();
	}
}

练习
题一
在这里插入图片描述

题二
****

class GeometricObject{  
    private String color;
    private double weight;
    public GeometricObject(String color,double weight){
        this.color = color;
        this.weight = weight;
    }
    public void setColor(String color){
        this.color = color;
    }
    public String getColor(){
        return color;
    }

    public void setWeight(double weight){
        this.weight = weight;
    }
    public double getWeight(){
        return weight;
    }
     public double findArea(){
        return 0.0;
    }

}
//子类
class Circle extends GeometricObject{
    private double radius;
    public Circle(double radius,String color,double weight){
        super(color,weight);
        this.radius = radius;
    }
    public double findArea(){
        return Math.PI * radius *radius;
    }
    public void setRadius(double radius){
        this.radius = radius;
    }
    public double getRadius(){
        return radius;
    }
}

class MyRectangle extends GeometricObject{
    private double width;
    private double height;
    public MyRectangle(double width,double height,String color,double weight){
        super(color, weight);
        this.width = width;
        this.height = height;
    }
    public void setWidth(double width){
        this.width = width;
    }
    public double getWidth(){
        return width;
    }
    public void setHeight(double height){
        this.height = height;
    }
    public double getHeight(){
        return height;
    }
     public double findArea(){
        return height * width;
    }
}

//测试
public class Test2{ 
    public static void main(String[] args) {
        Test2 t = new Test2();
        Circle c = new Circle(2.3, "green", 1.0);
        MyRectangle m = new MyRectangle(2.3, 3.0, "green", 2.0);
        t.displayGeometricObject(c);
        t.displayGeometricObject(m);
        boolean a = t.Area(c, m);
        System.out.println(a);
        
    }
    public boolean Area(GeometricObject s1,GeometricObject s2){
        return s1.findArea() == s2.findArea();
    }
    public void displayGeometricObject(GeometricObject s){
        System.out.println("面积" + s.findArea());
    }
}

在这里插入图片描述
在这里插入图片描述

3. 其他关键字

this

  • this表示当前对象，可以调用类的属性,方法和构造器
    在这里插入图片描述
public class Test3 {                
    public static void main(String[] args) {
		Person p = new Person(); //Person()即为空参的构造器
		p.setAge(10);
		p.info();
		p.setName("小王");
		p.info();
	}
}

class Person{
	private String name;
	private int age;
	//构造器
	public Person(){
	}
	public Person(String name){
		this.name = n;
	}
	public Person(String name,int age){
		this(name);//显示调用当前类的重载的指定的构造器
		this.age = a;
	}
	//方法
	public String getName(){
		return name;
	}
	public String getAge(){
		return age;
	}
	public void setAge(int a){
		age = a;
	}
	// public void setName(String n){
	// 	name = n;
	// }
	// public void setName(String name){ //调用此方法时，参数name与属性name混乱,name无法完成赋值操作
	// name = name;
	//  }
	public void setName(String name){ //
	this.name = name;
	 }
	public void info(){
		System.out.println("name: " + name + "age: " + age);
	}
}

输出结果：
在这里插入图片描述

  • 在方法内部使用，即此方法所属对象的引用
  • 在构造器内部使用，表示该构造器正在初始化的对象
  • 在构造器中，可以使用"this(形参)"的方式显示调用本类其他重载的指定
  • 构造器
    必须声明在首行；
    如一个类中有n个构造器，那么最多可以有n-1个构造器可以使用this(形参)

练习
题一
在这里插入图片描述

//这些类可以写在不同的文件里
public class Test3 { 
    public static void main(String[] args) {
		Boy boy = new Boy();
		boy.setAge(22);
		boy.setName("钱三一");

		Girl girl = new Girl();
		girl.setName("林妙妙");

		boy.marry(girl);
		boy.shout();
		System.out.println(" ");

		girl.marry(boy);

	}
}

class Boy{  
	private String name;
	private int age;

	public void setName(String name){
		this.name = name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public String getName( ){
		return name;
	}
	public String getAame( ){
		return age;
	}
	public void marry(Girl girl){
		System.out.println("我\u60F3要娶：" + girl.getName());
	}
	public void shout(){
		if(age > 24){
			System.out.println("我们可以先结婚");
		}else{
			System.out.println("\u6211\u4EEC可以先谈谈");
		}
	}
}

class Girl{
	private String name;
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void marry(Boy boy){
		System.out.println("我想要嫁给：" + boy.getName());
		boy.marry(this);
	}
}

package

  • 声明源文件所在包，写在程序的第一行
  • 每"."一次，代表一层文件目录
  • 包名都要小写
  • package语句后面的分号不要掉

例：

package com.huwei.t1;（com是一个文件夹，huwei是com下的一个文件夹，t1是huwei文件夹下的一个文件夹)

个人的项目命名

indi
个体项目（individual），指个人发起，但非自己独自完成的项目，可公开或私有项目，copyright主要属于发起者。
包名为“indi.发起者名.项目名.模块名……”

onem
单人项目（one-man），推荐用indi，指个人发起，但非自己独自完成的项目，可公开或私有项目，copyright主要属于发起者。
包名为“onem.发起者名.项目名.模块名……”

pers
个人项目（personal），指个人发起，独自完成，可分享的项目，copyright主要属于个人。
包名为“pers.个人名.项目名.模块名.……”

priv
私有项目（private），指个人发起，独自完成，非公开的私人使用的项目，copyright属于个人。
包名为“priv.个人名.项目名.模块名.……”

团体的项目命名

team
团队项目，指由团队发起，并由该团队开发的项目，copyright属于该团队所有。
包名为“team.团队名.项目名.模块名.……”

com
公司项目，copyright由项目发起的公司所有。
包名为“com.公司名.项目名.模块名.……”

import

  1. 显式导入指定包下的类或接口
import java.util,Scanner;
  1. 写在包声明与源文件之间
  2. 如果引用多个类或接口，就需要并列写出
import java.util.Scanner;      
import java.util.Date;
  1. import语句后面的分号不要掉
  2. 程序默认导入的是java.lang下的所有类和接口(即System,int,Math等)，使用时不需要再次导入
  3. 导入一个包下的所有类可以使用*代替
import java.util.*;
  1. 同名类的导入（如util与sql下都有Date类）就需要用常规方法导入其中一个类，另一个同名的就直接用包名.类名表示

如：java.sql.Date d1 = new java.sql.Date(234435L)

  1. import satic 表示导入指定类的static的属性或方法

如：

引用：import java.lang.System.out;   
调用：out.println("hello world!")
  1. import java.util.* 只能导入java.util下的所有类和接口,不能导入lang下的子包中的类和接口。

super

可以修饰属性，方法，构造器

  • 若子类与父类中的属性有重名，可以用”super.属性“来显示调用父类声明中的属性，”this.属性“来显示调用子类声明中的属性。
  • 若子类与父类中的方法有重名，可以用”super.方法（）“来显示调用父类声明中的属性，”this.属性“来显示调用子类声明中的属性。
  • 在子类中使用”super(形参列表)“来显式调用父类中指定的构造器。
    在构造器内部，”super(形参列表)“必须声明在首行，
    在构造器内部，”super(形参列表)“和”this(参数列表)“只能存在其一，
    建议:设计一个类时，尽量要提供一个空参的构造器。
    在构造器中，不显示的调用”super(形参列表)“或”this(参数列表)“其中一个，那默认调用的是父类空参的构造器。）
    在这里插入图片描述
// 父类
class Person{                                                         
	private int sex; 
	int id = 111;//身份证号
	public Person(int sex){ 
		this.sex = sex; 
	}
	public Person(){ 
		System.out.println("我是父类空参构造器");
	}

	public  int getSex() {
		return sex; 
	}
	
	public  void setSex(int sex) { 
		this.sex = sex; 
	}	

	public void manOrWorman(){ 
		if(sex == 1){
			System.out.println("man"); 
		}
		if(sex ==  0){ 
			System.out.println("woman"); 
		}
	}
}
//子类
 class Student extends Person{  
	private int yearOld; 
	int id = 222;//学号 
	//子类调用父类的构造器
	public Student(int yearOld){ 
		super(1); 
		this.yearOld = yearOld; 
	}
	public Student(){//此时程序也会调用父类空参的构造器
		this.yearOld = 33; 
	}
	

	public void yearOld(int yearOld){ 
		this.yearOld = yearOld; 
	}

	public void printAge(){ 
		System.out.println("yearOld: " + yearOld); 
	}
	public void show(){ 
		System.out.println(id);//222(子类) 
		System.out.println(super.id);//111（父类） 
	}
	
}

public class Test3{
	public static void main(String[] args) {
		Student student = new Student();

		student.setSex(0);
		student.yearOld(14);

		student.manOrWorman();
		student.printAge();
		student.show();
	}
}

感谢大家的支持，关注，评论，点赞！
参考资料：
尚硅谷宋红康20天搞定Java基础上部
Java包（package）的命名规范&规则

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

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

相关文章

手把手教你 使用SpringBoot 实现业务数据动态脱敏

手把手教你 使用SpringBoot 实现业务数据动态脱敏

文章目录 什么是数据脱敏静态数据脱敏动态数据脱敏 需求实现1. 切面AOP实现脱敏是否脱敏注解定义切入点测试单条记录结果多条记录结果分页记录结果 2. 自定义注解和自定义消息转换器实现数据脱敏自定义DataDesensitization注解定义脱敏类型枚举实现AnnotationFormatterFactory接…
阅读更多...
SAP度量单位转换功能

SAP度量单位转换功能

针对今天N2项目提出业务痛点：物料30011110的基本单位是KG，在XXX的BOM里单位是G，由于物料没配单位转换关系，但系统又能正常进行转换，开发需要技术支持。 经专项调查，G和KG的转换是SAP相同量纲转换标准功能&…
阅读更多...
econml双机器学习实现连续干预和预测

econml双机器学习实现连续干预和预测

连续干预 在这个示例中，我们使用LinearDML模型，使用随机森林回归模型来估计因果效应。我们首先模拟数据，然后模型，并使用方法来effect创建不同干预值下的效应（Conditional Average Treatment Effect，CATE&…
阅读更多...
现在转行搞嵌入式找工作难不难啊？

现在转行搞嵌入式找工作难不难啊？

对于应届生来说，嵌入式开发的经验不会有太多，所以要求也不会太高。 嵌入式开发常用的是C语言，所以需要你有扎实的功底，这一点很重要，数据结构算法，指针，函数，网络编程 有了上面的基…
阅读更多...
微服务——数据同步

微服务——数据同步

问题分析 mysql和redis之间有数据同步问题，ES和mysql之间也有数据同步问题。 单体项目可以在crud时就直接去修改，但在微服务里面不同的服务不行。 方案一 方案二 方案三 总结 导入酒店管理项目 倒入完成功启动后可以看见数据成功获取到了 声明队列和…
阅读更多...
word横向页面侧面页码设置及转pdf后横线变竖线的解决方案

word横向页面侧面页码设置及转pdf后横线变竖线的解决方案

在处理材料的时候，会遇到同一个文档里自某一页开始，页面布局是横向的，这时候页码要设置在侧面，方法是双击页脚，然后在word工具栏上选择“插入”——>“文本框”——>“绘制竖版文本框”，然后在页面左…
阅读更多...
Air001基于Arduino点灯实验

Air001基于Arduino点灯实验

Air001基于Arduino点灯实验 👉🏻Arduino平台环境搭建可以参考：https://wiki.luatos.com/chips/air001/Air001-Arduino.html 🔖使用国内的json，安装不仅成功率高还非常的快速。（当然取决于个人网络环境&…
阅读更多...
Windows安装Redis

Windows安装Redis

自己电脑做个测试，需要用到Redis，把安装过程记录下，方便有需要的人 1、找到下载地址：Releases microsoftarchive/redis GitHub Windows的Redis需要到GitHub上下载： 2、下载完后设置密码，打开文件夹&…
阅读更多...
RemObjects Suite Subscription for Delphi Crack

RemObjects Suite Subscription for Delphi Crack

RemObjects Suite Subscription for Delphi Crack Delphi的RemObjects套件订阅提供了一种方便且经济高效的方式，可以随时了解所有RemObjects Delphi产品的最新情况。它允许您访问所有当前和即将推出的产品，而不必担心错过重要的更新或新产品。当您的平台…
阅读更多...
医院智慧运营管理数字化方案

医院智慧运营管理数字化方案

近年来，随着医院的发展规模不断扩大，其人、财、物、技术等资源的配置活动愈加复杂，资产管理、成本管理、收支核算管理、资金预算管理、绩效管理等经济活动日常管理也日益繁重，医院对于数字化提升精细化管理的需求也愈发迫切。 国…
阅读更多...
块、行内块水平垂直居中

块、行内块水平垂直居中

1.定位实现水平垂直居中 <div class"outer"><div class"test inner1">定位实现水平垂直居中</div></div><style>.outer {width: 300px;height: 300px;border: 1px solid gray;margin: 100px auto 0;position: relative;}.te…
阅读更多...
DeepSort算法简介

DeepSort算法简介

SORT算法 SORT(Simple Online and Realtime Tracking)算法是一种目标追踪算法&#xff0c;其简单有效&#xff0c;基于IOU来匹配&#xff0c;并且融入了卡尔曼滤波和匈牙利算法来降低ID Switch(可以说&#xff0c;追踪算法的目标只有两个&#xff1a;1.提高速度 2.降低ID Swit…
阅读更多...
JMeter有对手了？RunnerGo这些功能真不错！

JMeter有对手了？RunnerGo这些功能真不错！

当谈到对于性能测试的需求时&#xff0c;JMeter和RunnerGo在测试场景设置、执行性能测试、性能测试结果分析等方面都提供了很多功能&#xff0c;但两个工具仍然存在一些区别。以下是详细的比较分析&#xff1a; 层次分明的模块化设计告别文件管理混乱&#xff1a; JMeter的设…
阅读更多...
SpringBoot异步框架

SpringBoot异步框架

参考&#xff1a;解剖SpringBoot异步线程池框架_哔哩哔哩_bilibili 1、 为什么要用异步框架&#xff0c;它解决什么问题&#xff1f; 在SpringBoot的日常开发中&#xff0c;一般都是同步调用的。但经常有特殊业务需要做异步来处理&#xff0c;例如&#xff1a;注册新用户&…
阅读更多...
idea找不到DataBase

idea找不到DataBase

一、我想把数据库跟我的idea链接&#xff0c;结果发现找不到。如图。 二、解决方案 找到 file ---setting 找到plugin------找到marketplace 我的已经出现了
阅读更多...
贪心-leetcode409最长回文串

贪心-leetcode409最长回文串

贪心-leetcode409最长回文串 思考&#xff1a; 总的思路&#xff1a;从数字中选择个数是偶数的去union&#xff0c;最后如果有过奇数则多union一个作为中心&#xff1b;从数组中select然后feasible是如果该数字为偶数则union到两边&#xff0c;如果为奇数则按照偶数处理再给中…
阅读更多...
Java版企业电子招标采购系统源码—企业战略布局下的采购寻源tbms

Java版企业电子招标采购系统源码—企业战略布局下的采购寻源tbms

​ 项目说明 随着公司的快速发展&#xff0c;企业人员和经营规模不断壮大&#xff0c;公司对内部招采管理的提升提出了更高的要求。在企业里建立一个公平、公开、公正的采购环境&#xff0c;最大限度控制采购成本至关重要。符合国家电子招投标法律法规及相关规范&#xff0c;以…
阅读更多...
分布式 - 消息队列Kafka：Kafka生产者发送消息的分区策略

分布式 - 消息队列Kafka：Kafka生产者发送消息的分区策略

文章目录 1. PartitionInfo 分区源码2. Partitioner 分区器接口源码3. 自定义分区策略4. 轮询策略 RoundRobinPartitioner5. 黏性分区策略 UniformStickyPartitioner6. hash分区策略7. 默认分区策略 DefaultPartitioner 分区的作用就是提供负载均衡的能力&#xff0c;或者说对数…
阅读更多...
【Shell编程】Linux Shell编程入门：输入输出、变量、条件判断、函数和运算

【Shell编程】Linux Shell编程入门：输入输出、变量、条件判断、函数和运算

在Linux操作系统中&#xff0c;Shell编程是一项非常重要的技能。通过Shell编程&#xff0c;我们可以自动化执行各种任务&#xff0c;提高工作效率。无论是系统管理、数据处理还是软件开发&#xff0c;都离不开Shell脚本的应用。本篇博客将带领大家深入了解Shell编程的基础知识&…
阅读更多...
木马免杀（篇一）基础知识学习

木马免杀（篇一）基础知识学习

木马免杀&#xff08;篇一&#xff09;基础知识学习 ———— 简单的木马就是一个 exe 文件&#xff0c;比如今年hw流传的一张图&#xff1a;某可疑 exe 文件正在加载。当然木马还可能伪造成各式各样的文件&#xff0c;dll动态链接库文件、lnk快捷方式文件等&#xff0c;也可能…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023