目录
首先我们要了解面向对象程序设计三大特性:
1.1 类的私有属性和私有⽅法:
1.2 定义方式
在定义属性或⽅法时,在属性名或者⽅法名前增加两个下划线,定义的就是私有属性或方法。]
# 定义Cat类
class Cat:
def __init__(self,name = "小白"):
# _name 为私有属性
self._name = name
# _eat 为私有方法
def _eat(self):
print(self._name + "吃饭")
def drink(self):
self._eat()
print(self._name + "喝水")
# 创建Cat 类
cat = Cat();
# 调用Cat 喝水的方法
cat.drink()
对于私有属性和私有方法,只能在类的内部访问,类的外部无法访问。
继承的概念:⼦类拥有⽗类的所有⽅法和属性。
语法:
class 类名(⽗类名): pass
# 定义Cat类
class Cat:
def __init__(self, name="小白"):
# _name 为私有属性
self._name = name
# _eat 为私有方法
def _eat(self):
print(self._name + "吃饭")
def drink(self):
self._eat()
print(self._name + "喝水")
# 创建cat的子类
class kitten(Cat):
def run(self):
pass
kitten = kitten();
kitten.drink();
⼦类继承⾃⽗类,可以直接享受⽗类中已经封装好的⽅法,不需要再次开发 。 ⼦类中应该根据职责,封装⼦类特有的属性和⽅法。
继承的传递性:
其实就是,B继承A,拥有了A的属性和方法,然后C又继承B,就拥有了B和A的所有属性和方法。
方法的重写:
当⽗类的⽅法实现不能满⾜⼦类需求时,可以对⽅法进⾏重写(override)。 重写⽗类⽅法有两种情况:
1、覆盖父类的方法
如果在开发中,⽗类的⽅法实现和⼦类的⽅法实现,完全不同 ,就可以使 ⽤覆盖的⽅式,在⼦类中重新编写⽗类的⽅法实现 。 重写之后,在运⾏时,只会调⽤⼦类中重写的⽅法,⽽不再会调⽤父类封装的方法。
# 定义Cat类
class Cat:
def __init__(self, name="小白"):
# _name 为私有属性
self._name = name
# _eat 为私有方法
def _eat(self):
print(self._name + "吃饭")
def drink(self):
self._eat()
print(self._name + "喝水")
# 创建cat的子类
class kitten(Cat):
def run(self):
pass
# 覆盖了父类的同名方法
def drink(self,name):
print(name + "喝水")
kitten = kitten();
kitten.drink("小小白");
2、对⽗类⽅法进⾏扩展
如果在开发中,既要使用父类的方法,又想增加功能, 就可以使⽤扩展的⽅式 。
# 定义Cat类
class Cat:
def __init__(self, name="小白"):
# _name 为私有属性
self._name = name
# _eat 为私有方法
def _eat(self):
print(self._name + "吃饭")
def drink(self):
self._eat()
print(self._name + "喝水")
# 创建cat的子类
class kitten(Cat):
def run(self):
pass
# 对父类的 sleep 方法进行了扩展
def drink(self, name):
super().drink();
print(name + "喝水")
kitten = kitten();
kitten.drink("小小白");
⽗类的私有属性和私有⽅法
object 类
不同的⼦类对象调⽤相同的⽗类⽅法,产⽣不同的执⾏结果
# 定义Cat类
class Cat:
def __init__(self, name="小白"):
# _name 为私有属性
self._name = name
# _eat 为私有方法
def _eat(self):
print(self._name + "吃饭")
def drink(self):
self._eat()
print(self._name + "喝水")
# 创建cat的子类
class kitten(Cat):
def run(self):
pass
# 对父类的 sleep 方法进行了扩展
def drink(self, name):
super().drink();
print(name + "喝水")
class dog(Cat):
def drink(self):
print("我是狗")
kitten = kitten();
# 调用父类的 drink 方法
kitten.drink("小小白");
dog = dog();
# 调用父类的 drink 方法
dog.drink();
不需要创建类的对象,通过 类名. 的⽅式就可以访问类的属性或者调用类的方法 。
1、类属性
# 定义Cat类
class Cat:
# name 为类属性,通过 Cat.name 访问
name = "小黄"
def __init__(self, name="小白"):
# _name 为私有属性
self._name = name
print(Cat.name)
2、类方法
# 定义Cat类
class Cat:
# name 为类属性,通过 Cat.name 访问
name = "小黄"
def __init__(self, name="小白"):
# _name 为私有属性
self._name = name
# drink 为类方法
@classmethod
def drink(cls):
print(cls.name + "喝水")
print(Cat.name)
Cat.drink()
注:在普通方法中通过 类名.类属性 或者 类名.类方法 来访问类属性和类方法
如果需要在类中封装⼀个⽅法,这个⽅法既不需要访问实例属性 或者调⽤实例⽅法也不需要访问类属性或者调⽤类⽅法, 这个时候,可以把这个⽅法封装成⼀个静态⽅法。
语法:
@staticmethod def 静态⽅法名(): pass
# 定义Cat类
class Cat:
# drink 为类的静态方法
@staticmethod
def drink():
print("喝水")
Cat.drink()