植物类(多态和继承)

//#include<iostream>
//#include<string>
//using namespace std;
//
//class Botany
//{
//public:
//	Botany(const string& name="")
//	:_name(name)
//	{
//		s_Count++;
//	}
//	Botany(const Botany& b)
//		:_name(b._name)
//	{
//		s_Count++;
//	}
//	Botany& operator=(const Botany& b)
//	{
//		if (this != &b)
//		{
//			_name = b._name;
//		}
//		return *this;
//	}
//	~Botany()
//	{
//		--s_Count;
//		cout << "~Botany()" << endl;
//	}
//	virtual void Display()
//	{
//		cout << "name"<<_name << endl;
//	}
//protected:
//	string _name;
//	static int s_Count;
//};
//int Botany::s_Count = 0;
//
//class  Tree:virtual public  Botany
//{
//public:
//	Tree(const string& s, int hight, int age)
//		:Botany(s)
//		, _hight(hight)
//		, _age(age)
//	{
//
//	}
//	Tree(Tree& t)
//		:Botany(t._name)
//		, _hight(t._hight)
//		, _age(t._age)
//	{
//
//	}
//	Tree& operator=(const Tree& t)
//	{
//		if (this != &t)
//		{
//			_name = t._name;
//			_hight = t._hight;
//			_age = t._age;
//		}
//		return *this;
//	}
//	~Tree()
//	{
//		cout << "~Tree()" << endl;
//	}
//	virtual void Display()
//	{
//		Botany::Display();
//		cout << "hight:" << _hight << endl;
//		cout << "age:" << _age << endl;
//	}
//protected:
//	int _hight;
//	int _age;
//
//};
//class Flower :virtual public Botany
//{
//public:
//	Flower(const string& name, const string& color)
//		:Botany(name)
//		, _color(color)
//	{
//
//	}
//	Flower(Flower& f)
//		:Botany(f._name)
//		, _color(f._color)
//	{
//
//	}
//	Flower& operator=(const Flower& f)
//	{
//		if (this != &f)
//		{
//			_name = f._name;
//			_color = f._color;
//		}
//		return *this;
//	}
//	~Flower()
//	{
//		cout << "~Flower()" << endl;
//	}
//	virtual void Display()
//	{
//		Botany::Display();
//		cout << "color" << _color << endl;
//	}
//protected:
//	string _color;
//};
//class MicheliaAlba:public Tree, public Flower
//{
//public:
//	MicheliaAlba(const string& name, int  hight, int age,const string& color,const string& kind)
//		:Botany(name)
//		,Tree(name, hight, age)
//		, Flower(name, color)
//		, _kind(kind)
//	{
//
//	}
//	MicheliaAlba(const MicheliaAlba& m)
//		:Botany(m._name)
//		, Tree(m._name, m._hight,m._age)
//		, Flower(m._name, m._color)
//		, _kind(m._kind)
//	{
//
//	}
//	MicheliaAlba& operator=(const MicheliaAlba& m)
//	{
//		if (this != &m)
//		{
//			_name = m._name;
//			_hight = m._hight;
//			_age = m._age;
//			_color = m._color;
//			_kind = m._kind;
//
//		}
//		return *this;
//	}
//	~MicheliaAlba()
//	{
//		cout << "~MicheliaAlba()" << endl;
//	}
//	virtual void Display()
//	{
//		Tree::Display();
//		Flower::Display();
//		cout << "kind" << _kind << endl;
//	}
//protected:
//	string _kind;
//};
//void Test1()
//{
//	MicheliaAlba m("白兰花",11,2,"红", "小");
//	m.Display();
//
//	Botany b("草");
//	b.Display();
//
//	Tree pine("松树", 15, 27);
//	pine.Display();
//
//	Flower f("玫瑰花", "红");
//	f.Display();
//
//
//}
//void Test2()
//{
//	Botany  b1("草");
//	b1.Display();
//
//	MicheliaAlba m1("白兰花", 11, 2, "红", "小");
//	m1.Display();
//
//	MicheliaAlba m2("白兰花",13, 4, "白", "大");
//	m2.Display();
//
//	Botany* b = &b1;
//	b->Display();
//
//	b=(Botany*)&m1;
//	b->Display();//多态
//
//}
//void Test3()
//{
//	Botany  b1("草");
//	b1.Display();
//
//	MicheliaAlba m1("白兰花", 11, 2, "红", "小");
//	m1.Display();
//
//	b1 = m1;
//	b1.Display();//以草输出:白兰花
//}
//int main()
//{
//	Test3();
//	system("pause");
//	return 0;
//}
//
时间: 2024-03-15 00:21:27

植物类(多态和继承)的相关文章

