[C++]:15.继承

news2024/11/24 20:57:28

继承

  • 一.继承：
    • 1.继承的概念和基本操作：
      • 1.概念：
      • 2.基本操作：
    • 2.继承格式和多种继承方法：
      • 1.基本继承格式：
      • 2.继承关系+访问限定符
    • 3.子类对象和父类对象之间的赋值：
      • 1.为什么存在赋值兼容转换？
      • 2.子类对象赋值给父类对象(赋值兼容转换)：
        • 2-1:对象赋值：
        • 2-2：对象指针赋值：
        • 2-3：对象引用赋值：
      • 3.总结：
    • 4.继承中的作用域：
      • 1.问题：子类和父类可以有同名成员？
        • 1-1：同名成员：
        • 1-2：同名函数：
      • 2.问题：子类和父类成员函数不是重载关系？
      • 3.总结：
    • 5.子类的默认成员函数！
      • 1.构造函数：
      • 2.析构函数：
      • 3.拷贝：
      • 4.赋值：
    • 7.继承和友元+继承和静态：
      • 1.继承和友元：
      • 2.继承和静态：
    • 8.多继承：
      • 1.菱形继承：特殊的多继承
      • 2.1.菱形虚拟继承：
    • 9.继承的总结和反思：
      • 1.多继承
      • 2组合和继承：
      • 3.继承的作用：

一.继承：

1.继承的概念和基本操作：

1.概念：

继承就是一种类的复用，我们以前写的代码比较多的都是在主函数中使用各种函数这是函数的复用，在接触类和对象以后需要学习类的复用也就是继承。继承是面向对象的，这样的语法可以让程序员在原来的类的基础上继承产生一个新的的类，这个新的的类有被继承类的成员函数和成员变量。

2.基本操作：

两个类一个老师类，一个学生类，提取两个类中共有的内容去反向定义一个类person类让老师类和学生类都去继承人这个类实现类的复用：我们先去写一个关于学生的复用。

	class preson {
	public:
		preson(string name="xxxx", string six="xxx", int age=18)
			:_name(name)
			,_six(six)
			,_age(age)
		{}
		void information_person()
		{
			cout << "名字：" << _name << endl;
			cout << "性别：" << _six << endl;
			cout << "年龄：" << _age << endl;
		}
	protected:
		string _name;
		string _six;
		int _age;
	};

	class student : public preson {
	public:
		student(int score,int grade)
			:_score(score)
			,_grade(grade)
		{}
		void information_student()
		{
			//1.被继承的成员变量可以直接使用：
			cout << "名字：" << _name << endl;
			cout << "性别：" << _six << endl;
			cout << "年龄：" << _age << endl;
			//2.间接使用：
			information_person();
			//3.学生部分：
			cout << "成绩：" << _score << endl;
			cout << "年级：" << _grade << endl;
		}
	protected:
		int _score;
		int _grade;
	};

	int main()
	{
		sfpy::student s1(88, 1);
		s1.information_student();
		return 0;
	}

在这里插入图片描述

观察代码和运行结果，我们发现被继承的这个类当前的成员变量和成员函数我们都可以去使用，这个地方没有办法去指定学生的person类中的成员内容？

2.继承格式和多种继承方法：

1.基本继承格式：

在这里插入图片描述

2.继承关系+访问限定符

1.继承方式：public继承 ，protected继承 ， private继承。
2.访问方式：public访问 ，protected访问 ， private访问。
4.继承方式+访问方式才可以确定子类对父类的成员的使用情况！
5.注意：
5-1：不去显示的去写继承方式，class来说默认private继承 ， struct是公有继承。
5-2：建议：public继承方式 + 成员变量使用保护 + 成员方法使用公有。
*
总结：父类的 A 成员 和 子类的B继承组合在一起，对于子类来说对于子类来说这个父类的成员在子类中有着 A&&B中较小的一个情况。
*
public > protected > private;
保护就是因为继承才产生的，公有+保护 保护+公有 保护+保护 对于子类来说都可以去使用父类的成员！
在这里插入图片描述

