精华内容
下载资源
问答
  • 有些教程将类的成员变量称为类的属性(Property),将类的成员函数称为类的方法(Method)。在面向对象的编程语言中,经常把函数(Function)称为方法(Method)。 与结构体一样,类只是一种复杂数据类型的声明,不...

    类是创建对象的模板,一个类可以创建多个对象,每个对象都是类类型的一个变量;创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例(Instance),拥有类的成员变量和成员函数。

    C++类的定义

    有些教程将类的成员变量称为类的属性(Property),将类的成员函数称为类的方法(Method)。在面向对象的编程语言中,经常把函数(Function)称为方法(Method)。

    与结构体一样,类只是一种复杂数据类型的声明,不占用内存空间。而对象是类这种数据类型的一个变量,或者说是通过类这种数据类型创建出来的一份实实在在的数据,所以占用内存空间。

    类的定义

    类是用户自定义的类型,如果程序中要用到类,必须提前说明,或者使用已存在的类(别人写好的类、标准库中的类等),C++语法本身并不提供现成的类的名称、结构和内容。

    一个简单的类的定义:

    class Student{
    
    public:
    
        //成员变量
    
        char *name;
    
        int age;
    
        float score;
    
        //成员函数
    
        void say(){
    
            cout<<name<<"的年龄是"<<age<<",成绩是"<<score<<endl;
    
        }
    
    };
    

    class是 C++ 中新增的关键字,专门用来定义类。Student是类的名称;类名的首字母一般大写,以和其他的标识符区分开。{ }内部是类所包含的成员变量和成员函数,它们统称为类的成员(Member);由{ }包围起来的部分有时也称为类体,和函数体的概念类似。public也是 C++ 的新增关键字,它只能用在类的定义中,表示类的成员变量或成员函数具有“公开”的访问权限。

    注意在类定义的最后有一个分号;,它是类定义的一部分,表示类定义结束了,不能省略。

    整体上讲,上面的代码创建了一个 Student 类,它包含了 3 个成员变量和 1 个成员函数。

    类只是一个模板(Template),编译后不占用内存空间,所以在定义类时不能对成员变量进行初始化,因为没有地方存储数据。只有在创建对象以后才会给成员变量分配内存,这个时候就可以赋值了。

    类可以理解为一种新的数据类型,该数据类型的名称是 Student。与 char、int、float 等基本数据类型不同的是,Student 是一种复杂数据类型,可以包含基本类型,而且还有很多基本类型中没有的特性,以后大家会见到。

    创建对象

    有了 Student 类后,就可以通过它来创建对象了,例如:

    Student liLei; //创建对象

    Student是类名,liLei是对象名。这和使用基本类型定义变量的形式类似:

    int a; //定义整型变量

    从这个角度考虑,我们可以把 Student 看做一种新的数据类型,把 liLei 看做一个变量。

    在创建对象时,class 关键字可要可不要,但是出于习惯我们通常会省略掉 class 关键字,例如:

    class Student LiLei;  //正确
    
    Student LiLei;  //同样正确
    

    除了创建单个对象,还可以创建对象数组:

    Student allStu[100];
    

    该语句创建了一个 allStu 数组,它拥有100个元素,每个元素都是 Student 类型的对象。

    访问类的成员

    创建对象以后,可以使用点号.来访问成员变量和成员函数,这和通过结构体变量来访问它的成员类似,如下所示:

    #include <iostream>
    
    using namespace std;
    
    //类通常定义在函数外面
    
    class Student{
    
    public:
    
        //类包含的变量
    
        char *name;
    
        int age;
    
        float score;
    
        //类包含的函数
    
        void say(){
    
            cout<<name<<"的年龄是"<<age<<",成绩是"<<score<<endl;
    
        }
    
    };
    
    int main(){
    
        //创建对象
    
        Student stu;
    
        stu.name = "小明";
    
        stu.age = 15;
    
        stu.score = 92.5f;
    
        stu.say();
    
        return 0;
    
    }
    
    

    运行结果:

    小明的年龄是15,成绩是92.5
    

    stu 是一个对象,占用内存空间,可以对它的成员变量赋值,也可以读取它的成员变量。

    类通常定义在函数外面,当然也可以定义在函数内部,不过很少这样使用。

    使用对象指针

    C语言中经典的指针在 C++ 中仍然广泛使用,尤其是指向对象的指针,没有它就不能实现某些功能。

    上面代码中创建的对象 stu 在栈上分配内存,需要使用&获取它的地址,例如:

    Student stu;
    
    Student *pStu = &stu;
    

    pStu 是一个指针,它指向 Student 类型的数据,也就是通过 Student 创建出来的对象。

    当然,你也可以在堆上创建对象,这个时候就需要使用前面讲到的new关键字(C++ new和delete运算符简介),例如:

    Student *pStu = new Student;
    

    在栈上创建出来的对象都有一个名字,比如 stu,使用指针指向它不是必须的。但是通过 new 创建出来的对象就不一样了,它在堆上分配内存,没有名字,只能得到一个指向它的指针,所以必须使用一个指针变量来接收这个指针,否则以后再也无法找到这个对象了,更没有办法使用它。也就是说,使用 new 在堆上创建出来的对象是匿名的,没法直接使用,必须要用一个指针指向它,再借助指针来访问它的成员变量或成员函数。

    栈内存是程序自动管理的,不能使用 delete 删除在栈上创建的对象;堆内存由程序员管理,对象使用完毕后可以通过 delete 删除。在实际开发中,new 和 delete 往往成对出现,以保证及时删除不再使用的对象,防止无用内存堆积。

    栈(Stack)和堆(Heap)是 C/C++ 程序员必须要了解的两个概念,我们已在《C语言内存精讲》专题中进行了深入讲解,相信你必将有所顿悟。

    有了对象指针后,可以通过箭头->来访问对象的成员变量和成员函数,这和通过结构体指针来访问它的成员类似,请看下面的示例:

    pStu -> name = "小明";
    
    pStu -> age = 15;
    
    pStu -> score = 92.5f;
    
    pStu -> say();
    
    下面是一个完整的例子:
    
    #include <iostream>
    
    using namespace std;
    
    class Student{
    
    public:
    
        char *name;
    
        int age;
    
        float score;
    
        void say(){
    
            cout<<name<<"的年龄是"<<age<<",成绩是"<<score<<endl;
    
        }
    
    };
    
    int main(){
    
        Student *pStu = new Student;
    
        pStu -> name = "小明";
    
        pStu -> age = 15;
    
        pStu -> score = 92.5f;
    
        pStu -> say();
    
        delete pStu;  //删除对象
    
        return 0;
    
    }
    

    运行结果:

    小明的年龄是15,成绩是92.5
    

    虽然在一般的程序中无视垃圾内存影响不大,但记得 delete 掉不再使用的对象依然是一种良好的编程习惯。

    展开全文
  • 为了防止数据被意外篡改,使用private修饰符可以数据域声明为私有,这也称为数据封装。 2、访问器(accessor)和修改器(mutator)定义 简单点说,访问器和修改器就是中定义方法。 为了能够访问私有数据...

    1、private修饰符的作用

    为了防止数据被意外篡改,使用private修饰符可以将数据域声明为私有的,这也称为是数据域的封装。

    2、访问器(accessor)和修改器(mutator)的定义

    简单点说,访问器和修改器就是类中定义的方法。
    为了能够访问私有数据域,可以提供一个get方法返回数据域的值。get方法称为是访问器;
    为了能更新一个数据域,可以提供一个set方法来给数据域设置新值。set方法称为是修改器。

    3、private在Java中的使用

    
    public class UserFile{
        public static void main(String[] args){
        	/* 创建一个叫做John的对象,年龄为20岁 */
            UserManagementCenter John = new UserManagementCenter(20);
            /* 使用修改器方法来设置John的用户ID */
            John.setUserID(12345);
            /** 使用访问器方法来查看John的用户ID */
            System.out.print(John.getUserID());
        }
    }
    
    class UserManagementCenter{
        private long userID;
        int userAge;
        static int userCount = 0;
    
        public UserManagementCenter(){
            userCount++;
            userAge = 0;
        }
        public UserManagementCenter(int age){
            userAge = age;
            userCount++;
        }
        /** 设置用户的ID账号 */
        public void setUserID(long newID){
            userID = newID;
        }
        /** 访问Jone的用户ID */
        public long getUserID(){
            return userID;
        }
    }
    

    这个程序输出的是Jone的用户ID‘12345’,使用private来修饰的变量只能在定义这个变量的类中被直接调用,而在类外直接调用private的变量Java编译器会提示出错。
    这句话也说明了,如果在主类中定义一个private的变量那么在主函数main()是可以通过创建对象直接修改和访问的,见如下程序

    /** private的数据可以在定义private的类中被方法访问 */
    public class UserFile {
        private long id;
        public static void main(String[] args){
            /** 创建一个叫做dopa的对象,年龄为20岁 */
            UserFile dopa = new UserFile(20);
            dopa.id = 12345;
            System.out.print(dopa.id);
        }
    }
    

    程序输出为‘12345’

    展开全文
  • 在面向对象的术语,我们说小明的自行车是被称为自行车类的对象实例。 任何车辆的例子。它包括轮子,马力,燃油或燃气罐容量。这些特点形成的类车辆的数据成员。可以从其他车辆区分这些特征。 车辆有一定的功能,如...
  • 一个对象的状态(state, 也称为特征( property) 或属性( atribute)) 是由数据域及其当前值来表示的。例如,圆对象具有一个数据域radius,它是描述圆的特征的属性。矩形对象具有数据域width和height,它们

    面向对象

    什么是面向对象程序设计

    面向对象程序设计(OOP)就是使用对象进行程序设计。对象(object) 代表现实世界中可以明确标识的一个实体。例如:一个学生、一张桌子、一个圆、一个按钮甚至-一笔贷款都可以看作一个对象。每个对象都有自己独特的标识、状态和行为。

    类的属性
    一个对象的状态(state, 也称为特征( property) 或属性( atribute)) 是由数据域及其当前值来表示的。例如,圆对象具有一个数据域radius,它是描述圆的特征的属性。矩形对象具有数据域width和height,它们都是描述矩形特征的属性。

    对象的方法
    一个对象的行为( behavior, 也称为动作(action)) 是由方法定义的。调用对象的一个方法就是要求对象完成一一个动作。例如,可以为圆对象定义名为getArea(和getPerimeter()的方法。圆对象可以调用getArea()返回其面积,调用getPeri-meter()返回其周长。还可以定义setRadius(radius)方法,圆对象调用这个方法来修改半径。

    实例化
    使用一个通用类来定义同一类型的对象。类是一一个模板、蓝本或者合约,用来定义对象的数据域以及方法。对象是类的实例。可以从一个类中创建多个实例。创建实例的过程称为实例化( instantiation)。对象(object) 和实例(instance) 经常是可以互换的。类和对象之间的关系类似于苹果派配方和苹果派之间的关系。可以用一种配方做出任意多的苹果派来

    类和对象的创建

    创建与初始化对象

    使用new关键字创建对象

    public class Student {
        String name;    //null
        int age;    //0
    
        //方法
        public void study(){
            System.out.println(this.name+"在学习");
        }
    
    }
    
    
    public class Application {
        public static void main(String[] args) {
            Student xiaoming = new Student();
            Student xiaohong = new Student();
    
            xiaoming.name="小明";
            xiaoming.age= 3 ;
    
            System.out.println(xiaoming.name);
            System.out.println(xiaoming.age);
    
            xiaohong.name="小红";
            xiaohong.age= 3 ;
            System.out.println(xiaohong.name);
            System.out.println(xiaohong.age);
    
            xiaohong.study();
        }
    }
    
    

    在这里插入图片描述

    构造器

    使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

    类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:

    • 必须和类的名字相同

    • 必须没有返回类型,也不能写void

    构造器必须要掌握

    代码如下

    public class Person {
        //一个类即使什么都不写,它也会存在一个方法
        //显示定义的构造器
    
        String name;
        int age;
    
        //使用new关键字,本质是在调用构造器
        //用来初始化
    
        public Person() {
        }
    
    
        //有参构造:一旦定义了有参构造,无参构造想使用就必须显式定义
        public Person(String name,int age){
            this.name=name;
            this.age=age;
        }
    
    }
    
    public class Application {
        public static void main(String[] args) {
        
            //实例化一个对象
            Person person = new Person("张瑞",20);
    
    
            System.out.println(person.name);
            System.out.println(person.age);
    
    
    
        }
    }
    
    

    在这里插入图片描述

    创建对象的内存分析

    在这里插入图片描述

    上图所表示的是关于创建对象的内存分析

    • 在pet类中定义两个对象dog和cat
    • pet中定义一个shout方法
    • 存在一个main方法
    • 对dog(引用变量)和cat(引用变量)进行实例化
    • dog进行赋值,cat没有赋值,为默认状态
    • pet中具有name和age属性

    可以根据画出来的图完成代码,也可以根据代码画出内存分析

    学习面向对象前必须了解方法的调用

    调用方法的时候

    • 动态的方法可以调用静态的方法
    • 静态的方法不能直接调用动态的方法

    使用动态的方法必须先实例化

    关于值传递和引用传递

    值传递

    public class Demo03 {
        //值传递
        public static void main(String[] args) {
            int a = 1;
            System.out.println(a);
    
            Demo03.change(a);
    
            System.out.println(a);
    
        }
        //因为是值传递,走过a=10之后没有返回值直接跳出,回去之后a依然等于1
    
        public static void change(int a){
            a=10;
        }
    
    }
    
    

    在这里插入图片描述
    可以debug调试观察

    引用传递

    引用传递本质也是值传递,调用的是对象

    public class Demo04 {
    
        //引用传递:对象 本质还是值传递
        public static void main(String[] args) {
            Person person = new Person();
            System.out.println(person.name);
    
            Demo04.change(person);
            System.out.println(person.name);
    
        }
        public static void change(Person person){
            person.name="张瑞";
        }
    }
    //定义一个Person类
    class Person{
        String name;    //初始值null
    }
    

    在这里插入图片描述

    小结

    • 类是一个模板,对象是一个具体的实例
    • 方法:定义,调用
    • 对用的引用:引用类型和基本类型,对象是通过引用来操作的,栈---->堆
    • 属性默认初始化
      • 数字:0
      • char:u0000
      • boolean:false
      • 引用:null
    • 对象的创建和使用
      • 必须使用new关键字创造对象 Person zhang = new Person();
      • 对象的属性:zhang.name
      • 对象的方法:zhang.sleep

    写在最后
    知之者不如好之者,好之者不如乐之者。

    展开全文
  • 对象的抽象是类,类的具体化就是对象,也可以类的实例就是对象。类用来描述一系列对象,概述了每个对象应包括的数据,并概述了每个对象的行为特征。 面向对象的三个基本特征: 一、封装  对象要有一个明确...

    具有相同或相似性质的一组对象的抽象就是类,类是对一类事物的描述,是抽象的、概念上的意义;


    对象是实际存在的该类事物的每个个体,因此也称为实例;


    对象的抽象是类,类的具体化就是对象,也可以说类的实例就是对象。类用来描述一系列对象,概述了每个对象应包括的数据,并概述了每个对象的行为特征。


    面向对象的三个基本特征:

    一、封装
            对象要有一个明确的边界;边界的划分(对象各司其职、对象的粒度、对象的可重用性)
            具体来说:
                    1.属性: 私有 private(提供set和get方法)
                    2.方法: 公开或私有public/private
                    3.方法声明 --> 公开
                      方法实现 --> 隐藏
                     实现改变时,对对象的使用者没有影响。
     
    二、继承
            共性放到父类,特性放到子类;子类,父类 --> 其实就是特殊 --> 一般
            1.关键字: extends  例如:Dog extends Animal{}
            2.java中一个类最多只能有一个直接的父类,即单继承(具有简单性、树形结构),
              C++中是单继承
              java中要实现多继承,通过接口来实现。
            3.父类中所有属性和方法都能继承给子类;父类中的私有方法不能继承给子类。
            4.java中的访问修饰符
                

    访问修饰符

    访问权限

     继承 

    private       

    本类内部                  

    不能继承

    default       

    本类+同包 

    同包子类可以继承           

    protected     

    本类+同包+不同子包  

    可以继承

    public        

    公开

    可以继承

     

            5.构造对象过程
                       (1)分配空间
                       (2)递归地构造父类对象
                                    a. 父类 初始化属性
                                    b. 父类 构造方法
                       (3)初始化属性
                       (4)调用构造方法

            6.super  
                   用法:
                       super()  调用父类的构造方法,只能出现在构造方法的第一行
                       super.方法名   super表示父类的对象,通过它去调用父类的方法
                   注意:在写类的时候,一定要写默认无参的构造方法,如果一个构造方法的
                         第一句既不是this(),也不是super()时,那么就会在这里隐含的调用
                         他的父类的无参的构造方法,即隐含的有super()。

    三、多态
                运行时多态。
                子类的对象放在父类的引用中,例如 Animal a=new Dog,子类对象当父类对象来使用。
            1.多态原则:
                      (1)对象类型不变
                      (2)只能用引用调用其引用类型中定义的方法
                      (3)运行时,根据对象的实际类型去找子类覆盖之后的方法
                 例子:
                      有Animal类中有eat()和sleep()两个方法,sleep()中睡8小时;子类Dog中有
                      eat()方法,sleep()方法中睡6小时,还有wangwang()方法。
                      现创建Animal a=new Dog(); 不能调用a.wangwang(),调用a.sleep()输出睡6小时。

              2.对象的强制转换
                     格式: 引用 instanceof 类型
                            引用所指的对象是否与类相符,返回值boolean值。
                     用法:
                           Animal a=new Cat();
                           if(a instanceof Dog)
                           {
                              Dog d=(Dog)a;
                              d.wangwang();
                            }
                     说明:如果只有Dog d=(Dog)a;运行时错误,因为a是Cat而不是Dog (多态原则第一条)

              3.多态的灵活变换
                      (1)用于参数列表上:
                                   public void m(A a){} 可以用A类的任何子类对象作为参数
                      (2)用在返回值上:
                                  public A m(){}  这个方法可能返回A类的任何子类对


    展开全文
  • Python的类对象

    2019-11-07 20:04:10
    在面向对象程序设计中,对象(object)可以看作数据以及可以操作这些数据的一系列方法集合。(这里方法,就是函数),只是这些函数写在了中,为了区分全局函数,将这些写在函数称为方法。想要访问这些...
  • 类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。  定义一个类,本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据,但它定义了类的名称意味着什么,就是说,它定义了类的对象包含了...
  • 对象成员也称为类的聚集,指在类的定义中数据成员可以为其他的类的对象,即类对象作为另一个类的数据成员。 如果在类定义中包含有对象成员,则在创建类对象时先调用对象成员的构造函数,再调用类本身的构造函数。析...
  • 对象本身已知的事物被称为: 实例变量,他们代表对象的状态(数据),且该类型的每一个对象都会独立拥有一份该类型的值,所以也可以把对象称为实例。 对象可以执行的动作被称为:方法 引用变量book : Book ...
  • 我们可以当成一种自定义的数据类型,可以使用来定义变量,这种类型的变量相当于指针类型的变量,就是说所有的都是指针类型的变量。 1.定义  面向对象两个重要的概念:(class)和对象(object,...
  • 类和对象的初步认识 定义类和对象 Java程序基本的单位是类(class)。 在面向对象中,类也是它的重要内容。...一定意义上来说,类也可以称为引用类型。 String str =new String();   定义类的格式:
  • 对象

    2019-08-13 17:09:12
    具有相同特性(数据元素)和行为(功能)的对象的抽象就是类,因此对象的抽象是类,类的具体化就是对象,也可以类的实例是对象。 类是概念模型,定义对象的所有特性和所需的操作,对象是真实的模型,是一个具体的...
  • 类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。还有为甚么要定义类?定义一个类,本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据,但它定义了类的名称意味着什么,就是说,它定义了...
  • 正在更新中… 1. 类的基本概念 (1) C语言和C++的区别 C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步...类中的元素称为类的成员:类中的数据称为类的属性或者成员变量;类中的函数称为类
  • Java中的对象

    2021-01-01 13:38:49
    一、对象 面向对象程序设计( OOP) 就是使用对象...• 一个对象的状态( state,也称为特征( property) 或属性( attribute)) 是由数据域及其当前值来表示的。 例如: 圆对象具有一个数据域 radius, 它是描述圆的特
  • 对象

    2019-08-03 19:15:40
    一个对象的状态,也称为特征或属性是由具有当前值的数据域来表示的 一个对象的行为也称为动作是由方法定义的。调用 提示 面向对象编程可以有效的帮助开发大规模软件以及图形用户见面 为对象定义的属性和行为...
  • 继承是面向对象三大特征之一,是实现软件复用的重要手段。  继承的特点 通过继承,在已有类型基础之上进行扩充或改造,得到新的数据类型。 已有的类型称为父类或超类。 得到的新数据类型,称为子类或派生 ...
  • 数据分类和聚类区别

    千次阅读 2018-06-05 14:59:06
    1.分类利用分类技术可以从数据集中提取描述数据类的一个函数或模型(称为分类器classifier),并把数据集中的每个对象归结到某个已知的对象类中。从机器学习的观点,分类技术是监督学习,即每个训练样本的数据...
  • 我们经常用到的输入和输出,都是以终端为对象的,即从键盘输入数据,运行结果输出到显示器屏幕上。从操作系统的角度看,每一个与主机相连的输入输出设备都被看作一个文件。除了以终端为对象进行输入和输出外,还经常...
  • 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。 局部变量:定义在方法中的变量,只作用于当前实例的类。 实例变量:在类的声明中,...
  • 根据表字段所规定的数据类型,我们可以e5a48de588b662616964757a686964616f31333431353361向其中填入一条条的数据,而表中的每条数据类似类的实例对象。表中的一行一行的信息我们称之为记录。没有数据表,关键字、...
  • 对象本身已知的事物称为实例变量,它们代表对象的状态(数据),且该类型的每一个对象都会独立的拥有一份该类型的值。 所以你也可以把对象当作为实例。 对象可以执行的动作称为方法。在设计时,你也会设计出操作对...
  • 类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。 一、类定义 实际上并没有定义任何数据,但它定义了类的名称意味着什么,就是说,它定义了类的对象包括了什么,以及可以在这个对象上执行哪些操作...
  • 对象

    2020-07-26 17:08:26
    对象的概念 ...python中对象的概念很广泛,python中一切内容都可以称为对象,除了数值,字符串,列表,元组,字典,集合,range对象等等,函数是对象,类也是对象 面向对象三个特征:封装,继承,多态
  • C++ & 对象

    2020-08-14 13:37:51
    类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。C++ 类定义一个类,本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据,但它定义了类的名称意味着什么,就是说,它定义了类的对象包括了...
  • 面向对象数据模型

    千次阅读 2018-03-28 09:22:25
    所谓面向对象数据模型指属性和操作属性的方法封装在称为对象类的结构中的模型。可以通过将一个对象类嵌套或封装在另一个类里来表示类间的关联,新的对象可以从更一般化的对象类中导出,如:以下是描述面向对象数据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,705
精华内容 682
关键字:

对象的数据也可以称为类的