对象特性

最新推荐文章于 2023-10-09 10:29:05 发布
最新推荐文章于 2023-10-09 10:29:05 发布
阅读量371 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41375318/article/details/113647271
版权

对 象 特 性 对象特性 对象特性

23.类和对象-对象特性-构造函数和析构函数

C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置

对象的初始化和清理也是两个非常重要的安全问题

  • 一个对象或者变量没有初始状态，对其使用后果是未知
  • 使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

对象的初始化和清理工作是编译器强制要我们做的事情。因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现。

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

构造函数语法:类名(){}
1.构造函数没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

析构函数语法:~类名(){}
1.析构函数，没有返回值也不写void
2.函数名称与类名相同,在名称前加上符号~
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

#include <iostream>
using namespace std;

//对象的初始化和清理
//1、构造函数进行初始化操作

class Person {
	//1.1、构造函数
	//没有返回值不用写void
	//函数名与类名相同
	//构造函数可以有参数，可以发生重载
	//创建对象的时候，构造函数会自动调用，而且只调用一次
public:
	Person()
	{
		cout << "Person构造函数的调用" << endl;
	}

};

void test01()
{
	Person p;
}


//2、析构函数进行清理的操作


int main()
{
	test01();
	return 0;
}

在这里插入图片描述

#include <iostream>
using namespace std;

//对象的初始化和清理
//1、构造函数进行初始化操作

class Person {

public:
	//1.1、构造函数
	//没有返回值不用写void
	//函数名与类名相同
	//构造函数可以有参数，可以发生重载
	//创建对象的时候，构造函数会自动调用，而且只调用一次
	Person()
	{
		cout << "Person构造函数的调用" << endl;
	}
	//2.析构函数进行清理的操作
	//没有返回值不写void
	//函数名和类名相同在名称前加~
	//析构函数不可以有参数的，不可以发生重载
	//对象在销毁前会自动调用析构函数,而且只会调用一次
	~Person() {
		cout << "Person析构函数的调用" << endl;
	}

};

void test02()
{
	Person p;
}



int main()
{
	test02();
	return 0;
}

在这里插入图片描述

构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构

24.类和对象-对象特性-函数的分类以及调用

构造函数的分类及调用

两种分类方式:

  • 按参数分为:有参构造和无参构造
  • 按类型分为:普通构造和拷贝构造

三种调用方式:

  • 括号法
  • 显示法
  • 隐式转换法
#include <iostream>
using namespace std;

// 构造函数的分类及调用
// 分类:
// 1.按照参数分类:无参构造（默认构造函数）和有参构造
// 2.拷贝构造函数
class Person {


public:
	int age;
	// 无参构造函数
	Person() {
		cout << "Person的无参构造函数" << endl;
	}
	// 有参构造函数
	Person(int a) {
		age = a;
		cout << "Person的有参构造函数" << endl;
	}

	// 拷贝构造函数
	Person(const Person& p) {
		// 将传入的人身上的所有属性，拷贝到我身上
		age = p.age;
		cout << "Person的拷贝构造函数" << endl;
	}
	// 析构函数
	~Person() {
		cout << "Person的析构函数" << endl;
	}
};


// 调用
void test01() {

	//1、括号法
	Person p1; // 默认构造函数调用
	Person p2(10); // 有参构造函数
	Person p3(p2); // 拷贝构造函数
	cout << "p2的年龄:  " << p2.age << endl;
	cout << "p3的年龄:  " << p3.age << endl;

	// 注意事项1
	// 调用默认构造函数时候，不要加()
	// 因为下面这行代码，编译器会认为是一个函数的声明，不会认为在创建对象
	// Person p4();

	//2、显示法
	Person p1; // 无参构造
	Person p2 = Person(10); // 有参构造 Person(10)表示匿名对象，匿名对象会在当前行执行结束后，会被系统立即回收
	Person p3 = Person(p2); // 拷贝构造

	// 注意事项2
	// 不要利用拷贝构造函数 初始化匿名对象，编译器会认为 Person(p3) ===> Person p3;
	// Person(p3)

	//3、隐式转换法
	Person p4 = 10; // 相当于 Person p4 = Person(10); 有参构造
	Person p5 = p4; // 拷贝构造
}

