6-继承

最新推荐文章于 2024-09-09 22:12:12 发布
最新推荐文章于 2024-09-09 22:12:12 发布
阅读量1.1k 收藏 17
点赞数 20
分类专栏： C++ 文章标签： 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40983975/article/details/139280697
版权

6-继承

1、基本语法和方式

class 子类 : 继承方式1 基类1, 继承方式2 基类2, ... {
	...
};
  • 继承方式
    公有继承：public
    保护继承：protected
    私有继承：private

2、继承的基本特点

2.1 三种继承方式相同的基本点

  • 继承所要达到的目的：
    • 子类对象包含基类子对象
    • 子类内部可以直接访问基类的所有非私有成员
  • 继承的本质：
    • 基类的非私有成员在子类中仅仅为可见，而非拥有
      注意：
      对于继承切忌不要理解为基类的成员变为子类的成员，继承不会改变类成员的作用域，基类的成员永远都是基类的成员，并不会因为继承而变成子类的成员
  • 尽管基类的公有和保护成员在子类中直接可见，但仍然可以在子类中重新定义这些名字，子类中的名字会隐藏所有基类中的同名定义
  • 如果需要在子类内部访问 一个在基类中定义却被子类标识符所隐藏的名字，可以借助作用域限定操作符“::”实现
  • 因为作用域的不同，分别在子类和基类中定义的同名成员函数(包括静态成员函数)，并不构成重载关系，相反是一种隐藏关系
  • 任何时候，在子类的内部，总可以通过作用域限定操作符“::”，显式地调用那些在基类中定义却被子类所隐藏的成员
// 继承最基本的特点
// (1) 子类对象的内部 包含 基类子对象
// (2) 子类内部可以直接访问 基类的 非私有(共有/保护)成员(变量/函数)
// (3) 一旦被子类同名定义隐藏 可以借助::指明访问基类
class Base{
public:
	int m_a;
	void foo(){ cout << "Base::foo" << endl; }
protected:
	int m_b;
	void bar(){ cout << "Base::Bar" << endl; }
private:
	int m_c;
	void hum(){ cout << "Base::hum" << endl; }
};
class Derived :public Base{
public:
	void fun(){
		m_a = 100;
		Base::foo();// 子类的foo函数将基类的foo函数隐藏，但可以通过作用域限定符访问基类的foo
		m_b = 100;
		bar();  //子类内部可以直接访问 基类的 非私有(共有/保护)成员(变量/函数)
		//m_c = 100;
		//hum();
	}
private:
	int m_d;
	void foo(){ cout << "Derived::foo" << endl; }
	void bar(){ cout << "Derived::Bar" << endl; }
};
int main(){
	Base b;// 基类对象
	cout << "基类对象b的大小" << sizeof(b) << endl; // 12
	Derived d;// 子类对象
	cout << "子类对象d的大小" << sizeof(d) << endl; // 16  子类对象的内部 包含 基类子对象
	d.fun();
	return 0;
}

2.2 三种继承方式的差别

  • 基类中的公有、保护和私有成员，在子类中将对这些基类成员的访问控制限定进行重新标记