3.子类对象和父类对象之间的赋值：

1.为什么存在赋值兼容转换？

不同类型之间在进行 赋值,大小比较,的时候都会产生临时变量。通过临时变量进行操作。下面这个地方通过a的值产生了一个float类型的临时变量然后临时变量和b进行比较在这个地方。

int main()
{
	int a = 10;
	float b = 20.5;
	
	if (a > b)
	{
		cout << "a>b" << endl;
	}
	else
	{
		cout << "a<b" << endl;
	}
	return 0;
}

子类赋值个父类的过程中是不存在中间变量的？
回答：临时变量具有常性不能把具有const类型的数据赋值给person对象。
解决办法：特殊处理—>赋值兼容转换—>中间不产生临时变量，做了一个切片处理。

2.子类对象赋值给父类对象(赋值兼容转换)：

子类的对象---->赋值给---->父类对象
子类的对象指针---->赋值给---->父类对象指针
子类的对象引用---->赋值给---->父类对象引用

int main()
{
	sfpy::student s1(88, 1);
	//1.切片赋值--->产生新的切片：
	sfpy::preson p1 = s1;
	//2.切片赋值
	sfpy::preson* p2 = &s1;
	//3.切片赋值
	sfpy::preson& p3 = s1;
	return 0;
}
2-1:对象赋值：

在这里插入图片描述

2-2：对象指针赋值：

在这里插入图片描述

2-3：对象引用赋值：

在这里插入图片描述

3.总结：

在这里插入图片描述

4.继承中的作用域：

1.问题：子类和父类可以有同名成员？

回答：子类和父类属于不同的作用域可以有同名成员！

1-1：同名成员：
class preson {
	public:
		preson(string name = "xxxx", string six = "xxx", int age = 18)
			:_name(name)
			, _six(six)
			, _age(age)
		{}
		void information()
		{
			cout << "名字：" << _name << endl;
			cout << "性别：" << _six << endl;
			cout << "年龄：" << _age << endl;
		}
	protected:
		string _name;
		string _six;
		int _age;
	};

	class student : public preson {
	public:
		student(string name ,int score, int grade)
			:_name(name)
			,_score(score)
			, _grade(grade)
		{}
		void information()
		{
			//1.被继承的成员变量可以直接使用：指定类域
			cout << "名字：" << preson::_name << endl;
			cout << "性别：" << _six << endl;
			cout << "年龄：" << _age << endl;


			cout << "名字：" << _name << endl;
			cout << "成绩：" << _score << endl;
			cout << "年级：" << _grade << endl;
		}
	protected:
		string _name;
		int _score;
		int _grade;
	};

在这里插入图片描述

1.成员变量的一个同名成员，子类优先访问自己的成员变量，如果在这样的情况下想要去访问父类的成员变量需要指定类域去进行访问。
2.父子类的同名成员变量，构成隐藏关系。

1-2：同名函数：
namespace sfpy {
	class preson {
	public:
		preson(string name="xxxx", string six="xxx", int age=18)
			:_name(name)
			,_six(six)
			,_age(age)
		{}
		void information()
		{
			cout << "名字：" << _name << endl;
			cout << "性别：" << _six << endl;
			cout << "年龄：" << _age << endl;
		}
	protected:
		string _name;
		string _six;
		int _age;
	};

	class student : public preson {
	public:
		student(int score,int grade)
			:_score(score)
			,_grade(grade)
		{}
		void information()
		{
			//1.被继承的成员变量可以直接使用：
			cout << "名字：" << _name << endl;
			cout << "性别：" << _six << endl;
			cout << "年龄：" << _age << endl;

			2.间接使用：指定类域
			person::information();
			
			//3.学生部分：
			cout << "成绩：" << _score << endl;
			cout << "年级：" << _grade << endl;
		}
	protected:
		int _score;
		int _grade;
	};

}

1.成员变量的一个同名成员，子类优先访问自己的成员变量，如果在这样的情况下想要去访问父类的成员函数需要指定类域去进行访问。
2.父子类的同名成员函数，构成隐藏关系，不需要考虑返回值和参数的情况！

