day15 面向对象 成员

成员
1. 变量
   1.实例变量 
   格式:
   变量.xxx=xx (称为实例变量,也叫属性,字段)给对象用的
   2.类变量
   类变量:直接写在类中的变量就是类变量,类变量一般用类名来访问
          其实就是类中相同的属性提取出来
   总结:实例变量, 给对象用的的.
        类变量, 多个对象共享的. 最好是用类名来访问. 这样更加规范.
    例:
    class Person:
        cooutry="中国"
        def __init__(self,name,age):
            self.name=name
            self.age=age
    Person.country="大清"                #类变量只能通过类名来改变                
    p1=Person("小王",18)
    p1.country="大清"                    #尽管对象拥有country这个类变量,但是并不会修改类变量,
                                         #只是给p1赋值了一个实例变量
    print(p1.country)                    #大清
    print(Person.country)                #直接通过类名访问  大清
    
    p2=Person("小红",16)
    print(p2.country)                    #大清

2.方法
  1.实例方法 
   语法:
   对象.方法() 直接调用
   说白了就是对象直接调用的方法
  
  2.类方法  加前缀@classmethod
  例:class Person:
    def chi(self):
        print("好吃")
    @classmethod
    def he(cls):              参数第一个位置要预留,默认为(cls),
        print("吃")           而静态方法,不需要预留这个,这是他们的区别
    p1=Person()
    p1.he()      #不管是类还是对象访问类方法,默认传进去的是类
                  最好是用类名去访问    
                  

  3.静态方法  加前缀@staticmethod
    例:
    class Computer:
       def play(self):
         print("我的电脑可以玩")
       @staticmethod                       静态方法第一个参数位置不需要预留
       def fare() :                        可以用对象访问也可以用类名访问,最好用对象
         print("我的电脑好, 可以煎鸡蛋")   访问,以区分类方法和实例方法(相当于在类中定义一个普通函数)
       @classmethod
       def cal(cls, a, b):
         print(cls)
         return a+b
       print(Computer.cal(1, 2)) # 此时会自动的把类名传递给类方法的第1个参数

3.属性
  语法: 对象.属性
  class ren:
     def __init__(name ,birthday)
         self.name=name
         self.birthday=birthday
     @property                          #把方法转为属性
     def age(self)
        return 2018-self.birthday
     r=ren("小王",1995)
     age=r.age
     print(age)
     注:
     1.方法只能有一个参数self
     2.必须加前缀@property
     3.调用时候,不需要括号,直接当成属性来使用就行
     4.只能取值,不能赋值(需要有返回值)

4.私有
   1.私有变量  2.私有方法  (注,私有方法,子类是无法继承的)
   例:
   class Person:
    def __init__(self,name):
        self.__name=name         #私有变量
        print("这里是构造函数(方法)")
    def init(self):
        print("这里是实例方法")
        return self.__name
    def __chi(self):
        print("这里是私有方法")
    def __laopo(self):
        print("这是刘强东的老婆")
    def he(self):
        self.__laopo()
        print("让你看看怎么调用私有的,比如别人的老婆")

p=Person("小王")
print(p.__name)   #报错,访问不到  私有变量
p._chi()          #报错,访问不到 私有方法

name=p.init()
print(name)           #通过其他方法访问到私有变量

p.he()                #老婆是刘强东的,但是我把她报出来玩了(
                    # 可以把别人的老婆(私有的)带到自己的世界玩,)
                    #(在自己的世界,别人私有的想怎么玩就怎么玩)
#总结:私有变量不是绝对的,可以通过其他非私有方法访问
#     静态变量和类变量是一样的道理

 

例
关于私有方法的一种注意事项,引用自老师
#正常情况
>>> class A:
...     def fa(self):
...         print('from A')
...     def test(self):
...         self.fa()
... 
>>> class B(A):
...     def fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from B
 

#把fa定义成私有的，即__fa
>>> class A:
...     def __fa(self): #在定义时就变形为_A__fa
...         print('from A')
...     def test(self):
...         self.__fa() #只会与自己所在的类为准,即调用_A__fa
... 
>>> class B(A):
...     def __fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from A