int main()
{
	test01();
	return 0;
}

Person(10)表示匿名对象，匿名对象会在当前行执行结束后，会被系统立即回收
在这里插入图片描述

25.类和对象-对象特性-拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况

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

	Person(int age) {
		my_age = age;
		cout << "Person 有参构造函数调用" << endl;
	}

	Person(const Person& p) 
	{

		my_age = p.my_age;
		cout << "Person 拷贝构造函数调用" << endl;
	}
	~Person()
	{
		cout << "Person 析构函数调用" << endl;
	}
};


//1、使用一个已经创建完毕的对象来初始化一个新对象
void test01() 
{
	Person p1(20);
	Person p2(p1);
	cout << "p1的age:"<<p1.my_age << endl;
	cout << "p2的age:"<<p2.my_age << endl;
}

//2、值传递的方式给函数参数传值
void doWork(Person p) 
{

}

void test02()
{
	Person p;
	doWork(p);
}

//3、值方式返回局部对象|


int main()
{
	//test01();

	test02();
	return 0;
}

在这里插入图片描述

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

	Person(int age) {
		my_age = age;
		cout << "Person 有参构造函数调用" << endl;
	}

	Person(const Person& p) 
	{

		my_age = p.my_age;
		cout << "Person 拷贝构造函数调用" << endl;
	}
	~Person()
	{
		cout << "Person 析构函数调用" << endl;
	}
};


//1、使用一个已经创建完毕的对象来初始化一个新对象
void test01() 
{
	Person p1(20);
	Person p2(p1);
	cout << "p1的age:"<<p1.my_age << endl;
	cout << "p2的age:"<<p2.my_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();
	//test02();
	test03();
	return 0;
}

在这里插入图片描述

26.类和对象-对象特性-构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数
1．默认构造函数(无参，函数体为空)
2．默认析构函数(无参，函数体为空)
3．默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下:

  • 如果用户定义有参构造函数，C++不在提供默认无参构造，但是会提供默认拷贝构造
  • 如果用户定义拷贝构造函数，C++不会再提供其他构造函数
#include <iostream>
using namespace std;
//构造函数的调用规则
// 1、创建一个类，C++编译器会给每个类都添加至少3个函数
// 默认构造(空实现)
// 析构函数（空实现） 
// 拷贝构造(值拷贝)
class Person
{
public:
	int my_age;
	Person()
	{
		cout << "Person 默认构造函数调用" << endl;
	}

	Person(int age) {
		my_age = age;
		cout << "Person 有参构造函数调用" << endl;
	}

	Person(const Person& p)
	{

		my_age = p.my_age;
		cout << "Person 拷贝构造函数调用" << endl;
	}
	~Person()
	{
		cout << "Person 析构函数调用" << endl;
	}
};

void test01()
{
	Person p;
	p.my_age = 22;
	Person p2(p);
	cout << "p2's age:  " << p2.my_age <<endl;
}

int main()
{
	test01();
	return 0;
}

在这里插入图片描述

如果我们写了有参构造函数，编译器就不再提供默认构造

在这里插入图片描述

在这里插入图片描述

#include <iostream>
using namespace std;
//构造函数的调用规则
// 1、创建一个类，C++编译器会给每个类都添加至少3个函数
// 默认构造(空实现)
// 析构函数（空实现） 
// 拷贝构造(值拷贝)

// 2.如果我们写了有参构造函数，编译器就不再提供默认构造，依然提供拷贝构造
// 3.如果我们写了拷贝构造函数，编译器就不再提供其他普通构造函数
class Person
{
public:
	int my_age;
	//Person()
	//{
	//	cout << "Person 默认构造函数调用" << endl;
	//}

