2021-11-07 C++封装继承多态---类和对象基本概念关系、对象的初始化和清理（附代码理解）

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

1 类和对象的概念和关系

类是对现实生活中一类具有共同属性和行为的事物的抽象
类的特点：1.类是对象的数据类型 2.类是具有相同属性和行为的一组对象的集合
什么是对象的属性？ 属性： 对象具有的各种特征，每个对象的每个属性都拥有特定的值
什么是对象的行为？ 行为：对象能够执行的操作
类和对象的关系 ：
类：类是对现实生活中一类具有共同属性和行为的事物的抽象 对象：是能够看得到摸得着的真实存在的实

1.1 访问权限

类在设计时，可以把属性和行为放在不同的权限下，加以控制访问权限有三种:
1.public公共权限 2. protected保护权限 3. private私有权限

#include<iostream>
using namespace std;

class Person
{
public:
	string m_name;
protected:
	string m_car;
private:
	int m_password;
public:
	void func()
	{
		m_name = "sss";
		m_car = "aaaaaaaaaaaaaa";
		m_password = 1111111111111;
	}
};

int main() {
	Person p1;

	p1.m_name = "aaaaaaaasssssssss";
	//p1.m_car = "sadsfsfsafa";
	void func();
	cout<<p1.m_name<<endl;  //公有权限，所以可以改变
	system("pause");
	return 0;
}

在这里插入图片描述

1.2 struct和class的区别

在C++中struct和class唯一的区别就在于默认的访问权限不同区别:
struct 默认权限为公共 class默认权限为私有

#include<iostream>
using namespace std;

class C1
{
	int m_a; //私有
};
struct C2
{
	int m_a; //公共
};
int main() {
	C1 c1; //实例化对象
	c1.m_a = 100; //不可以访问

	C2 c2;
	c2.m_a = 100;  //可以访问
	system("pause");
	return 0;
}

1.3 成员属性私有化

优点1:将所有成员属性设置为私有，可以自己控制读写权限
优点2:对于写权限，我们可以检测数据的有效性

#include<iostream>
using namespace std;

class Person
{
public:
	//提供一点公共的接口让你操作吧
	//以函数的形式实现可读可写
	//设置姓名
public:
	void setname(string name)
	{
		m_name = name;
	}
	//获取姓名
	string getname()
	{
		return m_name;
	}
	//年龄是只读的
	int getage()
	{
		int m_age = 999;
		return m_age;
	}
	//只写权限   //这个函数接口没有读出的语句
	void setlover(string lover)  
	{
		m_lover = lover;
	}
private:
	//name  可读可写
	string m_name;
	//age   只读
	string m_age;
	//情人  只写
	string m_lover;
};

int main() {
	Person p1;
	p1.setname("张三");
	cout << "姓名为" << p1.getname() << endl;
	cout << "年龄为" << p1.getage() << endl;
	//设置情人
	p1.setlover("仓井");
	//cout <<"情人为" << p1.m_lover<<endl; //不可访问咯！！！
	system("pause");
	return 0;
}

1.4 案例-设计立方体类

在这里插入图片描述

#include<iostream>
using namespace std;
//1 创建立方体类
//2 设计属性
//3 设计行为，获取面积，体积
//4 分别利用全局函数和成员函数，判断立方体是否相等

class Cube
{
public:
	//设置长
	void setl(int l )
	{
		m_l = l;
	}
	//获取长
	int getl()
	{
		return m_l;
	}
	//设置宽
	void setw(int w)
	{
		m_w = w;
	}
	//获取宽
	int getw()
	{
		return m_w;
	}
	//设置高
	void seth(int h)
	{
		m_h = h;
	}
	//获取高
	int geth()
	{
		return m_h;
	}
	//获取立方体面积
	int calculaetS()
	{
		return 2 * m_l * m_w + 2 * m_w * m_h + 2 * m_l * m_h;
	}
	//获取立方体体积
	int calculateV()
	{
		return m_l * m_w * m_h;
	}
//成员函数判断两个立方体是否相等
	bool issamebyclass(Cube &c2)
	{
		if (m_l == c2.getl() && m_w == c2.getw() && m_h == c2.geth())//自身的长宽高和传进来的长宽高进行对比判断
		{
			return true;
		}
		return  false;
	}
private:
	int m_l;
	int m_w;
	int m_h;

};

//利用全局函数判断两个立方体是否相同
bool issame(Cube c1, Cube c2)
{
	if (c1.getl() == c2.getl() && c1.getw() == c2.getw() && c1.geth() == c2.geth())
	{
		return true;
	}
	return false;
}


