25 组合 多态 封装

组合:

1 什么是组合

组合指得是某一个对象拥有一个属性,该属性的值是另外一个类的对象

2. 为何要用组合

通过为某一个对象添加属相(属相的值是另外一个类的对象)的方式,可以间接的将两个类关联/整合/组合到一起

3. 如何用组合

class OldboyPeople:
  school = ‘Oldboy‘

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

class OldboyStudent(OldboyPeople):
  def __init__(self, name, age, sex,score=0):
    OldboyPeople.__init__(self,name,age,sex)
    self.score = score
    self.courses=[]

  def choose_course(self):
    print(‘%s choosing course‘ % self.name)

  def tell_all_course(self):
    print((‘学生[%s]选修的课程如下‘ %self.name).center(50,‘=‘))
    for obj in self.courses:
      obj.tell_info()

class OldboyTeacher(OldboyPeople):
  def __init__(self,name,age,sex,level):
    OldboyPeople.__init__(self,name,age,sex)
    self.level=level
    self.courses=[]

  def score(self,stu,num):
    stu.score=num

  def tell_all_course(self):
    print((‘老师[%s]教授的课程如下‘ %self.name).center(50,‘*‘))
    for obj in self.courses:
      obj.tell_info()

class Course:
  def __init__(self,c_name,c_price,c_period):
    self.c_name = c_name
    self.c_price = c_price
    self.c_period = c_period

  def tell_info(self):
    print(‘<课程名:%s 价钱:%s 周期:%s>‘ %(self.c_name,self.c_price,self.c_period))

#创建课程对象
python=Course(‘python全栈开发‘,1900,‘5mons‘)
linux=Course(‘linux架构师‘,900,‘3mons‘)

#创建学生对象
stu1=OldboyStudent(‘刘二蛋‘,38,‘male‘)

#将课程添加到学生课程列表
stu1.courses.append(python)
stu1.courses.append(linux)

#显示学生所选课程
stu1.tell_all_course()

#创建老师对象
tea1=OldboyTeacher(‘egon‘,18,‘male‘,10)

#将课程添加到老师授课列表
tea1.courses.append(python)

#显示老师所授课程
tea1.tell_all_course()

用法实例

多态与多态性

1. 什么是多态

多态指的是同一种类/事物的不同状态

2 为什么要用多态

多态性:在多态的背景下,可以在不用考虑对象具体类型的前提下而直接使用对象
多态性的精髓:统一

3. 如何用多态

class Animal:
  def speak(self):
    pass

class People(Animal):
  def shuo(self):
    print(‘say hello‘)

class Dog(Animal):
  def jiao(self):
    print(‘汪汪汪‘)

class Pig(Animal):
  def chang(self):
    print(‘哼哼哼‘)

obj1=People()
obj2=Dog()
obj3=Pig()

def speak(animal):
  animal.speak()

speak(obj1)# obj1.speak()
speak(obj2)# obj2.speak()
speak(obj3)# obj3.speak()
#metaclass=abc.ABCMeta

#@abc.abstractmethod

#规定子类中一定要有父类的方法

import abc

class Animal(metaclass=abc.ABCMeta):
  @abc.abstractmethod
  def speak(self):
    pass

  @abc.abstractmethod
  def run(self):
    pass

# Animal() # 父类只是用来建立规范的,不能用来实例化的,更无需实现内部的方法

class People(Animal):
  def speak(self):
    print(‘say hello‘)

  def run(self):
    pass

class Dog(Animal):
  def speak(self):
    print(‘汪汪汪‘)

  def run(self):
    pass

class Pig(Animal):
  def speak(self):
    print(‘哼哼哼‘)

  def run(self):
    pass

obj1=People()
obj2=Dog()
obj3=Pig()

封装

1. 什么是封装

装:往容器中/名称空间里存名字

封:代表将存放于名称空间中的名字给藏起来,这种隐藏对外不对内

2 为什么要封装

# 封装数据属性:将数据属性隐藏起来,类外就无法直接操作属性,需要类内开辟一个接口来外部的使用可以间接地操作属性,可以在接口内定义任意的控制逻辑,
# 从而严格控制使用对属性的操作

