美文网首页
面向对象

面向对象

作者: pubalabala | 来源:发表于2018-11-27 14:58 被阅读0次
面向对象 - OOP(Object Oriented Programming)
  • 面向对象的四大支柱:

    1. 抽象: 类是抽象的, 对象是具体的. 定义类的过程就是一个抽象过程, 需要做数据抽象(发现静态特征(属性)) 和行为抽象(发现动态特征(方法))
    2. 封装: 把数据和操作数据的方法绑定到一起形成对象, 通过给对象发消息来解决问题, 这是一个隐藏实现细节暴露简单的调用接口的过程
    3. 继承: 从已有的类创建新类的过程, 提供继承信息的称为父类(基类/超类), 得到继承信息的成为子类(派生类)
    4. 多态: 字类再继承父类过程中可以重写父类(override)已有的方法, 不同的字类可以给出不同的实现版本, 调用相同的方法时会表现出多态的行为
  • 面向对象七原则:

    1. 单一职责原则 - SRP - 一个类只做该做的事情
    2. 开闭原则 - 软件实体应该对扩展开发对修改关闭
    3. 依赖倒转原则(x)
    4. 里氏替换原则 - 任何时候可以用字类对象替换掉父类对象
    5. 接口隔离原则(x)
    6. 合成聚合复用原则 - 优先使用强关联关系而不是继承关系复用代码
    7. 最少知识原则(迪米特法则) - 不要给没有必然联系的对象发消息
  • GoF设计模式 - 23种场景 - Python弱化了其中16种:

    • 创建型模式
    • 结构型模式
    • 行为型模式
from abc import ABCMeta, abstractmethod
# 元类 - 描述类的类
# 通过metaclass=ABCMeta可以将一个类声明为抽象类
# 通过abstractmethod装饰器可以将方法装饰为抽象方法
class Employee(object, metaclass=ABCMeta):
    """员工"""
    def __init__(self, name)
        self.name = name

    @abstractmethod
    def get_salary(self):
        """获取薪资"""
        pass

class Manager(Employee):
    """部门经理"""

    # 重写父类的抽象方法(如果没有重写抽象方法那么该类也是抽象类)
    # 不同的子类都会重写这个抽象方法,所以这个方法就是有多态行为的方法
    # 抽象类不能实例化(创建对象)它是专门给其它类去继承的
    def get_salary(self):
        return 15000

class Programmer(Employee):
    """程序员"""

    def __init__(self, name):
        super().__init__(name)
        self.working_hour = 0

    def get_salary(self):
        return 200 * self.working_hour

class Salesman(Employee):
    """销售员"""

    def __init__(self, name):
        super().__init__(name)
        self.sales = 0

    def get_salary(self):
        return 1800 + self.sales * 0.05

def main():
    """主函数"""
    emps = [Manager('曹操'), Programmer('荀彧'), Programmer('郭嘉'), Salesman('典韦')]
    for emp in emps:
        # 通过isinstance函数可以进行类型识别
        if isinstance(emp, Programmer):
            hour = int(input(f'{emp.name}本月工作时间:'))
            emp.working_hour = hour
        elif isinstance(emp, Salesman):
            sales = float(input(f'{emp.name}本月销售额:'))
            emp.sales = sales
        print(f'{emp.name}本月工资:{emp.get_salary()}元')

if __name__ == '__main__':
    main()
扑克游戏
"""
类和类之间的关系:
- is-a关系 (继承):
- has-a关系 (关联/聚合/合成):
- use-a关系 (依赖):
"""
from enum import Enum, unique
import random


# class Gender(Enum):

#     MALE = 1
#     FEMALE = 0
#     UNKNOWN = 2


# 枚举类型 - 定义符号常量的最佳选择, 符号常量总是优于字面常量
@unique
class Suite(Enum):
    """花色"""

    SPADE = 0
    HEART = 1
    CLUB = 2
    DIAMOND = 3


class Card(object):
    """牌"""

    def __init__(self, suite, face):
        """初始化方法
        suite: 花色
        face: 大小
        """
        self.suite = suite
        self.face = face

    def show(self):
        """显示牌面"""

        suites = ['♠', '♥', '♣', '♦']
        faces = [
            '', 'A', '2', '3', '4', '5', '6', '7',
            '8', '9', '10', 'J', 'Q', 'K'
        ]
        return f'{suites[self.suite.value]} {faces[self.face]}'

    def __str__(self):
        return self.show()

    def __repr__(self):
        return self.show()