int main() {
	
	//实例化对象
	Cube c1;
	
	c1.seth(10);
	c1.setl(10);
	c1.setw(10);

	cout << "体积为" << c1.calculaetS() << endl;
	cout << "面积为" << c1.calculateV() << endl;

	//创建第二个立方体
	Cube c2;
	c2.seth(10);
	c2.setl(10);
	c2.setw(10);
	//全局函数，开始判断
	bool ret = issame(c1, c2);
	if (ret)
	{
		cout<<"全局函数，开始判断,体积是相等的" << endl;
	}
	else
	{
		cout << "体积不是相等的" << endl;

	}
	//成员函数开始判断
	ret = c1.issamebyclass(c2);
	if (ret)
	{
		cout << "成员函数开始判断,体积是相等的" << endl;
	}
	else
	{
		cout << "体积不是相等的" << endl;

	}

	system("pause");
	return 0;
}

1.5 案例-点和圆的关系

在这里插入图片描述

#include<iostream>
using namespace std;
//点类
class point
{
public:
	//设置x
	void setx(int x)
	{
		m_x = x;
	}
	//获取x
	int getx()
	{
		return m_x;
	}
	//设置y
	void sety(int y)
	{
		m_y = y;
	}
	//获取y
	int gety()
	{
		return m_y;
	}
private:
	int m_x;
	int m_y;

};
//圆类
class circle
{
public:
	//设置半径
	void setr(int r)
	{
		m_r = r;
	}
	//获取半径
	int getr()
	{
		return m_r;
	}
	//设置圆心
	void setcenter(point center)
	{
		m_center = center;
	}
	//获取圆心
	point getcenter()
	{
		return m_center;
	}

private:
	int m_r;
	point m_center;


};
//判断点和圆的关系
void isincircle(circle& c, point& p)
{
	//计算两点之间的距离  平方
	int distance =
		(c.getcenter().getx() - p.getx()) * (c.getcenter().getx() - p.getx()) +
		(c.getcenter().gety() - p.gety()) * (c.getcenter().gety() - p.gety());
	//计算半径的平方
	int rdistance =
		c.getr() * c.getr();
	//判断关系
	if (distance = rdistance)
	{
		cout<<"点在圆上" << endl;

	}
	else if (distance > rdistance) 
	{
		cout << "点在圆外" << endl;
	}
	else
	{
		cout << "点在圆内" << endl;

	}
}

int main2() {

	//创建圆
	circle c;
	c.setr(10);
	point center;
	center.setx(10);
	center.sety(0);
	c.setcenter(center);

	//创建点
	point p;
	p.setx(10);
	p.sety(10);

	//判断关系
	isincircle(c, p);

	system("pause");
	return 0;
}

2 对象的初始化和清理

生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全。
C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。

2.1 构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题，一个对象或者变量没有初始状态，对其使用后果是未知，同样的使用完一个对象或变量，没有及时清理，也会造成—定的安全问题。
C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现。

构造函数:主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。·
析构函数:主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法:析构函数语法:
1.构造函数，没有返回值也不写void1.析构函数，没有返回值也不写void
2.函数名称与类名相同⒉.函数名称与类名相同,在名称前加上符号~
3.构造函数可以有参数，因此可以发生重载3.析构函数不可以有参数，因此不可以发生重载
4.程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次4.程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次
#include<iostream>
using namespace std;
//构造函数  初始化
//析构函数 清理
class person
{
public:
	//构造函数
	person()
	{
		cout << "构造函数" << endl;
	}
	
	//析构函数
	~person()
	{
		cout<<"析构函数" << endl;
	}
};
void test01()
{
	cout <<"aaaa" << endl;
	person p; //站上的数据，执行完毕后，就会释放这个对象
}

int main4() {
	test01();

	system("pause");
	return 0;
}

2.2 构造函数的分类以及调用

两种分类方式:
按参数分为:有参构造和无参构造
按类型分为:普通构造和拷贝构造
三种调用方式:括号法显示法隐式转换法

#include<iostream>
using namespace std;
//分类

class person
{
public:
	//普通函数
	//构造函数
	person()
	{
		cout << "构造函数" << endl;
	}
	//有参构造函数
	person(int a )
	{
		age = a;
		cout << "youcan构造函数" << endl;
	}
	//拷贝构造函数
	person(const person &p)
	{
		age = p.age;
		cout << "拷贝构造函数" << endl;
		//将传入的人的所有属性，拷贝到他身上
	}

	//析构函数
	~person()
	{
		cout << "析构函数" << endl;
	}
	int age;
};
//调用
void test01()
{
	//1 括号法
	//person p1;//默认构造
	//person p2(10);//有参构造
	//person p3(p2);//拷贝构造
	//cout << "p2年龄" << p2.age<<endl;
	//cout << "p3年龄" <<p3.age <<endl;

	//注意 1 ：
	//调用默认构造函数，不要加（），因为编译器会认为这是一个函数的声明
	//person p1();
	
	//2 显示法
	person p1;//默认构造
	person p2 = person(10);//有参构造
	person p3 = person(p2);//拷贝构造

	//person(10)  匿名对象。 特点：当前行执行结束后，系统就会回收了；
	//注意 2 ：
	//不要利用拷贝构造， 初始化匿名对象 , 编译器会认为 person(p3) == person p3; 对象声明
	//person (p3);
	
	//3 隐式转换法
	person p4 = 10; //有参构造
	person p5 = p4;//拷贝构造
}
int main() {
	test01();
	system("pause");
	return 0;
}

2.3 拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况
1.使用一个已经创建完毕的对象来初始化一个新对象·
2.值传递的方式给函数参数传值
3.以值方式返回局部对象

#include<iostream>
using namespace std;
//拷贝构造函数调用时机
//1 使用一个已经创建完毕的对象来初始化一个新对象
//2 值传递的方式给函数参数传值
//3 值方式返回局部对象
class person
{
public:
	//构造函数
	person()
	{
		cout << "默认构造函数" << endl;
	}
	person(int age)
	{
		m_age = age;
		cout << "有参构造函数" << endl;
	}
	//拷贝构造函数
	person(const person& p)
	{
		m_age = p.m_age;
		cout << "拷贝构造函数" << endl;

		//将传入的人的所有属性，拷贝到他身上
	}

	//析构函数
	~person()
	{
		cout << "析构函数" << endl;
	}
	int m_age;
};
//1 使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	person p1(20);
	person p2(p1);
	cout << "p2的年龄" << p2.m_age<<endl;
}
//2 值传递的方式给函数参数传值
void dowork(person p)
{

}
void test02()
{
	person p;
	dowork(p);

}
//3 值方式返回局部对象  //拷贝只传值，不传地址，所以值一样，地址不一样
person dowork2( )
{
	person p1;
	cout<<(int*)&p1<<endl;
	return p1;
}
void test03()
{
	person p = dowork2();
	cout << (int*)&p << endl;
}

int main() {

	//test01();
	test03();
	system("pause");
	return 0;
}

2.4 构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数
1．默认构造函数(无参，函数体为空)
2．默认析构函数(无参，函数体为空)
3．默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下:
如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造，
如果用户定义拷贝构造函数，C++不会再提供其他构造函数

#include<iostream>
using namespace std;
//1 创建一个类，c++会给每个类至少添加三个函数
class person
{
public:
	//person()
	//{
	//	cout << "构造函数" << endl;
	//}
	//有参构造函数
	person(int a)
	{
		age = a;
		cout << "有参构造函数" << endl;
	}
	//拷贝构造函数
	//person(const person& p)
	//{
		//age = p.age;
		//cout << "拷贝构造函数" << endl;

		//将传入的人的所有属性，拷贝到他身上
	//}

	//析构函数
	~person()
	{
		cout << "析构函数" << endl;
	}
	int age;
};
//1 创建一个类，c++会给每个类至少添加三个函数
//void test01()
//{
//	person p;
//	p.age = 18;
//	person  p2(p);
//	cout << "p2年龄为" << p2.age<<endl;
//}

//2 如果写了有参构造函数，编译器就不再提供默认构造，依然提供拷贝构造★★★★★★★★★★★★★★★★★★★★★★★
// 如果写了拷贝构造函数，编译器就不提供其他的了。★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
void test02()
{
	person p(129);
	person  p2(p);
	cout << "p2年龄为" << p2.age << endl;
}
int main() {
	//test01();
	test02();

	system("pause");
	return 0;
}

2.5 浅拷贝和深拷贝

浅拷贝:简单的赋值拷贝操作
深拷贝:在堆区重新申请空间，进行拷贝操作

