实例和对象有什么区别？

【问题标题】：What is the difference between an Instance and an Object?实例和对象有什么区别？
【发布时间】：2011-02-22 13:04:31
【问题描述】：

实例和对象有什么区别？ 有没有区别？

【问题讨论】：

  • 也许您可以从众所周知的错误消息中推断出“对象引用未设置为对象的实例。” :->
  • 来自 JVM 规范：“一个对象要么是一个动态分配的类实例，要么是一个数组。”docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html
  • StackOverFlow 刚才简单介绍了对象和实例的区别，希望对您有所帮助

标签： oop object instance


【解决方案1】：

Instance 和 Object 来自Object Oriented Programming。

对于一些编程语言，如 Java、C++ 和 Smalltalk，描述和理解代码很重要。在结构化编程中使用的其他语言中，这个概念是不存在的。

这是结构化编程的观点。没有真正的显着差异会消耗您过多的时间。可能有一些花哨的语言，有些人可能会占用很多空间来写，但归根结底，就编码员、开发人员、程序员、架构师而言，一个类和对象的含义相同，通常可以互换使用。在我的职业生涯中，我从未遇到过任何人会挑剔并花半小时试图指出差异，因为真的没有。可以更好地将时间花在其他开发工作上。

更新关于 Swift，这是发明 Swift 的苹果更喜欢的：

类的实例传统上称为对象。然而， Swift 的类和结构在功能上比在 其他语言，本章的大部分内容都描述了以下功能 可以应用于类或结构类型的实例。因为 其中，使用了更通用的术语实例。

【讨论】：

  • 那些没有类但有结构的语言呢？我可以说“结构的实例”还是本质上是错误的？在这种情况下我应该怎么称呼它？谢谢！
【解决方案2】：

很好的问题。

我会以最简单的方式解释它： 假设你的篮子里有 5 个苹果。这些苹果中的每一个都是 Apple 类型的对象，它具有一些特征（即大、圆、长在树上）。

在编程术语中，您可以有一个名为 Apple 的类，它具有变量 size:big、shape:round、habitat:grows on trees。要在您的篮子中有 5 个苹果，您需要实例化 5 个苹果。 Apple apple1, Apple apple2, Apple apple3 etc....

或者：对象是事物的定义，实例是物理事物。

这有意义吗？

【讨论】：

  • 它没有。 :) “对象是事物的定义” 你在这里所说的对象是类。
【解决方案3】：

Instance：instance 意味着只是创建一个引用（副本）。

object：表示当内存位置通过new操作符关联到对象（是类的运行时实体）时。

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

【讨论】：

  • 说实例是对对象的引用确实为我清除了一切。
  • @JohnC 不应该，因为它不正确。对象是类的一个实例。仅此而已。
【解决方案4】：

对象：

这是一个通用术语，基本上它是一个具有状态（变量）和行为（方法）的软件包

类：

对象的蓝图（模板） 实例——它是一个独特的对象，例如你创建了一个对象两次，这意味着你创建了两个实例

举个例子

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

对象示例：

学生 s1=new student("马丁"); 学生 s2=new student("Kumar");

s1,s2 有 Student 类的对象

实例：

s1 和 s2 是对象 student 的实例 这两个是独特的。

它也可以被称为参考。

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

【讨论】：

  • 一个对象是一个类的一个实例。
【解决方案5】：

假设你正在建造一些椅子。

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

假设您根据该图中的模式构建了五把椅子。同样，您可以根据类中的模式构造五个软件对象。

每把椅子的底部都刻有一个唯一的编号，以识别每把特定的椅子。椅子 3 是椅子模式的一个实例。同样，内存位置 3 可以包含软件模式的一个实例。

因此，一个实例（椅子 3）是椅子模式的一个独特、特定的表现形式。

【讨论】：

  • 一个对象是一个类的一个实例。实例不是对象的实例。答案毫无意义。
  • 哇，九年后终于有人指出了我解释中的缺陷。谢谢！现在好点了吗？
【解决方案6】：

对象和实例大多相同；但有一个非常小的差异。 如果Car 是一个类，则3 个Cars 是3 个不同的对象。所有这些对象都是实例。所以这 3 辆车是来自 Car 类实例的对象。

但“实例”一词也可以表示“结构实例”。但对象仅适用于类。

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

【讨论】：

    【解决方案7】：

    对象是一种构造，具有某些特性和特征的静态对象，例如属性和方法，它可以是任何东西（字符串、用户控件等）

    实例是该对象的唯一副本，您可以使用它并使用它来做事。

    想象一下像计算机这样的产品。

    xw6400 工作站是一个对象

    您的 xw6400 工作站（或您妻子的 xw6400 工作站）是 xw6400 工作站对象的一个​​实例

    【讨论】：

    • 您的第一段和第二段描述的是类，而不是对象。
    【解决方案8】：

    快速简单的回答

    • 类：一个规范，一个对象的蓝图
    • 对象：类在内存中的物理存在
    • 实例：对象的唯一副本（相同的结构，不同的数据）

    【讨论】：

      【解决方案9】：

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

      我认为它最好用 javascript 描述：

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

      诗句

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

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

      【讨论】：

        【解决方案10】：

        我不敢相信，除了一个没有人用代码解释过的人，让我也试一试！

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

var humanClassObject1 = HumanClass(name: "Rehan")

        现在左侧即“humanClassObject1”是对象，右侧即 HumanClass(name: "Rehan") 是该对象的实例。

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

        基本上，instance 包含该对象的特定值，而 objects 包含内存位置（在运行时）。

        请记住著名的语句“对象引用未设置为对象的实例”，这意味着未初始化的对象没有任何实例。 在某些编程语言（如 swift）中，编译器甚至不允许您设计一个无法初始化其所有成员的类（变量，例如：名称、年龄等），但在某些语言中，您可以这样做： 

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

        只有当您尝试执行以下操作时，才会在运行时显示错误：

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

        此错误表明，具体值（对于变量\属性）是 "INSTANCE"，正如我在上面试图解释的那样！ 对象即“myClass”包含内存位置（在运行时）。

        【讨论】：

          【解决方案11】：

          实例是对象的特定表示。对象是通用事物，而实例是已在内存中创建的单个对象。通常，一个实例将具有分配给它的属性的值，以区别于该对象类型的其他实例。

          【讨论】：

            【解决方案12】：

            如果我们看到 Object 和 Instance 对象的定义 -

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

            让我们看看实例的定义-

            在运行时分配的For Any内存被称为实例变量。

            现在了解any运行时内存分配的含义，也可以通过 Malloc、Calloc、Realloc 等在 C 中发生：

            struct p
{

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

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

            【讨论】：

            • 这里有一个正确的答案，但语言需要清理和简化。
            【解决方案13】：

            Object - 一个类的实例，它有自己的状态并且可以访问其类定义的所有行为。

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

            【讨论】：

              【解决方案14】：

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

              一个非常基本的分析示例

              Class House --> 房子的蓝图。但你不能活在蓝图中。您需要一个物理房屋，它是要居住的类的实例。即，对象的实际地址是实例。实例代表对象。

              【讨论】：

              • 实例指的是对象，而不是变量。
              【解决方案15】：

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

              因此类的实例是一个对象。当您提到它的起源时，使用“实例”一词，与“类的对象”相比，如果您说“类的实例”会更清楚（尽管可以使用后者）。

              还可以阅读此 Java 文档中关于嵌套类的“内部类”部分 - https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

              【讨论】：

                【解决方案16】：

                Java 是一种面向对象的编程语言 (OOP)。这意味着，Java 中除原始类型外的所有内容都是对象。

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

                那是对象。

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

                查看以了解有关Java classes and object的更多信息

                【讨论】：

                  【解决方案17】：

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

                  Employee e; // e is an object

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

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

                  但是，在某些语言（例如 Java）中，一个对象等同于一个实例，从 Oracle's documentation on Java 中写的那行可以看出：

                  注意：短语“实例化一个类”与“创建一个对象”含义相同。当你创建一个对象时，你是在创建一个类的“实例”，因此是在“实例化”一个类。

                  【讨论】：

                  • 这只是一个看起来很直观但错误的例子。在员工 e 中，e 指向无处且不存在。而理论上，对象是一些超出蓝图（类）存在的真实实体。
                  • @ManishSoni 您所说的是“实例”，除非您在将“对象”和“实例”视为同义词的语言环境中讲话！这就是整个答案所解释的。
                  • 这里的示例具有误导性，它与 Java 语法同义，但没有任何意义。但是，您的答案传达了相同的含义（在概念上是正确的），这就是我所说的“看起来很直观但错误”。
                  • @ManishSoni 该示例不仅仅是 Java 的同义词。如果您查看其他语言（C++、C#、JavaScript 等），其中许多使用 new 运算符和类。不要看这个例子，记住 Java 或任何语言的语法。该示例与语言无关。
                  • "当一个变量声明为自定义类型（类）时，只创建一个引用，称为对象。" :- 你觉得这个说法对吗？引用称为对象？您对答案的详细说明使这一点值得商榷。有一个简洁直接的答案。为什么要复杂化和混淆呢？
                  【解决方案18】：

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

                  【讨论】：

                    【解决方案19】：

                    你需要了解三件事：类、对象和实例。

                    Class : Class 是您将创建对象的蓝图代码

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

                    Instance ：当数据被填充到 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 Operator 从 Animal 类创建了一个 Object。该对象位于您的 RAM 中的某个位置。并且对该对象的引用在“a”中。 此时我们有 1 个对象和 1 个实例。

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

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

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

                    （阅读引用类型在 C# 中的工作原理以了解更多信息。希望您理解我的语言）

                    【讨论】：

                      【解决方案20】：

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

                      首先，你需要了解定义：

                      实例是对象的**唯一复制产品。

                      **独特 - 与对象相比具有不同的特征但共享相同的类

                      Object 是用于保存类信息的名称（即 方法）

                      假设有一个toy_1 作为对象。 还有toy_2 作为对象----> 也是toy_1 的实例。 同时，toy_1 也是toy_2 的一个实例。 （再次记住实例是复制产品）

                      这就是为什么我发现的大多数答案都说它是可互换的。谢谢。

                      【讨论】：

                        【解决方案21】：

                        我认为如果我们考虑 OOP 以外的其他方法（主要是假设并不总是使用术语 Class，因为许多 C 项目就是这种情况，它们仍然应用 的概念>对象），以下定义最有意义：

                        类定义了对象所遵循的接口。

                        对象是不同字段的集合。 （它不必“物理地”存在，但它可以）。

                        同一个类的所有对象都可以以相同的方式使用，由该类定义。

                        Instance 是 Object 的唯一实现。

                        由于许多 OOP 语言使用静态类型，对象描述通常已经是类的一部分。因此，当谈到 C/C++ 中的 Object 时，通常指的是 Object 的 Instance。 在没有静态类型的语言（如 JavaScript）中，对象可以有不同的字段，但仍然共享同一个类。

                        【讨论】：

                          【解决方案22】：

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

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

                          在我看来，对象是内存中的一个通用且活跃的实体，由它所使用的语言指定。就像Java 中的Object 类一样。我们不太关心它的类型，或者与它相关的任何其他内容，无论它是否由容器管理。

                          instance 是object，但与类型相关联，如this method accepts Foo instances 或you can not put Animal instances in an instance of a List of Vehicles。

                          objects 例如有locks 与它们关联，而不是instances，而instances 有方法。 objects 是垃圾收集，而不是 instances。

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

                          【讨论】：

                            【解决方案23】：

                            一个对象是一个泛型的东西，比如在数学中取一个线性函数

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

                            对象

                            一般

                            没有别的了

                            【讨论】：

                              【解决方案24】：

                              一个对象可以是一个类，比如你有一个名为篮球的类。

                              但您想拥有多个篮球，因此在您的代码中创建多个篮球

                              说篮球1和篮球2。 然后你运行你的应用程序。 您现在有 2 个对象篮球实例。

                              【讨论】：

                              • 这意味着对象是类构造函数的实例？
                              • 将对象视为蓝图。说我们有一个篮球蓝图，那就是班级。当篮球被创建并使其现在存在时，这意味着我们有 1 个对象篮球的实例。如果我们从对象（蓝图）构建另一个篮球。我们现在有 2 个篮球实例。总是只有 1 个对象，但我们可以创建该对象的多个实例。
                              • @Darxval 那么什么是类
                              【解决方案25】：

                              Object 指的是类，instance 指的是一个对象。换句话说，instance 是一个包含特定值的对象的副本。

                              【讨论】：

                                猜你喜欢
                                • 1970-01-01
                                • 2012-01-19
                                • 1970-01-01
                                • 2011-04-10
                                • 2012-06-07
                                • 1970-01-01
                                • 1970-01-01
                                • 1970-01-01
                                相关资源
                                最近更新 更多
                                热门标签
                                Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode