|
前言 1.面向对象的三大特点
2.学习继承语法
3.学习方法重写
4.学习类属性和类方法的使用 面向对象的程序设计一般有三大特性1.封装---根据要求将 属性和方法 封装到一个抽象的 类中
2.继承---实现代码的重复使用，相同的代码不需要重复编写
3.多态---不同的对象 调用相同的方法 实现不同的结果，不写死代码 一.封装
1.类的私有属性和私有方法
私有属性---即不公开的属性
私有方法---即不公开的方法
对于私有属性和私有方法，只能在类的内部访问，类的外部无法访问
2.定义方式
在属性或方法前，增加两个下划线即可 class woman: def __init__(self,weight = 0,age = 0,name = ''): self.__weight = 60 #定义weight为私有属性 self.__age = 25 #定义age为私有属性 self.name = '冰冰'w = woman()print(w.name)print(w.age )#不能在类的外部 调用成功
二.继承继承概念：子类拥有父类的所有方法和属性
类A 继承类B，类A 会拥有类B的所有属性和方法 语法格式 class 类名（父类名）： pass#案例如下： class animal: def sleep(self): print('睡') def eat(self): print('吃')class dog(animal):#d【og类 继承animal类】 def run(self): print('跑')d = dog() # 【dog 会拥有animal类 所有的属性和方法】d.run()d.sleep()d.eat()
继承 ---专业术语 dog类是animal类的子类
animal类是dog类的父类
dog类从animal类继承
dog类是animal类的派生类
animal类是dog类的基类
dog类从animal类派生 注意：一个父类 可以多个子类 class animal: def sleep(self): print('睡') def eat(self): print('吃')class dog(animal):#d【og类 继承animal类】 def run(self): print('跑')class bird(animal): def fly(self): print('天阔任鸟飞')class fish(animal): def swimming(self): print('海阔凭鱼跃')d = dog() # 【dog 会拥有animal类 所有的属性和方法】d.run()d.sleep()d.eat()b = bird()b.fly()f = fish()f.swimming()
继承---传递性 C类从B类继承，B类从A类继承
则C类就具有了B类和A类的所有属性和方法
子类从而拥有父类及父类的父类中封装的所有属性和方法 class animal(): def eat(self): print('吃')class dog(animal): def run(self): print('跑')class taidi(dog): def keai(self): print('可爱')t = taidi()t.eat()t.run()t.keai()#输出结果为吃跑可爱
类方法的重写：当父类的方法实现不能满足子类需求时，可以对方法重写
重写父类的方法2种情况：
1.覆盖父类的方法
2.对父类方法进行拓展
1.覆盖父类方法：
使用前提：当父类的方法实现和子类的方法实现完全不同时
实现方式：在父类下的子类中 定义一个 和父类同名的方法来实现
（重写之后，在运行时，只会调用子类中重写的方法，而不再会调用父类封装） 2.对父类方法进行拓展 在程序运行时，如果既要父类方法，又想增加功能 可以使用拓展方式来实现 实现方式：
1.在 子类中重写 父类方法
2.在需要的位置使用 super().父类方法 调用'父类'方法的执行
3.代码其他的位置 针对子类的需求，编写子类特有代码实现即可 class animal: def sleep(self): print('睡')class dog(animal): def sleep(self): #对父类中的 sleep方法进行了拓展 super().sleep()# 作用是：先调用父类方法，再执行dog子类中的代码 print('睡的更多')d = dog()d.sleep()
注意：父类中的私有属性和私有方法 都是不能继承给它的子类 三 .多态定义：不同的子类对象，调用相同的父类方法时，产生不同的执行结果
多态前提：不同的子类来自相同的一个父类，子类会覆盖父类的方法 #多态，不同的对象 调用相同的父类方法，产生不同的结果class animal: def food(self): pass def eat(self): self.food()class dog(animal): def food(self): print('狗吃肉')class cat(animal): def food(self): print('猫吃鱼')#如下，调用了相同的父类方法， 却是不同的结果d = dog()d.eat()c = cat()c.eat()
类属性和类方法
类属性不需要创建类的对象，直接通过 【类名.】 的方式就可以访问类的属性或者调用类的方法 class dog: name = '二哈' #写在这个位置的变量，就是类属性 def __init__(self): passprint(dog.name) #显示类属性的值dog.name = '泰迪' #修改类属性的值print(dog.name)
类方法 1.用@classmethod 修饰的方法叫类方法
2.类方法的参数为cls,在类方法内部通过 cls.类属性 cls.类方法 来访问 同一个类中其他的类属性和方法
3.类方法 只能访问同一个类中的 ：类属性和类方法
注意：
类方法内部使用类属性： cls.类属性名
在类方法内部，不能修改普通属性和调用普通方法 class dog: name = '二哈' @classmethod def set_name(cls,name): cls.name = name #通过类方法的形参来改变属性name的值 def __init__(self): self.age = 20 def eat(self): print('吃')print(dog.name) # 显示类属性的值dog.name = '泰迪' #修改类属性的值print(dog.name)dog.set_name('比尔')print(dog.name)
静态方法使用@staticmethod修饰的方法叫静态方法
通过 类名.静态方法 调用静态方法 语法格式@staticmethoddef 方法名() 方法内容 class student: @staticmethod def say(): print('---这是静态方法---')#用对象调用静态方法s = student()s.say()#直接用 类 调用静态方法student.say()
静态方法的使用场景 当代码量特别大的时候，函数也也特别多，为了避免函数重名 可以把同名函数放到不同的类里面 作为 静态方法.避免由于函数重名带来错误。 class dog: @staticmethod def help(): print('这是一个静态方法help')dog.help()class A: @staticmethod def help(): print('这是第二个静态方法help')A.help()
在python中，可以定义三种方法分别为 实例方法，类方法，静态方法，关于类方法，实例方法，静态方法区别如下：
实例方法：和对象有关
语法格式： def do_something(self) 类方法：和类有关
语法格式：@classmethod 修饰
静态方法：这些方法 与类无关 且不需要类的实例（可有可无）
语法格式：@staticmethod修饰 class game(object): num = 0 #类属性 @classmethod # 类方法 def add_num(cls): cls.num = 100 def __init__(self): #实例方法 self.name = '老王' #实例属性 @staticmethod #静态方法 def print_menu(): print('******')#第一种方式game.add_num()#【类名.方法名】直接调用类方法print(game.num)# 【类名.变量名】显示类的属性值#第二种方式g = game()print(g.num)game.print_menu()#静态方法的调用方法1：【类名.静态方法名】g.print_menu()#静态方法的调用方法2：【对象名.静态方法名】
|