2.问题：子类和父类成员函数不是重载关系？

回答：构成重载需要成员函数在同一作用域下！

3.总结：

1.在实际的情况当中不需要去定义同名的成员！
2.注意函数重载和隐藏关系的不同。

5.子类的默认成员函数！

子类和父类的这些默认成员函数进行分别调用的！
1.对子类做处理就去掉用子类
2.对父类做处理就去掉用父类

1.构造函数：

1.不去使用父类的默认构造通过显示的去调用父类的构造可以通过子类传参的方法对父类的成员进行初始化构造。
2.父类有默认构造函数那么如果我们不去显示的调用构造那么走默认构造(无参，全缺省，列表初始化)

	class preson {
	public:
		preson(string name = "xxxx", string six = "xxx", int age = 18)
			:_name(name)
			, _six(six)
			, _age(age)
		{}
		void information_person()
		{
			cout << "名字：" << _name << endl;
			cout << "性别：" << _six << endl;
			cout << "年龄：" << _age << endl;
		}
	protected:
		string _name;
		string _six;
		int _age;
	};

	class student : public preson {
	public:
		student(string name,string six, int age,int score, int grade)
			:preson(name,six,age)
			, _score(score)
			, _grade(grade)
		{}
		void information_student()
		{
			//1.被继承的成员函数可以直接使用：
			information_person();
			cout << "成绩：" << _score << endl;
			cout << "年级：" << _grade << endl;
			cout << endl;
		}
	protected:
		int _score;
		int _grade;
	};

在这里插入图片描述

2.析构函数：

在这里插入图片描述

为什么我们在子类的析构函数中显示的去掉用父类的析构函数会报错？
1.有父子关系的两个类的析构函数名称会被统一转化为distruct。
2.两个类的析构函数就构成了隐藏的关系。
3.同名称的函数需要指定类域。

在这里插入图片描述

我们如果去显示的去析构对象，先析构子的部分还是父的部分？
1.我们应该先析构子节点再去析构父节点。
2.因为如果存在先析构父节点那么如果子节点的析构操作需要父节点的数值怎么办？
3.为了保证先去调用子节点后调用父节点子类的析构函数不需要显示的去调用父类的析构函数。编译器会在调用完子类的析构然后自动的去调用父类的析构

3.拷贝：

1.编译器默认生成的 拷贝构造会去完成值拷贝。
2.对于当前的例子来说完成值拷贝是没有问题的。
3.显示的去调用父类的拷贝构造子类的初始化列表中去使用。
4.我们知道在一些情况下有可能发生浅拷贝的问题是需要进行显示调用。

class preson {
public:
	preson(string name = "xxxx", string six = "xxx", int age = 18)
		:_name(name)
		, _six(six)
		, _age(age)
	{}
	preson(const preson& p1)
	{
		_name = p1._name;
		_six = p1._six;
		_age = p1._age;
	}
	void information_person()
	{
		cout << "名字：" << _name << endl;
		cout << "性别：" << _six << endl;
		cout << "年龄：" << _age << endl;
	}
	~preson()
	{
		cout << "~preson" << endl;
	}
protected:
	string _name;
	string _six;
	int _age;
};

class student : public preson {
public:
	student(string name, string six, int age, int score, int grade)
		:preson(name, six, age)
		, _score(score)
		, _grade(grade)
	{}
	student(const student& s1)
		:preson(s1)
		,_score(s1._score)
		,_grade(s1._grade)
	{}
	void information_student()
	{
		//1.被继承的成员函数可以直接使用：
		information_person();
		cout << "成绩：" << _score << endl;
		cout << "年级：" << _grade << endl;
		cout << endl;
	}
	~student()
	{
		preson::~preson();
		cout << "~student" << endl;
	}
protected:
	int _score;
	int _grade;
};

}

4.赋值：

