继承和多态

已于 2023-12-03 21:42:32 修改
阅读量754 收藏 16
点赞数 21
文章标签： 开发语言
于 2023-12-03 21:30:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73752525/article/details/134770932
版权

继承和多态总结

一、继承

1.概念

1.概念：继承是面向对象程序代码设计中可以使代码进行复用的最重要的手段，它允许程序员在保持原有类的特性下进行了拓展，增加功能，这样产生的类叫派生类。继承呈现了面向对象设计的层次，由简单到复杂的认知过程。以前我们遇到的复用都是函数的复用，现在的继承都是类设计层次的复用。

class Person {
public:
	void Func()
	{
		cout<<Person::Func()<<endl;
	}

	Person(string name="Peter",int id=001)
		:_name(name)
		,_id(id)
	{
		cout << "Person()" << endl;
	}

private:
	string _name;
	int _id;
};

class Student :public Person{
public:
	Student(char sex = 'M')
		:_sex(sex)
	{
		cout << "Student()" << endl;
	}
private:
	char _sex;

};

int main()
{
	Person p;
	Student s('F');
	s.Func();
	return 0;
}

通过监视窗口我们可以看到Person的成员变量已经被Student继承下来了。

在这里插入图片描述

而通过下面的结果我们也可以看到属于Person的成员函数也可以被Student进行调用。

2.定义

2.1、继承关系分为三种：公有继承，私有继承，保护继承。

2.2、继承限定符分为三种：public访问，private访问，protected访问。

在这里插入图片描述

所以对于基类的访问方式和继承共有九种情况，其中最常见的就是圈出的两种。

这张表简单而言就是基类的成员遇到继承方式其的属性变成两者小的那个继承到派生类中。

例：原先在基类时，成员是protected，继承方式是private，所以此时在派生类中此变量就是private属性。

1、基类的派生类无论是哪一种继承方式都是不可见，这里的可见和不可见意思是在派生类中可以访问，但是这些不可见的私有成员还是被继承到了派生类中。

2、如果一个变量不想在类外面被访问的话就用protected进行修饰。

3、关键字class的默认继承方式是private，struct的默认继承方式是public。

3.基类与派生类互相进行赋值转换。

**1.派生类对象可以赋值给基类对象/基类指针/基类引用。**进行切片。

2.基类对象不可以赋值给派生类。
在这里插入图片描述

4.继承的作用域

1.继承中基类和派生类的作用域都是独立的。

2.子类与父类中有相同的成员，子类成员将屏蔽对父类成员的访问，叫做隐藏，也叫重定义。

class Person {
public:
	void Func()
	{
		cout << "Person::Func()"<< endl;
	}

	Person(string name = "Peter", int id = 001)
		:_name(name)
		, _id(id)
	{
		cout << "Person()" << endl;
	}

private:
	string _name;
	int _id;
};

class Student :public Person {
public:
	Student(char sex = 'M',string name = "good")
		:_sex(sex)
		,_name(name)
	{
		cout << "Student()" << endl;
	}
	
	void Func()
	{
		cout << "Student::Func()" << endl;
	}


private:
	char _sex;
	string _name;

};

在这里插入图片描述

子类与父类中的Func()函数不是构成重载，因为重载的要求是两个函数要在同一个作用域中，而这是两个类就是两个作用域即构成重定义。

5.派生类的默认成员函数

1.默认构造函数，派生类在创建对象的时候，派生类会自动调用基类的默认构造函数，如果派生类没有默认构造函数的话，则必须在初始化列表进行调用。即调用基类的构造函数后再调用派生类。

2.派生类的拷贝构造函数要调用基类的拷贝构造函数进行对基类的拷贝构造。

3.派生类的operator==同理。

4.派生类的析构函数在基类的析构函数调用后再调用。

6.友元不能继承

7.由基类创建的静态变量无论派生出多少个子类都只有这一个静态变量。

8.继承的种类

继承分为多继承和单继承，其中多继承中又有菱形继承。

1.单继承

在这里插入图片描述

2.多继承

在这里插入图片描述