#include<iostream>
using namespace std;
class person
{
public:
	//构造函数
	person()
	{
		cout << "构造函数" << endl;
	}
	//有参构造函数
	person(int a, int height)
	{
		m_age = a;
		m_height = new int(height);
		cout << "youcan构造函数" << endl;
	}
	//之前没有写拷贝构造函数，就是系统默认的垃圾拷贝构造函数啊。
	//自己实现拷贝构造函数，解决浅拷贝带来的问题
	person(const person& p)
	{
		cout<<"拷贝构造函数调用，myself" << endl;
		m_age = p.m_age;
		//m_height = p.m_height;  编译器默认实现的就是这行代码  qiankaobei
		//深拷贝操作
		m_height = new int(*p.m_height);  //从新申请一块内存    shenkaobei
	}
	//析构函数
	~person()
	{
		//析构代码， 将堆区开辟的数据做释放操作
		if (m_height != NULL)
		{
			delete m_height;
			m_height = NULL;
		}
		cout << "析构函数" << endl;
	}
	int m_age;
	int* m_height;
};
void test01()
{
	person p1(18, 160);

	cout << "p1的年龄为" <<p1.m_age<< "身高为" <<*p1.m_height<< endl;
	person p2(p1);   //浅拷贝??
	cout << "p2的年龄为" << p2.m_age <<"身高为" << *p2.m_height<< endl;
}

int main() {
	test01();
	
	system("pause");
	return 0;
}

2.6 初始化列表

作用:C++提供了初始化列表语法，用来初始化属性
语法:构造函数()∶属性1(值1) ,属性2(值2) …

#include<iostream>
using namespace std;
class person
{
public:
	//传统初始化的操作
	//person(int a, int b, int c)
	//{
	//	m_a = a;
	//	m_b = b;
	//	m_c = c;
	//}
	//初始化列表初始化属性
	person() : m_aa(10), m_bb(20), m_cc(30)
	{

	}
	//初始化列表初始化属性,升华
	person(int aa, int bb, int cc) : m_aaa(aa), m_bbb(bb), m_ccc(cc)
	{

	}
	int m_a;
	int m_b;
	int m_c;
	int m_aa;
	int m_bb;
	int m_cc;
	int m_aaa;
	int m_bbb;
	int m_ccc;
};
   

void test01()
{
	person p(10, 20, 30);
	cout << "m_a" << p.m_a << endl;
	cout << "m_b" << p.m_b << endl;
	cout << "m_c" << p.m_c << endl;

}
void test02()
{
	person p;
	cout << "m_aa" << p.m_aa << endl;
	cout << "m_bb" << p.m_bb << endl;
	cout << "m_cc" << p.m_cc << endl;
}
void test03()
{
	person p(99,88,55);
	cout << "m_aa" << p.m_aaa << endl;
	cout << "m_bb" << p.m_bbb << endl;
	cout << "m_cc" << p.m_ccc << endl;
}
int main() {
	test03();

	system("pause");
	return 0;
}

2.7 类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员。
B类中有对象A作为成员，A为对象成员。
那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后?

#include<iostream>
using namespace std;
//手机类
class phone
{
public:
	phone(string pname)
	{
		cout << "phone 的构造函数的调用" << endl;
		m_pname = pname;
	}
	//析构函数
	~phone()
	{
		cout << "phone析构函数" << endl;
	}
	//手机品牌名称 
	string m_pname;
};
//人类
class person
{
public:
	// phone m_phone = pname  隐式转换法
	person(string name, string pname) :m_name(name), m_phone(pname)
	{
		cout <<"person 的构造函数的调用" << endl;
	}
	//析构函数
	~person()
	{
		cout << "person析构函数" << endl;
	}
	//xingming
	string m_name;
	//phone
	phone m_phone;
};

// 当其他的类对象作为本类的成员时候，构造时候先构造类对象，再构造自身，而析构呢？？？？？？？