class preson {
public:
	preson(string name = "xxxx", string six = "xxx", int age = 18)
		:_name(name)
		, _six(six)
		, _age(age)
	{}
	preson(const preson& p1)
	{
		_name = p1._name;
		_six = p1._six;
		_age = p1._age;
	}
	void information_person()
	{
		cout << "名字：" << _name << endl;
		cout << "性别：" << _six << endl;
		cout << "年龄：" << _age << endl;
	}
	preson& operator=(const preson& p)
	{
		//1.不能自己给自己进行赋值：
		if (this != &p)
		{
			_name = p._name;
			_six = p._six;
			_age = p._age;
		}
		return *this;

	}
	~preson()
	{
		cout << "~preson" << endl;
	}
protected:
	string _name;
	string _six;
	int _age;
};

class student : public preson {
public:
	student(string name, string six, int age, int score, int grade)
		:preson(name, six, age)
		, _score(score)
		, _grade(grade)
	{}
	student(const student& s1)
		:preson(s1)
		,_score(s1._score)
		,_grade(s1._grade)
	{}
	void information_student()
	{
		//1.被继承的成员函数可以直接使用：
		information_person();
		cout << "成绩：" << _score << endl;
		cout << "年级：" << _grade << endl;
		cout << endl;
	}
	student& operator=(const student& s)
	{
		//1.不能自己给自己进行赋值：
		if (this != &s)
		{
			//2.分开显示的调用：
			preson::operator=(s);
			_score = s._score;
			_grade = s._grade;
		}
		return *this;
	}
	~student()
	{
		preson::~preson();
		cout << "~student" << endl;
	}
protected:
	int _score;
	int _grade;
};

}

在这里插入图片描述

7.继承和友元+继承和静态：

1.继承和友元：

1.友元关系不可以继承，子类的友元不能访问子类的私有和保护。
2.如果想要使用友元函数那么应该在自己的类域中去声明友元函数。

2.继承和静态：

1,父类定义了一个static成员那么无论有多少子类继承，产生了多少对象，都只有这一个static成员实例。

8.多继承：

1.单继承：一个子类只去直接继承一个父类。

class A {
public:
	A(int a)
	:_a(a)
	{
		cout << "A()" << endl;
	}
protected:
	int _a;
};

class B : public A{
public:
	B(int a, int b)
		:A(a)
		,_b(b)
	{
		cout << "B()" << endl;
	}
protected:
	int _b;
};

class C : public B {
public:
	C(int a, int b,int c)
		:B(a,b)
		, _c(c)
	{
		cout << "B()" << endl;
	}
protected:
	int _c;
};

2.多继承：一个子类直接继承多个父类。

class A {
public:
	A(int a)
	:_a(a)
	{
		cout << "A()" << endl;
	}
protected:
	int _a;
};

class B{
public:
	B(int b)
		:_b(b)
	{
		cout << "B()" << endl;
	}
protected:
	int _b;
};

class C : public B,public A {
public:
	C(int a, int b,int c)
		:B(b)
		,A(a)
		, _c(c)
	{
		cout << "B()" << endl;
	}
protected:
	int _c;
};

1.菱形继承：特殊的多继承

在这里插入图片描述

菱形继承存在两个问题：
1.数据冗余：存储了很多不需要的数据。
2.二意性:作为老师有一个名称，作为学生有一个名称。

class preson {
public:
	preson(string name)
		:_name(name)
	{}

protected:
	string _name;
};

class student : public preson{
public:
	student(string name , int id)
		:preson(name)
		,_student_id(id)
	{}
protected:
	int _student_id;
};

class Teacher : public preson {
public:
	Teacher(string name, int id)
		:preson(name)
		, _teacher_id(id)
	{}
protected:
	int _teacher_id;
};

class Assistan : public student,public Teacher {
public:
	Assistan(string name_1 , string name_2,int id_1 , int id_2 , int money)
		:student(name_1,id_1)
		,Teacher(name_2,id_2)
		,_money(money)
	{}
protected:
	int _money;
};