	Person(int age) {
		my_age = age;
		cout << "Person 有参构造函数调用" << endl;
	}

	//Person(const Person& p)
	//{

	//	my_age = p.my_age;
	//	cout << "Person 拷贝构造函数调用" << endl;
	//}
	~Person()
	{
		cout << "Person 析构函数调用" << endl;
	}
};

//void test01()
//{
//	Person p;
//	p.my_age = 22;
//	Person p2(p);
//	cout << "p2's age:  " << p2.my_age <<endl;
//}

void test02()
{
	Person p(18);
	Person p2(p);
	cout << "p2's age : " << p2.my_age << endl;
}

int main()
{
	test02();
	return 0;
}

在这里插入图片描述

如果我们写了拷贝构造函数，编译器就不再提供其他普通构造函数

27.类和对象-对象特性-深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑
浅拷贝:简单的赋值拷贝操作
深拷贝:在堆区重新申请空间，进行拷贝操作

#include <iostream>
using namespace std;

//深拷贝与浅拷贝

class Person
{
public:
	int my_age;
	int* my_height;
	Person()
	{
		cout << "Person 默认构造函数调用" << endl;
	}

	Person(int age,int height) {
		my_age = age;
		my_height = new int(height);
		cout << "Person 有参构造函数调用" << endl;
	}


	~Person()
	{
		// 析构代码，将堆区开辟数据做释放操作
		if (my_height != NULL) {
			delete my_height;
			my_height = NULL;
		}
		cout << "Person 析构函数调用" << endl;
	}
};


void test01()
{
	Person p1(18,170);
	cout << "p1's age : " << p1.my_age << "  p1's height : " << *p1.my_height << endl;

	Person p2(p1);
	cout << "p2's age : " << p2.my_age << "  p2's height : " << *p2.my_height << endl;
}

int main()
{
	test01();
	return 0;
}

在这里插入图片描述

浅拷贝的问题要利用深拷贝进行解决

#include <iostream>
using namespace std;

//深拷贝与浅拷贝

class Person
{
public:
	int my_age;
	int* my_height;
	Person()
	{
		cout << "Person 默认构造函数调用" << endl;
	}

	Person(int age,int height) {
		my_age = age;
		my_height = new int(height);
		cout << "Person 有参构造函数调用" << endl;
	}

	// 自己实现拷贝函数，解决浅拷贝带来的问题
	Person(const Person &p) {
		cout << "Person 拷贝构造函数调用" << endl;
		my_age = p.my_age;
		my_height = p.my_height; // 编译器默认实现就是这行代码
		// 深拷贝操作
		my_height = new int(*p.my_height);
	}



	~Person()
	{
		// 析构代码，将堆区开辟数据做释放操作
		if (my_height != NULL) {
			delete my_height;
			my_height = NULL;
		}
		cout << "Person 析构函数调用" << endl;
	}
};


void test01()
{
	Person p1(18,170);
	cout << "p1's age : " << p1.my_age << "  p1's height : " << *p1.my_height << endl;

	Person p2(p1);
	cout << "p2's age : " << p2.my_age << "  p2's height : " << *p2.my_height << endl;
}

int main()
{
	test01();
	return 0;
}

在这里插入图片描述

总结:如果属性有在堆区开辟的，一定要自己提供拷贝构造函数I防止浅拷贝带来的问题

28.类和对象-对象特性-初始化列表

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

1.传统初始化操作

#include <iostream>
using namespace std;

//深拷贝与浅拷贝

class Person
{
public:
	int my_a;
	int my_b;
	int my_c;

	// 传统初始化操作
	Person(int a ,int b,int c) 
	{
		my_a = a;
		my_b = b;
		my_c = c;
	}
	// 初始化列表初始化属性

};


