实例和对象的区别是什么？

假设你在造椅子。

显示如何构建椅子并将其组装在一起的图表对应于一个软件类。

Let's say you build five chairs according to the pattern in that diagram. Likewise, you could construct five software objects according to the pattern in a class.

每把椅子都有一个独一无二的编号，刻在椅子的底部，用来识别每把椅子。椅子3是椅子图案的一个实例。同样，内存位置3可以包含软件模式的一个实例。

因此，实例(椅子3)是椅子图案的一个独特的、特定的表现形式。

目标 :

它是一个泛型术语，基本上它是一个包含状态(变量)和行为(方法)的软件包

类别 :

对象的蓝图(模板) 这是一个唯一的对象例如你创建了一个对象两次这意味着你创建了两个实例

让我举个例子

Class student()
{
private string firstName;
public student(string fname)
{
firstName=fname;
}
Public string GetFirstName()
{
return firstName;
}
}

对象示例 :

学生 s1 = 新生(“马丁”) ; 学生 s2 = 新生(「库马」) ;

S1，s2有类 Student 的对象

实例 :

s1 and s2 are instances of object student the two are unique.

也可以称为 参考文献。

基本上 s1和 s2是分配给对象的变量

每个对象都被称为其类的一个实例，但是类的每个实例对于每个属性都有自己的值 Intances 与类的实例共享属性名和操作，但对象包含对其 on class 的隐式引用

Instance: Instance 意味着只是创建一个引用(副本)。

Object: 表示当内存位置通过使用 new 运算符与对象(是类的运行时实体)关联时。

简单来说，Instance 指的是对象在特定时间的副本，而 object 指的是类的内存地址。

如果我们看到对象和实例的定义对象-

在运行时为类成员分配的内存称为对象，或者对象是 Class 的实例。

让我们看看实例的定义-

Memory allocated For Any at run time is called as instance variable.

现在明白了 任何运行时内存分配的含义了吧，C 语言中的内存分配也是通过 Malloc、 Calloc、 Realloc 实现的，例如:

struct p
{


}
p *t1
t1=(p) malloc(sizeof(p))

所以这里我们也分配运行时内存分配但这里我们调用为实例所以 t1是实例我们不能说 t1是对象所以每个对象是类的实例但每个实例不是对象。

对象——一个类的实例，它有自己的状态，并且可以访问由它的类定义的所有行为。

实例-对该特定类的内存区域的引用。

对象和实例大部分是相同的，但是有一个非常小的区别。 如果 Car是一个类，那么3个 Car就是3个不同的对象。所有这些对象都是实例。所以这三辆车是来自 Car类实例的对象。

But the word "instance" can mean "structure instance" also. But object is only for classes.

所有对象都是实例。 并非所有的实例都必须是对象。实例可以是“结构实例”或“对象”。 我希望这能让你明白其中的区别。

类: 类是一个蓝图。 对象: 它是类的副本。 实例: 它是一个变量，用于保存对象的内存地址。

A very basic analytical example

班级住宅—— > 住宅蓝图。但你不能住在蓝图里。你需要一个实际的房子，这是类的实例居住。例如，对象的实际地址是 instance。实例表示对象。

对象引用类，实例引用对象。换句话说，实例是一个对象的副本，其中包含特定的值。

一旦你实例化了一个类(使用 new) ，这个实例化的东西就变成了一个对象。对象是可以遵循面向对象编程的封装、多态性、抽象原则以及程序与之交互以消费类中定义的实例成员的实际事物。对象包含实例成员(非静态成员)。

因此类的实例是一个对象。“ instance”这个词用在你指的是它的起源时，如果你说“ class 的 instance”比“ object of a class”更清楚(虽然后者可以用来表示)。

也可以在嵌套类 -https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html上读取这个 java 文档的“内部类”部分

关于 object和 instance之间的区别，我不认为有任何共识。

在我看来，人们在论文、博客文章、书籍或对话中几乎可以互换地改变它。

对我来说，我认为对象是内存中的一个通用的、活的实体，由它所使用的语言指定。就像 Java中的 Object类。我们不太关心它的类型，或者任何与它相关的东西，不管它是否由容器管理。

instance是 object，但与类型关联，如在 this method accepts Foo instances或 < code > 中，您不能将 Animal 实例放在 车辆名单

例如，与 object相关联的是 locks，而不是 instance，而 instance有方法。 objects是垃圾回收的，而不是 instance。

但正如我所说，这只是我的看法，我不认为有任何组织，我们可以参考一个标准的定义，他们之间的每个人都会有他们的略有不同的理解/定义(当然在限制范围内)。

Java 是一种面向对象程序设计语言(OOP)。这意味着，除了原语类型之外，Java 中的所有东西都是一个对象。

现在，Java 对象类似于现实世界中的对象。例如，我们可以在 Java 中创建一个 car 对象，它将具有诸如当前速度和颜色之类的属性，以及诸如: 加速和停车之类的行为。

那是 反对。

另一方面，Instance 是该对象的惟一初始化副本，看起来像 Car car = new Car()。

点击这里了解更多关于 Java 类和对象的信息

Quick and Simple Answer

• Class : a specification, blueprint for an object...
• Object : physical presence of the class in memory...
• Instance : < em > 对象的唯一副本(相同的结构，不同的数据) ..。