3.菱形继承

在这里插入图片描述

由于菱形继承的最后一个派生类同时继承了基类的基类的成员两次，所以会出现数据冗余和二义性的问题。

3.1菱形继承的解决方式

例：




class A {
public:
	A(int a=10)
		:_a(a)
	{}

public:
	int _a;
};


class B :public A {
public:
	B(int b=11,int b1=20)
		:_b(b)
		,_b1(b1)
	{}
private:
	int _b;
	int _b1;
};


class C :public A {
public:
	C(int c=12,int c1=21)
		:_c(c)
		,_c1(c1)
	{}
private:
	int _c;
	int _c1;
};

class D :public B,public C {
public:
	D(int d=13,int d1=22)
		:_d(d)
		,_d1(d1)
	{}
private:
	int _d;
	int _d1;
};


int main()
{
	D d1;
	d1.B::_a = 10;
	d1.C::_a = 100;




	return 0;
}

1.解决二义性：

就如上面对应的D类而言，同时继承了B类与C类的_a，为了区分B类和C类可以使用域作用限定符解决二义性的问题。

2.解决数据的冗余性：

如图所示，这是d1对象在内存中的存储情况，_a在B与C中同时存在，造成了数据的冗余。

在这里插入图片描述

解决方法是在腰部的类加上virtual进行菱形虚拟继承。

image-20231116220604327

在这里插入图片描述

在这里插入图片描述

右边就是虚基表，20（十六进制）就是B类与_a的距离（0x00EFFD90-0x00EFFD70）同理14。在这里插入图片描述在这里插入图片描述

1116222940622.png&pos_id=img-UyTsAXhF-1701610179984)

继承和组合（白箱和黑箱）

3.2菱形虚拟继承的优点

1.解决了数据冗余和二义性的问题

2.适当的节省了空间

采用虚拟继承：
在这里插入图片描述

未采用虚拟继承：

在这里插入图片描述

原因很简单，因为没有用虚拟继承是就B，C类会将A类的成员变量都复制一份，而采用虚拟继承的话机只是在B,C类中多两个指针。

二、多态

1.概念

1.1、概念：就是多种形态，具体就是不同对象完成某个行为会产生不同的效果。

2.多态的定义和实现

2.1多态的构成条件

多态的调用是在不同关系的继承对象，去调用同一函数，产生了不同的行为。

构成的条件：

1.必须是通过基类的指针或是引用调用虚函数。

2.调用的必须是虚函数，虚函数必须在派生类中进行重写。

class Person {
public:
	virtual void Ticket()
	{
		cout << "Person::Ticket()" << endl;
	}
};

class Student : public Person {
public:
	virtual void Ticket()
	{
		cout << "Student::Ticket()" << endl;
	}
};

//1.直接传值
void Func(Person s)
{
	s.Ticket();
}

//2.引用
void Func(Person& s)
{
	s.Ticket();
}

//3.指针
void Func(Person* s)
{
	(*s).Ticket();
}

int main()
{
	Person p1;
	Student s1;
	Func(p1);//Person类
	Func(s1);//Student类

	return 0;

}

直接传值：

在这里插入图片描述

引用传值：

<

指针传值：
在这里插入图片描述

如果是多态的话调用的函数就遵循多态的规则，如果是普通的对象的话（即不构成多态的条件）就看当前的类型

2.2虚函数

虚函数：被virtual关键字修饰函数就是虚函数。

virtual void Func();
2.3虚函数的重写

虚函数的重写（覆盖）：派生类有一个与基类完全想同的虚函数（即派生类的虚函数与基类的虚函数返回值类型，函数名字，参数列表也完全相同）

class Person {
public:
	virtual void Ticket()
	{
		cout << "Person::Ticket()" << endl;
	}
};

class Student : public Person {
public:
	virtual void Ticket()//派生类前也可以不加virtual（不过这样不是很规范，所以不是很推荐）
	{
		cout << "Student::Ticket()" << endl;
	}
};

虚函数重写的两个例外：

1.协变（基类和派生类的返回值类型不同）：

