精华内容
下载资源
问答
  • 一个完整的类(python任何类只要继承这个方法,他的实例对象都可以转换成dict) # 让一个类支持转换成dict()字典的基类(json.dumps方法序列必须继承这个类) class ClassIterator: def __init__(self): self....
    一个完整的类(python任何类只要继承这个方法,他的实例对象都可以转换成dict)
    
    
    
    # 让一个类支持转换成dict()字典的基类(json.dumps方法序列化必须继承这个类)
    class ClassIterator:
        def __init__(self):
            self.iter_keys = []
    
        # 对象转字典必须实现的方法,自动调用获取需要dict化的属性名
        def keys(self):
            return self.iter_keys
    
        # 对象模式序列化成dict必须实现的方法,和keys方法配合返回dict属性的value
        def __getitem__(self, key):
            return getattr(self, key)
    
        # 可以动态隐藏不需要返回的属性名
        def hide(self, *keys):
            for key in keys:
                self.iter_keys.remove(key)
            # 兼容链式调用(非常适合列表推导式)
            return self
    
        # 可以动态增加需要返回的属性名
        def append(self, *keys):
            for key in keys:
                self.iter_keys.append(key)
            # 兼容链式调用(非常适合列表推导式)
            return self

     

    展开全文
  • 万物皆对象任何一种事物都可以看做是对象。 2. 如何描述对象 通过对象的属性(名词,数量词,形容词)和行为(动词)来描述对象。 eg:描述冰箱对象 属性:品牌,容量,颜色,功耗 行为:装东西,冷冻,...

    小记:静默如初,安之若素

    1. 类和对象

    1. 什么是对象
    万物皆对象,任何一种事物都可以看做是对象。
    2. 如何描述对象
    通过对象的属性(名词,数量词,形容词)和行为(动词)来描述对象。

         eg:描述冰箱对象
         属性:品牌,容量,颜色,功耗
         行为:装东西,冷冻,冷藏
    

    3. 面向对象的程序设计
    对自然世界中对象的描述引入到编程实践的方法,这种方法称为“数据抽象”,即在描述对象的时候把细节的东西剥离出去,而只考虑一般性的,有规律性的,统一的东西。
    4. 什么是类?
    类是将多个对象的共性提取出来定义的新的数据类型,是对对象属性和行为的抽象描述。

    2.类的定义和实例化

    1. 类的一般形式

    class/struct 类名:继承方式 基类,...{
    访问控制属性:
    	类名(形参表):初始化表{} //构造函数
    	~类名(void{} //析构函数
    	返回类型 函数名(形参表){}//成员函数
    	数据类型 变量名;//成员变量
    };
    

    2. 访问控制属性
    2.1 public:公有成员,类的内部和外部都可以访问的成员
    2.2 protected:保护成员
    2.3 private:私有成员,只有在类的内部才可以访问的成员
    注:使用class定义的类默认的访问控制属性是private, 而使用struct定义的类默认的访问
    控制属性是public。

    eg:
     1 #include <iostream>
      2 using namespace std;
      3 
      4 //原来叫定义结构体,现在叫定义类
      5 //struct Student//struct 中的属性默认是公有的,class中的属性默认是私有的
      6 class Student
      7 {
      8 public:
      9   //行为:用成员函数描述
     10   void eat(const string &food)//string其实是一个类,对于类类型的参数都需要加引用,减少程序开销
     11   { 
     12     cout<<"I eat : "<<food<<endl;
     13   }
     14   void sleep(int hour)
     15   { 
     16     cout<<"I sleep "<<hour<<" hours"<<endl;
     17   }
     18   void learn(const string &course)
     19   { 
     20     cout<<"I am learning : "<<course<<endl;
     21   }
     22   void who(void)
     23   { 
     24     cout << "my name : "<< m_name << ", age : "<< m_age <<
     25         ", number : "<< m_num <<endl;
     26   }
     27 
     28 private:
     29   //属性:用成员变量描述
     30   string m_name;//私有
     31 public:
     32   //私有成员在类的外部不能直接访问,
     33   //但是可以提供公有的函数间接访问,在函数中可以
     34   //对非法数据加以限定,控制逻辑合理性
     35   void setName(const string &name)
     36   { 
     37     if(name == "two")
     38     { 
     39       cout<<"error"<<endl;
     40     }
     41     else
     42     { 
     43       m_name = name;
     44     }
     45   }
     46 public: 
     47   int m_age;
     48   int m_num;
     49 };
     50 
     51 int main(int argc, char * argv[])
     52 {
     53   //原来叫定义结构体类型变量
     54   //现在叫做创建对象,或实例化对象
     55   Student s;
     56   //s.m_name = "zhangfei";
     57   s.setName("zhangyide");
     58   s.setName("two");
     59   s.m_age = 18;
     60   s.m_num = 123456;
     61   s.who();
     62   s.eat("apple");
     63   s.sleep(8);
     64   s.learn("C++");
     65 
     66   return 0;
     67 }
    运行结果:
    error
    my name : zhangyide, age : 18, number : 123456
    I eat : apple
    I sleep 8 hours
    I am learning : C++
    

    3. 构造函数(Constructor)
    3.1 构造函数的函数名和类名相同,没有返回值;
    3.2 构造函数在创建对象时自动被调用,不能像普通成员函数一样直接去调用。

    构造函数的形式:
    class 类名{
    	类名(构造形参表){
    		//主要负责对象的初始化,即初始化成员变量
    	}
    }
    eg:
      1 #include <iostream>
      2 using namespace std;
      3 
      4 class Student
      5 {
      6 public:
      7   Student(const string& name, int age, int id)
      8   {
      9     cout <<"构造函数"<<endl;
     10     m_name = name;
     11     m_age = age;
     12     m_id = id;
     13   } 
     14 
     15   void who(void)
     16   {
     17     cout << "My name : "<<m_name<<" , age : "<<m_age<<", num : "<<m_id<<endl;
     18   } 
     19   
     20 private:
     21   string m_name;
     22   int m_age;
     23   int m_id;
     24 };
     25 
     26 int main()
     27 {
     28   //创建对象,构造函数将自动被调用
     29   //(...):指明构造函数所需要的实参
     30   Student s("rxl", 22, 12346);
     31   s.who();
     32   //构造函数不能显示的调用
     33   //s.Student("xl", 21, 1234);//error
     34   return 0;
     35 }
    ~      
    

    **练习:**实现一个电子时钟类,要求适用构造函数初始化当前的时间,以秒单位运行。

    //查看time函数的源码:man 2 time
      1 #include <iostream>
      2 #include <cstdio>
      3 #include <ctime>
      4 #include <unistd.h>
      5 
      6 using namespace std;
      7 
      8 class Clock{
      9 public:
     10   Clock(time_t t)
     11   {
     12     tm *local = localtime(&t);
     13     m_hour = local->tm_hour;
     14     m_min  = local->tm_min;
     15     m_sec = local->tm_sec;
     16   }
     17 
     18   void run(void)
     19   { 
     20     while(1)
     21     {
     22       printf("\r%02d:%02d:%02d", m_hour, m_min, m_sec);
     23       fflush(stdout);//刷新输出缓冲区
     24       if(++m_sec == 60)
     25       { 
     26         m_sec = 0; 
     27         if(++m_min == 60)
     28         { 
     29           m_min = 0;
     30           if(++m_hour == 24)
     31           { 
     32             m_hour = 0;
     33           }
     34         }
     35       }
     36       sleep(1);
     37     }
     38   }
     39 
     40 private:
     41   int m_hour;
     42   int m_min;
     43   int m_sec;
     44 };
     45 
     46 int main(int argc, char *argv[])
     47 { 
     48   Clock t(time(NULL));
     49   t.run();
     50   return 0;
     51 }
    运行结果:
    22:29:04
    

    4. 对象的创建和销毁
    4.1 在栈区创建单个对象:

    格式:
          类名  对象 (构造实参表);
          类名  对象   =  类名(构造实参表);//和上面等价 
    

    4.2 在栈区创建多个对象(对象数组)(了解):

    格式:
    	 类名 对象数组[元素个数] = {类名(构造实参表),...}

    4.3 在堆区创建单个对象

    创建:
    	类名 * 对象指针 = new 类名(构造实参表);
    销毁:
        delete 对象指针;
    

    4.4 在堆区创建多个数组(了解)

    创建:
    	类名 * 对象指针 = new 类名[元素个数]{类名(构造实参表),...};
    销毁:
    	delete []对象指针;
    
      1 #include <iostream>
      2 using namespace std;
      3 
      4 class Student
      5 {
      6 public:
      7   Student(const string& name, int age, int id)
      8   {
      9     cout <<"构造函数"<<endl;
     10     m_name = name;
     11     m_age = age;
     12     m_id = id;
     13   } 
     14   void who(void)
     15   {
     16     cout << "My name : "<<m_name<<" , age : "<<m_age<<", num : "<<m_id<<endl;
     17   } 
     18 private:
     19   string m_name;
     20   int m_age;
     21   int m_id;
     22 };
     23 
     24 int main()
     25 {
     26   //在栈区创建单个对象
     27   //Student s("rxl", 22, 12346);
     28   Student s = Student("red1", 22, 12346);
     29   s.who();
     30   
     31   //在栈区创建多个对象
     32   Student sarr[3] = {
     33     Student("red2", 18, 1109),
     34     Student("red3", 19, 1111),
     35     Student("red4", 20, 1112)
     36   };
     37   sarr[0].who();
     38   sarr[1].who();
     39   sarr[2].who();
     40   
     41   //在堆区中创建单个对象
     42   Student *ps = new Student("red5", 21, 1113);
     43   ps->who();//(*ps.who())
     44   delete ps;
     45   ps = NULL;
     46   
     47   //在堆区创建多个对象
     48   Student *parr = new Student[3]{
     49       Student("red6", 22, 1114),
     50       Student("red7", 23, 1115),
     51       Student("red8", 24, 1116)};
     52   parr[0].who();//(parr+0)->who();
     53   parr[1].who();//(parr+1)->who();
     54   parr[2].who();//(parr+2)->who();
     55   delete []parr;
     56   
     57   return 0;
     58 } 
    

    5. 多文件编程
    类的声明和定义可以分别放在不同的文件中:

    1. 类的声明部分放在xx.h
    2. 类的实现部分放在xx.cpp
    展开全文
  •  万物皆对象任何一种事物都可以看做对象 2、如何描述和表达对象  通过对象的属性(名词,数量词,形容词)和行为(动词)表达对象。 3、面向对象的程序设计  对自然世界中对象观察引入到编程实践中的一种...

    三、类和对象

    1、什么是对象

      万物皆对象,任何一种事物都可以看做对象

    2、如何描述和表达对象

      通过对象的属性(名词,数量词,形容词)和行为(动词)表达对象。

    3、面向对象的程序设计

      对自然世界中对象观察引入到编程实践中的一种理念和方法,这种成为“数据抽象”,即在描述对象时,把细节东西剥离出去,考虑一般性、有规律性,统一性的东西。

    4、什么是类

      将普遍的对象的共性提取出来来定义的一种数据类型,是对 对象的属性和行为的抽象描述,对象就是类的实例化。

    四、类的定义和实例化

    1、类的一般形式

    class /struct 类名:继承表{

    访问控制限定符:

      //构造函数

      类名(形参表)[:初始化表]{函数体}

      //析构函数

      ~类名(void){函数体}

      //成员函数

      返回类型  函数名(形参表)[cosnt]{//函数体}

      //成员变量

      数据类型 变量名

    };

    2、访问控制限定符

    public:公有成员,在类内部和外部都可以访问

    private:私有成员,只能在类内部访问

    protected:保护成员(后面讲)

    注意:

    struct 的默认访问控制属性是公有的

    class 的默认访问控制属性是私有的

     

    转载于:https://www.cnblogs.com/ptfe/p/11237912.html

    展开全文
  • 结构体实例(包括共用体)和类实例的初始方法完全相同,二者都可以应用于继承层次中。不同点是结构体(包括共用体)默认成员为public,而默认成员是private型的。  一、若和结构体所有数据成员均为public型...
  • namespace app\index\controller; /* 容器与依赖注入的原理 ...----------------------------- ...1.任何的url访问,最终是定位到控制器,由...容器(原生注册树)来进行管理,还可以实例对象)作为参...


    app\index\Demo1.php

    
    namespace app\index\controller;
    /*
    容器与依赖注入的原理
    -----------------------------
    1.任何的url访问,最终都是定位到控制器,由控制器中某换个具体方法去执行
    2.一个控制器对应着一个类,如果这些类需要进行统一管理,怎么办?
    容器(原生注册树)来进行类管理,还可以讲类的实例(对象)作为参数,传递给类方法,自动触发依赖注入
    依赖注入:讲对象类型的数据,以参数的方式穿传到方法的参数列表中
    
    url访问:通过GET方式将数据传到控制器指定的方法中,但是只能传字符串,数值。。。
    
    */
    class Demo1{
    
        // 可以通过字符串,数值用GET方式来传值到类方法中
        public function getName($name = 'Peter')
        {
            return 'Hello'.$name;
        }
    
    //   \app\common\Temp $temp:将会出发依赖注入
    
    public function getMethod(\app\common\Temp $temp)
    {
        //   \app\common\Temp $temp 等价于
        //   $temp = new \app\common\Temp;
             $temp-&gt; setName('value');
             return $temp-&gt;getName();
    }
    
    }
    
    


    app\common\Temp.php

    
    namespace app\common;
    
    class Temp
    {
        private $name;
        public function __construct($name = 'Peter')
        {
            $this-&gt;name = $name;
        }
        public function setName($name)
        {
            $this-&gt;name = $name;
        }
    
        public function getName()
        {
            // __METHO__返回类的方法名
            
          return '方法是:'.__METHO__.'属性是:'.$this-&gt;name;    
        }
    }
    
    
    展开全文
  • 虚指针又叫虚函数指针是一个虚函数的实现细节,带有虚函数的中每一个对象都有一个虚指针指向该的虚函数表 虚函数的入口地址和普通函数的入口地址有什么不同? 每个虚函数在虚表中占有一个表项,保存着一条...
  • 1.pickle对象串行 pickle模块实现了一个算法可以将任意的Python对象...任何类实例都可以pickled,如后面的例子所示。 import pickle import pprint data = [{'a': 'A', 'b': 2, 'c': 3.0}] print('DATA:', end='
  • JAVA对象实例化的方法 本贴主要对JAVA实例化方式做个简单的总结,尤其是Unsafe的方式,可能很多人...注意:任何类都有构造方法,但是new指令只能创建非抽象类的对象;构造方法不能是静态的,因为静态方法不能使用t...
  • 对象的装载和实例化

    2007-03-15 19:15:00
    这句话就是装载用的(和new 不一样,要分清楚) 给一个字符串,它代表一个的包名和类名,怎么实例化它(不知道其构造函数),可以考虑如下方法了Class.forName("package.A");//装载A a = Class.forName("package.A")....
  • 什么是反射机制 JAVA反射机制是在运行状态中...Java反射机制指的是在Java程序运行状态中,对于任何一个都可以获得这个的所有属性和方法;对于给定的一个对象,都能够调用它的任意一个属性和方法。这种动态获取...
  • 对象实例化方式有:直接new对象、Class.forName(xxx.xx.xx)、Spring的注入机制、反射Class.forName(xxx.xx.xx) 返回一个 。首先你要明白在Java里面任何一个class要装载在虚拟机上才能运行。这句话就是装载用...
  • − 定义了一件事物的抽象特点。的定义包含了数据的形式以及对数据的操作。 对象 − 是的实例。一切皆对象。由类实例化出来的。...访问修饰符public 公有的,任何地方都可以访问,包括...
  • 读书笔记 仅供参考不可实例化类不希望被实例化,例如工具,包含的是静态方法和静态属性,实例对它没有任何意义。错误的做法将做成抽象。 原因:抽象类可以被继承,子类可以实例化。正确的做法包含一个...
  • 对象

    2018-01-09 00:10:00
    对象  是用来描述具有相同的...根据来创建对象被称为 实例化,这让我们能够使用的实例。 1. 对象的创建和使用  使用几乎可以模拟任何东西。在Python 3 中,创建和使用的具体格式如下:  cl...
  • 2.1Python之实例

    2018-03-31 12:30:33
     (class)是一个用户自定义类型,开发者可以将其实例以获得实例(instance),实例表示这种类型的对象。在Python中,就是对象,开发者可以像对其他对象那样处理函数,可以在调用函数时传递一个作为参数,也...
  • Class.forName有什么作用 Class.forName(xxx.xx....至于什么时候用,你可以考虑一下这个问题,给你一个字符串变量,它代表一个的包名和类名,你怎么实例化它?只有你提到的这个方法了,不过要再加一点。  A a =
  • C++——对象

    2020-02-12 10:19:39
    文章目录对象什么是对象如何描述对象面向对象编程什么是类类的定义和实例化类的语法形式对象的创建和销毁构造函数和初始化表代码示例 对象 什么是对象 万物皆对象任何一种事物都可以看做是对象。 如何...
  • 浅谈 对象

    2020-05-03 17:51:13
    但是一旦抽象出来,它可以反作用于对象,也就是可以创建出对象来,这个过程叫做实例化对象也叫作实例。 2.对象:存在于现实中(如桌子),现实中的任何东西对象,但要抽象出,需要许多对象,这些...
  • 面向对象

    2016-04-28 15:47:00
    //对象任何东西都可以称之为对象类实例化出来的东西 //:对所有同类的对象抽象出来的东西 //Info:code,name,sex,nation,birthday //对象:一条具体信息 p001 张三 男 汉族 1990-2-3 // 理解小贴士:...
  • (2) 都不能被实例化 (3) 都可以包含方法声明 (4) 派生必须实现未实现的方法 区 别: (1) 抽象基类可以定义字段、属性、方法实现。接口只能定义属性、索引器、事件、和方法声明,不能包含字段。 (2) 抽象是一个不...
  • 对象的介绍

    2020-06-08 21:56:32
    系统地介绍一下对象的定义,并能够给出程序举例。 Markdown和扩展Markdown简洁的语法 定义 对象是现实中的对象在程序中的模拟,是对...在关键字public后面声明,它们是与外部的接口,任何外部函数都可以访问
  • 1、什么是?...万物皆对象对象是客观存在的事物,可以任何客观存在的事物可以成为对象。 3、两者关系? 对象的抽象,对象实例化对象的特征对应的属性 对象的行为对应的方法 ...
  • 对象入门

    2016-04-27 21:27:00
    //对象//对象任何东西都可以称为对象类实例化出来的东西//:对所有同类的对象抽象出来的东西 //Info: Code,Name,Sex,Nation,Birthday//对象:一条具体的信息 p001 张三 男 汉族 1990-2-3 //定义:...
  • java-对象

    2017-12-29 20:29:57
    对象和对象变量对象和对象变量之间存在着很重要的区别,一个对象变量并没有实际包含一个对象.看下面实例: Date time = new Date(); 其中对象变量time可以引用Date类型的...构造器构造器与同名,构造器在实例化对象
  • 归档:对象

    2016-10-27 14:33:00
    请写一个,在任何时候都可以向它查询“你已经创建了多少个对象?” 程序设计思想: 定义的静态变量初始化为0.每创建一个对象此静态变量加一,来记录实例化对象的个数。 源代码: 1 package keTang_06; ...
  • 对象也叫实例,是经过实例化后所得到的内存中的实体 引用变量 孩子与气球的关系。 气球不一定有孩子牵着。 多个孩子可以使用各自的绳子牵着同一个气球,(任何一个引用变量访问同一个实例) 也可以都通过一个绳子...
  • 创建一个对象可以说是 创建一个实例,或者实例化一个对象,或者把类实例化 这里说的是创建一个实实在在的食物 有好几种说法。 是相同属性特征,行为特征,这一群体,我们定义为 用来定义的 用来创建对象...
  • 对象对象:能够见到的任何东西都可以称为对象, 也可以理解为类实例化出来的东西: 对所有同类的对象抽象出来的东西 举例理解对象:比如班级里面每个人相同的有学号,上课时间,休息时间,所上...

空空如也

空空如也

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

任何类都可以实例化对象