一个对象是一个通用的东西，例如，在数学中取一个线性函数

Ax + b 是一个对象，而3x + 2是该对象的一个实例

对象 < < < 实例

一般 < < 具体

There is nothing more to this

我真不敢相信，除了一个没人用密码解释过的家伙，让我也试试！

// Design Class
class HumanClass {
var name:String
init(name:String) {
self.name = name
}
}


var humanClassObject1 = HumanClass(name: "Rehan")

现在，左边(即: “ human ClassObject1”)是对象，右边(即: HumanClass (名称: “ Rehan”))是该对象的实例。

var humanClassObject2 = HumanClass(name: "Ahmad") // again object on left and it's instance on the right.

So basically, instance contains the specific values for that object and objects contains the memory location (at run-time).

记住著名的语句“对象引用未设置为对象的实例”，这意味着未初始化的对象没有任何实例。 在一些编程语言中，比如 Swift，编译器甚至不允许你设计一个没有任何方法来初始化所有成员的类(变量: name，age e.t.c) ，但是在一些语言中，你可以这样做:

// Design Class
class HumanClass {
var name:String // See we don't have any way to initialise name property.
}

And the error will only be shown at run time when you try to do something like this:

var myClass = HumanClass()
print(myClass.name) // will give, object reference not set to an instance of the object.

这个错误表明，特定的值(为变量属性)是 "INSTANCE"，因为我试图解释这上面！ 而对象，即: “ myClass”包含内存位置(在运行时)。

这个答案可能被视为陈词滥调，但是担心实例和对象之间的差异已经是陈词滥调了。

我认为它在 javascript 中描述得最好:

let obj= {"poo":1}
// "obj" is an object

诗句

Class Trash {
constructor(){this.poo = 1;}
}


let i = new Trash();
// "i" is an instance

当变量声明为自定义类型(类)时，只创建一个引用，该引用称为对象。在这个阶段，没有内存分配给这个 对象。它只是一个指针(指向将来存储对象的位置)。这个过程被称为“宣言”。

Employee e; // e is an object

另一方面，当使用 new运算符声明自定义类型的变量时，该运算符将堆中的内存分配给该对象，并将引用返回给分配的内存。这个对象现在被称为 例子。这个过程称为“实例化”。

Employee e = new Employee(); // e is an instance

然而，在 Java 等一些语言中，一个对象等同于一个实例，从 Oracle 关于 Java 的文档中的一行就可以看出:

注意: 短语“实例化类”的意思与“创建对象”相同当您创建一个对象时，您正在创建一个类的“实例”，因此“实例化”了一个类。

有三件事情你需要理解: 类，对象和实例。

Class : Class is the blueprint code from which you will create an Object(s)

Object : 当内存分配给数据实体(从蓝图类创建)时，该数据实体或对它的引用称为 Object

实例 : 当数据填充到一个对象中时，它就成为该对象的一个实例。它也可以被称为该对象的状态。

示例 : 在 C # 的上下文中(这里对象是引用类型)

假设我们有这样一个类(这是您的蓝图代码)

public class Animal
{
//some fields and methods
}

我们创建一个这样的对象

Animal a = new Animal();
Animal b = a;
Animal c = a;
Animal d = b;

所以问题来了: 这里有多少对象和实例？

回答 : 只有1个对象但有4个实例。

为什么？

在第一行(Animal a = new Animal () ;)中，我们使用 new 操作符从类 Animal 创建了一个 Object。那个对象就在你的内存里。对那个 Object 的引用在“ a”中。 We have 1 object and 1 instance at this time.

现在，在下一行中，我们用一个。这里没有复制对象，但是“ a”中对象的引用也存储在“ b”中。因此，我们有2个实例，“ a 和 b”。

这种情况会继续下去，我们只复制位于某个内存中的同一对象的引用。

最后，我们用 new Operator 创建了一个对象的4个实例“ a，b，c，d”。

(详细阅读引用类型在 C # 中的工作原理，希望您能理解我的语言)

我不敢相信这很难解释，但实际上它比我读过的所有答案都要简单。就这么简单。

首先，你需要理解这个定义:

实例是对象的 * * 惟一副本产品。

我不知道你在说什么

对象是用于保存 Class 信息的名称(即 方法)

假设有一个 toy_1作为对象。 There is also toy_2 as an object ----> which ALSO an INSTANCE to toy_1. 同时，toy_1也是 toy_2的一个实例(请再次记住，实例是一个复制产品)

这就是为什么我找到的大部分答案都说它是可互换的。谢谢。

我认为，如果我们考虑 OOP 以外的其他方法(主要是假设术语 同学们并不总是被使用，因为许多 C 项目仍然应用 物品的概念) ，下面的定义将是最有意义的:

同学们定义了对象所依附的接口。

反对是不同字段的集合(它不一定“物理”存在，但它可以)。

同一类的所有 物品都可以以同样的方式使用，由 Class 定义。

实例是 反对的唯一实现。

As many OOP languages use static typing, the Object description is usually part of the Class already. As such, when talking about an 反对 in C/C++, what usually is meant is the 实例 of an 反对. 在没有静态类型的语言(如 JavaScript)中，对象可以具有不同的字段，同时仍然共享相同的 Class。