void test01()
{
	Person p(10, 20, 30);
	cout << "my_a = " << p.my_a << endl;
	cout << "my_b = " << p.my_b << endl;
	cout << "my_c = " << p.my_c << endl;

}

int main()
{
	test01();
	return 0;
}

在这里插入图片描述

2.初始化列表初始化属性

#include <iostream>
using namespace std;

//深拷贝与浅拷贝

class Person
{
public:
	int my_a;
	int my_b;
	int my_c;

	// 传统初始化操作
	//Person(int a ,int b,int c) 
	//{
	//	my_a = a;
	//	my_b = b;
	//	my_c = c;
	//}

	// 初始化列表初始化属性
	Person(int a ,int b,int c) :my_a(a), my_b(b), my_c(c) 
	{

	}
};


void test01()
{
	// Person p(10, 20, 30);
	Person p(200,232,999);
	cout << "my_a = " << p.my_a << endl;
	cout << "my_b = " << p.my_b << endl;
	cout << "my_c = " << p.my_c << endl;

}

int main()
{
	test01();
	return 0;
}

在这里插入图片描述

29.类和对象-对象特性-类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员

#include <iostream>
using namespace std;

// 类对象作为类成员

// 手机类
class Phone
{
public:

	Phone(string pName) {
		my_phoneName = pName;
		cout << "Phone的构造函数" << endl;
	}
	string my_phoneName;

	~Phone()
	{
		cout << "Phone的析构函数" << endl;
	}
};

class Person
{
public:
	// my_phone(p_name)  ==> Phone my_phone =p_name 隐式转换法
	Person(string name, string p_name) :my_name(name), my_phone(p_name) 
	{
		cout << "Person的构造函数" << endl;
	}
	// 姓名
	string my_name;
	// 手机
	Phone my_phone;
	~Person()
	{
		cout << "Person的析构函数" << endl;
	}

};

// 当其他类对象作为本类成员，构造时候先构造类对象，再构造自身，析构函数的执行顺序相反
void test01()
{
	Person p("major_s","huawei");
	cout << p.my_name << "  'phone :" << p.my_phone.my_phoneName << endl;
}

int main()
{
	test01();
	return 0;
}

在这里插入图片描述

30.类和对象-对象特性-静态成员-静态成员函数

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

静态成员分为:

  • 静态成员变量
    1.所有对象共享同一份数据。
    2.在编译阶段分配内存。
    3.类内声明，类外初始化

  • 静态成员函数
    1.所有对象共享同一个函数
    2.静态成员函数只能访问静态成员变量

2.静态成员函数只能访问静态成员变量

在这里插入图片描述

#include <iostream>
using namespace std;

// 静态成员函数
// 所有对象共享同一个函数
// 静态成员函数只能访问静态成员变量


class Person
{
public:

	// 静态成员变量
	static int my_a;
	// 非静态成员变量
	int my_b;
	// 静态成员函数
	static void func()
	{ 
		my_a = 100; // 静态成员函数 可以访问 静态成员变量 因为这是大家共享的
		// my_b = 1000; 错误，因为无法区分到底是哪个对象的属性
		cout << "static void func 调用 " << endl;
	}

	//Person() 
	//{
	//	cout << "Person的构造函数" << endl;
	//}

	//~Person()
	//{
	//	cout << "Person的析构函数" << endl;
	//}

};

int Person::my_a = 0;
// 两种访问方式
void test01()
{
	// 1.通过对象访问
	Person p;
	p.func();
	// 2.通过类名访问
	Person::func();
}

int main()
{
	test01();
	return 0;
}

31.类和对象-对象特性-成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上

C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置

#include <iostream>
using namespace std;

// 成员变量 和 成员函数 分开存储
class Person
{

};


void test01()
{

	Person p;
	// 空对象占用空间为 ： 1 个字节
	// C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
	// 每个空对象也应该有一个独一无二的内存地址
	cout << "size of p =" << sizeof(p) << endl;

}