// public继承的独特点
class publicBase :public Base{// 子类将对基类的成员重新标记访问限定符
	// 子类将对基类的成员重新标记访控限定 m_a/foo是public m_b/bar是protected m_c/hum是private
public:
	void fun(){ // //子类内部访问基类成员时，编译器需要查看这些成员在 基类中的原始标记
		m_a = 100;
		Base::foo();// 子类的foo函数将基类的foo函数隐藏，但可以通过作用域限定符访问基类的foo
		m_b = 100;
		bar();  //子类内部可以直接访问 基类的 非私有(共有/保护)成员(变量/函数)
	}
private:
	int m_d;
};
// protected继承的独特点
class protectedBase :protected Base{// 子类将对基类的成员重新标记访问限定符
	// 子类将对基类的成员重新标记访控限定 m_a/foo是protected m_b/bar是protected m_c/hum是private
public:
	void fun(){ //子类内部访问基类成员时，编译器需要查看这些成员在 基类中的原始标记
		m_a = 100;
		Base::foo();// 子类的foo函数将基类的foo函数隐藏，但可以通过作用域限定符访问基类的foo
		m_b = 100;
		bar();  //子类内部可以直接访问 基类的 非私有(共有/保护)成员(变量/函数)
	}
private:
	int m_d;
};
// private继承的独特点
class privateBase :private Base{// 子类将对基类的成员重新标记访问限定符
	// 子类将对基类的成员重新标记访控限定 m_a/foo是private m_b/bar是private m_c/hum是private
public:
	void fun(){ //子类内部访问基类成员时，编译器需要查看这些成员在 基类中的原始标记
		m_a = 100;
		Base::foo();// 子类的foo函数将基类的foo函数隐藏，但可以通过作用域限定符访问基类的foo
		m_b = 100;
		bar();  //子类内部可以直接访问 基类的 非私有(共有/保护)成员(变量/函数)
	}
private:
	int m_d;
};
int main(){
	publicBase d;// 利用子类对象在类外访问 基类成员时，编译器需要查看这些成员在 子类中的重新标记
	d.m_a = 10;
	d.foo();
	//d.m_b = 10; // err
	//d.bar();// err
	//d.m_c = 30;// err
	//d.hum();// err
	protectedBase b;// 利用子类对象在类外访问 基类成员时，编译器需要查看这些成员在 子类中的重新标记
	//b.m_a = 10;// err
	//b.foo();// err
	//b.m_b = 10; // err
	//b.bar();// err
	//b.m_c = 30;// err
	//b.hum();// err
	privateBase cd;// 利用子类对象在类外访问 基类成员时，编译器需要查看这些成员在 子类中的重新标记
	//cd.m_a = 10;// err
	//cd.foo();// err
	//cd.m_b = 10; // err
	//cd.bar();// err
	//cd.m_c = 30;// err
	//cd.hum();// err
	return 0;
}
基类中的在公有子类中标记为在保护子类中标记为在私有子类中标记为
公有成员公有成员保护成员私有成员
保护成员保护成员保护成员私有成员
私有成员私有成员私有成员私有成员
  • 当“通过”子类访问其所继承的基类的成员时，需要考虑因继承方式对访问控制限定的影响

2.3 公有继承的独有特点

(1) 只有在公有继承下，子类对象在类外可以访问基类的 公有成员(其他继承不可以)
(2) 如果被子类同名标识符隐藏可以借助::指明访问基类的成员
(3) 只有在公有继承下 子类类型指针 和 基类类型指针 之间可以进行转换
子类类型引用 和 基类类型引用 之间可以进行转换

class publicBase :public Base{
public:
	void foo(){
		cout << "publicBase：：foo" << endl;
	}
private:
	int m_d;
};
class Human{
public:
	int m_d;
	string m_name;
};
class Student :public Human{
public :
	int m_no;
};
int main(){
	publicBase b;
	b.m_a = 1000;
	b.foo(); // 调用的是自己的
	b.Base::foo(); // 调用的是基类的
	Human h;
	cout << "基类对象h的大小" << sizeof(h) << endl;
	Student s;
	cout << "子类对象s的大小" << sizeof(s) << endl;
	// 子类类型指针 和 基类类型指针
	Human* ph = &s; // Student* --> Human*
	// 子类类型引用 和 基类类型引用
	Human& rh = s;
	// 以上两种转换，编译器认为访问范围缩小，是安全的
	//Student* ps = &h;
	//Student& rs = h;
	// 以上两种转换，编译器认为访问范围扩大，是危险的
	Student* ps = static_cast<Student*> (&h);
	Student& rs = static_cast<Student&>(h);
	// 通过静态转换虽然可以成功，但是风险依旧存在，极其不建议这么使用
	Student* ps = static_cast<Student*>(ph);// ph 指向的就是C6_Student的对象
	Student& rs = static_cast<Student&>(rh);// rh 就是C6_Student对象的引用
	// 以上两种转换毫无风险，极其建议大家这么做
	// 基类指针或引用的实际目标，究竟是不是子类对象，完全由我们自己判断
	return 0;
}

