精华内容
下载资源
问答
  • 类对象是什么,对象又是什么,他们之间有什么区别。不是问什么是什么是对象!!
  • 类对象是将具有相似属性和方法的对象总结抽象为类对象,可以定义相似的一些属性和方法,不同的实例对象去引用类对象的属性和方法,能减少代码的重复率。 实例对象又称实例化对象,不是抽象而是一类对象中具体的一例...

    Y14


    一、类对象和实例对象
    简短理论:

    1. 类对象是将具有相似属性和方法的对象总结抽象为类对象,可以定义相似的一些属性和方法,不同的实例对象去引用类对象的属性和方法,能减少代码的重复率。
    2. 实例对象又称实例化对象,不是抽象而是一类对象中具体的一例对象。

    比喻理解:
      我相信有的人觉得有点绕,在这里我以比喻说明,希望你能明白。首先,要明白,在python中,“万物皆对象”。个人理解:

      类对象,好比有一篮“水果”,篮子里面的水果没有重复,那么这一篮中的“水果”就属于一个类,是抽象的,就像有人对你说“给我水果”,你的第一反应一定是“什么水果?”,所以是不确定性的。

      实例对象,好比篮子里面的“苹果”,是一个具体的对象,即一个实例。我想有人对你说“给我苹果”,你应该不会想选择哪个水果吧


    二、类变量和实例变量
    简短理论:

    1. 类变量:可在类的所有实例之间共享的值(也就是说,它们不是单独分配给每个实例的)。
    2. 实例变量:实例化之后,每个实例单独拥有的变量。实例变量:实例化之后,每个实例单独拥有的变量。

    比喻理解:
      其实,如果你理解了类对象和实例对象,在看过类变量和实例变量的理论,应该就能明白区别。

      类变量,接上面一篮水果比喻,好比是说“洗洗水果”(洗这个新加的动作就是你定义的一个类变量),你肯定是篮子里面的所有水果都会洗。也就是所有的水果都共享了“洗”这个新加的动作。即“类变量的值,实例可以共享”

      实例变量,这个简单,好比说“洗洗苹果”,这个洗的动作是有针对性的,是作用于一个苹果(实例)。即为“实例化后,每个实例单独拥有的变量”


    大家需要注意,以上问题也是python中常见面试题,若需代码理解,推荐:https://www.cnblogs.com/loleina/p/5409084.html ,愿你理解。

    个人小结,定有不足之处,欢迎指点。
    谢谢~

    展开全文
  • C++类对象指针的区别

    万次阅读 多人点赞 2019-04-17 20:57:28
    一篇转载率较高的帖子:C++ 类对象和 指针的区别 大佬都不贴结果。。。。所以这里我给出代码和结果: #include<iostream> using namespace std; class Test{ public: int a; Test(){ a = 1; } }; ...

    好奇这个,所以参考了一些帖子,写下心得。


    一篇转载率较高的帖子:C++ 类对象和 指针的区别

    大佬都不贴结果。。。。所以这里我给出代码和结果:

    #include<iostream>
    using namespace std;
    
    class Test{
    public:
        int a;
        Test(){
            a = 1;
        }
    };
     
    int main()
    {
        Test* t1 = new Test();
        t1->a = 10;
        
        Test* t2 = new Test();
        t2->a = 5;
        
        cout << "&t1:" << t1 << " a = " << t1->a << endl;
        cout << "&t2:" << t2 <<  " a = " << t2->a <<endl;
        
        cout << "------------------------------" << endl;
        t2 = t1;
        cout << "&t1:" << t1 << " a = " << t1->a << endl;
        cout << "&t2:" << t2 <<  " a = " << t2->a <<endl;
        
        cout << "------------------------------" << endl;
        
        t1->a = 111;
        t2->a = 222;
        cout << "&t1:" << t1 << " a = " << t1->a << endl;
        cout << "&t2:" << t2 <<  " a = " << t2->a <<endl;
        
        return 0;
    }
    

    结果:

    说明类指针和变量指针一样,指针赋值以后改动的就是地址了

    #include <iostream>
    using namespace std;
    class Test{
    public:
        int a;
        Test(){
            a = 1;
        }
    };
    int main()
    {
        Test t1;
        t1.a = 10;
        
        Test t2;
        t2.a = 5;
        
        cout << "&t1:" << &t1 << " a = " << t1.a << endl;
        cout << "&t2:" << &t2 <<  " a = " << t2.a <<endl;
        
        cout << "------------------------------" << endl;
        t2 = t1;
        cout << "&t1:" << &t1 << " a = " << t1.a << endl;
        cout << "&t2:" << &t2 <<  " a = " << t2.a <<endl;
        
        cout << "------------------------------" << endl;
        
        t1.a = 111;
        t2.a = 222;
        cout << "&t1:" << &t1 << " a = " << t1.a << endl;
        cout << "&t2:" << &t2 <<  " a = " << t2.a <<endl;
        
        return 0;
    }
    

    说明类对象和c++中的普通变量一样,赋值就是对值进行改动,对地址没有改动


    类的指针:他是一个内存地址值,他指向内存中存放的类对象(包括一些成员变量所赋的值).   
    对象:他是利用类的构造函数在内存中分配一块内存(包括一些成员变量所赋的值).   

    指针变量是间接访问,但可实现多态(通过父类指针可调用子类对象),并且没有调用构造函数。 
    直接声明可直接访问,但不能实现多态,声明即调用了构造函数(已分配了内存)。 

    类的对象:用的是内存栈,是个局部的临时变量.   
    类的指针:用的是内存堆,是个永久变量,除非你释放它.  

     

    在应用时:   
            1.引用成员:   对象用"   .   "操作符;   指针用"   ->   "操作符.   
            2.生命期:     若是成员变量,则是类的析构函数来释放空间;若是函数中的临时变量,则作用域是该函数体内.而指针,则需利用delete   在相应的地方释放分配的内存块.   
            注意:用new   ,一定要delete.. 

    看来类指针也是需要delete的?

     

    C++的精髓之一就是多态性,只有指针或者引用可以达到多态对象不行
    类指针的优点: 
    第一实现多态。 
    第二,在函数调用,传指针参数。不管你的对象或结构参数多么庞大,你用指针,传过去的就是4个字节。如果用对象,参数传递占用的资源就太大了


    趁热打铁再来一个博客:解析C++普通局部变量与指针类型的对象变量的应用区别

    首先我们先来了解一下MFC中的CPtrArray类,他可以说是CObject类型指针对象的集合。通过int Add(CObject* newElement );注意参数是一个指针类型)可以向集合中添加元素。首先我们定义一个CPtrArray类型的对象。

    CPtrArray pArray;//他是一个全局对象

    先设定一个举例的类类型。如:

    class A
    {
    public:
        A(int i)
        {
            a = i;
        }
        ~A(){}
    public:
        int a;
    };

    现在我们需要在某个函数中要实现将一个A类型对象数据加入到一个CPtrArray对象中。此函数func1()如下:

    void func1()
    {
        //首先定义一个A类型的对象
        A a(1);
        //使用pArray对象中的成员函数将此对象加入到容器中
        pArray.Add(&a);
    }

    另一个函数中我们使用pArray容器为我们保存的数据:

    void func2()
    {
        //首先声明一个A类型的对象
        A* a;
        //使用pArray对象中的成员函数GetAt()将A类型的对象取出
        for(int i; i < pArray.GetSize();i++)
        {
            a = (A*)pArray.GetAt(i);
            //使用A中的数据进行相关的操作代码。***此时也可以使用delete释放指针指向的内存区块,防止内存泄露***当然是后面一种方法时才用到,暂时无视之。
            ...
        }
         
    }

    现在我们发现按照上面的过程,当我们在func2()函数中将要使用pArray容器对象为我们保存的数据时,我们并不能得到想要的数据!!!为什么发生以上情况?图解如下

    pArray保存a保存资源的地址;

    func1函数执行完成,a发生析构,资源不可用;

    原来在func1()函数中,a对象是一个局部对象,当我们使用pArray.Add(&a);我们将a对象的地址保存到pArray对象中。但是作为局部对象,当func1

    执行完成后,资源需要回收,此时我们定义的a对象也在A类中的析构函数中被析构释放资源!而当我们在fun2()函数中执行取出保存的对象时,

    实际是根据保存的地址去内存中找到数据,虽然此时我们能能够找到此地址,但是这个地址上面的数据并不是我们需要的了!!!所以才发生面的情况!

    那么怎么才能解决呢?

    看下面,我们只需更改func1函数中的代码:

    void func1()
    {
        //首先定义一个A类型的对象
        //A a(1);//为对比,只是注释原来那句
        A* a = new A(1);
        //使用pArray对象中的成员函数将此对象加入到容器中
        pArray.Add(a);
    }

    这样,我们就能够在func2函数中使用pArray对象中包含的数据了!那么为什么定义了一个指针类型的对象就能够完成了呢?还是一个局部对象呀,

    前面说的func1函数执行完成后此对象还是要经历析构的啊!图解如下:

    pArray中保存a指向资源的地址;

    func1函数执行完成,a对象发生析构,pArray根据地址还能能够访问到之前的资源;

    对,是要析构,但是,我们在pArray.Add(a);中加入的是a对象资源的地址,我们先看看A* a = new A(1);在堆中分配资源,我们知道,在堆中分配的资

    源是在跟程序的生命周期是一致的。a对象虽然析构了(不存在了),因为a也是一个指针,a指针也就是保存这个资源的地址!我们在pArray中保存的a的地址出的资源并没有析构!所以在func2函数中我们还能够使用此地址访问此地址对应的资源!

     

    --------------------------------END---------------------------

     

     

     

     

    展开全文
  • 数组对象数组对象区别

    千次阅读 2017-03-05 13:43:38
    数组对象:(看例子) var a = {}; var i =10; while(i  a[i] = i*i; i++; } 数组对象: var b = []; var i =0; while(i b[i] = i*i; i++; } 其实你从源代码上面去看也没有什么大的区别: 但是...

    类数组对象:(看例子)           

    var a = {};       

    var i =10;

    while(i<10){

     a[i] = i*i;

    i++;

    }

    数组对象:

    var b = [];

    var i =0;

    while(i<10){

    b[i] = i*i;

    i++;

    }

    其实你从源代码上面去看也没有什么大的区别:

    但是js中是支持  1: 类名【属性名称】 = 值  相当于 2:类名.属性名称 = 值 

    要是你想在类中使用动态的属性  就必须用第一个   

    下面看下下区别吧:

    类数组对象:

    console.log(typeof a);//object 注意:数组也是对象哦

    console.log(a); //  Object {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81} 很明显对象啊

    console.log(a.length); //undefined  区别就在这了  类数组对象没有长度的属性和数组的方法

    console.log(Object.prototype.toString.call(a));//[object Object] 

    数组对象:

    console.log(typeof b);//object

    console.log(b);//  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]  很明显数组啊 

    console.log(b.length); //8

    console.log(Object.prototype.toString.call(b));//[object Array]

     

     

    在上一个判断是对象还是数组的方法

     

    var isArray = Function.isArray || function(o){

     return typeof o === "object" && Object.prototype.toString.call(o) == "[object Array]";

    }

     
    展开全文
  • java对象区别

    千次阅读 2014-09-30 15:25:23
    对象区别

          java类与对象的区别是个老生常谈的问题,刚开始学java的时候就开始接触类和对象,今天来总结一下他们之间的区别。

          首先讲讲class和object的区别,其实就是一句话:object是所有class的父类,所有class类都默认继承object。

          java中类是对一类“事物”的属性和行为一种抽象,比如人类就可以定义为一个Person类:

    public class Person {
    	public int age;//年龄
    	public String name;//姓名
    	public int hight;//身高
    	public int weight;//体重
    	public Person(){		
    	}
    	public Person(int age,String name,int hight,int weight){
    		this.age = age;
    		this.name = name;
    		this.hight = hight;
    		this.weight = weight;
    	}
    	public void doSth(){
    		//doSomething
    	}	
    }
    
            对象是类的实例化,也就是一个具体的个体,比如“摩罗”我就是Person类的一个具体的对象,我有自己具体的年龄姓名身高体重。

    简单来说类和对象的区别如下:

      1,类是一个抽象的概念,它不存在于现实中的时间/空间里,类只是为所有的对象定义了抽象的属性与行为。就好像“Person(人)”这个类,它虽然可以包含很多个体,但它本身不存在于现实世界上。
      2,对象是类的一个具体。它是一个实实在在存在的东西。
      3,类是一个静态的概念,类本身不携带任何数据。当没有为类创建任何对象时,类本身不存在于内存空间中。
      4,对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。对象的属性可以随着它自己的行为而发生改变

    最后再来看看类和对象调用方法上的区别:

    public class classAndObject {
    	//静态方法
    	public static void staticTest (){
    		System.out.println("这是静态方法!");
    	}
    	//动态方法
    	public void dynamicTest() {
    		System.out.println("这是动态方法!");
    	}
    	public static void main(String[] args) {
    		classAndObject.staticTest();//正确
    		classAndObject t = new classAndObject();
    		t.dynamicTest();//非静态方法必须使用“对象.方法”,因为它在对象创建前不存在,必须依赖对象的创建才能使用。
    		t.staticTest(); //此处显示警告:The static method staticTest() from the type classAndObject should be accessed in a static way
            //静态方法在对象创建前就已经存在了,它的使用不依赖对象的创建,可以直接使用“类.静态方法”

                                                    欢迎关注行者摩罗微信公众号(xingzhemoluo),共同交流编程经验,扫描下方二维码即可;

     
                                   

                                                                     

    展开全文
  • POJO对象和Java类对象区别和联系是什么 POJO对象和Java类对象区别和联系是什么
  • 对象区别

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

    千次阅读 2019-03-05 21:11:59
    对象对象的一个实例(有状态和行为。) 是一个模板,它描述一类对象的行为和状态。 举例:
  • 对象

    千次阅读 多人点赞 2019-05-15 21:49:28
    对象:是抽象概念,表示的是一个共性的产物,之中定义的是属性和行为(方法),是创建对象的模板; 什么是对象? 万物皆对象对象是客观存在的事物,可以说任何客观存在的都是可以成为对象,表示一个...
  • 作为C语言的超集,面向对象成为Objective-C与C语言的最大区别,因此,对象是Objective-C中最重要的部分之一。目前面向对象的语言有很多,Objective-C中的对象又和其他语言中的对象有什么区别呢?下面来简单介绍...
  • synchronized 对象锁和锁的区别

    千次阅读 2018-05-31 20:36:40
    synchronized 对象锁和锁的区别 synchronized 描述 一段synchronized的代码被一个线程执行之前,他要先拿到执行这段代码的权限, 在Java里边就是拿到某个同步对象的锁(一个对象只有一把锁); 如果这个时候...
  • 类对象指针的区别

    千次阅读 2010-10-27 22:06:00
    对象的指针的区别zz <br /> 如下程序: <br />#include <iostream> #include <string> using namespace std; <br />class Student {  public:  ...
  • 透彻理解 Java synchronized 对象锁和锁的区别

    万次阅读 多人点赞 2017-02-17 14:34:05
    synchronized 加到 static 方法...对象锁和锁是不同的锁,所以多个线程同时执行这2个不同锁的方法时,是异步的。 在Task2 中定义三个方法 doLongTimeTaskA和doLongTimeTaskB是锁,而doLongTimeTaskC是对象锁。pub
  • *对象含有的属性的值,这就是的实例化。正是由于属性的不同,才能区分不同的对象 *为了看清数组与对象真正的区别看下边的例子 */ class person{ public $name; public $gender; public f
  • java中对象的指针有神马区别和联系 java中对象的指针有神马区别和联系
  • 方法和对象方法的区别

    千次阅读 2016-06-13 20:50:46
    方法和对象方法的区别 0. 对象方法以-开头 方法以+开头 1. 对象方法必须用对象调用 方法必须用来调用 2. 对象方法中可以直接访问属性(成员变量) 方法中不可以直接访问属性(成员变量) 3. ...
  • Java中对象的概念区别

    千次阅读 2014-08-26 23:29:52
    Java是一种面向对象的程序设计语言(Object Oriented Programming:OOP),面向对象的程序设计语言中有对象的概念,它们在概念上有什么区别呢?  这往往是一个令面向对象的初学者感到迷惑的问题。    下面...
  • Java对象 详解(一)

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

    千次阅读 2017-09-18 15:19:32
    1.一个可以有多个对象,所以一个可以有多个对象锁。 2.当一个中有多个synchronized修饰的同步方法时,其中一个方法被线程访问持有锁,其他方法同样被锁住,其他线程依然不能访问其他同步方法,因为此时锁住的...
  • 对象区别和联系

    千次阅读 2019-04-01 16:25:42
    是封装对象的属性和行为的载体,在Java语言中对象的属性以成员变量的形式存在,而对象的方法以成员方法的形式存在。 对象:Java是面向对象的程序设计语言,对象是由抽象出来的,所有的问题都是通过对象来...
  • 适配器和对象适配器 适配器 Adapter 继承Adaptee (被适配),同时实现Target 接口(因为 Java 不支持多继承,所以只能通过接口的方法来实现多继承),在 Client 中我们可以根据需要选择并创建任一种...
  • java对象的联系,区别

    千次阅读 2017-10-11 17:29:24
    将具有相同属性及相同行为的一组对象称为。广义地讲,具有共同性质的事物的集合就称为。 在面向对象程序设计中,是一个独立的单位,它有一个类名,其内部包括成员变量,用于描述对象的属性;还包括的成员...
  • C++ 直接定义对象与new对象区别

    千次阅读 2015-09-01 22:02:24
    new创建类对象与直接定义的区别new创建对象的特点 new创建类对象需要指针接收,一处初始化,多处使用 new创建类对象使用完需delete销毁 new创建对象直接使用堆空间,而局部不用new定义类对象则使用栈空间 new对象...
  • 对象区别

    万次阅读 多人点赞 2018-08-13 09:35:36
    对于初学者来说,对象之间的关系的非常模糊不清的,在这里大家分享一下,让初学者有所帮助。   一、的概念: 是具有相同属性和服务的一组对象的集合。它为属于该的所有对象提供了统一的抽象描述,其...
  • 对象锁和锁的区别

    千次阅读 2020-04-12 16:47:25
    对象锁和锁的区别synchronized 关键字对象锁1、锁住 this 对象2、 锁住实体里的非静态变量3、直接锁非静态方法对象锁代码测试锁1、锁住 xxx.class2、锁住中的静态变量3、直接在静态方法上加 synchronized锁...
  • new创建类对象,使用完后需使用delete删除,申请内存类似。所以,new有时候又不太适合,比如在频繁调用场合,使用局部new类对象就不是个好选择,使用全局类对象或一个经过初始化的全局指针似乎更加高
  • 面向对象区别

    千次阅读 2011-11-15 20:37:50
    面向对象编程(Object Oriented Programming, OOP, 面向对象程序设计)是一种计算机编程架构,OOP的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成,OOP达到了软件工程的三个目标:重用性...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,313,492
精华内容 525,396
关键字:

对象跟类的区别