int main()
{
	test01();
	return 0;
}

在这里插入图片描述

#include <iostream>
using namespace std;

// 成员变量 和 成员函数 分开存储
 class Person
{
	int a = 10;  // 非静态成员变量 属于类的对象上
	static int b; // 静态成员变量 不属于类的对象上
	void func(){} // 非静态成员函数 不属于类的对象上
	static void func2() {} // 静态成员函数 不属于类的对象上
};

//int Person::b = 100;

void test01()
{

	Person p;
	// 空对象占用空间为 ： 1 个字节
	// C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
	// 每个空对象也应该有一个独一无二的内存地址
	cout << "size of p =" << sizeof(Person) << endl;

}


int main()
{
	test01();
	return 0;
}

在这里插入图片描述

32.类和对象-对象特性-this指针的用途

我们知道在C++中成员变量和成员函数是分开存储的

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码那么问题是:这—块代码是如何区分那个对象调用自己的呢?

C++通过提供特殊的对象指针，this指针，解决上述问题。
this指针指向被调用的成员函数所属的对象

  • this指针是隐含每—个非静态成员函数内的—种指针
  • this指针不需要定义，直接使用即可

this指针的用途:

  • 当形参和成员变量同名时，可用this指针来区分
  • 在类的非静态成员函数中返回对象本身，可使用return *this
#include <iostream>
using namespace std;

// 1 解决名称冲突
// 2 返回对象本身用*this

class Person {
public:
	int age;
	Person(int age) {
		age = age;
	}
};

void test01()
{
	Person p1(18);
	cout << "p1' age: " << p1.age << endl;
}
int main()
{
	test01();

	return 0;
}

在这里插入图片描述

#include <iostream>
using namespace std;

// 1 解决名称冲突
// 2 返回对象本身用*this

class Person {
public:
	int age;
	Person(int age) {
	//this指针指向被调用的成员函数所属的对象
		this->age = age;
	}
};

void test01()
{
	Person p1(18);
	cout << "p1' age: " << p1.age << endl;
}
int main()
{
	test01();

	return 0;
}

在这里插入图片描述

#include <iostream>
using namespace std;

// 1 解决名称冲突
// 2 返回对象本身用*this

class Person {
public:
	int age;
	Person(int age) {
		this->age = age;
	}

	Person& PersonAddAge(Person &p)
	{
		this->age += p.age;
		 // this指向p2的指针，而 * this指向的就是p2这个对象本体 |
		return *this;
	}
};

// 1 解决名称冲突
void test01()
{
	Person p1(18);
	cout << "p1' age: " << p1.age << endl;
}

// 2 返回对象本身用*this
void test02()
{
	Person p1(10);
	Person p2(10);
	// 链式编程思想
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
	cout << "p2' age: " << p2.age << endl;
}


int main()
{
	//test01();
	test02();
	return 0;
}

在这里插入图片描述

33.类和对象-对象特性-空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针
如果用到this指针，需要加以判断保证代码的健壮性

#include <iostream>
using namespace std;



class Person {
public:
	int my_age;


	void showClassName()
	{
		cout << "this is Person class" << endl;
	}

	void showPersonAge()
	{
		// 报错原因是因为传入的指针是为NULL
		if (this == NULL)
		{
			return;
		}
		cout << "age = " << my_age << endl;
	}

};

// 1 解决名称冲突
void test01()
{
	Person *p = NULL;
	p->showClassName();
	p->showPersonAge();
}


int main()
{
	test01();
	return 0;
}

在这里插入图片描述

34.类和对象-对象特性-const修饰成员函数

常函数:

  • 成员函数后加const后我们称为这个函数为常函数
  • 常函数内不可以修改成员属性
  • 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象:

  • 声明对象前加const称该对象为常对象
  • 常对象只能调用常函数
#include <iostream>
using namespace std;

