面向对象知识练习

#__author:"Ryzreal"
#date :2018/7/2
"""
类的定义
class 类名 :
    def 方法名(self,*args,**kwargs):
        print(args)
        return 1

中间人 = 类名()
ret = 中间人.方法名（1）
print（ret）

"""
#  self 等于被调用的中间人 ，公共的部分可以封装到中间人里
# class Ber:
#     def foo(self,args):
#         print(self,self.name,self.age,args)
#
# z = Ber()
# z.name = "alex"
# z.age = 18
# z.foo(666)
#
# z1 = Ber()
# z1.name = "ben"
# z1.age = 18
# z1.foo(777)
# 普通方法，构造方法__init__,  封装

# class Ber1:
#     def __init__(self,n1,n2,n3):
#         self.mane1 = n1
#         self.mane2 = n2
#         self.mane3 = n3
#         self.mane4 = n3
#         self.mane5 = n3
#         self.mane6 = n3
#     def foo(self):
#         print(self.mane1,self.mane2,self.mane3,self.mane4,self.mane5,self.mane6)
#
# z1 = Ber1(1,2,3)
# print(z1.mane1)
# z1.foo()
#
# class Person :
#     def __init__(self,name,age):
#         # 构造方法，构造方法的特性， 类名() 自动执行构造方法
#         self.n = name
#         self.m = age
#     def show(self):
#         print("%s-%s"%(self.n,self.m))
#
# lihuan = Person("李欢",13)
# lihuan.show()
# hu = Person("胡",13)
# hu.show()


#继承
# class F:
#     def f1(self):
#         print("F.f1")
#     def f2(self):
#         print("F.f2")
#
# class S(F):
#     def s1(self):                  #self永远是执行该方法的调用者
#         print("S.s1")
#     def f2(self):                #可以重写父类方法
#         super(S,self).f2()      #执行父类方法f2()，也可以执行重写的方法，第一种方法，，
#         F.f2(self)              #第二种方法
#         print("S.f2")
#
# obj = S()
# obj.s1()
# obj.f2()

#多继承
# class F1:
#     def a(self):
#         print("f1.a")
#
# class F2:
#     def a(self):
#         print("f2.a")
#
# class F3(F1,F2): #多继承从左（继承父类一条道走到黑，直到有共同的父类停止，再从另一条找到共同父类）到右优先继承
#     pass
#
# c = F3()
# c.a()


# class BaseReuqest:
#     pass
#
# class RequestHandler(BaseReuqest):
#
#     def serve_forever(self):
#         print("RequestHandler.serve_request")
#         self.process_request()
#     def process_request(self):
#         print("RequestHandler.process_request")
# class Minx:
#
#     def process_request(self):
#         print("minx.process_request")
#
# class Son(Minx, RequestHandler):
#     pass
#
# s = Son()
# s.serve_forever()


#字段与方法
# class Province:
#     #静态对象.属于类，执行时可以通过对象，也可以通过类访问
#     country = "中国"
#     def __init__(self,name):
#         #普通字段，属于对象，只能通过对象访问
#         self.name = name
#     #普通方法属于类，要先创建对象，执行时可以通过对象，也可以通过类访问（一般都用这种）
#     def ber(self):
#         print("bar")
#     #静态方法 保持在类中，在前面加装饰器 @staticmethod ，可以把sta(self)中self省去，且不需创建对象
#     @staticmethod
#     def sta():
#         print("sta")
#
#     @staticmethod
#     def sta1(a1,a2):
#         print(a1,a2)
#
#     #类方法 保持在类中，在前面加装饰器 @classmethod ，cls指当前类，默认是添加的。且不需创建对象
#     @classmethod
#     def classmet(cls):
#         print(cls)
#         print("classmet")
#
#     #属性或特性，在前面加装饰器 @property， 执行时obj.per可以不加（），有返回值
#     @property
#     def per(self):
#         print("per")
#         return 1
#
#     #设置 只是调用方法
#     @per.setter
#     def per(self, val):
#         print(val)
#
#     #删除 只是调用方法
#     @per.deleter
#     def per(self):
#             print(666)
#
# obj = Province("上海")
# r = obj.per
# print(r)
#
# #进入 per(self, val)
# obj.per = 123                               #这样目的是可以省去括号
# #进入 per(self)
# del obj.per

# Province.classmet()


# Province.sta()
# Province.sta1(1,2)
#
# obj = Province("江苏")
# obj .ber()

# print(Province.country)
# c = Province("浙江")
# print(c.country)
# print(c.name)