python（day028——面向对象1）

#使用类的编程方式，叫做面向对象编程，OOP
#object oriented programming

age = 100  #全局变量，在当前文件中，可以被访问
class Resume:  # 简历模板，类对象

    count = 0 #类变量，在内存中只保存一个地址。做统计，或者是不同实例可以一起访问的公有变量。

    def __init__(self, name, age):
        #不加self的变量叫做局部变量，只能在当前方法中使用
        #加self的变量叫做实例变量，可以再不同的实例方法中被访问到
        self.name = name
        self.age = age
        Resume.count+=1  #调用类变量

    def set_age(self,age):  #设置一下年龄
        self.age=age

    def get_age(self):  #读取一下年龄
        print (age)  #age定义在类外面，全局变量
        return self.age

# 为实例，实例对象
xiaozhang_resume = Resume("小张", 28)
xiaoli_resume = Resume("小李", 28)
xiaowu_resume = Resume("小吴", 28)

print(xiaozhang_resume.name)
print(xiaoli_resume.name)
print(xiaowu_resume.name)

print(xiaozhang_resume.get_age()) #调用了实例方法
xiaozhang_resume.set_age(11)
print(xiaozhang_resume.get_age())

print(Resume.count) #调用类变量，该类变量统计生成多少次实例
print(xiaozhang_resume.count) #用实例名也可以调用类变量

xiaozhang_resume.count=100  #定义了一个count的实例变量，和原本的count没关系，相互不影响
print(Resume.count)  #结果3
print(xiaozhang_resume.count)  #结果100

Resume.count=100  #调用类变量，count变为100
print(Resume.count)  #结果100
print(xiaozhang_resume.count)  #结果100

# 对象：类对象和实例对象
#类对象：类定义，有哪些方法含有那些变量。在内存中，只存一份类变量和类中定义的相关方法。
#实例对象：每个实例数据相互独立，那么在内存中，内一个实例单独占用一个独立的内存地址空间。
#方法：类里面定义的函数。如果包含self的参数，表示实例方法。
#实例变量：self.xxx。每个self.xxx中的内容都不一样。在类中的不同方法中可以可以使用。
#         不同实例的实例变量值是存在各自实例地址中，相互独立，且不影响。
#局部变量：只能在函数或类的方法中定义，且只能在当前方法中使用，外面不可使用
#全局变量:在当前文件中（文件默认命名空间里面），哪里都可以访问
#类变量：类名.xxx，类中所有方法均可访问，所有实例共用一个类变量。在内存中只有一个地址。

总结：

1.如果类变量名字，在实例中不存在，则：

   类名.xxx和实例名.xxx访问到都是类变量

2.如果类变量名字，在实例中存在，则：

   类名.xxx——>类变量，实例名.xxx访问的是实例变量

3.如果类变量名字在实例中不存在，但多了一步：

   在类的外面：实例名.类变量名字=yyy

   那么实例名.类变量名字访问的是新生成的实例变量，也就是yyy

   类名.xxx——>类变量

>>> class P:
...     count=0
...     def __init__(self):
...         P.count+=1
...
>>> p1=P()
>>> p2=P()
>>> P.count
2
>>> p1.count
2
>>> p2.count
2
>>> p1.count=123 #给实例变量赋值，不影响类变量值
>>> p2.count=456 #给实例变量赋值
>>> p1.count
123
>>> p2.count
456
>>> P.count
2

私有变量

class Resume:
    count = 0
    def __init__(self, name, age):
        self.name = name
        self.__age = age  #私有变量，等价于self._Resume__age
        Resume.count+=1  #调用类变量

    def set_age(self,age):  #设置一下年龄
        if isinstance(age,int) and age>0: #对变量的设置进行限制
            self.__age=age
        else:
            return None
        return self.__age

    def get_age(self):  #读取一下年龄
        return self.__age

# 为实例，实例对象
xiaozhang_resume = Resume("小张", 28)
xiaozhang_resume.__age=11  #相当于在外部生成了一个新的实例变量，和类里的私有变量不是同一个值
#修改的值和原有的私有变量，是两个不同变量
#在类里面的self.__age和self._Resume__age不一样
print(xiaozhang_resume.get_age())  #结果为28
#print(xiaozhang_resume.__age())  执行报错，私有变量在外部不能直接访问
print(xiaozhang_resume._Resume__age)#可以如此访问，但是不安全，不符合规则

---

1 实例方法：def xxx(self)，必须实例化之后才可以使用
2 staticmethod 方法
  @statcimethod
  def xxxx():
      类变量，不能使用实例变量
  通过类名或者实例名调用
3 classmethod方法
  @classmethod
  def xxxx(cls):
        类变量，不能使用实例变量
  通过类名或者实例名调用

---

静态方法

优势：可以用作把很多函数归类。使用静态方法定义常用的函数。

class Resume:
    count = 0
    def __init__(self, name, age):
        self.name = name
        self.__age = age  #私有变量，等价于self._Resume__age
        Resume.count+=1  #调用类变量

    def set_age(self,age):  #设置一下年龄
        if isinstance(age,int) and age>0: #对变量的设置进行限制
            self.__age=age
        else:
            return None
        return self.__age

    def get_age(self):  #读取一下年龄
        return self.__age

    @staticmethod #静态方法
    def get_count():
        return Resume.count #不能使用实例变量，可以使用类变量

# 为实例，实例对象
print(Resume.get_count()) 
#静态方法不需要实例化，在不生成实例时候，也可以直接调用，里面只能生成类变量
xiaozhang_resume = Resume("小张", 28)
print(xiaozhang_resume.get_count())

类方法

class String:

    @classmethod  # 类方法
    def get_all_upper_letters(cls, a, b):
        print(a, b)
        return None


print(String.get_all_upper_letters(1, 2))