// 常函数
class Person {
public:
	int my_age;
	mutable int my_special_age;//特殊变量，即使在常函数中，也可以修改这个值,加关键字mutable
	// this指针的本质是指针常量， 指针的指向是不可以修改的
	// 所以 void showPerson() const 等同 const Person * const this 指针的指向和值都不可以改
	// 在成员函数后面加const，修饰的是this指向，让指针指向的值也不可以修改
	void showPerson() const
	{
		my_special_age = 18;
		my_age = 20;
	}

};


void test01()
{

}


int main()
{
	test01();
	return 0;
}

在这里插入图片描述

#include <iostream>
using namespace std;

// 常函数
class Person {
public:
	int my_age;
	mutable int my_special_age;//特殊变量，即使在常函数中，也可以修改这个值,加关键字mutable
	// this指针的本质是指针常量， 指针的指向是不可以修改的
	// 所以 void showPerson() const 等同 const Person * const this 指针的指向和值都不可以改
	// 在成员函数后面加const，修饰的是this指向，让指针指向的值也不可以修改
	void showPerson() const
	{
		my_special_age = 18;
		//my_age = 20;
	}

	void func()
	{

	}

};


// 常对象
void test01()
{
	const Person p; //在对象前加const，变为常对象
	p.my_age = 100;
	p.my_special_age = 99999999999; // m_B是特殊值，在常对象下也可以修改

	//常对象只能调用常函数
	p.showPerson();
	p.func();//常对象不可以调用普通成员函数，因为普通成员函数可以修改属性

}


int main()
{
	test01();
	return 0;
}

在这里插入图片描述