派生类重写虚函数的时候返回类型不同，基类返回的是基类的指针或引用，派生类返回的是派生类的指针或引用即被称为协变。

//基类：
virtual Parent* Fun();//Parent也为基类

//派生类
virtual Son* Fun();//Son为派生类

2.析构函数的重写（每个类的析构函数的函数名都不同）

如果基类的析构函数是虚函数，而派生类进行重写的时候就算前面加virtual也没有用，因为函数名不同，所以这里编译器做了特殊处理将所有类的析构函数名都处理成destructor。

有可能会想为什么要重写派生类的析构函数，如下：

class Person {
public:
	~Person()
	{
		cout << "~Person()" << endl;
	}

};

class Student :public Person{
public:
	Student()
	{
		int* p = new int;
	}

	~Student()
	{
		cout << "~Student()" << endl;
		delete p;
	}
private:
	int* p;
};

int main()
{
	Person* p = new Student();
	delete p;

	return 0;
}

这里派生类申请了p的指针，如果不处理的话就会内存泄漏所以要进行重写，如果不满足多态就会泄露。

在这里插入图片描述

在这里插入图片描述

2.4 C++11中override和final标识符

1 final:

final标识符有两个作用，一是禁止类的继承：

二是禁止函数重写：

2 override:

用来检查虚函数是否进行重写：

2.5 重写，重载，重定义的区别

在这里插入图片描述

3.抽象类

在虚函数后面加上**=0**，就是纯虚函数，**含有纯虚函数的类是抽象类（也叫接口类），不能实例化对象。**派生类继承后派生类也不能创建对象，只有派生类对纯虚函数进行重写派生类才能创建对象。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

4.多态的原理

4.1虚函数表

class Person {
public:
	void Fumc() {}
private:
	char _id;
};
int main()
{
	cout << sizeof(Person) << endl;
	return 0;
}

在这里插入图片描述
Cimage-20231121211044750.png&pos_id=img-NoSN7xht-1701610179986)

显然这个结果是1，那么接下来的结果呢。

class Person {
public:
	virtual void Fumc() {}
private:
	char _id;
};
int main()
{
	cout << sizeof(Person) << endl;
	return 0;
}

在这里插入图片描述

为什么结果是8呢，我们进入调试模式看一下Person类创建的对象的内容。

在这里插入图片描述
31121213408844.png&pos_id=img-MxWbGcqr-1701610179986)

在对象p中，除了数据_id之外，前面还有一个虚函数指针，所以根据内存对齐原则共是八字节。一个含有虚函数的类都至少有一个虚函数表指针。因为虚函数的地址要放在虚函数表中，虚函数表也称为虚表。

class Person {
public:
	virtual void Func1() {}
	virtual void Func2() {}
	void Func() {}

private:
	char _id;

};

class Student :public Person {
public:
	virtual void Func1() {}
	void Func3();
private:
	char _sex;
};


int main()
{
	Person p;

	Student s;

	p.Func();
	return 0;

}

在这里插入图片描述
通过观察和发现，我们不难看出：

1.基类的vfptr就是一个指针数组，存储着基类中的虚函数，同样派生类也有一个虚函数指针，如果没有对基类的虚函数进行重写，那么存储的就是基类的虚函数的地址。

2.只有虚函数才会放入虚表，就比如基类的Func()函数和派生类的Func()3都不是虚函数，所以虚函数表中都没有存有。

3.虚函数表中的最后一位存有nullptr。

4.虚表的形成过程：

a.首先将基类的虚函数拷贝一份。

b.如果对基类的虚函数有重写就将自己重写的虚函数进行覆盖。

c.如果自己有新写的虚函数，则在虚表后添加新的虚函数。

4.2虚表和虚函数的存储问题

1.首先说虚函数，虚函数与普通函数一样，都存在代码段中。

2.其次是虚表：

虚表存储的内容是虚函数指针。而虚表的位置我们需要进行大概得验证猜测。

因此我们写如下的代码进行验证：

int main()
{

	Person p;

	Student s;

	//1.可能是栈区
	int a = 10;
	cout << "a位于栈内的地址: " << &a << endl;

	//2.可能是堆区
	int* b = new int;
	cout << "b位于堆内的地址: " << &b << endl;

	//3.可能是静态区
	static int c = 10;
	cout << "c位于静态区内的地址: " << &c << endl;

	//4.可能是在常量区（代码段）
	const char* d = "hello world";
	cout << "d位于常量区内的地址: " << &d << endl;

	printf("虚表1：%p\n", *((int*)&p));
	printf("虚表2：%p\n", *((int*)&s));
	return 0;

}

在这里插入图片描述

进行对比之后我们可以观察到虚表的地址离静态区的地址最近，所以大概估计虚表应该存储在静态区。

4.3多态的原理

1.首先想多态为什么一定要是基类的指针或引用，为什么不能是子类的指针或引用，为什么不能是父类的对象？

为什么不能是是直接的切片呢，因为在切片的时候不会进行虚表的拷贝，为什么不会进行的虚表的拷贝呢，因为如果进行了虚表的拷贝的话就会分不清到底是是父类的虚函数还是子类的。

举个例子：

在这里插入图片描述

如果这样的话在调用父类p1的Ticket函数就会调用子类的函数（注：在内存中是没有Student：这样的东西标识），所以不能进行拷贝，不能的话就不可以采用父类对子类的切片。

在这里插入图片描述

可以看到，p1与p2属于同一类共用一张虚表（从_vfptr指针就可以看出）。

2.

class Base1 {
public:
	Base1()
		:b1(1)
	{}

	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};
class Base2 {
public:
	Base2()
		:b2(2)
	{}
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:

		int b2;
};
class Derive : public Base1, public Base2 {
public:
	Derive()
		:d1(10)
	{}
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};

int main()
{
	Base1 b1;
	Base2 b2;
	Derive d;

}

在这里插入图片描述

通过&d可得到d的地址，观察上述表可知：

在这里插入图片描述

通过前面继承的基础我们可以知道这是虚基表，因为我使用的是vs2022是小端机器。

0x01019d24:毫无疑问就是Base1的虚指针。

0x01019b6c:毫无疑问就是Base2的虚指针。

在这里插入图片描述

由图中的指针可以了解到b1和b2虚表的组成，但是我们观察到b1在给出自己两者的函数外还有另外的一个指针，根据前面的代码可知，Derive这个派生类还写了一个虚函数Func3，但在调试窗口我们未曾看见，所以我们可以猜测一下是否该指针对应的是Func3，所以我们接下来对我们的想法进行验证。

//因为虚表的本质是一个函数指针的数组，所以我们先typedef一个函数指针

typedef void(*VFTR)();

void Print(VFTR vftrtable[])
{
	int i = 0;
	cout << "虚表地址>" << vftrtable << endl;
	while (vftrtable[i])//虚表一般都是以空指针nullptr作为结束，所以这样可以很好的判断
	{
		printf("第%d个虚函数地址：0x%x", i, vftrtable);
		VFTR f = vftrtable[i];
		f();
		i++;
	}
	cout << endl;
}
	Derive d;
	//因为我使用的x86环境，所以指针位数是4个字节，所以我们打印虚表的话就需要Derive d的虚表的指针
	//所以首先先去取d的地址，然后在强转成int*,在对其解引用就取到了前面的四个字节，然后在把这四个字节表示的内容，即函数指针
	//在进行函数指针的强转，得到该函数的地址，再将其传到打印函数即可
	VFTR* f = (VFTR*)*((int*)&d);
	VFTR* f1 = (VFTR*)*((int*)&b1);

	Print(f);
	Print(f1);

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

十分清晰的可以看出我们调试窗口没出现的就是func3因此我们的验证显然正确。

所以我们也可以得知，派生类的虚函数会被写到第一个继承的基类中。

4.4重写一样的函数地址不同问题
Derive d;

	Base1& b11 = d;
	b11.func1();

	Base2& b22 = d;
	b22.func1();

当我们在运行这样一段代码的时候，根据前面的学习我们可以知道结果。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