3. 如何封装

在类内定义的属性前加__开头(没有__结果)
总结:
1. __开头的属性实现的隐藏仅仅只是一种语法意义上的变形,并不会真的限制类外部的访问
2. 该变形操作只在类定义阶段检测语法时发生一次,类定义阶段之后新增的__开头的属性并不会变形
3. 如果父类不想让子类覆盖自己的属性,可以在属性前加__开头

class Foo:
  __x=111 # _Foo__x
  __y=222 # _Foo__y

  def __init__(self,name,age):
    self.__name=name
    self.__age=age

  def __func(self): #_Foo__func
    print(‘func‘)

  def get_info(self):
    print(self.__name,self.__age,self.__x) #print(self._Foo__name,self._Foo__age,self._Foo__x)
#报错
print(Foo.__x)
print(Foo.__func)
print(Foo.__dict__)

#没报错
print(Foo._Foo__x)
print(Foo._Foo__y)
print(Foo.__dict__)

#类定义阶段之后新增的__开头的属性并不会变形
Foo.__z=333

print(Foo.__z) 
class People:
  def __init__(self,name,age):
    self.__name=name
    self.__age=age

  def tell_info(self):
    print(‘<name:%s age:%s>‘ %(self.__name,self.__age))

  def set_info(self,name,age):
    if type(name) is not str:
      print(‘名字必须是str类型傻叉‘)
      return
    if type(age) is not int:
      print(‘年龄必须是int类型傻叉‘)
      return
    self.__name=name
    self.__age=age

obj=People(‘egon‘,18)
# obj.tell_info()
# obj.set_info(‘EGON‘,19)
# obj.set_info(123,19)
obj.set_info(‘EGON‘,‘18‘)
obj.tell_info()

# 封装函数属性:隔离复杂度

class ATM:
  def __card(self):
    print(‘插卡‘)
  def __auth(self):
    print(‘用户认证‘)
  def __input(self):
    print(‘输入取款金额‘)
  def __print_bill(self):
    print(‘打印账单‘)
  def __take_money(self):
    print(‘取款‘)

def withdraw(self):
  self.__card()
  self.__auth()
  self.__input()
  self.__print_bill()
  self.__take_money()

a=ATM()
a.withdraw()

property

property装饰器是用来将类内的函数属性伪装成数据属性

class People:
  def __init__(self,name,weight,height):
    self.name=name
    self.weight=weight
    self.height=height

  @property
  def bmi(self):
    return self.weight / (self.height ** 2)

obj=People(‘egon‘,80,1.83)
obj.height=1.85
obj.weight=75

#print(obj.bmi())
print(obj.bmi)

# 了解....

class People:

  def __init__(self,name):
    self.__name=name

  @property
  def name(self):
    return ‘<名字:%s>‘ %self.__name

  @name.setter
  def name(self,obj):
    if type(obj) is not str:
      print(‘name必须为str类型‘)
      return
    self.__name=obj

  @name.deleter
  def name(self):
    print(‘不让删‘)
    del self.__name

obj=People(‘egon‘)
print(obj.name)
obj.name=‘EGON‘
obj.name=123
print(obj.name)

del obj.name
print(obj.__dict__)

原文地址:https://www.cnblogs.com/ouyang99-/p/10415311.html

时间: 2024-10-13 06:41:05

25 组合 多态 封装的相关文章

组合&amp;多态&amp;封装

组合&多态&封装 一.组合 1.1什么是组合 对象的属性是另一个对象 class Foo: pass class Bar: pass f = Foo() f.bar = Bar() 1.2 为什么要用组合 减少代码冗余 1.3 如何使用组合 首先我们有老师类和学生类,他们都有共同的属性,课程姓名,课程价格,课程时间,为了避免代码冗余,我们就需要用组合. #这样的代码,我们看起来是不是和繁琐,那我们就把他们相同的属性拿出来,重新定义一个类,用的时候,我们就直接传入这个对象就好了. class