黑马程序员--oc 类的封装 继承 和多态

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 成员变量的命名规范: 成员变量名要以 _开头 作用: 1.可以让成员变量和get方法的名称区分开 2.可以和局部变量区分开,一看到以_开头的变量一般都是成员变量 封装: 在定义成员变量时,尽量不要用@public 这种写法 ,而是使用set方法和get方法 @interface Student : NSObject { int _age; } /* set方法: 作用:提供一个方法给外界设置成

RUBY的类封装,继承,多态简单演示

class Person def initialize(name,age=18) @name=name @age=age @motherland="China" end def talk puts "my name is " [email protected]+",age is "+@age.to_s if @motherland == "China" puts "I am a China." else p

.NET Core CSharp初级篇 1-6 类的多态与继承

.NET Core CSharp初级篇 1-6 本节内容为类的多态与继承 简介 终于讲到了面向对象三大特性中的两大特性--继承与多态.通过继承与多态,我们能很好的将类的拓展性发挥到了极致.在下面的内容讲解中,我们将从各个方面对继承和多态进行刨析. 继承 继承事实上是一个非常好理解的语法,在C#中实现继承使用A:B,表示A类继承B类.子类(一称为派生类)继承于父类(一称为基类)就好比孩子继承了父亲的一切,但是孩子总归是有自己的个性的,而父亲也有一些不会告诉孩子的事情.如果我们从之前的访问控制符这一

多态公有继承

多态公有继承:所谓多态公有继承,就是同一个方法在派生类和基类中的行为不同. 实现多态公有继承的机制:1,在派生类重新定义基类的方法.(用于对象)2,使用虚方法(多用于指针和引用),虚方法在基类用关键字virtual声明,在派生类中会自动识别基类中声明的虚方法.所以,在派生类中可以用(也可以不用)virtual显式标出哪个方法是虚方法.通俗来讲:为了实现一种方法可以在派生类和基类中的行为不同,于是在派生类中重新定义基类函数的方法(比如基类有方法A, 但又在派生类中重新定义了方法A, 它们名字一样,

七:Java之封装、抽象、多态和继承

本文章介绍了关于Java中的面向对象封装.抽象.继承.多态特点 Java面向对象主要有四大特性:封装.抽象.继承和多态. 一.封装 封装就是将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也就是将数据与操作数据的源代码进行有机的结合,形成"类",其中数据和函数都是类的成员. 在面向对象语言中,封装特性是由类来体现的,我们将现实生活中的一类实体定义成类,其中包括属性和行为(在Java中就是方法),就好像人类,可以具有name,sex,age等属性,同时也具有eat(),sle

深入浅出OOP(四): 多态和继承(抽象类)

在本文中,我们讨论OOP中的热点之一:抽象类.抽象类在各个编程语言中概念是一致的,但是C#稍微有些不一样.本文中我们会通过代码来实现抽象类,并一一进行解析. 深入理解OOP(一):多态和继承(初期绑定和编译时多态) 深入理解OOP(二):多态和继承(继承) 深入理解OOP(三):多态和继承(动态绑定和运行时多态) 深入理解OOP(四):多态和继承(C#中的抽象类) 深入理解OOP(五):C#中的访问修饰符(Public/Private/Protected/Internal/Sealed/Cons

深入理解OOP(二):多态和继承(继承)

本文是深入浅出OOP第二篇,主要说说继承的话题. 深入理解OOP(一):多态和继承(初期绑定和编译时多态) 深入理解OOP(二):多态和继承(继承) 深入理解OOP(三):多态和继承(动态绑定和运行时多态) 深入理解OOP(四):多态和继承(C#中的抽象类) 深入理解OOP(五):C#中的访问修饰符(Public/Private/Protected/Internal/Sealed/Constants/Static and Readonly Fields) 深入理解OOP(六):枚举(实用方法)

多态&amp;抽象&amp;继承

多态 package cn.itcast.extend; public class ExtendDemo2 { public static void main(String[] args) { A a=new B();//多条 System.out.println(a.num); a.show();//非静态 a.say();//静态方法 } } class A{ int num=10; //静态方法 public static void say(){ System.out.println("父

Swift3.0 多态 、继承 、 强制转换

又有点空开始瞎BB一下,写写博客了.这几天发现了一个现象,在博客园特别能吸粉的,只有两类人,一种大神 .一种 美女程序媛,看到大神呢,默默的粉一个,毕竟还是得好好学学人家的,看到美女程序媛呢,默默地多看两眼,从来也不粉,就这样静静的装着B,没办法,习惯了..估计也有很多像我这样,有时间就写写的孩纸其实挺多的,有时候吧,粉不粉这种事,不能太认真.一你不是大神,二不是漂亮MM.写点东西,就是想告诉自己,有时间其实你也在前进着,快慢不说,至少没停下吧.该有的都会有的.不瞎BB了,说主题,3.0 的多态

多态与继承

1.多态 多态是通过虚函数来实现的,也就是说虚函数是允许子类重新定义成员函数,而子类通过定义和父类一样的函数的方法,被成为覆盖或者是重写. 多态的作用,使得代码可以重用,代码模块化: 函数重写: (1)子类定义的函数与父类原型相同的函数 (2)函数的重写只有发生在父类和子类之间 class Parent { public: void f() { cout << "Parent" << endl; } }; class Child : public Parent