向上造型：

  • 子类类型指针 隐式 转换为基类类型指针
  • 子类类型引用 隐式 转换为基类类型引用

3、子类的构造、析构

3.1 子类的构造

  • 子类没有定义构造函数
    • 编译器为子类提供的默认无参构造函数，定义基类子对象，并调用其基类的无参构造函数，构造该子类对象中的基类子对象。
  • 子类定义构造函数但没有在初始化表中指明基类部分构造方式
    • 定义基类子对象，并调用其基类的无参构造函数，构造该子类对象中的基类子对象。
  • 子类定义构造函数并在初始化表中指明基类部分构造方式
    • 定义基类子对象并 调用指明的其基类的构造函数。
  • 子类对象的构造过程
    • 构造基类子对象->构造成员变量->执行构造代码

3.2 子类的析构

  • 子类没有定义析构函数
    • 编译器将提供一个默认析构函数，析构完所有的成员变量以后，会自动调用其基类的析构函数.
  • 子类定义析构函数
    • 子类的析构函数在执行完自身析构代码，并析构完所有的成员变量以后，会自动调用其基类的析构函数.
  • 子类对象的析构过程
    • 执行析构代码->析构成员变量->析构基类子对象

3.3 子类的拷贝构造函数

  • 子类没有定义拷贝构造函数
    • 编译器为子类提供的默认拷贝构造函数，定义基类子对象，并调用其基类的拷贝构造函数构造该子类对象中的基类子对象
  • 子类定义了拷贝构造函数，但没有在初始化表指明其基类部分的构造方式
    • 定义基类子对象，并调用其基类的无参构造函数，构造该子类对象中的基类子对象
  • 子类定义了拷贝构造函数，同时初始化表中指明了其基类部分以拷贝方式构造
    • 定义基类子类对象，并调用其基类的拷贝构造函数，构造该子类对象中的基类子对象

3.4 子类的拷贝赋值

  • 子类没有定义拷贝赋值函数
    • 编译器为子类提供的缺省拷贝赋值函数，会自动调用其基类的拷贝赋值函数，复制该子类对象中的基类子对象
  • 子类定义了拷贝赋值函数，但没有显式调用其基类的拷贝赋值函数
    • 子类对象中的基类子对象将得不到复制
  • 子类定义了拷贝赋值函数，同时显式调用了其基类的拷贝赋值函数
    • 子类对象中的基类子对象将得到复制