*Major*
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
对象的三大特性
Scropiooo的博客
01-11 1553
继 承（面向对象特征之一） 好处： 1：提高了代码的复用性。 2：让类与类之间产生了关系，提供了另一个特征多态的前提。 继承的一个弊端：打破了封装性。对于一些类，或者类中功能，是需要被继承，或者复写的。 这时如何解决问题呢？介绍一个关键字， final : 最终。 final 特点： 1：这个关键字是一个修饰符，可以修饰类，方法，变量。 2：被 final 修饰的类是一个最
javascript--对象的特性
weixin_33922670的博客
05-21 113
对象具有三大特性：封装，继承，多态 一、封装　　 　　1.函数的封装是为了函数的安全性，将对象进行包装，通过有限的接口衍化不同的对象 　　2.工厂函数封装 　　　　工厂函数是设计模型中的一种说法，不是通过类实例化构造函数，而是通过函数进行构造对象，在函数内部创建一个对象，通过参数的传递实现对象的更多控制，并将对象返回，当属性相同时造成内存的浪费。 // (函数里创建一个对象，对象的属...
对象的特点
斜阳雨陌
03-10 4465
对象有如下一些基本特点。 (1) 以数据为中心。操作围绕对其数据所需要做的处理来设置，不设置与这些数据无关的操作，而且操作的结果往往与当时所处的状态      (数据的值)有关。 (2) 对象是主动的。它是进行处理的主体。不能从外部直接加工它的私有数据，必须通过它的公有接口向对象发消息，请求它执行它的      某个操作，处理它的私有数据。 (3) 实现了数据封装。对象好像是一只黑盒子，它的
对象的特征
CHERISHGF的博客
04-02 646
实例属性：类被实例化后才会具有的属性。 类属性：类定义后就存在，而且不需要实例化 私有属性：使用__开头的变量名加以标志，只有类对象自己能访问；使用_开头的变量名加以标注，应该只有类对象及其子类能访问（非强制），单下划线是标志性的不是限制性的，在类外是可以修改的 特殊属性：__doc__;__name__对象的名称;__dict__;__module__;__base__包含类对象的全部基类...
一阶单容上水箱对象特性的测试实验报告.pdf
07-09
这篇实验报告详细介绍了关于一阶单容上水箱对象特性的测试，主要涉及控制工程的基础概念和实践操作。实验的目的是通过测试单容水箱的阶跃响应来确定其对象特性，包括特征参数K、T以及传递函数。实验设备包括实验装置...
java-面向对象特性PPT.ppt
10-31
"java-面向对象特性PPT" 本资源摘要信息主要讲解了面向对象编程的基本概念、面向对象设计、类和对象的概念、Java中的类和对象的使用等知识点。 面向对象编程是一种编程思想，强调以对象为中心来思考问题。面向对象...
javascript面向对象特性代码实例
10-25
主要介绍了javascript面向对象特性代码实例,包括类、静态成员、对象、重载,需要的朋友可以参考下
C++结构体非面向对象特性
01-20
结构体部分的学习也是面向对象中类的基础。结构体定义将会在C++程序中形成一种类型的概念，用于开发者创建其对象实例使用。C++中结构体定义的一般语法形式： 　struct struct_name //声明结构体名称为struct_name ...
【Js Beginner】理解对象和对象的描述特性
weixin_33786077的博客
10-31 89
Date: Updated At Oct 31, 2018 | JavaScript | 面向对象 | Author: ZhengAo | 面向对象的语言都有一个特性 -- 都有类的概念。通过类可以创建一系列属性相近，功能类似的对象。 JavaScript 中没有类的概念，JS 有特殊的面向对象的技巧--通过原型的方式。每个对象都是基于一个引用类型创建的 [TOC] 首先要对...
Java对象的四个基本特性
weixin_30642029的博客
09-26 200
抽象：把客观事物用代码抽象出来，包括两种抽象：第一种是数据抽象，也就是对象的属性。第二种是过程抽象，也就是对象的行为特征。 封装：把客观事物封装成抽象的类，对不可信的对象隐藏，对可信的对象或者类进行操作。 继承：对着父类进行继承extends，implements实现接口。 多态：允许不同类的对象对同一消息做出响应。方法的重载、方法的继承就是体现这一关系。 转载于:https://w...
对象的三大特征
yang492363277的博客
06-19 3527
面向对象的三大特征：封装 继承 多态  封装：       封装就是把对象的属性和行为结合成一个独立的相同单位（就是类class），并尽可能隐蔽对象的内部细节       优点：           信息隐蔽，封装即隐藏   继承：        扩展父类的内容，注意只能继承publie和protected修饰的内容，而private修饰的则不能继承      关键字： extend
对象——对象三个特性（第二层）
特大号虾米的博客
08-31 346
原型属性： 在ECMAScript5中，Object.getPrototypeOf():将对象作为参数传入，可以查询它的原型。在ECMAScript3中，o.constructor.prototype来检测一个对象的原型。 isPrototypeOf()方法：要检测一个对象是否是另一个对象的原型。 var p = {x:1};
对象特性-静态成员
foreverqq24的博客
12-04 329
静态成员 静态成员就是在成员变量和成员函数前加上关键字static ，分为：静态成员变量和静态成员函数。 静态成员变量： 所有对象共享同一份数据 编译阶段分配内存 类内声明，类外初始化 静态成员函数 所有对象共享同一函数 静态成员函数只能访问静态成员变量 ...
面对对象的三大特性
九之者
01-17 409
面对对象的三大特性： 封装 封装，就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。 继承 继承，指可以让某...
【②C++ | 类和对象】四大特性 | 创建 | 实例化
热爱编程的小K的博客
12-29 1103
通过使用类和对象，可以将代码组织为更加模块化、可重用和易于维护的方式。类定义了对象的属性和行为，而对象则是这些属性和行为的实际体现。封装、继承和多态等概念使得面向对象编程成为一种强大的编程范式，可用于构建复杂的软件系统。
深入理解JAVA对象的四大特性（附案例及代码示例）
最新发布
m0_48717384的博客
10-09 441
详细介绍了java对象的几大特性以及案例分析说明，基于继承方式和组合方式分别实现LruCache，附代码示例
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值