Python【面向对象编程】

#1、python中,类名首字母都大写
#2、在python3中,经典类和新式类没有任何区别
#3、在python2中，经典类和新式类的区别主要体现在多继承上,经典类是深度优先,新式类是广度优先
#4、在python3中，都是广度优先

#定义一个【经典类】
class Japanese:
    pass

#定义一个【新式类】
class Chinese(object):
    pass

print("=============定义一个类===========")

 class Person(object):

     #构造函数:可有可无,不是必须存在的
     #在实例化一个类的对象时,自动执行构造函数,不需要我们手动显式的调用构造函数
     def __init__(self,skin='white',nose='high',eye='blue'):
         self.skin_color = skin
         self.nose = nose
         self.eye_color = eye
         self.__language='english'

     # 析构函数:在实例被销毁的时候自动执行,不需要我们手动调用析构函数
     # 析构函数可有可无,不是必须存在的,一般可在该函数中,执行一些关闭数据连接的操作
     def __del__(self):
         # ..........
         # ..........
         # ..........     此处省略掉关闭数据库连接的代码行
         pass

     # 类变量:公共的变量,每个实例都可以用
     country = 'usa'
     #实例变量：比如前面构造函数中的【self.nose】,【self.skin_color】等,可以在所有实例方法中访问,也可以在类外部访问
     #私有变量:比如前面构造函数中的【self.__language】,只能在类内部访问,类外部无法访问到,变量名是两个下划线开头命名的

     #实例方法:self代表本类对象
     #可以访问类变量和类方法
     #可以访问静态方法
     #可以访问属性方法
     def run(self):
         print(self.country)
         self.eat_class_1()
         self.sleep_static_1()
         self.walk_property_1
         self.run_1()

     def run_1(self):
         print("实例方法")

     #属性方法:通过实例对象调用,不要通过类进行调用
     @property
     def walk_property(self):
         print(self.country)
         self.eat_class_1()
         self.sleep_static_1()
         self.run_1()
         self.walk_property_1

     @property
     def walk_property_1(self):
         print("属性方法")

     #类方法:
     # 1、不用实例化就可以直接调用
     # 2、它可以通过cls使用类变量
     # 3、它不能调用这个类里面的其他实例方法和实例变量
     # 4、可以访问静态方法
     # 5、cls代表对的就是Person
     @classmethod
     def eat_class(cls):
         print(cls.country)
         cls.sleep_static_1()
         cls.walk_property_1
         cls.eat_class_1()

     @classmethod
     def eat_class_1(cls):
         print('类方法')

     #静态方法
     # 1、一个普通函数，只不过是写在类里面而已，它用不了类变量、类方法、实例变量、实例方法、属性方法、静态方法
     @staticmethod
     def sleep_static():
         try:
             self.run_1()
         except Exception as e:
             print(e)
         try:
             self.walk_property_1
         except Exception as e:
             print(e)

         try:
             self.sleep_static_1()
         except Exception as e:
             print(e)

         try:
             self.eat_class_1()
         except Exception as e:
             print(e)

     @staticmethod
     def sleep_static_1():
         print('这个是静态方法，它和一个没写在类里面的函数一样')

     #私有方法:只能在类内部访问,类外部无法访问到,方法名是两个下划线开头命名的
     def __speak(self):
         print ("这是个私有方法")

     #实例方法：方法名是一个下划线开头命名的
     def _shopping(self):
         self._flower = "rose"
         print("方法名一个下划线开头的实例方法")

     def tool(self):
         print(self.__language)
         return self.__speak()

print("==========修改类变量===========")

 #实例化两个美国人
 p = Person()
 p1 = Person()

 p.country='USA'
 #Person.country = 'USA'
 print("p.........:",p.country)
 print('p1.......',p1.country)
 print('Person.......',Person.country)
 #结论:p.country='USA'和Person.country = 'USA'两种赋值方式有区别:
 #1、通过Person.country = 'USA'这种方式给【country】类变量赋值,则:Person.country、p.country、p1.country 三个的值都是USA,
     #说明影响的是类的所有实例以及类本身
 #2、通过p.country='USA'这种方式给【country】类变量赋值,则：p.country的值是USA,而Person.country和p1.country的值是空,
     #说明影响的是当前实例,并不会影响其他实例和类本身

print("========通过实例调用四种不同类型的方法=========")

 print(p.walk_property)          #通过实例调用属性方法:正确
 print(p.eat_class())            #通过实例调用类方法:正确
 print(p.sleep_static())         #通过实例调用静态方法:正确
 print(p.run())                  #通过实例调用实例方法:正确
 print(p._shopping())            #通过实例调用一个下划线开头的实例方法:正确
 print(p._flower)                #通过实例调用一个下划线开头的成员变量:正确

 print(p.tool())                 #通过tool()方法间接调用私有方法和私有变量

print("========通过类调用四种不同类型的方法========")

 print(Person.walk_property)     #通过类调用属性方法:错误
 print(Person.eat_class())       #通过类调用类方法:正确
 print(Person.sleep_static())    #通过类调用静态方法:正确
 #print(Person.run())            #通过类调用实例方法:错误

print("=======类的继承==========")

 #支持多继承，比如class Japanese(Person,XXX,XX)
 class Japanese(Person):
     def play(self):
         print("我是一个子类")

     #重写父类方法
     def run(self):
         # 调用父类方法
         Person().run()

         #如果继承多个父类,super会根据继承的父类顺序,从左至右依次去找每一个父类,如果在某个父类中找到该方法,则停止寻找，
         #直接实例化一个第一次找到的那个父类的对象,然后再调用父类的方法
         super(Japanese, self).run()
         print("重写父类方法")

 j1 = Japanese(nose='flat',skin='yellow',eye='black')
 j2 = Japanese()
 Japanese.country='Japan'
 print('Japanese.......',Japanese.country)
 print('j1........',j1.country)
 print('j2........',j2.country)

# if __name__ == '__main__':
# 1、判断python文件是在别的地方导入的，还是直接运行的这个python文件
# 2、这句话一般是做调试的时候用的。
# 3、如果是直接运行这个python文件的时候，这句话一点用都没有