1.person有一个属性名称。
2.作为学生有学生编号和名称。
3.作为老师有老师编号和名称。
4.作为助理继承了老师和学生的两个身份同时可以有工资这个属性。
5.这么一看好像没有什么问题但是人的公有属性名称在内存中的存贮是什么样子的？
6.如果说presson类有非常多的数据名字，住址，性别，身份证号等等，我们需要存贮两份数据吗？

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

2.1.菱形虚拟继承：

class A {
public:
	A(int a = 0)
	:_a(a)
	{
		cout << "A()" << endl;
	}
protected:
	int _a;
};

class B : virtual public A{
public:
	B(int a , int b)
		:A(a)
		,_b(b)
	{
		cout << "B()" << endl;
	}
protected:
	int _b;
};

class C : virtual public A{
public:
	C(int a, int c)
		:A(a)
		,_c(c)
	{
		cout << "B()" << endl;
	}
protected:
	int _c;
};

class D :  public B , public C{
public:
	D(int a,int b,int c,int d)
		:B(a,b)
		,C(a,c)
		,_d(d)
	{}
protected:
	int _d;
};

为什么有虚继承？
在语法上新增加了一个虚继承去解决数据冗余和二意性。
注意：虚拟继承可以解决菱形继承继数据冗余和二意性问题，只能在B和C中去使用虚拟继承就可以解决问题。从底层来看相同的数据只会去保存一份节省了空间。

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

在这里插入图片描述

9.继承的总结和反思：

1.多继承

1.多继承是C++的缺陷，有了多继承就有菱形继承，不得不新增语法解决问题。

2组合和继承：

1.我们应该优先去使用组合而不是继承。
黑箱：组合
1.我们使用组合对象之间关系不太一个类被维护不会影响到另一个类。
2.为什么称为黑箱呢？
3.使用一个对象我们只需要去使用对象的接口我们不需要关心对象中内容只需要去使用相关的接口。对象里面的内容我们是看不见的！
4.组合之间没有非常强的依赖关系，耦合度底。

白箱：继承
1.对于子类来说父类就是一个白箱，父类中的内容我们大部分都可以访问到。操>作父类内容比较麻烦可能产生问题，
2.改变父类会影响子类，子类和父类的依赖关系是非常强的。
3.代码的耦合度是非常高的。

3.继承的作用：

在实际情况中可以使用组合就使用组合，组合的耦合度底，代码方便维护，对于继承来说合适使用继承的地方还是可以去使用继承，多态的前提条件也是需要有继承关系的。

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

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

相关文章

基于Spring Boot的校友录管理系统

基于Spring Boot的校友录管理系统

基于Spring Boot的校友录管理系统 1、绪论1.1 研究背景及意义1.2 研究内容 2、系统设计2.1 系统架构设计2.2 系统功能设计2.3 数据库设计2.3.1 系统实体类2.3.2 实体之间的联系 3、系统实现3.1 系统登录页3.2 系统首页3.3 校友信息实现3.3.1 校友批量上传 3.4 活动中心实现3.4.…
阅读更多...
DS：经典算法OJ题（2）

DS：经典算法OJ题（2）

创作不易&#xff0c;友友们给个三连吧&#xff01;&#xff01; 一、旋转数组&#xff08;力扣&#xff09; 经典算法OJ题&#xff1a;旋转数组 思路1&#xff1a;每次挪动1位&#xff0c;右旋k次 时间复杂度&#xff1a;o(N^2) 右旋最好情况&#xff1a;k是n的倍数…
阅读更多...
‘begin_code.h‘ file not found 问题解决办法

‘begin_code.h‘ file not found 问题解决办法

/usr/include/x86_64-linux-gnu/SDL2/SDL_platform.h:179:10: fatal error: ‘begin_code.h’ file not found 问题解决办法 问题 在使用SDL2库时编译程序出现如下问题&#xff1a; 解决办法 在Google搜索未果后&#xff0c;考虑到对于头文件找不到问题&#xff0c;可以通…
阅读更多...
clickhouse在MES中的应用-跟踪扫描

clickhouse在MES中的应用-跟踪扫描

