一、封装
封装:在面向对象编程中,所有的类通常情况下很少让外部直接访问类内部的属性和方法,而是向外部类提供一些按钮,对其内部的成员进行访问,以保证程序的安全性。
- 1> 封装是面向对象编程的一大特点
- 2> 面向对象编程的第一步,将属性和方法封装到一个抽象的类中
- 3> 外界使用类创建对象,然后让对象调用方法
- 4> 对象方法的细节都被封装在类的内部
示例1:
class Person:
def __init__(self, name, weight):
self.name = name
self.weight = weight
def __str__(self):
return '我是%s,体重是%.2f' % (self.name, self.weight)
def run(self):
print '%s 爱跑步' % self.name
self.weight -= 0.5
def eat(self):
print '%s 吃饭' % self.name
self.weight += 1
# 创建对象xiaoming和xiaomei
xiaoming = Person('小明', 75.0)
xiaomei = Person('小美', 45.0)
print xiaoming
xiaoming.run()
xiaoming.eat()
print xiaoming
print xiaomei
xiaomei.run()
# """结果如下"""
# 我是小明,体重是75.00
# 小明 爱跑步
# 小明 吃饭
# 我是小明,体重是75.50
# 我是小美,体重是45.00
# 小美 爱跑步
示例2:
class Student:
def __init__(self, name, age):
self.__name = name
self.__age = age
def setter(self, name, age):
if not isinstance(name, str):
raise TypeError("名字必须是字符串类型")
if not isinstance(age, int):
raise TypeError("年龄必须是整数类型")
self.__name = name
self.__age = age
def tell(self):
print("学生的信息是:%s\t%s" % (self.__name, self.__age))
if __name__ == '__main__':
student = Student("Alex", 25)
student.tell()
student.setter("Tom", 40)
student.tell()
"""结果如下"""
# 学生的信息是:Alex 25
# 学生的信息是:Tom 40
二、继承
- 1、一个类从已有的类那里获得其已有的属性与方法,这种现象叫做类的继承
- 2、方法重写指在子类中重新定义父类中已有的方法,这中现象叫做方法的重写
- 3、若A类继承了B类,则aa对象既是A,又是B,继承反映的是一种谁是谁的关系,只有在谁是谁的情况下,才能用继承解决代码冗余的问题。
- 4、寻找属性和方法的顺序问题:先从对象自己的命名空间中找,然后在自己的类中,最后在从父类当中去找
- 5、在python3当中,所有的类都是新式,所有的类都直接或者间接的继承了Object
- 6、在python中,新建的类可以继承一个或多个父类
示例1:单继承
1.继承的概念:子类拥有父类的所有属性和方法(子类只需要封装自己特有的方法)
2.语法
class 类名(父类):
def 子类特有的方法
# _*_ coding:utf-8 _*_
class Animal:
def eat(self):
print '吃'
def drink(self):
print '喝'
def run(self):
print '跑'
def sleep(self):
print '睡'
class Cat(Animal):
# 子类拥有父类的所有属性和方法
def call(self):
print '喵喵~'
kitty = Cat()
kitty.eat()
kitty.drink()
kitty.run()
kitty.sleep()
kitty.call()
"""结果如下"""
# 吃
# 喝
# 跑
# 睡
# 喵喵~
Cat类继承了Animal所有的属性和方法,然后Cat类又定义了自己特有的方法。
示例2:继承的传递性
继承的传递性:通俗的讲(爷爷 爸爸 儿子的关系)
- C 类从B类继承,B类又从A类继承
- 那么C类就具有B类和A类的所有属性和方法。
# _*_ coding:utf-8 _*_
class Animal:
def eat(self):
print '吃'
def drink(self):
print '喝'
def run(self):
print '跑'
def sleep(self):
print '睡'
class Cat(Animal):
# 子类拥有父类的所有属性和方法
def call(self):
print '喵喵~'
class Hellokitty(Cat):
def speak(self):
print '我可以说日语'
# 创建一个Hellokitty对象
kt = Hellokitty()
kt.speak()
kt.call()
# 继承的传递性 子类拥有父类的父类的属性和方法
kt.eat()
kt.drink()
kt.sleep()
kt.run()
"""结果如下"""
# 我可以说日语
# 喵喵~
# 吃
# 喝
# 睡
# 跑
示例3:
方法的重写
- 覆盖父类的方法(重写父类方法)
- 对父类方法进行扩展
# _*_ coding:utf-8 _*_
class Cat(object):
# 子类拥有父类的所有属性和方法
def call(self):
print '喵喵~'
class Hellokitty(Cat):
def speak(self):
print '我可以说日语'
def call(self):
# 1.针对子类特有的需求,编写代码
print '欧哈呦~'
# 2.调用原本子阿父类中封装的方法
Cat.call(self)
kt =Hellokitty()
# 如果子类中,重写了父类的方法
# 在运行中,只会调用在子类中重写的方法而不会调用父类的方法
kt.call()
"""结果如下"""
# 欧哈呦~
# 喵喵~
示例4:
多继承
- 子类拥有一个父类叫作单继承
- 子类可以拥有多个父类,并且具有所有父类的属性和方法
- 例如:孩子会继承自己父亲和母亲的特征
class A(object):
def test(self):
print 'A---------test 方法'
def demo1(self):
print 'A--------demo方法'
class B(object):
def test(self):
print 'B -------test方法'
def demo2(self):
print 'B ---------demo 方法'
class C(B,A):
"""多继承可以让子类对象,同时具有多个父类的属性和方法"""
pass
# 创建子类对象
c = C()
c.test()
c.demo2()
"""结果如下"""
# B -------test方法
# A--------demo方法
多继承C类既继承了A类,也继承了B类,对象c调用方法的时候,若A类和B类的方法同名,则在C类继承A和B的时候谁写在前面就调用谁的方法。不同名的就直接调用对应的类中的方法。
补充:新式类和旧式类
新式类和旧式(经典)类:
object是Python为所有对象提供的基类,提供有一些内置的属性和方法,可以使用dir函数查看
- 新式类:以object为基类的类,推荐使用
- 经典类:不以object为基类的类,不推荐使用
在python3.X中定义的类时,如果没有指定父类,会默认使用object作为基类,python3.x中定义的类都是新式类
在python2.x中定义类时,如果没有指定父类,则不会以object作为基类
推荐使用新式类
新式类和旧式类在多继承时会影响到方法的搜索顺序,为保证编写的代码能够同时在python2.x和python3.x运行,今后在定义类时,如果没有父类,建议统一继承自object类
>>> class A(object):
... pass
...
>>> a = A()
>>> dir(a) #查看内置的属性和方法
>>> class B:
... pass
...
>>> b=B()
>>> dir(b)
Python早期,它对于class的定义在很多方面都是严重有问题的。当他们承认这一点的时候已经太迟了,所以逼不得已,他们需要支持这种有问题的class 。
为了解决已有的问题,他们需要引入一种“新类”,这样的话“旧类”还能继续使用,而你也有一个新的正确的类可以使用了。
这就用到了“类即是对象”的概念,他们决定用小写的“object”这个词作为一个类,让你在创建新类时从它继承下来。
三、多态
多态是以封装和继承为前提。
- 1> 多态可以增加代码的灵活度
- 2> 以继承和重写父类的方法为前提
- 3> 调用方法,不会影响到类的内部设计
示例:
# _*_ coding:utf-8 _*_
class Dog(object):
def __init__(self, name):
self.name = name
def game(self):
print '摇尾巴...'
class GoldDog(Dog):
def game(self):
print '上天入地...'
class Person(object):
def __init__(self, name):
self.name = name
def game(self, dog):
print '%s 和 %s 一起玩耍' % (self.name, dog.name)
dog = Dog('旺财')
# dog = GoldDog('飞天神狗')
XiaoMing = Person('小明')
XiaoMing.game(dog)
"""结果1:注释掉GoldDog类实例的对象"""
# 小明 和 旺财 一起玩耍
"""结果2:注释掉Dog类实例的对象"""
# 小明 和 飞天神狗 一起玩耍