python ====面向对象=== 16


面向对象 

  什么时候使用面向对象?

    代码量大,  功能多的时候

    处理比较复杂的角色之间的关系的时候

  代码的清晰度更高:

    可读性    :   无论是开发者还是调用者都能明确  的分辨出每个角色拥有的方法

    增加了代码的可扩展性

    更加规范

类:  具有相同属性和技能的一类事物     比如   :  人类

    类和类型  是一个东西   每个类型都是一个类   

    type( obj )   obj是一个对象,  那么它的type  就是它的类型

  创建一个类 :   

      class  类名    类也是被创建出来的,   被 type创建出来的类  

        type ( 对象 )   ===>   对象所在的类名

        type( 类名 )  ===>    type类型      除非制定class  类名(metaclass=***)     那么type就是这个类的元类

      class  A( metaclass=ABCMeta):

          那么  ABCMeta  创建了  A类  那么ABCMeta  就是A的元类   

      其他的  type  是所有类的元类

对象 :   python中 一切皆为对象   基础的数据类型  都是对象

  具体的某一个事物 , 具体的类的表现 

   ,具体到类中的某一个东西,某个实例   ,   例如 :  张杰

  类创造对象的过程就是实例化的过程    先new开辟空间  再init初始化

  可以通过指针类找到类的空间中的内容   

  对象本身内部也储存了一些只属于对象的属性

定义一个人类:     类名首字母必须大写

class  Person:           #  定义一个类     人类(类名)

  mind = " 有思想的 "     ====>

  animal = " 高级动物 "        ===>     静态变量  部分    静态字段    变量

  faith = " 有信仰的 "     =====     

  def  _ _init_ _(self):            #      构造方法

    print(666)

  def  work(self) :

    print("会工作...")

  def  shop(self) :

    print("可以消费")

从类名的角度调用类中的静态变量

  print(Person. _ _dict_ _)  #    查询 类中所有的内容,  查出来形式是 字典的形式

  print( Person . _ _dict_ _[ faith ]  )  ===>  有信仰的     # 类名的角度调用静态变量,但是  一般查询单个内容不用_ _dict_ _查询

  Person._ _dict_ _不能进行增删改     只能查

 

从类名的角度对  类中的单个变量进行  增删改查  

  用  万能的  点   .      类名 . 属性

  print( Person.mind )  ===>  有思想的     #   查询静态变量

  print( Person. animal )  ===>   高级动物    

 

  Person . money  = " 运用货币 "   #   增加一个 静态变量   

  print(Person._ _dict_ _)   打印可以看到其中多了   money: 运用货币

 

  Person . mind = " 无脑的  "      #   修改    静态变量

  print(Person._ _dict_ _)   打印可以看到  其中 有思想的    改为了   无脑的

 

  del Person.mind     #   删除   静态变量 

  print(Person._ _dict_ _)   打印可以看到   mind= " 无脑的 "   被删除了

 

从类名的角度  操作类中的方法  (工作中基本不用)

  Person . work( 111 )  ==> 都会工作... 

 

从对象的角度   操作

 

类名 + ( )  : 过程  :  实例化过程  ,  相当于创建了一个  实例的 对象

Person( )   

1.  只要有 一个  类名+ ()    就会产生一个对象  自动执行  _ _init_ _  函数方法

  ret=Person()    #   看似没有对象实际上是将  对象传给 self   自动传给第一个位置参数   self

  print(ret) ===> 666

def  _ _init_ _(self,name,age,hobby):            #      构造方法

    self.name=name

    self.age=age

    self.hobby=hobby

    print(name,age,hobby)

  ret=person("alex",28,"IT")

  print(ret)===>   alex,28,IT

 

实例化过程

:   1.     类名+()   产生一个实实例 ( 对象 )  (对象空间) 

  2.     自动执行类中的 _ _ init_ _方法  并将对象空间传给 _ _init_ _中的 self  

  3.    执行具体的 _ _init _ _中的代码   ., 给对象  封装相应的  属性   

    _ _iniit_ -中的self 后边的参数  就是封装的  属性    例如:

                              self.name=name

                              self.age=age

                              self.hobby=hobby

        

对象的角度  操纵类中的静态变量    

  print(ret.mind)   ===>   有思想    #   只能查 

  1.   对象名 . _ _dict_ _     #查询 对象中  所有的内容  

    p1=Person("alex", 28, "IT")

       print(p1._ _dict_ _)====>   {'name': 'alex',  'age': 28, 'hobby': "IT"}

  2.  万能的  .   对象名. 属性

    print( p1.name )====>  alex   #   查询  

    p1.hight = 175     #  增加

    print( p1._ _dict_ _)   可以看出   {'name': 'alex',  'age': 28, 'hobby': "IT"  , "hight" : 175 }

    del  p1. name     #   删除

    print( p1._ _dict_ _)   可以看出    {  'age': 28, 'hobby': "IT"  , "hight" : 175 }

    p1.age=73

    print( p1._ _dict_ _)   可以看出   {  'age': 73, 'hobby': "IT"  , "hight" : 175 }

对象的角度   调用类中的方法   :   

    第一个参数不用传  , 

    工作中常用  ,通过对象 执行类中的方法  ,而不是通过类名

    p1.shop()

操作类中的方法  除了类方法. 静态方法   需要用类名调用之外,  剩下的方法,  都要用对象名调用

  在类中添加属性

    def  func(self):

      self.hight=175

 

为什么要在   _ _init_ -中封装属性?

  因为 ,在他里边封装.   只要有 类名 +( )  它就可以自动执行    方便

 

计算实例化次数

  class  Count:

    count=0

    def   _ _init_ _(self):  

      Count.count=Count.count  +1   #  Count.count  指的是静态变量的 count   

                      ,因此    最终结果只能用 Count.count  来表示

或者       Count.count= self.count  +1       #   self.count   这时传进去的count  和外边的是一样的,但是结果必须用

                      Cont.count表示                                          

  odj=count()

  obj1=count()

  print(Count.ount)  ===>2 

 

查询顺序

  通过  类名  查询   

    类名 . 属性    先从本类  空间中找   ,如果找不到  再从父类中找  ,

  通过   对象查询

    对象 . 属性     先从对象所在空间 找,  若找不到  再从所在类的空间找,   再找不到,   再去父类中找...

 

通过类名  可以改变 类中的静态变量的值  

  但是 通过对象  不能改变,  只能引用类中的静态变量  ,   因为   通过对象一改  就相当于  新增了  一个属性

 

 

 

 

 

 

 


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
  © 2014-2022 ITdaan.com 联系我们: