精华内容
下载资源
问答
  • 对象和对象
    万次阅读 多人点赞
    2018-06-02 01:41:28

    最近初学java对于对象和对象的引用以及实例化有诸多迷惑,查了很多博客和API,现整理自己的理解如下:

    Java是一种面向对象的语言,采用类和对象的概念。Java中每个对象都有一种类型,即对象所属的类。类有两个主要成员:域(field)和方法(method)。

    1. 域是与一个类或该类的对象相关联的数据的变量。域中存储初值或执行类的方法得到的计算结果。
    2. 方法包含该类的可执行代码。方法由语句构成。方法被调用的方式,以及这些方法所包含的语句最终指导程序的执行。

    对象以及对象的引用

    关键字new用来创建对象。从一个类中创建用一个对象被称为实例化,所以,对象也常被称为实例。

    Java中新创建的对象被放在被称为“堆”的系统存储区中。Java中的对象都通过“对象引用”(object reference)来访问。一个类的变量持有一个对象,实际上是对该对象的引用。当变量不再引用任何对象时,该对象引用就为null。而我们说的把对象传给一个方法实际上是把对象的引用传给一个方法(参考C++中指针的概念)。但是多数情况下,对象和对象引用的区别都被大家忽略。而这又恰恰是理解对象的关键。

    现在这里有一个类:

    class Point{
        public static void main(String[] args){
        System.out.println("hello");
    }

    对于Point类我们创建对象的通常语句为:

    Point point=new Point();

    通常大家以为point即为所创建的类,其实并不是这样,实际上point是我们创建的对象的引用。这个语句可以分解为两部分来看:

    Point point;//①
    point=new Point();//②

    Point是这里自定义的一个类型,即类类型。

    在语句①中经由Point声明了一个类类型的变量point,是Point类引用变量,它存放在栈空间中。也就是用来指向Point的对象的对象引用。但是此时point不是任何对象的引用,其指向为null,因为对象要在语句②中才创建。

    在语句②中由关键字new创建了一个Point的对象,并将之存放在堆中,然后利用操作符“="使得point引用变量指向刚刚创建的在堆中的对象。

    对象本身看不见摸不着,它是堆中的一块内存实体,甚至说对象本身没有名字。Point不是对象,因为一个类可以创建n个对象不可能每一个都叫做Point,point也不是对象它是Point定义的一个变量,经由语句②它成为了对象的引用。有了对象的引用,就可以方便的调用方法等操作。

    对象和对象引用的关系

    ”但是此时point不是任何对象的引用,其指向为null“上一部分我们讲到对象的引用可以指向null。它真正的含义是:

    一个对象的引用可以:指向一个具体的已经创建的对象或者指向null。即对象的引用只有唯一的指向,不能同时指向多个对象,这一点也很好理解,借用指针的概念,一个指针某一时刻只能指向唯一的内存块代表唯一的内存地址。既然point这个引用变量可以被”赋值“操作,那么自然的如果Point类此时通过”point2=new Point();"又创建了一个新的对象2,我们可以有:

    point=point2;

    这样point就成了对象2的引用,对象1和对象2为堆中的不同的内存块。但是point2此时仍旧是对象2的引用,即对象2有两个引用变量指向它。如果把气球比作对象的话,系气球的绳子比作对象的引用,那么对象2这个气球上面系了两个绳子。显然最初创建的对象1上面没有任何绳子系在上面,也就是说它没有“对象引用”,对于这样的对象就要面临被废区收集器(garbage collection)自动回收,从而在堆中消除。但是并不是立即消除,系统会判断在一个合适的时候回收。

    总结起来:对象的引用某一时刻只可以有唯一指向(或null),对象本身可以同时被多个引用变量引用(或0个)。

    得不到



    更多相关内容
  • ElasticSearch中存入JSON对象和对象数组

    万次阅读 2019-01-16 16:29:09
    存入JSON对象 在现实中我们常常会遇到各种复杂对象,比如: { "region": "ZH-CN", "manager": { "age": 30, "name": { "first": "John&...

    存入JSON对象

    在现实中我们常常会遇到各种复杂对象,比如:

    { 
      "region": "ZH-CN",
      "manager": { 
        "age":     30,
        "name": { 
          "first": "John",
          "last":  "Smith"
        }
      }
    }
    

    实际上,我们在ES内部是用K-V的形式存储的,所以在内部其实是这样存储的:
    实际上这有点像properties的格式。

    {
      "region":             "US",
      "manager.age":        30,
      "manager.name.first": "John",
      "manager.name.last":  "Smith"
    }
    

    在Mapping的内部是这样存储的:

    {
      "mappings": {
        "my_type": { 
          "properties": {
            "region": {
              "type": "keyword"
            },
            "manager": { 
              "properties": {
                "age":  { "type": "integer" },
                "name": { 
                  "properties": {
                    "first": { "type": "text" },
                    "last":  { "type": "text" }
                  }
                }
              }
            }
          }
        }
      }
    }
    

    存入JSON对象数组

    假如有以下JSON对象

    {
      "group" : "fans",
      "user" : [ 
        {
          "first" : "John",
          "last" :  "Smith"
        },
        {
          "first" : "Alice",
          "last" :  "White"
        }
      ]
    }
    

    this is a typical json object array
    在ES中这个JSON对象数组将会被解析成如下:

    {
      "group" :        "fans",
      "user.first" : [ "alice", "john" ],
      "user.last" :  [ "smith", "white" ]
    }
    
    展开全文
  • C++类和对象的使用之对象指针

    万次阅读 多人点赞 2019-07-04 21:38:07
    和对象的使用之对象指针 对象指针的一般概念 对象指针:指向类的成员的指针。在C++中,可以说明指向类的数据成员成员函数的指针。 对象指针遵循一般变量指针的各种规则:类名 *对象指针名; 对象指针名*成员名;...

    类和对象的使用之对象指针

    对象指针的一般概念

    对象指针:指向类的成员的指针。在C++中,可以说明指向类的数据成员和成员函数的指针。
    对象指针遵循一般变量指针的各种规则:类名 *对象指针名;
    对象指针名*成员名;
    对象指针在使用之前,也一定要先进行初始化,让它指向一个已经声明过的对象,然后再使用。通过对象指针,可以访问到所指向对象的公有成员。

    指向对像的指针

    在建立对像时,编译系统会为每一个对像分配一定的存储空间,以存放其成员,对像空间的起始地址就是
    对像的指针。可以定义一个指针变量,用来存和对像的指针。如果有一个类:

    class Time
    {
       public:
     int hour;
            int minute;
            int sec;
            void get_time();
    };
    void Time::get_time()
    {
       cout << hour << ":" << minute << ":" << sec << endl;
    }
    

    在此有以下语句:

    Time *pt;//定义pt 为指向Time类对像的指针变量
    Time t1;//定义t1为Time类对像
    pt=&t1;//将t1的起始地址赋给pt
    

    这样,pt 就是指向Time类对象的指针变量,它指向对象t1。
    定义指向类对象的指针变量的一般形式为:

    类名 *对象指针名;
    

    可以通过对象指针访问对象和对象的成员。如:

    *pt       pt所指向的对像,即t1
    (*pt).hour      pt所指向的对象中的hour成员,即t1.hour
    pt->get_time()  pt把指向的对象中的get_time函数,即t1.get_time()
    (*pt).get_time()
    

    指向对象成员的指针

    a.指向对象数据成员的指针

    定义指向对象数据成员的指针的方法与定主指向变通的指针变量的方法相同。如:

    int *p;
    

    定义指向对象数据成员的指针变量的一般形式为:

    数据类型名 *指针变量名;
    

    b.指向对象成员函数的指针

    定义指向对象成员函数的指针变量的方法和定义指向变通函数的指针变量方法有所不同。
    定义指向变通函数的指针变量的方法:

    数据类型名  (*指针变量名)();如:
    void (*p)();//p是指向void型函的指针变量
    

    定义指向成员函的指针:

    数据类型名 (类名::*指针变量名)();
    使指针变量指向一个公用成员函数的一般形式为
    指针变量名=&类名::成员函数名;
    

    示例:

     1 #include <iostream>
     2 using namespace std;
     3 class Time
     4 {
     5  public:
     6   Time(int ,int ,int );
     7   int hour;
     8   int minute;
     9   int sec;
    10   void get_time();
    11 };
    12 Time::Time(int h,int m,int s)
    13 {
    14  hour = h;
    15  minute= m;
    16  sec = s;
    17 }
    18 void Time::get_time()
    19 {
    20  cout << hour << ":" << minute << ":" << sec << endl;
    21 }
    22 
    23 int main()
    24 {
    25  Time t1(10,13,56); //定义Time类对象t1
    26  int *p1=&t1.hour;//定义指向整型数据的指针变量p1,并使p1指向t1.hour
    27  cout << *p1 << endl;
    28  t1.get_time();//调用对象t1的成员函数get_time()
    29 
    30  Time *p2=&t1;//定义指向Time类对象的指针变量p2,并使p2指向t1
    31  p2->get_time();//调用p2所指向对象的get_time()函数
    32  void (Time::*p3)();//定义指向Time类公用成员函数get_time
    33  p3 = &Time::get_time;//使p3指向Time类公用成员函数get_time
    34  (t1.*p3)();//调用对象t1中p3所指的成员函数
    35 
    36  return 0;
    37 }
    

    4、指向类的非静态成员的指针(非指向对象,而是指向对象成员)

    指向对象成员的指针使用前也要先声明,再赋值,然后引用,因此首先要声明指向该对象所在类的成员的指针。注意,通过指向成员的指针也只能访问到公有成员。
    语法形式:

                 类型说明符   类名::*指针名;          //声明指向公有数据成员的指针
                 类型说明符   (类名::*指针名)(参数表);//声明指向公有函数成员的指针
    

    对数据成员指针赋值:

    指针名 = &类名::数据成员;
    

    此时还不能通过指针访问变量。类的声明只确定了各个数据成员的类型、所占内存大小以及它们的相对位置,在声明时并不为数据成员分配具体的地址。因此经上述赋值之后,只是说明了被赋值的成员指针式专门用于指向哪个数据成员的,同时在指针中存放该数据成员在类中的相对位置,当然通过这样的指针现在并不能访问什么。
    由于类是通过对象而实例化的,在声明类的对象时才会为具体的对象分配内存空间,这时只要将对象在内存中的起始地址与成员指针中存放的相对偏移结合起来就可以访问到对象的数据成员了。

    语法形式:对象名.*类成员指针名
        或          对象指针名à*类成员指针名
       成员函数指针赋值:
                      指针名 = 类名::函数成员名;
       经过上述对成员函数指针赋值之后,还不能用指针直接调用成员函数,而是需要首先声明类的对象,因为必须要通过对象来调用非静态成员函数。
       利用指针调用成员函数:
                      (对象名.*类成员指针名)(参数表)
     或      (对象指针名à*类成员指针名)(参数表)
    

    5、指向类的静态成员的指针

       类的静态成员可以用普通的指针来指向和访问。/**形式上把静态成员看成普通变量就可以**/
    

    对象指针:在C++中,可以说明指向类的数据成员和成员函数的指针。

    1. 对象指针作函数的参数

    使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处:

    1. 实现传址调用。可在被调用函数中改变调用函数的参数对象的值,实现函数之间的信息传递。

    2. 使用对象指针实参仅将对象的地址值传给形参,而不进行副本的拷贝,这样可以提高运行效率,减少时空开销。

    当形参是指向对象指针时,调用函数的对应实参应该是某个对象的地址值,一般使用&后加对象名。 下面举一例子说明对象指针作函数参数。

     1 #include <iostream.h>
     2     class M
     3     {
     4     public:
     5         M() { x=y=0; }
     6         M(int i, int j) { x=i; y=j; }
     7         void copy(M *m);
     8         void setxy(int i, int j) { x=i; y=j; }
     9         void print() { cout<<x<<","<<y<<endl; }
    10     private:
    11         int x, y;
    12     };
    13 
    14     void M::copy(M *m)
    15     {
    16     x=m->x;
    17     y=m->y;
    18     }
    19 
    20     void fun(M m1, M *m2);
    21     void main()
    22     {
    23     M p(5, 7), q;
    24     q.copy(&p);
    25     fun(p, &q);
    26     p.print();
    27     q.print();
    28     }
    29 
    30     void fun(M m1, M *m2)
    31     {
    32     m1.setxy(12, 15);
    33     m2->setxy(22,25);
    34     }
    35 
    36     输出结果为:
    37     5,7
    38     22,25
    

    从输出结果可以看出,当在被调用函数fun中,改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2->setxy(22, 25)]以后,可以看到只有指向对象指针作参数所指向的对象被改变了,而另一个对象作参数,形参对象值改变了,可实参对象值并没有改变。因此输出上述结果。

    2. 对象引用作函数参数

    在实际中,使用对象引用作函数参数要比使用对象指针作函数更普遍,这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点,而用对象引用作函数参数将更简单,更直接。所以,在C++编程中,人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。

     1 #include <iostream.h>
     2     class M
     3     {
     4     public:
     5         M() { x=y=0; }
     6         M(int i, int j) { x=i; y=j; }
     7         void copy(M &m);
     8         void setxy(int i, int j) { x=i; y=j; }
     9         void print() {cout<<x<<","<<y<<endl; }
    10     private:
    11         int x, y;
    12     };
    13 
    14     void M::copy(M &m)
    15     {
    16         x=m.x;
    17         x=m.y;
    18     }
    19 
    20     void fun(M m1, M &m2);
    21 
    22     void main()
    23     {
    24         M p(5, 7), q;
    25         q.copy(p);
    26         fun(p, q);
    27         p.print();
    28         q.print();
    29     }
    30 
    31     void fun(M m1, M &m2)
    32     {
    33         m1.setxy(12, 15);
    34         m2.setxy(22, 25);
    35     }
    

    该例子与上面的例子输出相同的结果,只是调用时的参数不一样。

    3.this指针

    this指针是一个隐含于每一个类的成员函数中的特殊指针,它用于指向正在被成员函数操作的对象。实际过程是,当通过一个对象调用成员函数时,系统先将该对象的地址赋给this指针,然后调用成员函数,成员函数对对象的数据成员进行操作时,就隐含使用了this指针。/难怪:在成员函数之外无法访问数据成员,找不到对象呀!(当然中间的private,protected另作谈论/

    当对一个对象调用成员函数时,编译程序先将对象的地址赋给this指针,然后调用成员函数,每次成员函数存取数据成员时,由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。

     1 #include <iostream.h>
     2     class A
     3     {
     4     public:
     5     A() { a=b=0; }
     6     A(int i, int j) { a=i; b=j; }
     7     void copy(A &aa);    //对象引用作函数参数
     8     void print() {cout<<a<<","<<b<<endl; }
     9     private:
    10     int a, b;
    11     };
    12 
    13     void A::copy(A &aa)
    14     {
    15     if (this == &aa) return;    //这个this是操作该成员函数的对象的地址,在这里是对象a1的地址
    16     *this = aa;    //*this是操作该成员函数的对象,在这里是对象a1。
    17             //此语句是对象aa赋给a1,也就是aa具有的数据成员的值赋给a1的数据成员
    18     }
    19 
    20     void main()
    21     {
    22     A a1, a2(3, 4);
    23     a1.copy(a2);
    24     a1.print();
    25     }
    
    展开全文
  • vue循环 数组对象 对象

    万次阅读 2017-12-14 15:47:51
    在标签中v-for循环 1.循环数组对象列表(一般后台返回的形式) 2.循环对象(3个参数【有序】:value,key,index)

    一、在标签中v-for循环

    1.循环数组对象列表(一般后台返回的形式)

     


    2.循环对象(3个参数【有序】:value,key,index)




    二、在js中循环

    遍历数组对象(其实这是es6语法)

    for (leti ofthis.optWithdrawList){
        console.log(i.entrustNo) }


    展开全文
  • 基于对象和面向对象的区别

    千次阅读 多人点赞 2018-12-06 16:18:30
    通常“基于对象”是使用对象,但是无法利用现有的对象模板产生新的对象类型,继而产生新的对象,也就是说“基于对象”没有继承的特点。而“多态”表示为父类类型的子类对象实例,没有了继承的概念也就无从谈论“多态...
  • 添加核心代码如下: this.data.push...i 全部代码如下: ============================32、在Vue项目中实现动态添加或者删除对象和对象数组============================ 效果图如下: 更多技术请关注QQ群:636212586
  • C++类对象和类指针的区别

    万次阅读 多人点赞 2019-04-17 20:57:28
    一篇转载率较高的帖子:C++ 类对象和 指针的区别 大佬都不贴结果。。。。所以这里我给出代码和结果: #include<iostream> using namespace std; class Test{ public: int a; Test(){ a = 1; } }; ...
  • 基本类型的包装类对象使用 == equals进行比较的结果 1、值不同,使用==equals比较都返回false 2、值相同 使用==比较: 基本类型-基本类型、基本类型-包装对象返回true 包装对象-包装对象返回...
  • Java 判断对象对象中属性是否为空

    万次阅读 2019-09-18 09:08:37
    import java.lang.reflect.Field; /** * Created by hj. */ public class VoUtilsTool { ... * @return 如果对象不为空,且没有空值。返回false,对象为空或者有空值,返回true * */ public...
  • 数组和对象的区别总结

    万次阅读 2018-06-27 15:04:21
    1、创建方法:2、对象没有长度3、调用方法不同4、因为没有长度。所以对象没有for 循环5、对象键值唯一,数组可以重复6、都可以用for in 循环
  • 对于刚接触不久面向对象的真小白童鞋来说,类的对象对象的实例,对象的引用,引用变量的问题以及莫过于没得对象虽然博主也没得对象,本文将逐个逐个讲解! 1.何谓对象? 在Java中有一句比较流行的话,叫做“万物皆...
  • 面向过程面向对象区别

    万次阅读 2022-05-13 15:47:30
    面向对象:程序设计的重点是把构成问题的事物分解成对象,从局部着手,通过迭代的方式逐步构建出整个程序,是一种以数据为核心,以类设计为主的自下而上的程序设计方法。 (2)从适用范围来看。 面向过程:由于不...
  • Java中对象的赋值与引用

    万次阅读 多人点赞 2017-07-28 19:52:34
    Java中对象的赋值与引用详解
  • Java类和对象 详解(一)

    万次阅读 多人点赞 2016-10-06 20:48:02
    一、面向对象简述面向对象是一种现在最为流行的程序设计方法,几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由IBM提出的,在70年代的Smaltalk语言之中进行了应用,后来根据面向对象的设计...
  • 对象实例数据和对象类型数据

    千次阅读 多人点赞 2019-07-30 16:32:29
    对象类型:对象中各个实例字段的数据 对象类型数据:对象的类型、父类、实现的接口、方法等
  • 什么是面向对象

    万次阅读 多人点赞 2019-09-09 16:54:50
    面向对象(OOP)概述 从我们开始接触Java这门语言后,就有人告诉我们这是一门面向对象的语言。说的最多的是new个对象,其实并不知道什么是对象。以为对象就是一个class(类),并不觉得有什么特殊。直到很久之后,...
  • Session对象和Application对象都是计算机的存储系统。 1、作用不同 session对象用于存储特定的用户DAO会话所需的信息 。 Session对象的引入是为了弥补HTTP协议的不足,HTTP协议是一种无状态的协议。 application是...
  • 面向对象 面向过程 的区别

    万次阅读 2022-03-28 15:02:53
    一、面向对象与面向过程的区别 面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了;面向对象是把构成问题事务分解成各个对象,建立对象的目的不是...
  • //json字符串-简单对象 String jsonStr = "{\"studentName\":\"张三\",\"studentAge\":18}"; //json字符串-数组类型 String jsonArrStr = "[{\"studentName\":\"张三\",\"studentAge\":18},{\"studentName\":\"李四\...
  • Python中的可变对象和不可变对象

    千次阅读 2017-12-11 10:25:31
    Python在heap中分配的对象分成两类:可变对象和不可变对象。所谓可变对象是指,对象的内容是可变的,例如list。而不可变的对象则相反,表示其内容不可变。不可变对象:int,string,float,tuple 可变对象 :l
  • 初学JavaScript的时候总是分不清什么是本地对象、内置对象和宿主对象,现在写一篇博客来记录一下。一、本地对象ECMA-262把本地对象(native object)定义为:独立于宿主环境的ECMAScript实现的对象。 这里简单说...
  • Vue 比较两个对象里的值是否相同

    千次阅读 2020-09-10 19:47:00
    JSON.stringify一下,把对象转化为字符串 let r = JSON.stringify(this.RightDetail); let l = JSON.stringify(this.LeftDetail); console.log(r == l) if(r == l){ this.$Message.warning("配货明细,必须修改!...
  • 面向对象编程(Object Oriented Programming,OOP,面向对象程序设计)的主要思想是把构成问题的各个事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙一个事物在整个解决问题的步骤中的行为。...
  • jquery对象和js对象的相互转换

    万次阅读 2018-07-06 11:02:50
    两种转换方式将一个jQuery对象转换成js对象:[index].get(index); (1)jQuery对象是一个数据对象,可以通过[index]的方法,来得到相应的js对象。 如:var $v =$("#v") ; //jQuery对象 var v=$v[0]; //...
  • js中获取对象的属性名

    万次阅读 2019-11-12 16:45:56
    dataObj = { name : "gao", age : 26 }; for(var d in dataObj) { var d; // 属性名name var dataObj[d]; //属性值gao }
  • Java之路:对象的声明使用

    千次阅读 多人点赞 2018-12-03 21:42:53
    一、对象的声明 下面定义了由类产生对象的基本形式: 类名 对象名 = new 类名(); 创建属于某类的对象,需要通过下面两个步骤实现: ⑴ 声明指向“由类所创建的对象”的变量。 ⑵ 利用new创建新的对象,并指派给先前...
  • JVM快速找出耗内存大对象

    千次阅读 2019-07-01 17:42:16
    当我们的java应用运行时,突然出现内存占用暴增,说明系统中存在长期占用的对象无法回收,或者出现巨大的对象如何快速定位产生的大对象是什么? 找到耗内存的进程 top命令查看你的应用对应的进程ID 1、输入top命令 ...
  • 如何实现面向对象

    千次阅读 2022-05-05 15:48:09
    如何实现面向对象面向对象的定义面向对象的三大特征、面向对象的基础实现面向对象基本准则实例 ...封装:在面向对象中,对数据动作进行包装,其中的某些数据动作,可以是私有的,不能被外界访问,以此来实现对数
  • Spring是使用反射创建的对象,而且可以指定对象的生命周期, beanan生命周期 scope控制bean的生命周期,scope的取值有5种取值: 在Spring 2.0之前,有singletonprototype两种; 在Spring 2.0之后增加另外三种:...
  • 面向对象的概念应用已超越了程序设计软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解抽象的方法,是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,891,308
精华内容 4,356,523
关键字:

对象和对象