标签：导致 round blog 成员函数 问题 场景 ISE details pen
一、面向对象知识。
1、 理解面向对象：
2、面向对象的设计原则。
3、设计模式单概念与分类。
4、动态语言的设计模式。
5、设计模式的分类--[创建模式、结构模式、行为模式]
1、对象：含义是指具体的某一个事物，即在现实生活中能够看得见摸得着的事物。[车、人、牛]
在python里面，一切皆是对象。每个类的实例或变量都具有自己的内存地址或身份。
对象就是类的实例：
1.1、对象表示石开发应用程序内的实体。
1.2、实体与实体交互来解决现实世界的问题。
例子：人是实体，车是实体。人可以驾驶车，到一个地方。
class name:
pass
name() #对象创建
2、类：某一个对象的抽象化表示。
2.1、他定义对象的属性和行为。属性：是数据成员。
行为：由成员函数表示。
2.2、类包含构造函数，作用：初始化
2.3、类是一类对象的抽象化，易于重复使用。
#定义一个类
class name:
pass
类与对象的主要区别
对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
类：类是一个模板，它描述一类对象的行为和状态。
3.方法
3.1、他表示对象单行为。
3.2、对属性进行处理，从而实现需要的功能。
class Person(object):
def __init__(self,name,age):
self.name=name
self.age=age
def get_person(self):
return "<person(%s,%s)>"%(self.name,self.age)
p=Person("teddy",32)
print ("Type of object",type(p),"memory address",id(
面向对象编程的概念：
面向对象就是：把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。对象即为人对各种具体物体抽象后的一个概念，人们每天都要接触各种各样的对象，如手机就是一个对象。
面向对象编程（OOP： object-oriented programming） [封装、继承、多态]
1. 类调用类中的变量和方法
(1) __dict__方法(操作类中的静态变量):只能查询不能增删改.
class Person:
mind = ‘有思想‘
belif = ‘有信仰‘
animal = ‘高级动物‘
print(Person.__dict__) #查询类Person中所有的内容,表现形式是字典.
print(Person.__dict__[‘belif‘]) #查询类Person中的变量‘belif‘
# Person.__dict__[‘belif‘] = ‘无信仰‘ #修改变量‘belif‘的值报错
(2). 万能的点： .
class Person:
mind = ‘有思想‘
belif = ‘有信仰‘
animal = ‘高级动物‘
def work():
print(‘666‘)
def money():
print(‘777‘)
print(Person.animal) #高级动物
print(Person.mind) #有思想
Person.mind = ‘没有思想‘ #修改变量‘mind‘的值,可以通过__dicy__查看修改后的内容
Person.pay = ‘货币交换‘ #增加变量‘pay‘和它的值,可以通过__dicy__查看增加后的内容
Person.say = ‘语言交流‘
print(Person.work()) #也可以调用类中的方法(函数),一般不用类名去操作
print(Person.__dict__) #查看类中所有的内容
2. 对象调用类中的变量和方法
__init__方法是一个特殊的方法,只要类名+() 产生一个对象,自动执行类中的__init__方法,并把类的地址传给方法里的第一个参数,约定把第一个参数定为‘self‘, 再给对象封装相应的属性.
(1) __dict__ 查询对象中的所有的内容
(2) 万能的点： .
class Person:
mind = ‘有思想‘
belif = ‘有信仰‘
animal = ‘高级动物‘
def __init__(self, name,age,hobby):
self.name = name
self.age = age
self.hobby = hobby
print(name,age,hobby)
def work(self):
print(‘会工作‘)
return self
def money(self):
print(‘会消费‘)
print(self)
ret = Person(‘jack‘,22, ‘敲键盘‘) # 类名+() 的这个过程:实例化的过程(创建一个对象的过程)
# jack 22 敲键盘
print(ret) #Person()创建一个对象空间,把这个空间的地址赋值给ret
# <__main__.Person object at 0x0000021248F46550>
print(ret.__dict__) #查询对象中所有的内容: {‘name‘: ‘jack‘, ‘age‘: 22, ‘hobby‘: ‘敲键盘‘}
print(Person.work(111)) #调用方法,并把111传给self,(一般通过对象调用类的方法,而不是类)
# 会工作 # 111 # print(Person.money()) 类调用方法时不传参数会报错
ret.work() # 对象可以直接调用类中的方法不用给self传参
# 会工作
二、设计模式[]
设计模式的定义:为了解决面向对象系统中重要和重复的设计封装在一起的一种代码实现框架,可以使得代码更加易于扩展和调用
四个基本要素:模式名称,问题,解决方案,效果
六大原则:
1.开闭原则:一个软件实体,如类,模块和函数应该对扩展开放，对修改封闭。既软件实体应尽量在不修改原有代码的情况下进行扩展。
2.里氏替换原则:所有引用父类的方法必须能透明的使用其子类的对象
3.依赖倒置原则:高层模块不应该依赖底层模块，二者都应该依赖其抽象,抽象不应该依赖于细节，细节应该依赖抽象，换而言之,要针对接口编程而不是针对实现编程
4.接口隔离原则:使用多个专门的接口,而不是使用单一的总接口,即客户端不应该依赖那些并不需要的接口
5.迪米特法则:一个软件实体应该尽可能的少与其他实体相互作用
6.单一直责原则:不要存在多个导致类变更的原因.即一个类只负责一项职责
零:接口
定义:一种特殊的类,声明了若干方法,要求继承该接口的类必须实现这种方法
作用:限制继承接口的类的方法的名称及调用方式,隐藏了类的内部实现
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):
@abstractmethod#定义抽象方法的关键字
def pay(self,money):
pass
# @abstractmethod
# def pay(self,money):
# raise NotImplementedError
class AiliPay(Payment):
#子类继承接口,必须实现接口中定义的抽象方法,否则不能实例化对象
def pay(self,money):
print(‘使用支付宝支付%s元‘%money)
class ApplePay(Payment):
def pay(self,money):
print(‘使用苹果支付支付%s元‘%money)
一:单例模式
定义:保证一个类只有一个实例,并提供一个访问它的全局访问点
适用场景:当一个类只能有一个实例而客户可以从一个众所周知的访问点访问它时
优点:对唯一实例的受控访问,相当于全局变量,但是又可以防止此变量被篡改
class Singleton(object):
#如果该类已经有了一个实例则直接返回,否则创建一个全局唯一的实例
def __new__(cls, *args, **kwargs):
if not hasattr(cls,‘_instance‘):
cls._instance = super(Singleton,cls).__new__(cls)
return cls._instance
class MyClass(Singleton):
def __init__(self,name):
if name:
self.name = name
a = MyClass(‘a‘)
print(a)
print(a.name)
b = MyClass(‘b‘)
print(b)
print(b.name)
print(a)
print(a.name)
原文链接：https://blog.csdn.net/sugar_no1/article/details/86366714
标签：导致 round blog 成员函数 问题 场景 ISE details pen
原文地址：https://www.cnblogs.com/1314520xh/p/12129669.html