开发的MES&#xff0c;往往都要做生产执行跟踪扫描&#xff0c;这样会产生大量的扫描数据&#xff0c;用关系型数据库&#xff0c;很容易造成查询冲突的问题。 生产跟踪扫描就发生的密度是非常高的&#xff0c;每个零部件的加工过程&#xff0c;都要被记录下来&#xff0c;特别…
阅读更多...
老师没收学生东西违法吗怎么处理

老师没收学生东西违法吗怎么处理

身为一名老师&#xff0c;面对没收学生东西这个话题&#xff0c;确实让人感到有些尴尬和无奈。毕竟&#xff0c;我们教育的初衷是为了引导学生健康成长&#xff0c;而不是与他们产生矛盾和冲突。 老师在未经允许的情况下没收学生的物品&#xff0c;是违法的。学生的个人财物&a…
阅读更多...
python+flask人口普查数据的应用研究及实现django

python+flask人口普查数据的应用研究及实现django

作为一款人口普查数据的应用研究及实现&#xff0c;面向的是大多数学者&#xff0c;软件的界面设计简洁清晰&#xff0c;用户可轻松掌握使用技巧。在调查之后&#xff0c;获得用户以下需求&#xff1a; &#xff08;1&#xff09;用户注册登录后&#xff0c;可进入系统解锁更多…
阅读更多...
微服务的幂等性

微服务的幂等性

微服务架构设计的中心思想是将服务进行拆分&#xff0c;但是在这个过程中&#xff0c;如果被依赖的服务发生奔溃&#xff0c;就会引起一系列问题。为了解决这个问题&#xff0c;就会引入重试的机制&#xff0c;重试又会引入幂等性的问题&#xff0c;下面我们就分析这个过程&…
阅读更多...
面试150 颠倒二进制位 位运算分治 逻辑右移

面试150 颠倒二进制位 位运算分治 逻辑右移

Problem: 190. 颠倒二进制位 文章目录 思路复杂度位运算分治法 思路 &#x1f468;‍&#x1f3eb; 参考题解 >>>&#xff1a;逻辑右移&#xff08;符号位一起移动&#xff0c;高位补零&#xff09; 复杂度 时间复杂度: O ( log ⁡ n ) O(\log{n}) O(logn) 空间…
阅读更多...
Quartus IP学习之ISSP（In-System Sources Probes）

Quartus IP学习之ISSP（In-System Sources Probes）

一、ISSP IP概要&#xff1a; ISSP&#xff1a;In-System Sources & Probes Intel FPGA IP 作用&#xff1a; 分为In-System Sources与In-System Probesn-System Sources&#xff0c;输入端&#xff0c;等价于拨码开关&#xff0c;通过输入板载FPGA上的拨码开关状态改变…
阅读更多...
如何结合ChatGPT生成个人魔法咒语词库

如何结合ChatGPT生成个人魔法咒语词库

3.6.1 ChatGPT辅助力AI绘画 3.6.1.1 给定主题让ChatGPT直接描述 上面给了一个简易主题演示一下&#xff0c;这是完全我没有细化的提问&#xff0c;然后把直接把这些关键词组合在一起。 关键词&#xff1a; 黄山的美景&#xff0c;生机勃勃&#xff0c;湛蓝天空&#xff0c;青…
阅读更多...
鲜花销售|鲜花销售小程序|基于微信小程序的鲜花销售系统设计与实现(源码+数据库+文档)

鲜花销售|鲜花销售小程序|基于微信小程序的鲜花销售系统设计与实现(源码+数据库+文档)

鲜花销售小程序目录 目录 基于微信小程序的鲜花销售系统设计与实现 一、前言 二、系统功能设计 三、系统实现 1、前台功能模块 2、后台功能模块 (1) 后台登录 (2) 管理员功能模块 用户管理 商家管理 鲜花信息管理 鲜花分类管理 管理员管理 系统管理 (3) 商家功…
阅读更多...
SerDes PoC 电感网络工作原理详解

SerDes PoC 电感网络工作原理详解