但在奇怪的是当我们打开监视窗口的时候却发现：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

都是重写func1为什么函数的地址不同呢？

我们进行反汇编的观察：

1.在这里插入图片描述

进行第一个多态的实践分析：

在这里插入图片描述

进行分析，首先当代码执行到b11->func1()这一行时有如上操作。

（1）、ecx存储b11 this指针的地址。eax存放下一次跳转的指令。

（2）、jmp指令执行后再跳转。

（3）、正常执行func1()函数。

2.

进行第二个多态的实践分析：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

（1）、同样的将b22 this指针压入ecx中，下一个执行的指令压入eax寄存器中。

（2）、到jmp指令后不喝b11的一样而是去对ecx中的this指针减8，为什么会这样呢？下面给出说明.

（3）、后面就和b11执行的一样调用func1()；

现在说明为什么要进行ecx的sub 8操作：

在这里插入图片描述

我们都知道d满足这个表，而在上述调用Func1中，Func1属于Derive的函数，所以要传d的地址，因为b11的地址与d的地址相同，所以正常的进行函数调用，而b22的地址比d的地址高8,所以需要进行调整才能调用Func1函数，因此前面的调用是对this指针的修正。

func1为什么函数的地址不同呢？**

我们进行反汇编的观察：

1.[外链图片转存中…(img-yGoXP1r4-1701610179989)]

进行第一个多态的实践分析：

[外链图片转存中…(img-5T0OCnsV-1701610179989)]

进行分析，首先当代码执行到b11->func1()这一行时有如上操作。

（1）、ecx存储b11 this指针的地址。eax存放下一次跳转的指令。

（2）、jmp指令执行后再跳转。

（3）、正常执行func1()函数。

2.[外链图片转存中…(img-Ivfb4bsy-1701610179989)]

进行第二个多态的实践分析：

[外链图片转存中…(img-NKNJEOxz-1701610179989)]

（1）、同样的将b22 this指针压入ecx中，下一个执行的指令压入eax寄存器中。

（2）、到jmp指令后不喝b11的一样而是去对ecx中的this指针减8，为什么会这样呢？下面给出说明.

（3）、后面就和b11执行的一样调用func1()；

现在说明为什么要进行ecx的sub 8操作：

[外链图片转存中…(img-MENlWRRA-1701610179989)]

我们都知道d满足这个表，而在上述调用Func1中，Func1属于Derive的函数，所以要传d的地址，因为b11的地址与d的地址相同，所以正常的进行函数调用，而b22的地址比d的地址高8,所以需要进行调整才能调用Func1函数，因此前面的调用是对this指针的修正。

