前言
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:【对象名.静态方法名】
联系客服