精华内容
下载资源
问答
  • 类和对象
    万次阅读 多人点赞
    2019-07-04 21:38:07

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

    对象指针的一般概念

    对象指针:指向类的成员的指针。在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     }
    
    更多相关内容
  • 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(垃圾收集器)不定期的进行回收与空间的释放。

    未完待续。。。

    展开全文
  • Java类和对象(重点详解)

    千次阅读 多人点赞 2021-04-23 18:25:35
    类和对象类和对象的关系。的介绍变量(静态变量)public && private一些建议小结写在最后的话 这段时间博主学习了一些Java中类和对象的知识,今天我们就来聊聊Java中的类和对象类和对象的关系。 ...


    这段时间博主学习了一些Java中类和对象的知识,今天我们就来聊聊Java中的类和对象。

    类和对象的关系。

    类其实就是一个模板,比如说类就好比一张房子的设计图纸,或者说是一个倒印模具,创建一个类就好比设计一张图纸,刻一个模板。对象就好比一座建好的房子,一个成型的模型,无疑想要一座房子或者一个模型都先需要一张图纸和一个模板,而这就是类和对象的关系。

    类的介绍

    首先Java里面的类由关键字class定义,类中的元素称为:成员属性。类中的函数称为:成员方法。

    class Person {
        public int age;//成员属性 实例变量
        public String name;
        public String sex;
        public void eat() {//成员方法
           System.out.println("吃饭!");  
       }
        public void sleep() {
           System.out.println("睡觉!");  
       }
    }
    

    如下就是定义一个类

    class Person {
        public String name;
        public String sex;
        public int age;
        //....人的属性
    }
    

    然后拿这个类创建一个对象,然后我们可以通过点号 . 来访问这个对象的成员,看下图

    Person person = new Person();//实例化一个对象
    

    在这里插入图片描述
    可以看到在没有赋值之前是会默认赋值为类型相对应的0值。

    类型对应的0值
    整型0
    浮点型0.0
    字符类型r/u0000
    引用类型null

    注:这里之所以有默认的0值,是因为他们都是成员变量,不属于局部变量,所以有默认值,局部变量需要自己赋值才能使用。

    类变量(静态变量)

    所谓的类变量也就是静态变量,由关键字static修饰,存储在方法区,在类加载的时候就会分配空间,所以类变量是脱离对象的,就是说,就算没有实例化对象也是可以使用类变量的,看下图,没有对象依然可以通过 类名.变量名 使用类变量
    在这里插入图片描述
    同样的,由static修饰的方法也是类方法也叫静态方法,它和类变量具有相同的性质,类加载时分配空间,不依赖于实例化的对象,可以直接通过 类名.函数名() 调用。
    如果不是静态的变量和方法,那么我们就需要先通过new关键字实例化一个对象才可以使用。

    public && private

    在类的定义中有许多的访问权限修饰符,而public和private是两个最常使用的,顾名思义,public修饰的变量是公开的,所谓的公开就是说可以直接访问,举个栗子
    在这里插入图片描述
    当我们使用public修饰成员变量时可以正常使用,通过点号访问对象的成员,但是当我们使用private修饰的时候,就会报错,因为private是私有的,只能在当前类里面使用,不能被外部引用。
    在这里插入图片描述
    如果要其他类中需要使用的话就需要提供公开的接口,给需要使用的类调用,简单来讲就是,我写个公开的方法,你把数据通过方法传给我,我自己来操作,比如以下方法,看名字也能知道这些方法的作用,我们来使用一下这些方法
    在这里插入图片描述
    在这里插入图片描述
    可以看到,通过公开的接口我们可以对私有的成员变量进行一系列的操作,细心的小伙伴们可能会发现在setName等等方法里面都出现了 this.变量名那么这个是什么呢,this其实是一个关键字,表示当前方法的引用,那么为什么要有这个关键字呢,那是因为当变量名相同时,局部变量有限使用,可能会导致无法赋值等情况,看下图,当去掉this之后,名字明显为初始值,这就是因为局部变量优先使用的原因,导致类里面的成员变量没有被赋值。
    在这里插入图片描述

    一些建议和小结

    1.建议实现类的时候将成员变量尽量设置为private属性,防止数据被直接篡改,而方法非必要公开的接口也设置为private属性的,具体根据实际情况来定

    2.变量名和方法名使用小驼峰命名规则,尽量做到见名知意,做不到应该给上适当的中文注释,帮助其他人理解代码的意思

    3.static修饰的代码和代码块优先于任何代码执行

    4.一个类可以创建多个对象,很好理解,一张图纸可以建造多栋相同的房子,比如小区的楼房就是一张图纸建造出来的

    5.在实例化一个对象的时候会调用一个构造方法,所谓的构造方法就一个名字与类名相同的方法,可以带参数,没有返回值类型声明,并且如果你没有定义的话,编译器就会自动实现一个不带参数的构造方法,如果你定义了,那么编译器就不会自动生成。并且构造方法也是支持重载的,构造方法的用处之一就是可以在创建对象的时候就进行赋值。
    在这里插入图片描述
    在这里插入图片描述
    加上一句this.name ,就可以不需要setname了,只需要创建对象的时候,直接传参即可,其他的博主就不在赘述了。
    在这里插入图片描述

    在这里插入图片描述

    写在最后的话

    以上就是博主这段时间的学习内容,今天分享就到这里了,如果文章中有表达不清楚或者表述有错误的地方欢迎评论或者私信指出,博主会及时处理,好了本篇博客就到此结束了,我们下篇博客见。

    展开全文
  • 怎么来理解java类和对象的区别

    千次阅读 多人点赞 2018-05-08 11:29:19
    对象在需求中的使用在具体问题中如何使用面向对象去分析问题,如何使用面向对象。以把大象装冰箱为例进行分析:在针对具体的需求,可以使用名词提炼的办法进行分析,寻找具体的对象。需求:把大象装冰箱里对象:...

    对象在需求中的使用

    在具体问题中如何使用面向对象去分析问题,和如何使用面向对象。

    以把大象装冰箱为例进行分析:

    在针对具体的需求,可以使用名词提炼的办法进行分析,寻找具体的对象。
    需求:把大象装冰箱里
    对象:大象、冰箱
    分三步:
        1、打开冰箱门
        2、将大象装进去
        3、关闭冰箱门
    分析发现打开、装、关闭都是冰箱的功能。即冰箱对象具备如下功能:
        1)冰箱打开
        2)冰箱存储
        3)冰箱关闭
    用伪代码描述,上述需求中有两个具体的事物 大象 和  冰箱
    描述大象:
        class 大象
            {
            }
    描述冰箱
        class冰箱
            {
                void 打开(){}
                void 存储(大象){}
                void 关闭(){}
            }
    当把具体的事物描述清楚之后,需要使用这些具体的事物,Java使用具体的事物,需要通过new关键字来创建这个事物的具体实例。
    使用对象:
        1、创建冰箱的对象
            冰箱 bx = new 冰箱();  
        2、调用冰箱的功能
            对象.功能();
            bx.打开();
            bx.存储(new 大象());
            bx.关闭();
    总结:
    1、先按照名词提炼问题领域中的对象
    2、对对象进行描述,其实就是在明确对象中应该具备的属性和功能
    3、通过new的方式就可以创建该事物的具体对象
    4、通过该对象调用它以后的功能。

    对象在代码中的体现

    在分析现实生活中的事物时发现,这些事物都有其具体的特点和功能,这些特点和功能就组成了这个特殊的事物。
    描述小汽车。
    分析:
    事物的特点(属性):
    颜色。
    轮胎个数。
    事物的(功能):
    运行。

    发现:事物其实就是由特点(属性)和行为(功能)组成的。
    可以简单理解:属性就是数值,其实就是变量;行为就是功能,就是方法。
    小汽车 {
    颜色;
    轮胎个数;
    运行() { }
    }
    通过计算机语言Java来描述这个事物。

    定义类的格式

    public class 类名 {
    	//可编写0至n个属性
        数据类型 变量名1;
        数据类型 变量名2;
    	
    	//可编写0至n个方法
    	修饰符 返回值类型 方法名(参数){
    		执行语句;
    }
    }
    

    汽车类

    public class Car {
    	String color;
    	int number;
    
    	void run() {
    		System.out.println(color + ":" + number);
    	}
    }
    
    通过代码的描述,知道类的真正意义就是在描述事物。属性和功能统称为事物中的成员。
    事物的成员分为两种:成员属性和成员功能。
    成员属性在代码中的体现就是成员变量
    成员功能在代码中的体现就是成员方法

    把写好的代码测试一下。需要一个可以独立运行类。

    创建对象的格式:

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

    测试类

    public class CarDemo {
    	public static void main(String[] args) { 
    		/*
    		 *  测试:Car类中的run方法。
    		 */
    		// 1,创建Car的对象。给对象起个名字。
    		Car c = new Car();// c是类类型的变量。c指向了一个具体的Car类型的对象。
    		// 2,通过已有的对象调用该对象的功能。格式:对象.对象成员;
    		// 3,可以该对象的属性赋值。
    		c.color = "red";
    		c.number = 4;
    		c.run();
    	}
    }
    

    类和对象的区别

    面向对象的编程思想力图在程序中对事物的描述与该事物在现实中的形态保持一致。为了做到这一点,面向对象的思想中提出两个概念,即类和对象。其中,类是对某一类事物的抽象描述,而对象用于表示现实中该类事物的个体。接下来通过一个图例来抽象描述类与对象的关系,如下图所示。


    在上图中,可以将玩具模型看作是一个类,将一个个玩具看作对象,从玩具模型和玩具之间的关系便可以看出类与对象之间的关系。类用于描述多个对象的共同特征,它是对象的模板。对象用于描述现实中的个体,它是类的实例。从上图中可以明显看出对象是根据类创建的,并且一个类可以对应多个对象,接下来分别讲解什么是类和对象。

    经过前面几个知识点的学习,基本上掌握了类是用于描述事物的,类中可以定义事物的属性和行为。而对象是通过描述的这个类,使用new关键字创建出来,通过对象就可以调用该对象具体的属性和功能了。

    局部变量和成员变量区别

    理解清楚了类和对象之后,发现在描述类的属性定义变量差别不大,唯一区别就是位置发生了改变,那么类中定义的变量,和在方法定义的变量有什么差别呢?总结下面几点异同
    区别一:定义的位置不同
        定义在类中的变量是成员变量
        定义在方法中或者{}语句里面的变量是局部变量
    区别二:在内存中的位置不同
        成员变量存储在对内存的对象中
        局部变量存储在栈内存的方法中
    区别三:声明周期不同
        成员变量随着对象的出现而出现在堆中,随着对象的消失而从堆中消失
        局部变量随着方法的运行而出现在栈中,随着方法的弹栈而消失
    区别四:初始化不同
        成员变量因为在堆内存中,所有默认的初始化值

        局部变量没有默认的初始化值,必须手动的给其赋值才可以使用。

    本文结。


    展开全文
  • JAVA基础语法:函数(方法)、类和对象

    千次阅读 多人点赞 2020-01-12 04:14:38
    和对象 蓝桥杯主要考察一些算法,会写简单的就可以了,这里就简单说一下对象和类的概念以及java中的定义。 是具有共同特征的对象的集合,对象是的实例。 比如 人是一个 张三是其中一个对象。 中包含...
  • 类和对象(一)——&对象概念及定义

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

    千次阅读 多人点赞 2019-08-11 19:04:04
    什么是面向对象,以及什么是类和对象 ​ 1.1面向过程与面向对象的区别 ​ 面向对象是一种现在最为流行的程序设计方法 。将面向过程与面向对象进行比较。 ​ 首先这两个种都是一种编程思维, 在一些简单的动作...
  • 面向对象(Object Oriented,OO)。 面向对象(Object Oriented,OO)是软件开发方法。面向对象的概念应用已超越了程序设计软件开发,扩展到如数据库系统、交互式界面、...核心特性包括:对象,方法,封装,继承...
  • Java类和对象知识点的整理

    千次阅读 多人点赞 2019-04-14 18:00:01
    通过学习视频,特意写下此次博客。本次博客目的是为了...一、类和对象 1.面向对象 (1)面向对象的理解 面向对象是已对象为基础,完成各种操作主要强调对象。 (2)面向对象的特点 面向对象是一种常见的思想,...
  • 类和对象举例

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

    千次阅读 2018-07-09 19:35:00
    类和对象面向对象编程的2个非常重要的概念:类和对象对象是面向对象编程的核心,在使用对象的过程中,为了将具有共同特征行为的一组对象抽象定义,提出了另外一个新的概念——类类就相当于制造飞机时的图纸,用它...
  • 类和对象的区别联系

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

    千次阅读 多人点赞 2018-08-18 15:19:09
    一、及其实例化 1、定义  要先声明后使用;不能声明两个名字相同的是具有唯一标识符的...中有数据成员成员函数,不有在声明中对数据成员使用表达式进行初始化。 ⑴ 声明  声明以class...
  • python中的类和对象,属性方法

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

    万次阅读 多人点赞 2019-03-07 15:07:44
    根据一类对象进行概括,将对象的特征概括为属性,将对象的行为概括为方法,将这一类对象用一个类表示 --- 类是对象的概括/抽取 通过new关键字来创建这个对象,然后可以给对象中的属性赋值,也可以调用方法 ...
  • Java中类和对象的概念

    万次阅读 多人点赞 2018-06-01 23:50:23
    首先说说类和对象。今天心情不错,来复习复习Java基础:类和对象。Java是什么?Java是一门面向对象的编程语言(OOP),想要理解Java,首先要理解(Class)和对象(Object)这两个概念。Java中的可以看成C语言的...
  • 7.1 理解类和对象 7.1.1 对象 现实世界中的所有具体的事物都可以视为对象 Java中万物皆对象
  • 学习笔记之——Python中类和对象的理解

    千次阅读 多人点赞 2019-01-16 20:26:13
    学习笔记之——Python中类和对象的理解一、 面向对象的含义特性二、1. Python中的定义、结构、创建1. Python的定义2. Python的结构3. 的创建4. 的属性5. 的方法三、对象1. 对象的创建四、参考资料 ...
  • (2):具有相同特性(数据元素)行为(功能)的对象的抽象就是。因此,对象的抽象是的具体化就是对象,也可以说的实例是对象实际上就是一种数据类型。具有属性,它是对象的状态的抽象,用数据...
  • 类和对象的概述及二者之间的关系

    千次阅读 2018-12-30 16:40:16
    是一个抽象的概念,是对具有相同特征行为事物的统称 对象是这一事物中某一个确定的个体。 可以把理解成一个模板,对象理解成通过这个模板创建的产品.从这个角度出发,可以说一个能创建多个对象,一个对象只能...
  • C++类和对象数组

    万次阅读 多人点赞 2018-05-14 23:47:15
    //有10个元素的学生类对象数组 2:对象数组的访问形式:数组名[下标].成员名; Eg: asa[j].print(); 3:对象数组的初始化:对象数组的初始化通常也是由构造函数来完成的。 Eg: #include”student.h” int main ...
  • 类和对象之间的关系?封装继承多态?

    千次阅读 2018-03-04 09:19:00
    在面向对象的编程思想中把对象的属性行为分别称为对象的属性方法,是构成对象的两个主要因素;在编程中,对象的属性被存储在一些变量里;对象的行为则通过定义方法来实现。三大基本特征:封装,继承,多态。 ...
  • 类和对象、实例的关系理解

    千次阅读 2017-11-15 15:31:00
    所以实例和类基本就是同一个概念。 最常见的举例是: Class:鸟 的方法(函数):(鸟)会飞 的属性(变量):爪子,翅膀 实例: 对象:麻雀,是(Class)鸟的一种 对象方法(函数):麻雀会飞 对象的...
  •  (2分)重载函数中不允许使用默认参数重载函数中编译根据参数表进行选择不要使用重载函数来描述毫无相干的函数构造函数重载将会给初始化带来多种方式2-3在下面声明中,关于生成对象不正确的是( )。class point{ ...
  • 什么是?什么是对象类和对象有什么关系?

    万次阅读 多人点赞 2016-05-13 15:26:11
    面向对象(Object Oriented,OO)。 起初,“面向对象”是指在程序设计中采用封装、继承、多态等设计方法。现在,面向对象的思想已经涉及到软件开发的各个方面。如,面向对象的分析(OOA,ObjectOriented Analysis),...
  • Python学习笔记(十一):类和对象

    万次阅读 多人点赞 2021-02-11 00:10:46
    Python学习笔记(十一):类和对象 关于类和对象Python学习笔记(十一):类和对象一.变量实例变量变量实例变量二.函数装饰器带参数的函数装饰器函数装饰器的嵌套三.property()四.封装机制五.继承机制 一....
  • 类和对象 子类父类

    万次阅读 2018-06-24 13:31:59
    实例化对象 实例化对象格式 对象变量 = () 的类型为 type <class 'type'>...的值就是本身 ...对象的类型为 ...检测类和对象的成员 检测成员 类名.__dict__ 检测对象成员 对象._...
  • 类是对于某一类对象的一个统称,类是对象的抽象化,对象是类的实例。定义一个类时,相当于定义了一个数据类型的蓝图。但实际上并没有定义任何的数据,但它定义了类的名称意味着什么,也就是说,类的对象由什么组成及在...
  • [C/C++]详解C++的类和对象

    万次阅读 多人点赞 2021-05-24 13:09:01
    类和对象是面向对象编程技术中的最基本的概念。 1.面向对象 首先来理解什么是面向对象编程。 C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题。 C++是基于面向对象的,关注的是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,911,139
精华内容 2,364,455
关键字:

类和对象

友情链接: 5.zip