class Poker(object):
    """扑克"""

    def __init__(self):
        self.index = 0
        self.cards = [Card(suite, face)
                      for suite in Suite
                      for face in range(1, 14)]

    def shuffle(self):
        """洗牌(随机乱序)"""
        random.shuffle(self.cards)
        self.index = 0

    def deal(self):
        """发牌"""
        card = self.cards[self.index]
        self.index += 1
        return card

    @property
    def has_more(self):
        return self.index < len(self.cards)


class Players(object):
    """玩家类"""

    def __init__(self, name):
        # Python解释器搜索一个变量会按照LEGB的顺序进行搜索
        # Local -> Embedded -> Global -> Built-in
        # 在函数中定义的变量正常请款下属于局部作用域
        # 但是可以通过nonlocal或者global关键字将其放到嵌套或全局作用域
        self.name = name
        self.cards = []

    def get_one(self, card):
        """摸一张牌"""
        self.cards.append(card)

    def sort_card(self, comp=lambda card: (card.suite.value, card.face)):
        """整理手上的牌"""
        self.cards.sort(key=comp)



def main():
    poker = Poker()
    poker.shuffle()
    players = [
        Players('东邪'), Players('西毒'), Players('南帝'),
        Players('北丐')
    ]
    for _ in range(13):
        for player in players:
            player.get_one(poker.deal())
    for player in players:
        player.sort_card()
        print(player.name, player.cards)

if __name__ == '__main__':
    main()
类的继承
"""
UML - Unified Modeling Language - 统一建模语言
标准化的图形符号 - 便于沟通交流 - 一图胜千言
最重要的三种图:用例图 / 类图 / 时序图 
多重继承和MRO(方法解析顺序)- Method Resolution Order
Python 2的MRO类似于深度优先搜索
Python 3的MRO类似于广度优先搜索(C3算法)
"""


class A(object):

    def foo(self):
        print('foo() in A')


class B(A):
    pass
    # def foo(self):
    #     print('foo() in B')


class C(A):

    def foo(self):
        print('foo() in C')


class D(B, C):
    pass


def main():
    print(D.mro())
    # print(D.__mro__)
    d = D()
    d.foo()


if __name__ == '__main__':
    main()

相关文章

  • PHP全栈学习笔记8

    面向对象的基本概念,面向对象编程,oop,面向对象,面向对象的分析,面向对象的设计,面向对象的编程,什么是类。 类...

  • PHP全栈学习笔记8

    面向对象的基本概念,面向对象编程,oop,面向对象,面向对象的分析,面向对象的设计,面向对象的编程,什么是类。 类...

  • 总结.Net基础知识——献给即将入坑的同行们(一期)

    什么是面向对象 面向对象OO = 面向对象的分析OOA + 面向对象的设计OOD + 面向对象的编程OOP; 通俗...

  • 面向对象基础

    面向对象编程包括: 面向对象的分析(OOA) 面向对象的设计(OOD) 面向对象的编程实现(OOP) 面向对象思想...

  • 20-OOP类与对象

    面向对象 Object Oriented 学习面向对象:XXOO 面向对象的学习: 面向过程和面向对象的区别: 面...

  • JavaScript面向对象核心知识归纳

    面向对象 概念 面向对象就是使用对象。面向对象开发就是使用对象开发。 面向过程就是用过程的方式进行开发。面向对象是...

  • 面向对象(未完成)

    面向对象 标签(空格分隔): 面向对象 第一章:面向对象(上) 什么叫面向对象 面向过程、面向对象、两者区别 构造...

  • 面向对象:创建对象&继承

    博客内容:什么是面向对象为什么要面向对象面向对象编程的特性和原则理解对象属性创建对象继承 什么是面向对象 面向对象...

  • 面向对象

    了解什么是面向对象 首先,我们学习面向对象,要了解什么是面向对象,面向对象的重要概念:类,对象。 面向对象提出的这...

  • 面向对象的三大基本特征和五大设计原则

    1、面向对象概念 1.1、理解面向对象 面向对象是相对面向过程而言; 面向对象和面向过程都是一种思想; 面向过程:...

网友评论

      本文标题:面向对象

      本文链接:https://www.haomeiwen.com/subject/iqlgqqtx.html