class C6_people{
public:
	C6_people(int age = 0, const char*name = "无名"):m_age(age), m_name(name){
		//【int m age=age;】定义mage,初值为age
		//【string m name(name);】定义m name,利用m name,string(name)
		cout << "people类的缺省构造函数被调用" << endl;
	}
	C6_people(const C6_people&that):m_age(that.m_age),m_name(that.m_name){
		// 【int m_age = that, mage; 】定义mage, 初值为that.m age
		//【string m name=that.m name;】定义m name,利用m name.string(that.m name)
		cout << "people类的拷贝构造函数被调用" << endl;
	}
	C6_people&operator=(const C6_people& that){
		//编译器不会在自定义拷贝赋值函数中塞任何操作
		cout << "people类的拷贝赋值函数被调用" << endl;
		this->m_age=that.m_age;
		this->m_name=that.m_name; // this->m name.operator=(that.m name)
		return *this;
	}
	~C6_people(){
		cout << "C6_people类的析构函数被调用" << endl;
		//对于基本类型的成员变量m_age,什么都不做
		//对于类类型的成员变量m_name,利用m_name,~string()
		//释放m_age/m_name本身所占内存空间
	}
	void getinfo(){
		cout << "姓名：" << m_name << ",年龄：" << m_age ;
	}
private:
	int m_age;// 基本类型成员变量
	string m_name;// 类类型成员变量
};
class C6_stu : public C6_people{
public:
	//子类没有定义构造函数编译器为子类提供的默认无参构造函数
	//C6_stu(){
	//	【Human(); 】定义基类子对象，利用基类子对象.Human()
	//  【float m score; 】
	//	【string m remark; 】
	//}
	C6_stu(int age = 45, string name = "张三", float score = 0.0, string remark = "优秀") :m_score(score), m_remark(remark), C6_people(age,name.c_str()){
		cout << "基类的缺省构造被调用了" << endl;
	}
	void getinfo(){
		C6_people::getinfo();
		cout << "分数:" << m_score << "评语：" << m_remark << endl;
	}
	//子类没有定义析构函数编译器将提供一个默认析构函数
	//~C6_stu(){
	//对于基本类型的成员变量m_score,什么都不做
	//对于类类型的成员变量m m_remark,利用m_remark,~string()
	// 对于基类子对象，利用基类子对象.~C6_people()
	//释放m_score/m_remark本身所占内存空间
	//}
	~C6_stu(){
		cout << "C6_stu类的析构函数被调用" << endl;
	}
	//子类没有定义拷贝构造函数编译器为子类提供的默认拷贝构造函数
	//C6_stu(const C6_stu& that){
	//	// [C6_people(that)] 定义基类子对象，利用基类子对象.C6_people(that) ->C6_people类拷贝构造函数
	//	// ...
	//}
	// 子类没有定义拷贝赋值函数编译器为子类提供的缺省拷贝赋值函数
	//C6_stu& operator=(const C6_stu& that){
	//	C6_people *p = this;
	//	*p = that;// C6_people类的拷贝赋值函数
	//}

private:
	float m_score;
	string m_remark;
};
int main(){
	cout << "----s1" << endl;
	C6_stu s1(22,"李四",89.7,"良好");// 构造
	s1.getinfo();
	cout << "----s2" << endl;
	C6_stu s2 = s1; // 拷贝构造
	s2.getinfo();
	cout << "----s3" << endl;
	C6_stu s3;
	cout << "s3赋值前" << endl;
	s3.getinfo();
	s3 = s2; // 赋值拷贝
	cout << "s3赋值后" << endl;
	s3.getinfo();
	return 0;
}

4、多重继承

4.1 内存布局

  • 子类对象中的多个基类子对象，按照继承表的顺序依次被构造，析构的顺序则与构造严格相反，各个基类子对象按照从低地址到高地址排列
    在这里插入图片描述
class C06_A{
public:
	int m_a;
	C06_A(){ cout << "C06_A构造" << endl; }
	~C06_A(){ cout << "C06_A析构" << endl; }
};
class C06_B{
public:
	int m_b;
	C06_B(){ cout << "C06_B构造" << endl; }
	~C06_B(){ cout << "C06_B析构" << endl; }
};
class C06_C{
public:
	int m_c;
	C06_C(){ cout << "C06_C构造" << endl; }
	~C06_C(){ cout << "C06_C析构" << endl; }
};
class C06_D :public C06_A, public C06_B, public C06_C{ // 汇聚子类
public:
	int m_d;
	C06_D(){ cout << "C06_D构造" << endl; }
	~C06_D(){ cout << "C06_D析构" << endl; }
};
int main(){
	C06_D d;
	cout << "汇聚子类对象d的大小:" << sizeof(d) << endl;
	C06_D * pd = &d;
	cout << "整个汇聚子类对象的首地址D* pd:" << pd << endl;
	cout<< "A基类子对象的首地址：" << &d.m_a<<endl;
	cout << "B基类子对象的首地址：" << &d.m_b << endl;
	cout << "C基类子对象的首地址："<<&d.m_c<< endl;
	cout << "D基类子对象的首地址：" << &d.m_d << endl;
	return 0;
}