void test01()
{
	person p("张三", "苹果max");
	cout << p.m_name << "拿着" << p.m_phone.m_pname << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

在这里插入图片描述

2.8 静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分为:

静态成员变量静态成员函数
所有对象共享同一份数据。在编译阶段分配内存所有对象共享同一个函数
类内声明，类外初始化·静态成员函数只能访问静态成员变量

2.8.1静态成员变量（1）

#include<iostream>
using namespace std;
//静态成员变量
class person
{
public:
	//1 所有对象都共享同一份数据
	static int m_a;
private:
	static int m_b;

};
int person::m_a = 100;
int person::m_b = 200;
void test01()
{
	person p;
	cout<<p.m_a<<endl;

	person p2;
	p2.m_a = 200;
	cout << p2.m_a << endl;
	cout << p.m_a << endl;
}
void test02()
{
	//静态成员变量 不属于某个对象 所有对象都共享同一份数据

	//1.通过对象访问
	person p;
	cout <<p.m_a<<endl;
	//2. 通过类名访问
	cout << person::m_a << endl;
	cout << person::m_a << endl;

}
int main() {
	test01();
	system("pause");
	return 0;
}

2.8.2 静态成员变量（2）

#include<iostream>
using namespace std;
//静态成员函数
class person
{
public:
	//1 所有对象都共享同一份数据
	static void func()
	{
		m_a = 100;  //静态成员可以访问 静态成员变量
		//m_b = 200;  //静态成员函数 不可以访问 非静态成员变量，无法区别到底是那个对象的m_b

		cout << "static的调用" << endl;
	}
	static int m_a;
	int m_b ;
private:
	static void func2()
	{
		cout << "私有的static的调用" << endl;
	}

};
int person::m_a = 100;

void test01()
{

	//1.通过对象访问
	person p;
	p.func();
	//2. 通过类名访问
	person::func();
	//person::func2();  //私有不可以访问 ！！！！！！！！
}
int main() {
	test01();

	system("pause");
	return 0;
}
爱抖腿的小松鼠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象程序设计-C++-试卷分析(与“函数”相关共66张).pptx
11-13
C++ 是一种支持面向对象编程的强类型语言，它不仅包含了C语言的基本特性，还扩展了面向对象的概念。 在C++中，函数是实现功能的基本单元。函数可以接收参数并返回结果，是代码复用的关键。试卷分析中涉及的几个关键...
南开大学复习资料-面向对象程序设计10001.docx
12-13
13. **构造函数与析构函数**：构造函数是类的一个特殊成员函数，用于初始化对象，而析构函数则在对象生命周期结束时执行，用于清理资源。 14. **指针与对象**：指针可以存储对象的地址，允许间接访问和操作对象。...
C++特性之封装：类与对象
Scl_Diligent的博客
11-27 332
封装： 将东西包裹起来，使外界无法知道，只能通过某些特定的方式才能访问。其目的是增强安全性和简化编程，使用方无需知道其具体实现，只能通过外部接口以及特定的权限来使用其成员。 C++中的类就是把属性和方法进行封装，同时对外部的访问通过访问限定符进行限制。而类是一种抽象的概念的数据类型，就像设计图一样，是对设计物抽象的描述，而真实存在的是物品。对于C++而言，对象是类的存在形式，占用内存空间。 ...
C++ 类的封装继承多态
恋恋风辰的技术博客
04-28 2283
C++ 特性 C++ 三大特性，封装继承多态。我们先实现一个Quote作为基类 class Quote { public: Quote() = default; Quote(const std::string &book, double sales_price) { price = sales_price; bookNo = book; } std::string isbn() const { retu
类与对象 ---C++三大特性之封装
weixin_48565202的博客
11-11 533
类与对象 文章目录类与对象1. 面向面向过程和面向对象初步认识2. 类的引用3. 类的定义4. 类的访问限定符及封装4.1 访问限定符4.2 封装5. 类的作用域6. 类的实例化7. 类对象模型7.1 计算类对象的大小7.2 猜猜类的存储8 隐含的this指针8.1 引出this指针8.2 this指针的特性9. 类的6个默认成员函数10. 构造函数11. 析构函数12. 拷贝构造函数13 赋值重载运算符13. 1 运算符重载13.2 赋值运算符重载14. `const`成员14.1 `const`修饰的成
一个例子告诉你什么是封装，继承和多态(C++ 代码实例) （一）
wangjianbo09的博客
08-30 8145
add by WJB   date 2018/08/30 面向对象的三大特性：封装，继承和多态； 封装：将事物拥有的属性和动作隐藏起来，只保留特定的方法与外界联系。 继承：子类可以拥有父类的属性和方法； 多态：以说是“一个接口，多种实现”或者说是父类的引用变量可以指向子类的实例，被引用对象的类型决定调用谁的方法，但这个方法必须在父类中定义 定义五花八门，所以定义不重要，重在理解和应用，接...
面向对象
chousushi0504的博客
03-07 160
1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能、行为 面向对象：将功能封装进对象，强调具备了功能的对象 面向对象是基于面向过程的 面向过程例子： 把大象放进冰箱里分为以下步骤：把冰箱门打开；把大象放进去；关上冰箱门（强调过程和过程中所涉及的行...
c++语言程序设计课件_C语言教程_C++程序设计--类与对象_
09-30
C++的面向对象特性还包括封装、继承和多态。封装是将数据和操作数据的方法捆绑在一起，形成一个独立的实体，这样可以隐藏内部实现细节，只对外提供接口。继承允许一个类（子类）继承另一个类（父类）的属性和方法，...
cpp代码-c++学习笔记——类与对象
07-14
总结起来，C++的类和对象是面向对象编程的核心，它们通过封装、继承和多态等机制，使得代码更加模块化、易于理解和维护。在实际编程中，正确地设计和使用类与对象能够显著提高软件的可扩展性和复用性。
FMI-OOP-2018:面向对象编程20182019大学课程
05-09
1. **基础概念**：首先，学生需要了解面向对象的基本概念，如类（Class）、对象（Object）、封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。类是对象的蓝图，定义了对象的属性和行为；对象是类...
类和对象——封装
m0_61705102的博客
12-27 586
封装是C++面向对象三大特征之一
Java基础之类和对象
qq_49912778的博客
01-10 381
类是面向对象语言的程序设计中的概念，是面向对象编程的基础。类是对现实生活中一类具有共同特征的事物的抽象，用来构造对象模板。简单来说，我们可以把具体的对象从三个层次进行解析。假设这个具体的对象是一名学生，在概念层上是学生，在逻辑层上是由学号、姓名、班级等一系列信息组成的一份档案，这些信息特征表现为属性，对其行为抽取表现为方法，在物理层上是在内存中的存储形式。 面向对象是相对于面向过程来讲的。面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统，更贴近事
Java类和对象的概念
一只小菜鸡
04-08 584
1.什么是类？ 类实际上在现实世界当中是不存在的，是一个抽象的概念。是一个模板。是我们人类大脑进行“思考、总结、抽象”的一个结果。 类本质上是现实世界当中某些事物具有共同特征，将这些共同特征提取出来形成的概念就是一个“类”，“类”就是一个模板。 eg. 歌手是一个类 2.什么是对象？ 对象是实际存在的个体。（真实存在的个体） 李荣浩就是一个对象 薛之谦就是一个对象 刘德华就是一个对象 李荣浩、薛之谦、刘德华这3个对象都属于“歌手”这个类。 3.重点 ★★★★★ 在java语言中，要想得到“对象”，必须先定义
类与对象的概念
zxha6868的博客
08-25 156
类与对象的概念 类 是现实中不存在的，是一个模板，是一个概念，是人脑抽象出来的结构，类代表的一类事物 在现实世界中，事物A与事物B的共同特征，进行抽象形成的模板，成为类。 对象 是实际存在的个体，现实中存在的 软件开发的过程 程序员观察世界，寻找对象。找到N个对象，寻找共同特征，在脑中形成一个模板，这个模板就是类 java程序员通过代码来表示这个类，再通过类创造对象，有了对象，让对象协作起来，形成一个系统。 类——(实例化)——>对象 对象——(抽象)——>类 对象又称为实例/instance
类与对象（一）对象和类的基本概念、类与对象的定义和使用
Endeavor_G的博客
05-11 1408
对象和类的基本概念 Java语言中的对象是对现实生活的模拟，现实生活中的对象存在于现实生活中，Java语言中的对象（实例）在计算机内存中。ps:Java中的对象也称实例。 我们在认识事物时要知道他的属性和功能，能做哪些事情，Java中的对象也是如此，只是叫法不同，属性也称全局变量（也称作成员变量），功能也可称之为方法。 Java语言把一组对象中相同的属性和方法抽象到一个Java源文件中就形成...
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
qq_19319481的博客
08-09 382
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C++笔记5•内存管理•
最新发布
qq_64446190的博客
08-12 1060
内存管理
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1252
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
【C++】类的默认成员函数，构造函数、析构函数、拷贝构造函数、运算符重载
2402_82757055的博客
08-10 949
这篇我们继续学习C++类和对象部分，大概会说一下类的一些默认成员函数，构造函数、析构函数、拷贝构造函数、赋值运算符重载这些知识。
C++对象与类详解-理解对象和类的概念
继承允许一个类（子类）继承另一个类（父类）的属性和行为，多态允许不同类的对象以相同的方式进行处理，而封装则是将数据和操作数据的方法绑定在一起，保护数据免受外部的不当访问。 在实际编程中，类和对象的使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值