Traits.
关注
  • 21
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C#第六章 初始继承和多态.pdf
09-04
C#第六章 初始继承和多态.pdfC#第六章 初始继承和多态.pdfC#第六章 初始继承和多态.pdf C#第六章 初始继承和多态.pdfC#第六章 初始继承和多态.pdf
C#基础继承和多态详解
09-05
C#基础继承和多态详解，需要的朋友可以参考一下
Python学习之-继承和多态
Summer的博客
04-02 1772
什么是继承？什么是多态？面向对象的三大特性：封装：根据 职责 将属性和方法封装到一个抽象类中继承： 实现代码的重用，相同的代码不需要重复的编写多态： 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度继承继承是一种机制，它使得一个类（称为子类或派生类）能够继承另一个类（称为父类或基类）的属性和行为（方法）。子类除了可以继承父类的功能外，还可以添加新的功能或重写某些功能。单继承: 当一个类仅继承自一个父类时。多继承: 当一个类继承自多个父类时。
C++ 继承和多态
凡事都是靠练习
08-17 2030
讲解继承和多态，多态的实现原理
封装 继承和多态
weixin_48121041的博客
01-28 4369
封装继承和多态 封装 我们在设计程序时，讲究六个字，高内聚，低耦合 封装就是我们对数据进行隐藏，多用于来封装属性，封装方法较少。 记住封装的核心，就是私有（private） 令属性为私有后我们调用不了类里面的属性，所以我们设置一些get方法和set方法来操作私有的属性 get方法，set方法 public int getAge(){ return age; } public void setAge(int age){ this.age = age; } 具体代码应用 设置一个学生类，令其定义的属
C++ 封装、继承和多态
SimpleForest的博客
07-08 1147
多态指的是同一个函数名可以调用不同类型的函数，从而实现不同对象之间的差异性行为。静态多态是通过函数重载和运算符重载来实现的，而动态多态则是通过虚函数来实现的。多态的目的是实现代码的灵活性和可扩展性，使得程序可以更好地适应不同的应用场景。封装是指的是将数据和操作数据的方法封装在类中，使得数据和方法不能被外部直接访问，只能通过类的公共接口进行访问和修改。封装的目的是实现代码模块化和信息隐藏，提高代码的可维护性和可重用性。继承是指的是一个类（子类）通过继承另一个类（父类）的属性和方法，从而实现代码的扩展。
封装、继承和多态
crazy_xieyi的博客
08-07 2084
封装就是对类内部的实现细节进行隐藏，然后对类外提供公开的接口。继承其实是父类对子类的共性的抽取， 实现代码的复用。一个引用调用同一个方法，因为这个引用 引用的对象不一样，导致调用这个方法，所表现出来的行为不一样。这种思想就叫做多态。 ...
【Java】继承和多态
qq_74455045的博客
04-30 1445
关键字super；关键字protected；关键字final；组合；小练习：三者乘积；重写override；向上转型与向下转型；运行时绑定；多态
C++的继承和多态
linzixi0220的博客
01-30 1722
继承与派生 面向对象程序设计的三大特征是封装、继承和多态。其中继承体现的是一种持续发展的、开放的编程态度。继承和派生可以在不破坏原有类的封装特性的情况下获得原有类的数据和功能，并在此基础上增加新的数据和功能。基类是为解决以前的老问题而设计的，但在遇到新问题时其功能就有局限，这是在继承的基础上进行派生则能够在基类的基础上添加功能来解决新问题。因此通过继承和派生可提高代码的可重用性和持续性。 继承与派生概念：保...
【Java SE】继承和多态(保姆级教学)
热门推荐
书生-w的博客
11-24 2万+
子类继承了父类的属性和方法，并且可以扩展 ,多态是建立在继承的基础上的，多个不同的子类拥有各自不同的形态，也就是多态,了解继承和多态这也是学好java的前提
Java继承和多态
m0_68814541的博客
12-05 678
Java中继承和多态的相关知识
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析.md
11-09
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析
Python类继承和多态原理解析
12-20
这篇文章主要介绍了python类继承和多态原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 现在属于是老年人的脑子，东西写着写着就忘了，东西记着记着就...
SB2B2C商城系统如何挑选？开发语言、功能模块、商城优势分析
weixin_42958899的博客
05-16 416
为满足不断增长的市场需求，SB2B2C商城模式应运而生，以此将供应商、企业客户、消费者紧紧连接在一个平台上，从而为各方提供便利和增加商业价值。上述开发语言拥有各自的特性，考虑到商城软件的特殊性，所以现在90%企业都是采用java语言来搭建商城平台，因为java语言的安全、稳定性方面非常突出，在一定程度上更适合企业应用到电商项目上来。一种动态脚本语言，具有丰富的语法特性和灵活的语言结构，因为php语言简单易学，许多人在网上通过下载教程进行学习，这也造成函数命名不规范等问题。
node-v0.8.10-sunos-x64.tar.gz
最新发布
05-16
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
【课程设计】实现的金融风控贷款违约预测python源码.zip
05-16
【课程设计】实现的金融风控贷款违约预测python源码.zip
node-v0.10.27-x86.msi
05-16
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
python封装继承和多态
03-25
Python中的封装、继承和多态是面向对象编程的重要概念。下面我将为你介绍一下它们： 1. 封装（Encapsulation）： 封装是将数据和对数据的操作封装在一个类中，通过定义类的属性和方法来实现。封装可以隐藏类的内部...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值