精华内容
下载资源
问答
  • Java类和对象 详解(一)

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

    一、面向对象简述

    面向对象是一种现在最为流行的程序设计方法,几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由IBM提出的,在70年代的Smaltalk语言之中进行了应用,后来根据面向对象的设计思路,才形成C++,而由C++产生了Java这门面向对象的编程语言。

    但是在面向对象设计之前,广泛采用的是面向过程,面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主,实现之后就完成了,也不考虑修改的可能性,面向对象,更多的是要进行子模块化的设计,每一个模块都需要单独存在,并且可以被重复利用,所以,面向对象的开发更像是一个具备标准的开发模式。

    在面向对象定义之中,也规定了一些基本的特征:
    (1)封装:保护内部的操作不被破坏;
    (2)继承:在原本的基础之上继续进行扩充;
    (3)多态:在一个指定的范围之内进行概念的转换。

    对于面向对象的开发来讲也分为三个过程:OOA(面向对象分析)、OOD(面向对象设计)、OOP(面向对象编程)。

    二、类与对象的基本概念

    类与对象时整个面向对象中最基础的组成单元。

    :是抽象的概念集合,表示的是一个共性的产物,类之中定义的是属性和行为(方法);
    对象:对象是一种个性的表示,表示一个独立的个体,每个对象拥有自己独立的属性,依靠属性来区分不同对象。

    可以一句话来总结出类和对象的区别:类是对象的模板,对象是类的实例。类只有通过对象才可以使用,而在开发之中应该先产生类,之后再产生对象。类不能直接使用,对象是可以直接使用的。

    三、类与对象的定义和使用

    在Java中定义类,使用关键字class完成。语法如下:

    class 类名称 {
             属性 (变量) ;
             行为 (方法) ;
    }

    范例:定义一个Person类

    class Person {     // 类名称首字母大写
        String name ;
        int age ;
        public void tell() {        // 没有static
              System.out.println("姓名:" + name + ",年龄:" + age) ;
             }
    }

    类定义完成之后,肯定无法直接使用。如果要使用,必须依靠对象,那么由于类属于引用数据类型,所以对象的产生格式(两种格式)如下:

    (1)格式一:声明并实例化对象

    类名称 对象名称 = new 类名称 () ;

    (2)格式二:先声明对象,然后实例化对象:

    类名称 对象名称 = null ;
    对象名称 = new 类名称 () ;

    引用数据类型与基本数据类型最大的不同在于:引用数据类型需要内存的分配和使用。所以,关键字new的主要功能就是分配内存空间,也就是说,只要使用引用数据类型,就要使用关键字new来分配内存空间。

    当一个实例化对象产生之后,可以按照如下的方式进行类的操作:
    对象.属性:表示调用类之中的属性;
    对象.方法():表示调用类之中的方法。

    范例:使用对象操作类

    package com.wz.classandobj;
    
    class Person { 
        String name ;
        int age ;
        public void get() {
            System.out.println("姓名:" + name + ",年龄:" + age);
        }
    }
    
    public class TestDemo {
            public static void main(String args[]) {
                Person per = new Person() ;// 声明并实例化对象
                per.name = "张三" ;//操作属性内容
                per.age = 30 ;//操作属性内容
                per.get() ;//调用类中的get()方法
            }
    }

    运行结果:

    姓名:张三,年龄:30

    以上完成了一个类和对象的操作关系,下面换另外一个操作来观察一下:

    package com.wz.classandobj;
    
    class Person { 
        String name ;
        int age ;
        public void get() {
            System.out.println("姓名:" + name + ",年龄:" + age);
        }
    }
    
    public class TestDemo {
            public static void main(String args[]) {
                Person per = null;//声明对象
                per = new Person() ;//实例化对象
                per.name = "张三" ;//操作属性内容
                per.age = 30 ;//操作属性内容
                per.get() ;//调用类中的get()方法
            }
    }

    运行结果:

    姓名:张三,年龄:30

    那么,问题来了,以上两种不同的实例化方式有什么区别呢?
    我们从内存的角度分析。首先,给出两种内存空间的概念:
    (1)堆内存:保存对象的属性内容。堆内存需要用new关键字来分配空间;
    (2)栈内存:保存的是堆内存的地址(在这里为了分析方便,可以简单理解为栈内存保存的是对象的名字)。

    1

    任何情况下,只要看见关键字new,都表示要分配新的堆内存空间,一旦堆内存空间分配了,里面就会有类中定义的属性,并且属性内容都是其对应数据类型的默认值。

    于是,上面两种对象实例化对象方式内存表示如下:
    这里写图片描述

    两种方式的区别在于①②,第一种声明并实例化的方式实际就是①②组合在一起,而第二种先声明然后实例化是把①和②分步骤来。

    另外,如果使用了没有实例化的对象,结果如何?
    如下:

    package com.wz.classandobj;
    
    class Person { 
        String name ;
        int age ;
        public void get() {
            System.out.println("姓名:" + name + ",年龄:" + age);
        }
    }
    
    public class TestDemo {
            public static void main(String args[]) {
                Person per = null;//声明对象
                //per = new Person() ;//实例化对象
                per.name = "张三" ;//操作属性内容
                per.age = 30 ;//操作属性内容
                per.get() ;//调用类中的get()方法
            }
    }

    运行结果:

    Exception in thread "main" java.lang.NullPointerException
        at com.wz.classandobj.TestDemo.main(TestDemo.java:15)

    此时,程序只声明了Person对象,但并没有实例化Person对象(只有了栈内存,并没有对应的堆内存空间),则程序在编译的时候不会出现任何的错误,但是在执行的时候出现了上面的错误信息。这个错误信息表示的是“NullPointerException(空指向异常)”,这种异常只要是应用数据类型都有可能出现。

    四、对象引用传递初步分析

    引用传递的精髓:同一块堆内存空间,可以同时被多个栈内存所指向,不同的栈可以修改同一块堆内存的内容。

    下面通过若干个程序,以及程序的内存分配图,来进行代码的讲解。

    我们来看一个范例:

    class Person {     
             String name ;
             int age ;
             public void tell() {        
                       System.out.println("姓名:" + name + ",年龄:" + age) ;
             }
    }
    public class TestDemo {
             public static void main(String args[]) {
                       Person per1 = new Person() ;         // 声明并实例化对象
                       per1.name = "张三" ;
                       per1.age = 20 ;
                       Person per2 = per1 ;  // 引用传递
                       per2.name = "李四" ;
                       per1.tell() ;
             }
    }

    对应的内存分配图如下:

    11

    再来看另外一个:

    class Person {
             String name ;
             int age ;
             public void tell() {
                       System.out.println("姓名:" + name + ",年龄:" + age) ;
             }
    }
    public class TestDemo {
             public static void main(String args[]) {
                       Person per1 = new Person() ;         // 声明并实例化对象
                       Person per2 = new Person() ;
                       per1.name = "张三" ;
                       per1.age = 20 ;
                       per2.name = "李四" ;
                       per2.age = 30 ;
                       per2 = per1 ;// 引用传递
                       per2.name = "王五" ;
                       per1.tell() ;
             }
    }

    对应的内存分配图如下:
    12

    垃圾:指的是在程序开发之中没有任何对象所指向的一块堆内存空间,这块空间就成为垃圾,所有的垃圾将等待GC(垃圾收集器)不定期的进行回收与空间的释放。

    未完待续。。。

    展开全文
  • 对象和对象的引用

    千次阅读 多人点赞 2018-06-02 01:41:28
    最近初学java对于对象和对象的引用以及实例化有诸多迷惑,查了很多博客和API,现整理自己的理解如下:Java是一种面向对象的语言,采用类和对象的概念。Java中每个对象都有一种类型,即对象所属的类。类有两个主要...

    最近初学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个)。

    得不到



    展开全文
  • 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     }
    
    展开全文
  • 和对象(一)——类&对象概念及定义

    万次阅读 多人点赞 2018-05-22 00:09:19
    面向对象程序设计(OOP)是一种程序设计的泛型,同时也是一种程序开发的方法,它将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的重用性、灵活性和扩展性二、类和对象的概念1. 类:类是现实世界在...

    c++是基于面向对象的语言,并不是纯面向对象的语言,因为它包含c的部分,c是面向过程的语言

    一、面向对象

    概念:面向对象程序设计(OOP)是一种程序设计的泛型,同时也是一种程序开发的方法,它将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的重用性、灵活性和扩展性

    二、类和对象的概念

    1. 类:类是现实世界在计算机中的反映,它将数据和对这些数据的操作封装在一起(并没有开空间)


    2. 对象:类的实例(占有实际的空间)


    class Student        //类
    {
    public:
    	Student()
    	{}
    
    private:
    	int _num;
    	char* _name;
    	int _age;
    };
    
    int main()
    {
    	Student s;   //对象-> 类的实例
    	system("pause");
    	return 0;
    }

    1)类相当于盖楼房的图纸一样,虽然定义了有哪些成员,但并没有实际的空间

    2)类可以实例化出多个对象,实例化出的对象占有实际空间(用来存储成员变量)


    三、类的三大特性:

    1.封装    2.继承   3.多态

    封装:函数的封装是一种形式,隐藏对象的属性和实现细节(函数内部),仅仅对外提高函数的接口和对象进行交互。

    类的访问限定符可以协助其完成封装


    四、类的三个访问限定符


    1.public:公有的,类的成员可以从类外直接访问

    2.private/protected:类的成员不能从类外直接访问

    3.类的每个访问限定符可以多次在类中使用,作用域为从该限定符开始到下一个限定符之前/类结束

    4.类中如果没有定义限定符,则默认为私有的(private)

    5.类的访问限定符体现了类的封装性


    因为_name是私有的,所以在类外不能使用,而_age,Eat()是公有的,所以在类外可以直接使用


    五、类的定义

    1.定义一个简单的类


    2.类的对象可以直接通过来访问类的公有成员,类的对象指针可以通过->来访问类的公有成员

    class person
    {
    public:
    	void Display()
    	{
    		cout << _name <<"-"<< _age << endl;
    	}
    public:
    	int _age;
    	char* _name;
    };
    
    int main()
    {
    	person p;
    	p._age = 18;
    	p._name = "peter";
    	p.Display();
    
    	person* ptr = &p;
    	ptr->_age = 20;
    	ptr->_name = "jack";
    	ptr->Display();
    
    	system("pause");
    	return 0;
    }

    3.类外定义成员函数,需要使用::(作用域解析符)指明其属于哪个类

    class person
    {
    public:
    	void Display();   //声明
    };
    
    void person::Display()//类外定义
    {
    	//......
    }

    六、类的大小

    类的成员函数放在公共代码区,所有该类的对象共享这些成员函数,每个对象的大小为类内成员变量的大小之和,遵循内存对齐原则


    1.为什么要内存对齐?

    答:为了提高程序的性能,方便cpu访问内存,处理器并不是一个字节一个字节来访问内存,一般是4个字节或8个字节

    2.空类占多少个字节?为什么?

    答:空类占1个字节,占位用,告诉系统我这里定义了一个类,虽然它是空的



    展开全文
  • C++类和对象数组

    万次阅读 多人点赞 2018-05-14 23:47:15
    C++类和对象数组 【1】对象数组 1:对象数组的定义:类名 数组名[元素个数] Eg: student asa[10];//有10个元素的学生类对象数组 2:对象数组的访问形式:数组名[下标].成员名; Eg: asa[j].print(); 3:对象...
  • Java的对象头和对象组成详解

    万次阅读 多人点赞 2018-07-20 10:46:47
    一,对象头 1,Mark Word 2,指向类的指针 3,数组长度 二,实例数据 三,对齐填充字节 Java对象保存在内存中时,由以下三部分组成: 1,对象头 2,实例数据 3,对齐填充字节 一,对象头 java的对象头...
  • Unity3D框架学习_对象池和对象池管理

    千次阅读 2019-04-14 20:41:04
    Unity3D框架学习_对象池和对象池管理 目录 1、博客介绍 2、内容 (1)ObjectPoolContainer 对象容器 (2)ObjectPool 单一对象池 (3)PoolManager 对象池管理 3、推送 4、结语 1、博客介绍 本篇博客介绍...
  • 类图和对象图详解

    万次阅读 多人点赞 2016-11-03 12:34:13
    对于类图和对象图来说我们需要了解的是类图和对象图的概念,类图的组成,使用Rose创建类图和对象图。当然最重要的是如何使用Rose创建类图案例分析。具体的创建通过选课管理系统的简单用例说明创建类图和对象图的方法...
  • java中map和对象互转工具类

    万次阅读 多人点赞 2019-01-05 13:33:41
    在项目开发中,经常碰到map转实体对象或者对象转map的场景,工作中,很多时候我们可能比较喜欢使用第三方jar包的API对他们进行转化,而且用起来也还算方便,比如像fastJson就可以轻松实现map和对象的互转,但这里,...
  • python中的类和对象,属性和方法

    万次阅读 多人点赞 2018-04-26 13:18:30
    一、面向对象的概述面向对象是一种描述业务问题、设计业务实体和实体之间关系的方法二、类和对象1、类和对象得区别:类是对客观世界中事物得抽象,而对象是类实例化后的实体 例如:汽车模型就是一个类,制造出来的...
  • 对象实例数据和对象类型数据

    千次阅读 多人点赞 2019-07-30 16:32:29
    对象类型:对象中各个实例字段的数据 对象类型数据:对象的类型、父类、实现的接口、方法等
  • 对象的引用和对象的指针 (常指针与常引用)const 左定值,右定向,修饰不变参
  • JAVA 类和对象的实例

    万次阅读 多人点赞 2019-01-15 11:01:23
    JAVA 类和对象的实例 什么是类? 1. 类是具有相同的属性和功能的事物的抽象的集合,在面向对象程序设计中,人们把一类事物的静态属性和动态可以执行的操作组合在一起就得到类这个概念。 2. 类是个抽象的概念,用来...
  • 1、将对象转换为JSON格式字符串 JSON.stringify(object) 2、将JSON字符串转换为对象 JSON.parse(jsonString); 更多技术请关注QQ群:636212586
  • 类锁和对象锁的详解

    万次阅读 多人点赞 2017-12-10 15:18:42
    最近在面试中遇到很多关于多线程的问题,特别是锁的应用,现在我就来说说类锁和对象锁。 对象锁(synchronized method{})和类锁(static sychronized method{})的区别 对象锁也叫实例锁,对应synchronized关键字...
  • Java中类和对象的概念

    万次阅读 多人点赞 2018-06-01 23:50:23
    首先说说类和对象。今天心情不错,来复习复习Java基础:类和对象。Java是什么?Java是一门面向对象的编程语言(OOP),想要理解Java,首先要理解类(Class)和对象(Object)这两个概念。Java中的类可以看成C语言的...
  • vue循环 数组对象 对象

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

    万次阅读 2013-03-08 17:24:58
    笔试题之三:类和对象的区别 类是对象的抽象,对象是类的具体实例。 类是抽象的,不占用内存,而对象是具体的,占有内存空间。 例如:类就是水果,对象就是苹果。 继承与多态 多态性指用一个名字定义不同的...
  • javascript如何获取数组和对象的值

    千次阅读 2018-12-21 17:55:30
    JavaScript只有一种数据类型可以包含多个值:...数组和对象都有一个key -&gt; value结构。但是数组中的键必须是数字,而任何字符串都可以用作对象中的键。键值对也称为“属性”。 可以使用点表示法访问对象属性...
  • 7.1 理解类和对象 7.1.1 对象 现实世界中的所有具体的事物都可以视为对象 Java中万物皆对象
  • 和对象举例

    千次阅读 2019-03-05 14:11:28
    以狗为例,狗本身是一个对象 它属于动物类,动物类这个东西不存在,而狗这个物体存在,所以对象就是类的实体化,对象就是类的抽象化,类描述一类对象的行为状态。举几个例子 人是一个类 具体的某个人就是对象 他的...
  • ElasticSearch中存入JSON对象和对象数组

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

    千次阅读 2019-04-01 16:25:42
    类:类是封装对象的属性行为的载体,在Java语言中对象的属性以成员变量的形式存在,而对象的方法以成员方法的形式存在。 对象:Java是面向对象的程序设计语言,对象是由类抽象出来的,所有的问题都是通过对象来...
  • Python中的类的定义和对象的创建

    万次阅读 多人点赞 2018-08-16 17:35:59
    面向对象中两个重要的概念: 1.类 :对一类事物的描述,是抽象的、概念上的定义。...1.创建类创建类对象 1.创建类,类主要由类名,属性,方法组成,当然创建一个类时,属性方法可以选择的。 cla...
  • 工作中遇到一个问题就是要动态给数组是对象中添加或者删除某个数组,,本来想用for循环的但是这样就会有一个bug就是每次都会添加,,最后只能使用indexOF  var a =[{"name":"1111"},{"name...把数组和对象全转成strin
  • 面向对象的概念应用已超越了程序设计软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解抽象的方法,是...
  • js----map和对象的区别

    千次阅读 2019-01-24 17:30:10
    js 中 map 和对象都是键值对的集合, 区别在于对象的 key值全部自动转成了字符串或者symbol值 而map 是完整的值-值  
  • 为了能够更好的解释类属性和对象属性的区别,先创建类People和两个对象student1和student2如下: class People(object):  # 类属性是指定义在类的内部而且在方法的外部的属性  money = 10000  def __init__...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,071,482
精华内容 2,828,592
关键字:

和对象的