day20 Pyhton学习 面向对象-成员

一.类的成员

class 类名:
 # 方法
 def __init__(self, 参数1, 参数2....):
 # 属性变量
 　　self.属性1 = 参数1
 　　self.属性2 = 参数2
 ....
 # 方法
 def method(self):
 　　pass

在上面的代码中__init__和method都属于类的成员方法,又称为实例方法.self.属性1 = 参数1,这个代码的含义是给对象设置属性信息,又被称为成员变量或者实例变量.

二.类的成员-变量

　　在类中变量分成两大类:

　　　1.实例变量/成员变量

　　　2.类变量

class Person:
 # 类变量, 表示所有的该类的对象都共享这个变量.
     country = "中国"

 　　 def __init__(self, name, num, birthday):
 # 实例变量(字段) 表示你创建的每⼀个⼈都有这三个变量
         　　self.name = name
         　　self.num = num
         　　self.birthday = birthday
p1 = Person("alex", 18, "1840年06⽉01⽇")
print(p1.name) # alex
print(p1.country) #中国
p2 = Person("wusir", 28, "1894年07⽉25⽇")
print(p2.name) # wusir 
print(p2.country) # 中国   

p1 = Person("alex", 18, "1840年06⽉01⽇")
p1.country = "大清"
print(p1.name)
print(p1.country) # 大清
p2 = Person("wusir", 28, "1894年07⽉25⽇")
print(p2.name)
print(p2.country) # 中国

执行p1.country = "大清"的时候,并没有改变类中的country.而是添加了p1中的实例变量,这个实例变量只在p1中存在,在p2中不存在

通过程序来记录当前类被创建了多少个对象.

class Foo:
     count = 0
         def __init__(self):
                 Foo.count += 1
print(Foo.count) # 0
Foo()
Foo()
Foo()
print(Foo.count) # 3

好了. 来做个简单的总结:

　　实例变量, 给对象用的.

　　类变量, 多个对象共享的. 最好是用类名来访问. 这样更加规范.

 三.类的成员-方法

　　1.成员方法(实例方法)

　　2.静态方法

　　3.类方法

1.成员方法:

class Computer:

 # 实例方法(成员方法)
         def play(self):
             print("我的电脑可以玩儿")
c = Computer()
c.play() # 对象直接去调用实例方法

2.静态方法:静态方法不需要我们给方法传递self. 也就是说. 当出现一个方法不需要使用到成员变量的时候. 就可以选择使用静态方法. 静态方法需要我们在方法上面添加一个@staticmethod

@staticmethod
def fare():
     print("我的电脑非常牛B, 可以煎鸡蛋")

Computer.fare() # 类名可以直接访问的
c.fare() # 对象也可以访问. 但最好不要这么干. 以便于区分静态方法和实例方法

3.类方法. 类方法和静态方法差不多, 只不过类方法需要在参数列表中的第一个位置预留一个位置, 通常我们给第一个参数起名字叫cls. 类方法在被调用的时候也不需要传递实例对象. 但是. 系统会自动的把类传递给第一个参数. 类方法在编写的时候, 需要在类方法上面添加@classmethod

class Computer:
     def play(self):
         print("我的电脑可以玩⼉")
     @staticmethod
     def fare():
         print("我的电脑⾮常⽜B, 可以煎鸡蛋")
     @classmethod
     def cal(cls, a, b):
         print(cls)
         return a+b
print(Computer.cal(1, 2)) # 此时会自动的把类名传递给类方法的第一个参数                    

四 类的成员-属性

属性其实就是通过方法改造过来的一种变量的写法, 在方法上添加一个@property就可以 了

class Person:
     def __init__(self):
         pass
     @property
     def age(self):
         return 1

p = Person()
age = p.age
print(age)

应用场景: 我们一般保存数据的时候, 不会保存一个人的年龄. 因为随着时间的推移. 每个人的年龄都时刻在改变着. 那如何保存更加完美呢? 很简单. 保存出生年月日. 然后用程序来计算,你当前的年龄. 实时的. 那这个时候就需要进行相应的计算了. 而计算属于一个功能. 当然要写方法里了. 但是对于年龄这个属性而言. 他应该是一个数值. 而不是动作. 所以python就提供了这样一种机制. 通过方法来描述一个属性.
 注意:
 1. 方法参数只能有一个self
 2. 方法上方要写@property
 3. 调用的时候, 我们不需要写括号. 直接当成属性变量来用就可以了.
 4. 这种套路只能取值. 不能设置值

五.私有变量

class Person:
     def __init__(self, laopo, mimi):
         self.__laopo = laopo # 私有的
         self.__mimi = mimi
alex = Person("wusir", "他俩搞基")
print(alex.__mimi) # 私有的. 谁都不能碰

程序报错. 私有的内容是访问不到的. 但是, 这个访问不到是有一定的局限性的. 比如: 

class Person:
    def __init__(self, laopo, mimi):
        self.__laopo = laopo # 私有的
        self.__mimi = mimi
    def gaosuni(self):
        print("大喇叭开始广播了")
        return self.__mimi # 私有的内容.在他自己的方法那里, 他可以任意的进行使用
alex = Person("wusir", "他俩搞基")
mimi = alex.gaosuni() # 通过一个非私有的方法, 访问到了他的秘密.
print(mimi)

私有方法:

class Person:
    def __init__(self):
        pass
    def __yue(self):
        print("我要约会")
    def job(self):
        print("我要⼯作")
        # self.__yue()#在自己类中访问自己的其他方法. 哪怕是私有的. 也是自己在用
p = Person()
# Person.____yue()#报错
# p.__yue() # 报错
p.job()

需要注意的是, 对于私有的内容而言. 子类是无法继承的. 

class Fu:
     __qingfu = "情妇_⼩潘潘"
class Zi(Fu):
     pass
print(Zi.__qingfu) # 报错

class 类名: # ⽅法 def __init__(self, 参数1, 参数2....): # 属性变量 self.属性1 = 参数1 self.属性2 = 参数2 .... # ⽅法 def method(self): pass