4.2 类型转换

  • 将多重继承的子类对象的指针，隐式转换为它的基类类型，编译器会根据各个基类子对象在子类对象中的内存位置，进行适当的偏移计算。
  • 反之，将任何一个基类类型的指针静态转换为子类类型，编译器同样会进行适当的偏移计算
  • 无论在哪个方向上，重解释类型转换(reinterpret_cast)都不进行任何偏移计算–不要使用
    在这里插入图片描述
int main(){
	C06_D d;
	cout << "汇聚子类对象d的大小:" << sizeof(d) << endl;
	C06_D * pd = &d;
	cout << "整个汇聚子类对象的首地址D* pd:" << pd << endl;// 004FF730
	cout << "A基类子对象的首地址：" << &d.m_a << endl; // 004FF730
	cout << "B基类子对象的首地址：" << &d.m_b << endl; // 004FF734
	cout << "C基类子对象的首地址：" << &d.m_c << endl; // 004FF738
	cout << "D基类子对象的首地址：" << &d.m_d << endl; // 004FF73C
	C06_A* pa = pd;
	cout << "隐式转换" << endl;
	cout << "D* pd ---> A* pa:" << pa << endl; // 004FF730
	C06_B* pb = pd;
	cout << "D* pb ---> B* pb:" << pb << endl; // 004FF734
	C06_C* pc = pd;
	cout << "D* pd ---> C* pc:" << pc << endl; // 004FF738
	cout << "静态转换" << endl;
	C06_D* p1 = static_cast<C06_D*>(pa);
	cout << "A* pd ---> D* p1:" << p1 << endl; // 004FF730
	C06_D* p2 = static_cast<C06_D*>(pb);
	cout << "B* pb ---> D* p2:" << p2 << endl; // 004FF730
	C06_D* p3 = static_cast<C06_D*>(pc);
	cout << "C* pc ---> D* p3:" << p3 << endl; // 004FF730
	return 0;
}
  • 引用的情况与指针类似，因为引用的本质就是指针
    在这里插入图片描述

4.3 名字冲突问题

  • 如果在子类的多个基类中，存在同名的标识符，那么任何试图通过子类对象，或在子类内部访问该名字的操作，都将引发歧义。
    名字冲突问题解决方法
  • 子类隐藏该标识符–不建议使用
  • 通过作用域限定操作符“::”显式指明所属基类
class C06_E{
public:
	int m_a;
	int m_c;
};
class C06_F{
public:
	int m_b;
	int m_c;
};
class C06_G :public C06_E, public C06_F{
public:
	int m_d;
	void foo(){
		// m_c = 100;歧义
		C06_E::m_c = 100;
	}
};
int main(){
	C06_G g;
	cout << "汇聚子类对象g的大小:" << sizeof(g) << endl;
	// g.m_c=100; 歧义
	g.C06_E::m_c = 100;
	return 0;
}

5、砖石继承

  • 砖石继承的问题
    一个子类继承自多个基类，而这些基类又源自共同的祖先，这样的继承结构称为钻石继承(菱形继承)
    在这里插入图片描述
class C06_AA{ // 公共基类
public:
	int m_a;
};
class C06_X :public C06_AA{ // 中间子类
public:
	int m_x;
};
class C06_Y :public C06_AA{ // 中间子类
public:
	int m_y;
};
class C06_Z :public C06_X, public C06_Y{ // 汇聚子类
public:
	int m_z;
};
int main(){
	C06_Z z; // X中间子类子对象|Y中间子类子对象|m_z|-->
			// A公共基类子对象 m_x|A公共基类子对象 m_y|m_z|-->
			// m_a m_x |m_a m_y|m_z|
	cout << "汇聚子类对象g的大小:" << sizeof(z) << endl;// 20
	return 0;
}
  • 钻石继承问题
    在汇聚子类内部，或通过汇聚子类对象，访问公共基类的成员，会因继承路径的不同而导致匹配歧义

6、虚继承

解决砖石继承存在的问题而诞生的

  • 在继承表中使用virtual关键字

  • 虚继承可以保证
    （1）公共虚基类子对象在汇聚子类对象中仅存一份实例
    在这里插入图片描述

    （2）公共虚基类子对象被多个中间子类子对象所共享
    虚继承实现原理

  • 汇聚子类对象中的每个中间子类子对象都持有一个指针，通过该指针可以获取中间子类子对象的首地址到公共虚基类子对象的首地址的偏移量
    在这里插入图片描述

class C06_AA{ // 公共基类
public:
	int m_a;
};
class C06_X :virtual public C06_AA{ // 中间子类
public:
	int m_x;
	void setAge(/* X* this */int age){
		m_a = age; // this -> X 中间子类子对象-》指针1-》偏移量-》this+偏移量-》A公共基类子对象-》m_a
	}
	
};
class C06_Y :virtual public C06_AA{ // 中间子类
public:
	int m_y;
	int getAge(/* Y* this*/){ 
		return m_a;// this->Y 中间子类子对象 - 》指针2 - 》偏移量 - 》this + 偏移量 - 》A公共基类子对象 - 》m_a
	}
};
class C06_Z :public C06_X, public C06_Y{ // 汇聚子类
public:
	int m_z;
};
int main(){
	C06_Z z; // X中间子类子对象|Y中间子类子对象|m_z|A公共基类子对象|-->
			// 指针1 m_x |指针2 m_y|m_z|m_a|
	cout << "汇聚子类对象g的大小:" << sizeof(z) << endl;// 32
	z.setAge(100); // setAge(&z) -->实参类型Z*
	cout << "age:" << z.getAge() << endl; // getAge(&z) -->实参类型Z*
	return 0;
}
启航zpyl
关注
专栏目录
jmu-Java-03面向对象基础-04-形状-继承 PTA
qq_43427314的博客
10-31 3507
jmu-Java-03面向对象基础-04-形状-继承 PTA题目本题描述：思考分析答案 题目 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 1.定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:public double getPerimeter(),public double getArea() 2.Rectangle与Circle类均继承自Shape类。 Rectangle类
Java---继承
热门推荐
X_H学Java的博客
09-22 1万+
1. 概念 继承的基本思想是，基于已有的类创造新的类。继承已存在的类就是复用这些类的方法，而且可以增加一些新的方法和字段，使新类能够适应新的情况，继承是Java程序设计中一项核心技术，它主要解决的问题是：共性的抽取，实现代码复用。例： 上图中，dog和cat都继承Animal类，dog和cat可以称为Animal的子类或者派生类，继承之后，子类可以复用父类的方法和属性，子类在实现时只关心自己新增加的成员即可。 2. 语法 Java中表现继承的关系需要借助关键字extends： 修饰符 ..
jmu-Java-03面向对象基础-04-形状-继承
黑白的黒's Blog
10-01 3050
前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 定义抽象类Shape 属性： 不可变静态常量double PI，值为3.14， 抽象方法: public double getPerimeter(),public double getArea() Rectangle与Circle类均继承自Shape类。 Rectangle类(属性： int width,length)、Circle类(属性： int radius
Java PTA练习：jmu-Java-03面向对象基础-04-形状-继承
黄佳俊的博客
10-27 5523
前言 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述 1.定义抽象类Shape属性：不可变静态常量double PI，值为3.14，抽象方法:public double getPerimeter(),public double getArea() 2.Rectangle与Circle类均继承自Shape类。 Rectangle类(属性：int width,length)、Circle类(属性：int radius
c++-继承详解
qq_52905520的博客
09-11 2083
c++-继承详解
C++-继承
AI_ELF的博客
02-13 1522
C++-继承继承继承关系和访问限定符继承基类成员访问方式的变化 继承 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承是类设计层次的复用。 继承的定义： #define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> using namespace std; cl
6-7 汽车类的继承
weixin_73276974的博客
12-11 782
6-7 汽车类的继承
python-继承
前路艰险，路途漫长
01-17 8158
目录   一.继承特征 1、什么是继承 2.继承中的子类和父类的概念 3、继承的作用 二.基本方法 1.查看继承的父类 _bases_ 2.方法的复写 3.super(父类) 6.__init__方法 7.派生属性 三.多继承 格式 继承原理(钻石继承) 四.抽象类 1.定义抽象类 2.定义抽象方法 一.继承特征 1、什么是继承 继承就是让类和类之间产生父子...
三大特性--继承
weixin_53417761的博客
01-02 1561
2、子类和父类有同名函数时，子类会屏蔽父类的同名函数(隐藏和重定义，这里要和后面多态中的重写(覆盖)区分，并且可以通过类名::的方式访问父类的同名成员)。3、基类中其他成员的在派生类中的访问方式是继承方式和在基类中的访问方式的最小值，这里public > protected > private。1、构造函数：子类的构造函数必须先调用父类的构造函数，对父类部分进行初始化，如果子类没有默认构造函数，必须在子类构造函数的初始化列表显式调用。， 体现了由简单到复杂的认知过程。，增加功能，这样产生新的类，称派生类。
Java练习题---------继承
учёба
08-11 3774
第一题继承的应用 定义宠物类（ Pet ），猫类（Cat）和狗类（Dog） 1、宠物都有属性姓名（name）和年龄(age) 2、宠物都有吃（eat）、喝（drink）、叫（shout）的方法 3、猫有爬树（ climbTree ）的方法 4、狗有警戒（ police）的方法 package Day0811; public class demo2 { public static void main(String[] args) { Cat cat = new Cat(); cat.name =
Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company
12-28
pta题目java的继承覆盖综合题源码，全部内容为自己原创，能够运行但是有些代码可能写的不是很精简，这个摘要也太长了吧，凑不够字数啊
haohailiang#manual#6-3-继承-JS高级程序设计1
07-25
6.3.1稳妥构造函数模式 6.3.2借用构造函数 6.3.3组合继承[借用构造函数+原型链]
CSE-200-继承
02-20
6. **密封类与不可继承** 使用 `sealed` 关键字可以阻止其他类继承当前类，这样可以防止不期望的继承层次结构。 7. **构造函数与继承** 子类可以调用基类的构造函数，使用 `base` 关键字。子类的构造函数总是在其...
一个php快速项目搭建框架源码，带一键CURD等功能
jiyc2008的博客
08-26 6452
框架易于功能扩展，代码维护，方便二次开发，帮助开发者简单高效降低二次开发成本，满足专注业务深度开发的需求。百度网盘下载。
【C++】STL—vector的使用
2301_77112794的博客
09-04 694
本文介绍了vector重点函数接口的使用
【c++23种设计模式概述】
最新发布
m0_45463480的博客
09-09 359
c++23种设计模式概述。
【C++】vector的简单模拟实现
2303_80828380的博客
09-05 1181
vector的简单模拟实现！！！
C语言——strcpy、sprintf与memcpy
鲸落博客
09-09 689
该函数和printf()函数有很多相似之处，例如printf()将不同类型的数据格式化到终端，而sprintf()函数是将不同类型的数据格式化到字符串中。另外，和strcpy()函数一样，该函数也不会对目标缓冲区进行检查，容易造成溢出。它是一种非常通用的内存复制函数，不仅限于复制字符串，还可以复制任何类型的内存块。3. 未定义行为：程序可能会继续运行，但结果不可预测，可能会输出错误的结果或导致其他未预料的行为。如果memcpy复制字符串，要复制的字节数超过原内存块本身的内存数，会怎么样？
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 272
QWidget(c++)嵌入window环境的exe
7-6 jmu-java-03面向对象-06-继承覆盖综合练习-person、student、employee、company
06-28
这是一个综合练习，涉及到面向对象中的继承和覆盖。题目中给出了四个类：Person、Student、Employee、Company。我们需要在这些类中定义属性和方法，使得它们能够正确地继承和覆盖。 Person类是基类，它包含了一个人...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

启航zpyl

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值