【Pyyhon中的】面向对象和多态

最新推荐文章于 2023-07-13 15:46:51 发布

强力胶

最新推荐文章于 2023-07-13 15:46:51 发布

阅读量491

点赞数

本文链接：https://blog.csdn.net/weixin_43831670/article/details/89217098

版权

前言：

面向对象的分析根据抽象关键的问题域来分解系统。面向对象的设计

是一种提供符号设计系统的面向对象的实现过程，它用非常接近实际领域

术语的方法把系统构造成“现实世界”的对象。它的核心由两部分组成，即

类和对象。

对象：具有状态，一个对象用数据值来描述它的状态，

对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为。

对象实现了数据和操作的型结合，是数据和操作封装于对象的统一体中

类：具有相同的属性（数据元素）和行为（功能）的对象就是类。

多态：多态指的是相同的操作或者函数，过程可用于多种类型对象上并获得不

同的结果。不同的对象，收到统一消息可以产生不同的结果，称为多态。

正文：

一、示例1、

class Studnet():                      ###定义一个对象
    name = ''                         ###类中的元素属性
    age = 0

    def print_file(self):             ###定义类中的方法
        print('name'+ self.name)
        print('age' +  ' ' + str(self.age))

studnet1 = Studnet()          ###进行类的示例化
studnet1.print_file()         ###进行方法的调用

执行结果：
/home/kiosk/PycharmProjects/面向对象/venv/bin/python /home/kiosk/PycharmProjects/面向对象/面向对象1/面向对象练习1.py
name
age 0

Process finished with exit code 0

二、同一个类进行多次示例化结果是不同的

示例2、

class Studnet():
   name = ''
   age = 0

   def do_homework(self):
       print('go ahead')

student1 = Studnet()
studnet2 = Studnet()
student1.do_homework()
studnet2.do_homework()
print(id(student1))
print(id(studnet2))

执行结果：
/home/kiosk/PycharmProjects/面向对象/venv/bin/python /home/kiosk/PycharmProjects/面向对象/面向对象1/面向对象练习2.py
go ahead
go ahead                         ###两者结果相同但是示例化后两者就发生了改变
139625469146784
139625469146896

Process finished with exit code 0

三、进行函数的构造

注意的是：进行构造的初始化函数，当自定义函数中有输出时候，当对该

对象进行实例化后，输出将自动执行

函数的返回值为None

示例1：

 class Studnet():
    name = ''
    age = 0
    def __init__(self,name,age):             ###进行初始化函数的构造
        self.name = name
        self.age = age
        print('student')            

    def do_homework(self):
        print('name' + ' ' + self.name )
        print('age' + ' ' + str(self.age) )

student1=Studnet('王月',20)
print(student1.name)
print(student1.age)
print(student1.do_homework())

执行结果：
/home/kiosk/PycharmProjects/面向对象/venv/bin/python /home/kiosk/PycharmProjects/面向对象/面向对象1/进行函数的构造.py
student
王月
20
name 王月
age 20
None

Process finished with exit code 0

四、构造函数，返回值为特定的字符串

示例1：

class Dog():
    def __init__(self,name):
        self.name = name

    def __str__(self):
        return '这是一个%s'%(self.name)

gaofu = Dog('旺才')
print(gaofu)

执行结果：
/home/kiosk/PycharmProjects/面向对象/venv/bin/python /home/kiosk/PycharmProjects/面向对象/面向对象1/返回特定的字符串.py
这是一个旺才

Process finished with exit code 0

五、封装

封装：讲属性和方法封装到一个抽象的类中

外界使用类创建对象，对象调用方法，对象

的细节被封装在类的内部。

示例1、

需求：李雷体重75.0公斤

李雷每次跑步会减肥0.5公斤

李雷每次吃东西体重会增加1公斤

class Person():

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

    def __str__(self):
        return '%s的体重为：%f' %(self.name,self.sweit)

    def run(self):
        print('跑步减肥')
        self.sweit-= 0.5

    def eat(self):
        print('吃饭增重')
        self.sweit +=1

student = Person('王月',45)
student.run()
print(student)

执行结果：
/home/kiosk/PycharmProjects/面向对象/venv/bin/python /home/kiosk/PycharmProjects/面向对象/面向对象1/封装.py
跑步减肥
王月的体重为：44.500000

Process finished with exit code 0

六、继承

继承：实现代码的重复使用

注意的是：子类继承来自父类，可以直接享受父类中已经

封装好的方法，并且可以对父类中的方法进行重写，在进

行形同的方法时，会调用重写的方法也可以封装子类中特

有的属性和方法。

示例1：

class Animal():

    def eat(self):
        print('吃')

    def drink(self):
        print('喝')

    def paly(self):
        print('玩')

class Cat(Animal):

    def eat(self):
         print('吃饭')

    def shout(self):
        print('眇眇')

jiafei = Cat()
jiafei.eat()
jiafei.drink()
jiafei.shout()

执行结果：
/home/kiosk/PycharmProjects/面向对象/venv/bin/python /home/kiosk/PycharmProjects/面向对象/面向对象1/继承.py
吃饭
喝
眇眇

Process finished with exit code 0

2、继承具有传递性

注意的是：

示例1、子类继承弗雷的所有的当法和属性

继承具有传递性，子类拥有父类的父类的属性和方法

class Animal():

    def eat(self):
        print('吃')

    def play(self):
        print('玩游戏')

class Cat(Animal):

      def shangshu(self):
          print('上树')

class jiafeimao(Cat):

       def zhualaoshu(self):
           print('喜欢抓老鼠')


cat1 = jiafeimao()
cat1.eat()
cat1.zhualaoshu()

执行结果：
/home/kiosk/PycharmProjects/面向对象/venv/bin/python /home/kiosk/PycharmProjects/面向对象/面向对象1/继承的传递型.py
吃
喜欢抓老鼠

Process finished with exit code 0

3、进行多继承

注意的是：当进行多继承是，方法名形同的，继承为括号中的第一个

class A():
     def a(self):
         print('A---test方法')

     def demo(self):
         print('A---doemo方法')

class B():

      def b(self):
          print('B---这是b方法')

      def demo(self):
          print('B---这是doemo方法')

class C(B,A):
    pass

test = C()
test.demo()

执行结果：
/home/kiosk/PycharmProjects/面向对象/venv/bin/python /home/kiosk/PycharmProjects/面向对象/面向对象1/进行对继承.py
B---这是doemo方法
B---这是doemo方法

Process finished with exit code 0

七、多态

子类和父类存在形同的方法时，子类会覆盖父类的方法，运行时会调用子类方法

示例1：


class Animal(object):
    def run(self):
        print('running...')
    def cry(self):
        print('crying...')

class Dog(Animal):
    def run(self):
        print('dog running...')

    def eat(self):
        print('dog eating...')

class Cat(Animal):
    def run(self):
        print('cat running...')

cat = Cat()
cat.run()

dog = Dog()
dog.run()

执行结果：
/home/kiosk/PycharmProjects/面向对象/venv/bin/python /home/kiosk/PycharmProjects/面向对象/面向对象1/多太性.py
cat running...
dog running...

Process finished with exit code 0

八、习题练习：

1、进行栈原理的实现：

具体功能：

(1)可以进行栈元素的查看

(2)可以进行栈元素的添加

(3)可以进行栈元素的删除，当栈长度为0时，会进行报错，

遵循的删除原则是先进后出

(4)进行栈长度的查看

(5)进行退栈

"""
题目要求：模拟栈的工作方式
1、可以进行栈元素的擦看
2、可以进行栈元素的添加
3、可以进行栈元素的删除，注意的是，当
栈的长度为0时，会进行报错。
4、可以进行栈长度的查看
5、进行栈的退出

题目分析：
1、使用面向对象对所有的方法进行封装
2、进行对象的示例化，进行方法的调用
"""

class Zhan():
    def __init__(self):
        self.list1 = []

    def check(self):
        print('栈的查看结果为：%s' %(self.list1))

    def add1(self,name1):
        self.name1 = name1
        self.list1.append(self.name1)
        print('添加%s成功'%(self.name1))

    def delete1(self):
        if len(self.list1) > 0:
            self.list1.pop()
            print('删除元素成功')
        else:
            print('栈中元素为空，不能进行删除')

    def len1(self):
        a = len(self.list1)
        print('栈的长度为:%d' %(a))

    def eixt1(self):
            print('欢迎下次使用')
            exit()

zhan1= Zhan()
zhan1.delete1()
zhan1.add1('westos')
zhan1.check()
zhan1.len1()

执行结果：
/home/kiosk/PycharmProjects/面向对象/venv/bin/python /home/kiosk/PycharmProjects/面向对象/习题练习/栈的原理.py
栈中元素为空，不能进行删除
添加westos成功
栈的查看结果为：['westos']
栈的长度为:1

Process finished with exit code 0

2、练习

需求：

1、房子有户型，总面积和家具名称的列表

新房子没有任何的家具。

2、家具有名字和占地面积，其中

床：占地4平米

衣柜：占地2平米

餐桌：占地1.5平米

3、将一以上三件家居添加到房子中

4、打印房子时，要求输出：弧形，总面积，剩余面积，家居名称列表

"""
房子有户型，总面积和家具名称列表
新房子没有任何家具
家具有名字和占地面积，其中
床： 占地 4 平米
衣柜：占地 2 平米
餐桌：占地 1.5 平米

 题目分析：
 1、定义两个类，分别为房子类和家具类
 2、对房子类进行初始化，初始化中房子中没有
 任何家具，
 3、对房子类进行方法的定义，接受一个参数整体的参数（这个参数由家具示例化进行产生）
 4、在方法中进行家具面积和剩余面积的比较，如果家具面积大于剩余面积，则不能进行家具
 的添加，并且会进行报错，如果家具面积小于剩余面积，可以进行家具的添加，剩余面积
 进行相应的缩减，并将家具添加到列表中
 3、对房子类进行字符的输出
 4、对家具类进行定义
 5、完成家具类的初始化，要求接受面积和家具名称的参数
 6、对家具进行字符的输出
"""
class jiaju():
    def __init__(self,name,arae):
        self.name = name
        self.arae = arae

    def __str__(self):
        return '%s的占地面积为：%d' %(self.name,self.arae)


class House():

    def __init__(self,type,areas):
        self.type = type
        self.areas = areas
        self.shengyu = areas
        list1 = []
        self.list1 = list1

    def __str__(self):

        return '%s的总面积为：%d 剩余面积为：%f 家具为%s' %(self.type,self.areas,self.shengyu,self.list1)

    def add1(self,item):
        if item.arae > self.shengyu:
            print('房间面积不足，不能进行家具的添加')
        else:
            self.list1.append(item.name)
            self.shengyu -= item.arae



bed = jiaju('床',4)
print(bed)
fangzi = House('三室一厅',200)
fangzi.add1(bed)
print(fangzi)

执行结果：
/home/kiosk/PycharmProjects/面向对象/venv/bin/python /home/kiosk/PycharmProjects/面向对象/习题练习/进行家居的添加.py
床的占地面积为：4
三室一厅的总面积为：200 剩余面积为：196.000000 家具为['床']

Process finished with exit code 0