如下图所示，PoC的工作原理可以描述如下： 1. 直流状态时，电感处于短路状态，电容处于开路状态，因此，接收端的电源能够通过电感注入到信号传输系统中，并在另一端通过电感为本地电路供电，而不会透过电容影响到两端的高速收发器； 2. 交流状态时，即高频信号注入时，电容器是…
阅读更多...
华为机考入门python3--（5）牛客5-进制转换

华为机考入门python3--（5）牛客5-进制转换

分类&#xff1a;数字 知识点&#xff1a; 十六进制转int num int(hex_num, 16) int转十六进制 hex_num hex(num) 题目来自【牛客】 hex_num input().strip() dec_num int(hex_num, 16) print(dec_num) by 软件工程小施同学
阅读更多...
【OpenCV学习笔记28】- OpenCV 中的直方图 - 直方图 - 2：直方图均衡

【OpenCV学习笔记28】- OpenCV 中的直方图 - 直方图 - 2：直方图均衡

这是对于 OpenCV 官方文档中 图像处理 的学习笔记。学习笔记中会记录官方给出的例子&#xff0c;也会给出自己根据官方的例子完成的更改代码&#xff0c;同样彩蛋的实现也会结合多个知识点一起实现一些小功能&#xff0c;来帮助我们对学会的知识点进行结合应用。 如果有喜欢我笔…
阅读更多...
【Java并发】聊聊Disruptor背后高性能的原理

【Java并发】聊聊Disruptor背后高性能的原理

为什么需要Disruptor 对于单机生产者消费者来说&#xff0c;JUC本身提供了阻塞队列&#xff0c;ArrayBlockingQueue、LinkedBlockingQueue 等&#xff0c;但是为了保证数据安全&#xff0c;使用了reentrantLock进行加锁操作会影响性能&#xff0c;另一方面&#xff0c;本身如果…
阅读更多...
Kafka相关内容复习

Kafka相关内容复习

为什么要用消息队列 解耦 允许你独立的扩展或修改两边的处理过程&#xff0c;只要确保它们遵守同样的接口约束。 可恢复性 系统的一部分组件失效时&#xff0c;不会影响到整个系统。消息队列降低了进程间的耦合度&#xff0c;所以即使一个处理消息的进程挂掉&#xff0c;加入队…
阅读更多...
XCTF：3-1[WriteUP]

XCTF：3-1[WriteUP]

从题目中获取文件 使用file命令查看文件类型 修改后缀为.rar后进行解压缩 再次使用file命令查询该文件的类型 再次修改后缀为.pcap或者.pcapng 使用wireshark打开&#xff0c;直接搜索flag字样 在多个数据包里发现了flag.rar、flag.txt等文件 尝试使用http导出文件 有一个fl…
阅读更多...
小程序＜scroll-view/＞组件详解及使用指南

小程序＜scroll-view/＞组件详解及使用指南

目录 引言小程序的流行和重要性scroll-view 组件在小程序中的作用和优势什么是 scroll-view 组件scroll-view 组件的基本概念scroll-view 组件的基本功能scroll-view 组件的属性与用法scroll-view 组件的常用属性参考代码scroll-view 组件的滚动事件scrolltoupper
阅读更多...
【开源】SpringBoot框架开发大学计算机课程管理平台

【开源】SpringBoot框架开发大学计算机课程管理平台

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 实验课程档案模块2.2 实验资源模块2.3 学生实验模块 三、系统设计3.1 用例设计3.2 数据库设计3.2.1 实验课程档案表3.2.2 实验资源表3.2.3 学生实验表 四、系统展示五、核心代码5.1 一键生成实验5.2 提交实验5.3 批阅实…
阅读更多...
ESU毅速丨为什么增材制造广受关注？

ESU毅速丨为什么增材制造广受关注？

随着科技的飞速发展&#xff0c;增材制造3D打印技术逐渐成为制造业的新宠。包括航空航天、汽车、家电、电子等各行业都在积极拥抱3D打印&#xff0c;为什么3D打印能引起制造业广泛关注与应用&#xff1f;它的主要优势有哪些&#xff1f; 首先&#xff0c;3D打印减少浪费。3D打印…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023