类与对象_类与对象的概念 - CSDN
精华内容
参与话题
  • Java对象 详解(一)

    万次阅读 多人点赞 2016-10-06 20:48:53
    一、面向对象简述面向对象是一种现在最为流行的程序设计方法,几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由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(垃圾收集器)不定期的进行回收与空间的释放。

    未完待续。。。

    展开全文
  • C ++类与对象

    千次阅读 2019-06-07 20:19:07
    将具有相同结构、操作,并遵守相同约束规则的对象聚合成一组,这组对象集合就称为。它是把许多对象进行抽象。 1、定义 1.1、定义的形式 1.11、C++中说明的一般形式为: class 类名 { private: (可...

    一、类

    将具有相同结构、操作,并遵守相同约束规则的对象聚合成一组,这组对象集合就称为类。它是把许多对象进行抽象。

    1、类定义

    1.1、类定义的形式

    1.11、C++中说明类的一般形式为:

           class 类名 {
                       private:  (可缺省)
                          私有数据成员和函数成员
                        protected:
                          保护段
                        public:
                          公有数据成员和函数成员
    };
    

    1.12、 最低限度应包括如下内容:

    1. 类名;
    2. 内部表示,即类里面有哪些数据;(数据成员)
    3. 对外接口,对于操纵类实例——对象的外部可施加的操作;(成员函数)
    4. 内部实现,接口数据在内部的动作;(成员函数)
      例一:
    class Student{//学生类 
     private:
    int age;//数据成员 
    int ID;//数据成员 
    char name[20];//数据成员 
     protected:
    void id(){//成员函数 (内部动作) 
       ID+=1;
    }
     public:
    Student(int a,int I,char *n){//成员函数 (对外接口) 
       age=a;
       ID=I;
    strcpy(name,n);
    }
    void Setage(int a){//成员函数 (对外接口) 
       age=a;
    }
    void display(){//成员函数 (对外接口) 
    id();
       cout<<name<<" "<<age<<" "<<ID<<endl;
    }
    }; 

    1.2、访问属性

    1.21、public
    属性为public的成员,不仅该可以在该成员所属类的内部进行访问,而且可以在类外通过类的对象来访问。

    1.22、private
    属性为private的成员,只能在该成员所属类的内部进行访问,而不能在类外通过类的对象来访问。换句话说,对外不可见。在类中可缺省。

    1.23、protected
    属性为protected的成员,只能在该类所属的类的内部和其类的派生类中进行访问。

    1.3、数据成员

    1.31、定义:数据成员是一个类的核心内容、设计类的主要内容是设计数据成员。同类的对象之所以互不相同。是由于他们有不同的属性值。

    1.32、数据成员的定义格式:
    数据成员类型 数据成员名;
    例二:

    int  sum;
    char name[20];
    float num;
    A a;//类A
    //或一些自定义的类型

    1.33、数据成员的修饰符
    如 const 、static、final 等;

    1.4、成员函数

    1.41、定义:函数的原型要写在类体中的函数。

    1.42、成员函数的分类及定义形式:

    1. 构造函数
      默认构造函数 类名 ( ){ }
      含参构造函数 类名 (参数表){ }
      拷贝构造函数 类名 (类名 & 参数名){ }
      例三、
    2. 析构函数
      ~类名( ){ }
    3. 一般函数
      返回值类型 函数名 (参数表){ }

    例三:

    class A{  private:   int x;   int y;  public:
      A(){
       x=0;
       y=0;
      }
      A(int X,int Y){
       x=X;
       y=Y;
      }
      A(A &a ){
       x=a.x;
       y=a.y;
      }
      void display(){
       cout<<x<<" "<<y; 
      }
      ~A();
    }; 

    1.43 成员函数的定义位置

    1. 类内:直接写函数体。

    2. 类外: 其他不变,在函数名前加 “类名::”

      返回值类型 类名::函数名 (参数表){ }
      或者使用内联函数 inline;

    2、类的声明

    2.1、类的声明形式

    class 类名;

    2.2、前向声明
    我们可以仅仅声明类而暂时不定义它,这种声明被称为前向声明。在它声明之后定义之前该类是个不完全类型。

    不完全类型只能在非常有限的情况下使用:可以定义指向这种类型的指针或引用,也可以作为一个已经声明(但没有定义)的函数的参数或返回类型。

    二、对象

    1、对象的创建

    1.1、在声明类的同时,直接定义对象

    class   point{                              
           private:
               int x, y; 
           public:
               void   setpoint(int,  int); 
               int  getx();     
               int  gety();
    }  op1, op2;  

    1.2、声明类之后,在使用时定义对象

    class   point{                              
           private:
               int x, y; 
           public:
               void   setpoint(int,  int); 
               int  getx();     
               int  gety();
    } ;
    int main(void){
          point op1,op2;
    }

    1.3、声明类之后,在使用new定义对象

    class   point{                              
           private:
               int x, y; 
           public:
               void   setpoint(int,  int); 
               int  getx();     
               int  gety();
    } ;
    int main(void){
          point *op;
          op=new point();
    }

    2、对象的存储

    问题:

    • 用类去定义对象时,系统会为每一个对象分配存储空间。
    • 如果一个类包括了数据和函数,要分别为数据和函数的代码分配存储空间。
    • 按理说,如果用同一个类定义了10个对象,那么就需要分别为10个对象的数据和函数代码分配存储单元 。
    • 能否只用一段空间来存放这个共同的函数代码段,在调用各对象的函数时,都去调用这个公用的函数代码。
    • 显然,这样做会大大节约存储空。C++编译系统正是这样做的。

    得出结论:

    每个对象所占用的存储空间只是该对象的数据部分所占用的存储空间,而不包括函数代码所占用的存储空间。

    展开全文
  • 对象(一)——&对象概念及定义

    万次阅读 多人点赞 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个字节,占位用,告诉系统我这里定义了一个类,虽然它是空的



    展开全文
  • 一:类与对象

    2020-10-08 18:57:59
    1、面向对象简介 面向过程指的是面对于一个问题的解决方案,更多的情况下是不会做出重用的设计思考,而面向对象的主要设计形式为模块化设计,并且可以进行重用配置。所以,在整个的面向对象的设计里面更多情况下...

    1、面向对象简介

              面向过程指的是面对于一个问题的解决方案,更多的情况下是不会做出重用的设计思考,而面向对象的主要设计形式为模块化设计,并且可以进行重用配置。所以,在整个的面向对象的设计里面更多情况下考虑的是标准,在使用时根据标准进行拼装。面向对象的三个主要特征:

                        1)封装性:内部的操作对外部而言不可见,内部的操作不可直接使用,具有安全性;

                        2)继承性:在已有结构的基础上继续进行功能的扩充;

                        3)多态性:在继承性的基础上扩充而来,指类型的转换处理;

              在进行面向对象程序的开发之中一般还有三个步骤:

                        1)OOA:面向对象分析;

                        2)OOD:面向对象设计;

                        3)OOP:面向对象编程。

              面向对象的核心组成:类与对象

     

    2、类与对象简介

              类是对某一类事物的共性的抽象概念,而对象描述的是一个具体的产物。例如:人类是一个类(人都有的共性是:有一个头,两个眼睛,一个嘴巴,一个鼻子,两个耳朵等),每个具体的人(每个具体的人是不一样的,眼睛的大小等)是一个对象。所以,人和人之间有区别是依靠的我们各自的属性,每一个属性的集合就构成了一个对象,但是所有的属性都应该是群体的定义,而群体的定义就形成了一个类。

              或者,类是一个模板,而对象才是类可以使用的实例,现有类再有对象。

              类的组成:

                        成员属性(Field):简称为属性;

                        操作方法(Method):定义对象具有的处理行为;

     

    3、类与对象的定义与使用

              范例:定义一个类

    关键词 代码
    class class Person{
        String name;//姓名
        int age;//年龄
        public void tell(){
            System.out.println("姓名:"+name+"、年龄"+age);
        }
    }

              上述代码实现了定义一个简单类,若要使用简单类,则需要对象来进行调用,而产生对象的代码如下:

                        1)声明并实例化对象:类名称    对象名称  =  new   类名称();

                        2)分步骤完成:

                                            a.声明对象:类名称   对象名称  =  null;

                                            b.实例化对象:对象名称   =   new   类名称();

              当获取实例化对象之后,需要通过对象进行类中的操作调用:

                        1)调用类中的属性:实例化对象.成员属性;

                        2)调用类中的方法:实例化对象.方法名称();

              范例:使用对象操作类

    代码 结果

    package cn.demos;

    class Person {
        String name;// 姓名
        int age;// 年龄
        public void tell() {
            System.out.println("姓名:" + name + "、年龄" + age);
        }
    }

    public class Demo1 {
        public static void main(String[] arge) {
            //声明实例化对象
            Person person = new Person();
            person.name = "张三";
            person.age = 18;
            person.tell();
        }
    }

    姓名:张三、年龄18

              注意:若此时并没有对对象中的属性进行赋值,则输出结果为其对应的默认值。

             

    4、对象内存分析(暂略)

    5、对象引用分析(暂略)

    6、引用与垃圾产生分析(暂略)

    展开全文
  • 类与对象总结

    千次阅读 2018-04-26 00:45:55
    知识点总结类类的定义:⑴是对具有相同属性和行为的一组对象的抽象统一描述。是用户自定义的数据类型。 ⑵的定义包括行为和属性两个部分。 ⑶属性以数据表示,行为通过函数实现。格式:class 类名 { ...
  • 类与对象的关系

    千次阅读 2018-09-03 11:34:58
    简单记录一下类与对象的关系,问题不难,但觉得还是写出来,会帮助自己记忆更牢固,而且万一以后有需要,可以及时回顾。 参考文献: 类与对象的区别 Java对象 详解(一) Java对象 详解(二) 声明对象、...
  • 类与对象

    2020-10-22 08:16:16
    类与对象简介 面向对象是一种程序的设计方法。 面向过程解决的是当下的需求。 面向对象是模块化设计,对于现在的程序开发更多情况下就像是汽车组装一样,不同情况下就可以形成一辆汽车,并且当某一个零件坏掉的时候...
  • Java对象 详解(一)(转载)

    千次阅读 2018-07-04 10:45:50
    一、面向对象简述面向对象是一种现在最为流行的程序设计方法,几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由IBM提出的,在70年代的Smaltalk语言之中进行了应用,后来根据面向对象的设计...
  • 对象

    千次阅读 2019-02-12 17:14:50
    对象是指的实例,将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的应用性、灵活性和扩展性。C++是基于面向对象的语言。 特点 封装、继承、多态 三种访问限定符 public(公有) protected...
  • 面向对象(Object Oriented,OO)。 面向对象(Object Oriented,OO)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、...核心特性包括:对象,方法,封装,继承...
  • Python 类与对象

    万次阅读 多人点赞 2019-04-10 16:49:40
    类与对象的理解封装特性 面向对象编程语言 - : 一个模板, (人类)---是一个抽象的, 没有实体的 - 对象: (eg: 张三, 李四) - 属性: (表示这东西的特征, 眼睛, 嘴巴, 鼻子) - 方法: (表示这物体可以...
  • 什么是对象类与对象的关系是什么?

    千次阅读 多人点赞 2020-05-23 22:29:48
    对象 什么是对象?          万物皆对象。它包括现实中客观存在的事物,也包括抽象的时间、规则、思维。简单点说,对象具有状态、行为和标识。 什么是?  &...
  • 谈谈我对面向对象以及类与对象的理解

    千次阅读 多人点赞 2018-02-26 22:43:12
    面向对象首先,一言不和先百度,得到如下定义:一切事物皆对象,通过面向对象的方式,将现实世界的事物抽象成对象,现实世界中的关系抽象成、继承,帮助人们实现对现实世界的抽象数字建模。我们知道,编写程序的...
  • Java中类与对象的定义使用

    千次阅读 2018-10-31 20:38:54
     把客观事物封装成抽象的,每个都有自己的属性方法,并且可以让自己的数据和方法只让可信的对象操作,对不可信的进行信息隐藏。内部操作对外部而言不可见(保护性) 0.2 继承性  它可以是现有的...
  • C++中类与对象的讲解(通俗易懂)

    万次阅读 多人点赞 2018-07-25 15:20:44
    概念 描述 成员函数 的成员函数是指那些把定义和原型写在定义内部的函数,就像定义中的... 的构造函数是一种特殊的函数,在创建一个新的对象时调用。的析构函数也是一种特殊的函数,在删...
  • java中类与对象的关系区别

    万次阅读 多人点赞 2019-04-08 15:25:54
    参考博客:https://blog.csdn.net/scbiaosdo/article/details/79912037 https://blog.csdn.net/dingd1234/article/details/79576730 https://blog.csdn.net/wei_zhi/article/d...
  • C++面向对象实验二:类与对象

    千次阅读 2016-11-24 17:26:13
    C++实验二:类与对象一、实验目的 的创建和使用来创建对象的数据成员的声明。 成员函数的声明和定义。 Private,public访问限定符的使用。 使用提供的公有的成员函数给对象成员赋值。 二、实验要求:包含...
  • 类与对象的区别?

    万次阅读 2018-08-13 09:35:36
    对于初学者来说,类与对象之间的关系的非常模糊不清的,在这里跟大家分享一下,让初学者有所帮助。   一、的概念: 是具有相同属性和服务的一组对象的集合。它为属于该的所有对象提供了统一的抽象描述,其...
  • 面向对象和面向过程 面向对象就是解决问题是将问题分解成一个个的步骤,每个步骤依次解决后也就意味着这个问题的解决了,一个个步骤可以对应一个个的函数,这些函数都定义好了,依次调用就行了。 面向过程则是将自然...
  • C++类与对象_简单练习题

    千次阅读 2019-03-25 17:19:33
    ## C++ 类与对象练习题: **在主函数中生成一个时钟对象,并为其设置时间和显示时间** 这是一道入门题,主要是为了熟悉类与对象,以及成员函数,数据成员的实现; 在此先强调几点C的区别或者说创建类与对象的...
1 2 3 4 5 ... 20
收藏数 4,433,893
精华内容 1,773,557
关键字:

类与对象