python面向对象之继承/多态/封装

老师说,按继承/多态/封装这个顺序来讲. 子类使用父类的方法: #!/usr/bin/env python # coding:utf-8 class Vehicle: def __init__(self,name,speed,load,power): self.name = name self.speed = speed self.load = load self.power = power def run(self): print("开动啦.") class Benz(Vehicle

Python 面向对象 组合-多态与多态性-封装-property

面向对象-组合 1.什么是组合 组合指的是某一个对象拥有一个属性,该属性的值是另外一个类的对象 1 class Foo: 2 xxx = 111 3 4 class Bar: 5 yyy = 222 6 7 obj = Foo() 8 obj.attr = Bar() 9 10 print(obj.xxx) 11 >>>111 12 print(obj.attr.yyy) 13 >>>222 2.为何要用组合 通过为某一个对象添加属性(属性的值是另外一个类的对象)的方式

python面向对象:组合、封装、property装饰器、多态

一.组合二.封装三.property装饰器四.多态 一.组合 ''' 1. 什么是组合 一个对象的属性是来自于另外一个类的对象,称之为组合 2. 为何用组合 组合也是用来解决类与类代码冗余的问题 3. 如何用组合 ''' # class Foo: # aaa=1111 # def __init__(self,x,y): # self.x=x # self.y=y # # def func1(self): # print('Foo内的功能') # # # class Bar: # bbb=2222

Python全栈开发——面向对象的三大特性(继承 &amp; 多态 &amp;封装)

1.继承 1.两层意思改变和扩展(详细看随笔继承和组合) 2.多态(体现在运行时的状态) 1.不同的类可以调用相同的方法,得到不同的结果 2.实际上是继承的一种体现机制 class H2o: def __init__(self,name,temperature): self.name=name self.temperature=temperature def turn_ice(self): if self.temperature<0: print('温度太低,变成[%s]' %self.name

面向对象之组合、封装、多态性、鸭子类型

一.组合 1. 什么是组合 一个对象的属性是来自于另外一个类的对象,称之为组合 2. 为何用组合 组合也是用来解决类与类代码冗余的问题 3. 如何用组合 # class Foo: # aaa=1111 # def __init__(self,x,y): # self.x=x # self.y=y # # def func1(self): # print('Foo内的功能') # # # class Bar: # bbb=2222 # def __init__(self, m, n): # sel

类的组合与封装

一.组合 解决类与类之间代码冗余问题有两种解决方案: 1.继承 2.组合 1.继承:描述的是类与类之间,从属关系 2.组合:描述的是类与类之间的关系,是一种什么有什么关系 一个类产生的对象,该对象拥有一个属性,这个属性的值是来自于另外一个类的对象 class Date: def __init__(self,year,mon,day): self.year = year self.mon = mon self.day = day def tell_birth(self): print('出生年月日

Python_015(面向对象(接口类,抽象类,多态,封装)

一.抽象类与接口类 1.抽象类:抽象即类似或者说比较像的部分,继承描述的是父类与子类的一种关系,要找出这种关系,必须先抽象再继承; a:抽象分成两个层次: 1)由对象->类:将两个有相似地方的对象抽取成类; 2)由类->父类:将两个有相似地方的类抽取成父类; :抽象最主要的作用就是划分类别(可以隔离关注点,降低复杂度) 2.为什么要有抽象类 与Java一样,Python也有抽象类的概念,需要借助模块实现,它是一个特殊的类,特殊之处在于只能被继承,不能被实例化; 类是从一些对象中抽取相同的内容而

组合与封装

1. 什么是组合 组合指的是某一个对象拥有一个属性,该属性的值是另外一个类的对象class Foo: pass class Bar: pass obj=Foo()obj.attr=Bar() obj.xxxobj.attr.yyy 2. 为何要用组合 通过为某一个对象添加属性(属性的值是另外一个类的对象)的方式,可以间接地将两个类关联/整合/组合到一起 从而减少类与类之间代码冗余 class Foo1: passclass Foo2: passclass Foo3: pass class Bar