day06 面向对象编程

面向对象：

世界万物，皆可分类

世界万物，皆为对象

只要是对象，就肯定属于某种品类

只要是对象，就肯定有属性

特性：

多态：

一个统一的接口，多种实现

例如: 一个公司有程序员，销售，前台，但是他们都属于员工

老板只需说工作，那么下面的员工就开始各自的工作，不管你是程序猿，前台都会各自做各自的事情

定义语法:

#定义一个狗类型

class Dog:

def bulk(self): #会叫

print("汪汪汪")

#创建一个狗

dog1 = Dog()

#创建多个狗:

dog2 = Dog()

dog3 = Dog()

#就为了传名字

构造函数：

#在实际化时做一些类的初始化的工作.

就是把 r1 这个变量名传进去类里了

self 就是你创建的对象的变量名

实践：

 class Role:

     def __init__(self,name,role,weapon,life_value=100,money=15000):

         self.name = name

         self.role = role

         self.weapon = weapon

         self.life_value = life_value

         self.money = money

     def shot(self):

         print("shotting ...")

     def got_shot(self):

         print("ah .... ,i got shot ...")

     def buy_gun(self,gun_name):

         print("{_name} buy the {_gun_name} gun".format(_name=self.name,_gun_name=gun_name))

 r1 = Role("Alex","F","ak-47")

 r2 = Role("小明","T","m4-a1")

 r1.buy_gun("m4")

 r2.got_shot()

运行结果：

实例变量：

也就是静态属性：

方法：

也就是动态属性

类变量：

新加变量：

默认去找实例变量，找不到实例变量才去找类变量

r1添加变量，r2 实例化不变，因为是r1 添加变量

改变类变量，如果实例里没有那个变量，那么就会跟着改变

对于list 会导致所有的改变

实验：

验证字符串及其他变量的区别：

 class Role:

     n = 123

     n_lsit = []

     def __init__(self,name,role,weapon,life_value=100,money=15000):

         self.name = name

         self.role = role

         self.weapon = weapon

         self.life_value = life_value

         self.money = money

     def shot(self):

         print("shotting ...")

     def got_shot(self):

         print("ah .... ,i got shot ...")

     def buy_gun(self,gun_name):

         print("{_name} buy the {_gun_name} gun".format(_name=self.name,_gun_name=gun_name))

 r1 = Role("Alex","F","ak-47")

 r2 = Role("小明","T","m4-a1")

 # r1.buy_gun("m4")

 #

 # r2.got_shot()

 print("r1",r1.n,r1.n_lsit)

 print("r2",r2.n,r2.n_lsit)

 r1.n = "heh1"

 r2.n = "hah2"

 print("Class:",Role.n,Role.n_lsit)

 r1.n_lsit.append("r11")

 print("r1",r1.n,r1.n_lsit)

 r2.n_lsit.append("r22")

 print("r2",r2.n,r2.n_lsit)

 print("Class:",Role.n,Role.n_lsit)

 print("r1",r1.n,r1.n_lsit)

运行结果：

得出：

1 实例变量：就是每个实例的特有属性

2 类变量：就是大家共用的属性，节省内存开销，如下两个的区别即是

析构函数：

在实例释放、销毁的时候自动执行的，通常用于做一些收尾工作，比如：

1 关闭数据库连接

2 关闭打开的临时文件

写一个：

如果在这之前就del 那么就会提前执行，也就是这个会在一个实例销毁时执行的

私有属性：

例如生命值，只有自己可以访问，别人不能调用也不能访问：

把这个变量隐藏了，对外不可用

外面想要查看，那么就定义一个函数然后在外面来调用这个函数即可

当然外面的不能访问，必然不能修改，所以想修改就要在里面定义好修改的方式，如下:

私有方法：

同上，把对应的方法前加__ 就不能在外面调用了，只能在里面调用：

实践私有属性：

 class Role:

     n = 123

     n_lsit = []

     def __init__(self,name,role,weapon,life_value=100,money=15000):

         self.name = name

         self.role = role

         self.weapon = weapon

         self.__life_value = life_value

         self.money = money

     def shot(self):

         print("shotting ...")

     def got_shot(self):

         print("ah .... ,i got shot ...")

     def show_life_value(self):

         print("{_name}'s life value is {_life_value}".format(_name=self.name,

                                                              _life_value=self.__life_value))

     def buy_gun(self,gun_name):

         print("{_name} buy the {_gun_name} gun".format(_name=self.name,_gun_name=gun_name))

 r1 = Role("Alex","F","ak-47")

 r2 = Role("小明","T","m4-a1")

 r1.buy_gun("m4")

 r2.got_shot()

 r1.show_life_value()

 r2.show_life_value()

实践私有方法：

同上，如果在外面调用此方法就会提示错误：

正确方式就是在类里定义另一个方法来调用这个方法：

 class Role:

     n = 123

     n_lsit = []

     def __init__(self,name,role,weapon,life_value=100,money=15000):

         self.name = name

         self.role = role

         self.weapon = weapon

         self.__life_value = life_value

         self.money = money

     def shot(self):

         print("shotting ...")

     def __got_shot(self):

         print("ah .... ,i got shot ...")

         self.__life_value -= 50

     def show_life_value(self):

         print("{_name}'s life value is {_life_value}".format(_name=self.name,

                                                              _life_value=self.__life_value))

     def buy_gun(self,gun_name):

         print("{_name} buy the {_gun_name} gun".format(_name=self.name,_gun_name=gun_name))

     def out_shot(self):

         print("调用里面的私有方法被射中...")

         self.__got_shot()

 r2 = Role("小明","T","m4-a1")

 r2.out_shot()

 r2.show_life_value()

封装就是把实现的方式内部用私有方法，私有变量实现

继承

写一个大类：

class People:

写一个男人：

增加新功能，并先调用父类方法：

这就等于重构了父类的方法

创建一个woman：

实践：

 class People:

     def __init__(self,name,age):

         self.name = name

         self.age = age

     def eat(self):

         print("{_name} is eatting ...".format(_name=self.name))

     def sleep(self):

         print("{_name} is sleepping ...".format(_name=self.name))

 class Man(People):

     def piao(self):  #添加新的方法，这个方法只能是这个类来用

         print("{_name} can piaoing ...".format(_name=self.name))

     def sleep(self):    #修改父类里的方法，添加功能，实现个性化

         People.sleep(self)

         print("给睡觉添加新的功能")

 class Woman(People):

     def sheng(self):   #添加新的方法，这个方法只能是这个类来用

         print("{_name} can shenghaizi ...".format(_name=self.name))

 m1 = Man("小明",22)

 w1 = Woman("小花",18)

 print("m1")

 m1.sleep()

 print("w1")

 w1.sleep()

 print("m1")

 m1.piao()

 print("w1")

 w1.sheng()

子类中的初始化：

对构造函数进行重构：

父类的所有参数都要写一遍，写完后面加自己的初始化变量

下面功能一样：更方便一些。当大类修改了后子类不需要修改

类：

新式和经典的区别就是新式和经典的多继承不一样了

多继承， python 支持，有的语言支持，有的语言不支持

实践：

 class People:

     def __init__(self,name,age):

         self.name = name

         self.age = age

     def eat(self):

         print("{_name} is eatting ...".format(_name=self.name))

     def sleep(self):

         print("{_name} is sleepping ...".format(_name=self.name))

 class Action(object):

     def make_friends(self,object):

         print("{_name} is making from {_obj_name}".format(_name=self.name,

                                                       _obj_name=object.name))

 class Man(People,Action):

     def piao(self):  #添加新的方法，这个方法只能是这个类来用

         print("{_name} can piaoing ...".format(_name=self.name))

     def sleep(self):    #修改父类里的方法，添加功能，实现个性化

         People.sleep(self)

         print("给睡觉添加新的功能")

 class Woman(People):

     def sheng(self):   #添加新的方法，这个方法只能是这个类来用

         print("{_name} can shenghaizi ...".format(_name=self.name))

 m1 = Man("小明",22)

 w1 = Woman("小花",18)

 m1.make_friends(w1)

扩展版：

 #!/usr/bin/env python3

 # Author: Shen Yang

 class People:

     def __init__(self,name,age):

         self.name = name

         self.age = age

     def eat(self):

         print("{_name} is eatting ...".format(_name=self.name))

     def sleep(self):

         print("{_name} is sleepping ...".format(_name=self.name))

 class Action(object):

     def make_friends(self,object):

         print("{_name} is making from {_obj_name}".format(_name=self.name,

                                                       _obj_name=object.name))

         self.firends.append(object)

     def pay_money(self,object):

         print("{_name} giveing {_obj_name} {_money} money".format(_name=self.name,

                                                                   _obj_name=object.name,

                                                                   _money=self.money))

 class Man(People,Action):

     firends = []

     def __init__(self,name,age,money):

         super(Man,self).__init__(name,age)

         self.money = money

     def piao(self):  #添加新的方法，这个方法只能是这个类来用

         print("{_name} can piaoing ...".format(_name=self.name))

     def sleep(self):    #修改父类里的方法，添加功能，实现个性化

         People.sleep(self)

         print("给睡觉添加新的功能")

 class Woman(People):

     def sheng(self):   #添加新的方法，这个方法只能是这个类来用

         print("{_name} can shenghaizi ...".format(_name=self.name))

 m1 = Man("小明",22,6800)

 w1 = Woman("小花",18)

 m1.make_friends(w1)

 m1.pay_money(w1)

 w1.name ="小花花"

 print(m1.firends[0].name)

多继承的顺序问题：

新式类：

只继承第一个的初始化__init__

构造方法查找顺序：

1 广度优先先找同一级的同一级的没有才往更上一级查找

2 深度优先查找上级，上级没有就会往更上一级查找

python3 中的经典类和新式类都是广度优先：

python2 的经典类是按深度优先继承，新式类是按广度优先继承。。。。。。

这就是最大区别

object 是所有类的类：

class SchoolMember(object):

写一个学校，员工，学生的对象程序：

 #!/usr/bin/env python3

 # Author: Shen Yang

 #object 是所有类的类：

 class School(object):

     def __init__(self,name,addr):

         self.name = name

         self.addr = addr

         self.students = []

         self.staffs = []

     def enroll(self,stu_obj):

         print("为{_stu_obj} 办理了入学手续。。。".format(_stu_obj=stu_obj.name))

         self.students.append(stu_obj)

     def hire(self,staff_obj):

         print("雇佣了新员工 {_staff_obj}".format(_staff_obj=staff_obj.name))

         self.staffs.append(staff_obj)

 class SchoolMember(object):

     def __init__(self,name,age,sex):

         self.name = name

         self.age = age

         self.sex = sex

     def tell(self):

         pass

 class Student(SchoolMember):

     def __init__(self,name,age,sex,stu_id,grade):

         super(Student,self).__init__(name,age,sex)

         self.stu_id = stu_id

         self.grade = grade

     def tell(self):

         print('''

         ----- info of Student: {_name} -----

         Name:{_name}

         Age:{_age}

         Sex:{_sex}

         Stu_id:{_stu_id}

         Grade:{_grade}

         '''.format(_name=self.name,_age=self.age,_sex=self.sex,_stu_id=self.stu_id,_grade=self.grade))

     def pay_tuition(self,amount):

         print("{_name} has paid tuition {_amount}".format(_name=self.name,_amount=amount))

 class Teacher(SchoolMember):

     def __init__(self,name,age,sex,salary,coure):

         super(Teacher,self).__init__(name,age,sex)

         self.salary = salary

         self.coure = coure

     def tell(self):

         print('''

         ----- info of Teacher: {_name} -----

         Name:{_name}

         Age:{_age}

         Sex:{_sex}

         Salary:{_salary}

         Coure:{_coure}

         '''.format(_name=self.name,_age=self.age,_sex=self.sex,_salary=self.salary,_coure=self.coure))

     def teach(self):

         print("{_name} has teach {_coure}".format(_name=self.name,_coure=self.coure))

 #初始化一个学校

 school = School("老男孩","沙河")

 #初始化两个教师

 t1 = Teacher("Oldboy",35,"M",20000,"Linux")

 t2 = Teacher("Alex",22,"M",3000,"Python")

 #初始化一个学生

 s1 = Student("Yang",26,"M",1001,"Python")

 #让第一个老师打印信息然后开始教课

 t1.tell()

 t1.teach()

 #让第二个老师打印信息

 t2.tell()

 #让学生打印信息然后缴费

 s1.tell()

 s1.pay_tuition(6888)

 #学校给学生办理入学手续

 school.enroll(s1)

 #打印学校学生

 print(school.students[0].name)

 school.hire(t1)

 school.hire(t2)

 for i in school.staffs:

     print(i.name)

多态：

巴特西

day06 面向对象编程

最新文章

热门文章