面向对象01-成员&属性 面向对象的

思想高度绝对上层建筑！

1.抽象数据类型（ADT）

——基本思想：把数据定义为抽象数据对象集合，然后为其定义合法基本操作，操作细节及数据储存细节不暴露！

——合法基本操作：（1）构造操作，创建抽象数据对象；（2）解析操作，有一系列getxxxx()方法；（3）修改操作，有一系列的setxxxx()方法；

同时具备以上三种操作，该抽象数据类型为可变类型；只具备第一二不具备第三种操作为不可变类型；

数据结构是抽象数据类型的物理实现；物理实现是指抽象概念实例化一个具体的对象；

程序 = 数据结构 + 算法，设计一个程序，考查的是数据结构及其操作和算法的设计与实现；

审视问题域的视角，即观察问题和解决问题的主要目标，如一个学生管理系统始终围绕学生和老师这两个客体实现，每个客体都有一些属性和行为；学生属性（姓名，学号等），（上课，考试等）行为[对外提供的操作]；

封装是将某个客体的的属性和行为绑定一起，放置在一个逻辑单元内！外界对客体内部属性的所有访问只能通过提供的用户接口实现；

2.面向对象基础概念

计算机中多个客观存在的对象，取共性抽象出一个类；计算机表示某一个类，可以具体出若干个具有相同特性，客观存在的对象、由对象得到类叫抽象化，由类得到对象叫实例化！

面向对象概念组成结构：面向对象分析OOA[采用面向对象的设计方法对任意一个可行需求进行分析与思考]，面向对象设计OOD[采用面向对象设计方法对任意需求进行功能实现设计]，面向对象编程OOP[采用面向对象设计方法对任意需求采用支持面对对象编程的语言进行实现；]

面向对象的核心思想——以面向对象为中心，注重解决一个问题的方法

面向对象基本概念专业名称总结：
（1）实体、客观实体、客体、实例、对象
实体：表示现实世界中的一个实例，计算机世界中的一个对象；
（2）类型、抽象数据类、类：
类型：表示概念世界的一个抽象数据类，计算机中的一个类；
（3）抽象、抽象化
抽象：现实世界中客观存在的多个实体到概念世界中一个类型的过程；
抽象化：计算机世界中客观存在的多个对象得到某一个类的过程；
（4）具体、实例化
具体：概念中存在某一个类型到现实实现中某些具体存在的客观实体的过程；
实例化：计算机中一个抽象类得到若干个具体化对象的过程；

对象：一切万物皆可称为对象【即具有真实意识形态的客观实体，戏称东西】；对象的组成结构：属性（描述对象的形态、特征）和方法（即对象的行为，对外提供的操作与功能，事件流程实现）

类是一系列具有相同属性（特征）及方法（操作、功能）的对象的抽象化概念。类的组成结构：属性（若干个结果值描述该类实例化得到对象的属性）和方法（若干封装了一个功能的函数描述该类对象的若干个方法）；若干对象抽象化得到的，可以实例化若干个对象，本质上就是一种可以自定义的抽象数据类型；

成员：描述一个对象或一个类中属性和方法的集合。属性成员是指所有对象或类中封装好的属性；方法成员是指所有对象或类中封装好的方法；

类的三大特性：

——封装性：将一组属性和方法放在一个类或对象中；

——继承性：一个类或一个类的实力可以共享，重复使用其他类的属性或方法；

——多态性：同一种操作作用于不同的类或该类的实力，产生不同的效果、不同的解释；

类的结构关系：类与类之间存在一定的关系，具体结构关系，又叫泛化关系，继承、实现、依赖；部分结构关系又叫关联关系，关联、组合、聚合；

面向对象语法：

类创建：
class 类名(默认object基类可写也可不写[继承关系]):
	'''
 类的文档解释
	'''
 def __init__(self,[可随意传参]):
 		方法体
    
  #  class:python关键字，声明一个变量绑定类；
  # __init__(self):类的初始化方法，用于初始化类的实例
  
  函数和方法有区别，方法是类内部声明的函数叫方法，函数是不依托于类及对象声明；
  
  #类的实例化语法：
  对象名 = 类名([实参传递])

3.类与对象的成员

（1）成员访问修饰符

——公有成员：public，默认声明的是公有成员；

——私有成员：private，声明成员变量用__开头修饰；

——受保护成员：protected，定义受保护成员类的内部、子类的内部可以访问并修改的成员。声明成员变量用_开头；

（2）属性

——公有属性：公有实例属性与公有类属性

公有实例属性：即类的对象，创建语法：

def __init__(self):
	self.实例属性名 = 实例属性值

观察是否有self，有self就是归属实例的属性

#访问：
类内访问，通过实例访问：self.实例属性名
类外访问，通过实例访问：对象名.实例属性名
#修改语法：
类内通过实例修改：self.属性名 = 新的属性
类外通过实例修改：对象名.实例属性名 = 新的属性

公有类属性：归属于类，在类的内外部均可通过类和类的实力访问，但是只能通过类修改

创建语法：
类属性名 = 类属性值

访问语法：
类内：类访问---类名.公有类属性名   实例访问---self.公有类属性名
类外：类访问---类名.公有类属性名  实例访问---对象名.公有类属性名

修改：
类内修改---类名.公有类属性名 = 新属性名，self.公有类属性名 = 新属性名
 类外修改---类名.公有类属性名 = 新属性

——私有属性

私有实例属性：归属于实例属性，类内部无法通过类访问及修改，可以通过实例访问及修改，类外部哪里都不能访问与修改；

创建语法：
def __init__(self):
 self.__私有实例属性名 = 实例属性值

访问语法：
实例访问类内----self.__属性名
修改语法：类内通过实例修改--self.__私有实例属性名 = 新属性值

私有类属性：在类内部，可以通过类及实例访问，只能通过类修改，在类外无法访问与修改；

创建语法：
__类名属性 = 类属性值
访问语法：
类内访问----类名.__私有类属性名
实例访问----self.私有属性名

修改语法：
类内修改：类名.__私有属性名 = 新属性值

——受保护属性：

受保护实例属性：在类内部可以通过实例访问和修改，在类的外部，无法通过类访问与修改也无法通过实例访问和修改。【实际上在类外可以通过实例访问和修改】

创建语法：
def __init__(self):
		self._受保护实例属性名 = 实力属性值

访问语句：
类内实例访问：self._受保护实例属性名

修改语法：
类内通过实例修改：self._受保护实例属性名 = 新的属性值

受保护类属性：在类的内部可通过类及实例来访问，但只能通过类修改。在类外部，均不可！【实际上，类外可通过类及实例访问，只能通过类修改】

创建语法：
_受保护类属性名 = 受保护类属性值

访问语法：
类内：类访问---类名._受保护属性名   实例访问：self._受保护类属性名

修改语法：
类内，通过类修改。类名._受保护类属性名 = 新属性值

——魔术属性：内置属性，python中内置属性名均由__魔术属性名__格式构成

产看一个类已有的内置属性，可以使用dir()自省函数查看

常用魔术属性：
__doc__:返回一个类或对象的文档解释说明；

__name__：返回类或对象的名称；

__class__:返回实例对应的类；

__dict__:以字典结构返回实例的自定义成员;

4.方法

——初始化方法：__init__，创建语法def __init__(self,[可选其他形参])，用于初始化实例对象；类的实例化时自动调用；

——公有方法

公有实例方法：归属实例的方法，在类的内部由类及类的实例调用；在类的外部，由类及类的实例调用；

创建语法：实例方法，必须写self
def 实例方法(self,[可选其他形参]):
	'''
	文档解释说明
	'''
	方法体
   return 返回值

调用语法：
类内：通过类调用------[结果对象] = 类名.实例方法(self，[实参序列])
	                     实例调用-------[结果对象] = self.实例方法名([实参序列])

类外：通过类调用------[结果对象] = 类名.实例方法(实例对象，[实参序列])
	            通过实例调用---------[结果对象] = 对象名.实例方法名([实参序列])

公有类方法：归属类的方法，在类的内部由类及类的实例调用；在类的外部，由类及类的实例调用；

创建语法：类方法必须要cls参数，将当前类本身作为参数
@classmethod                #用于创建一个类方法的内置装饰器
def 类方法名(cls,[可选其他形参]):
	'''
	文档解释说明
	'''
	方法体
   return 返回值


调用语法：
类内：通过类调用------[结果对象] = 类名.类方法名([实参序列])
	                     实例调用-------[结果对象] = self.类方法名([实参序列])

类外：通过类调用------[结果对象] = 类名.类方法(实例对象，[实参序列])
	            通过实例调用---------[结果对象] = 对象名.类方法名([实参序列])

——私有方法：

私有实例方法：归属实例的方法，内外均不可

创建语法：
def __私有实例方法名(self,[可选其他形参]):
	'''
文档解释
	'''
	方法体
  return 返回值

调用语法：
类内，通过类调用：[结果对象] = 类名.私有实例方法名(self,[实参序列])
              通过实例调用：[结果对象] = self.__私有实例方法名([实参序列])

私有类方法：归属于类的方法，类内可以由类及类的实力调用，类外均不可；

创建语法:
@classmethod
def __私有类方法名(cls,[可选其他形参]):
	'''
文档解释
	'''
	方法体
  return 返回值

调用方法：
类内，通过类调用：[结果对象] = 类名.私有类方法名([实参序列])
              通过实例调用：[结果对象] = self.__私有类方法名([实参序列])

——受保护方法：

受保护实例方法：归属实例的方法，类内可有类与实例调用，类外不可以。实质上内外由类及类的实力调用；

创建语法：
def _受保护实例方法名(self,[可选其他形参]):
	'''
文档解释
	'''
	方法体
  return 返回值

调用语法：
类内：通过类调用：[结果对象] = 类名受保护方法名(self,[实参序列])
              通过实例调用：[结果对象] = self._受保护方法名([实参序列]) 

受保护类方法：归属类的方法，类内可由类与实例调用，类外不可以。实质上内外由类及类的实力调用；

创建语法:
@classmethod
def _受保护类方法名(cls,[可选其他形参]):
	'''
文档解释
	'''
	方法体
  return 返回值

调用方法：
类内，通过类调用：[结果对象] = 类名.受保护类方法名([实参序列])
              通过实例调用：[结果对象] = self._受保护类方法名([实参序列])

——静态方法：属于类，不属于实例的方法；静态方法定义类会立刻分配内存空间；非静态方法在对象调用时会分配空间。静态方法只能调用其他静态成员，非静态成员可以调用静态成员；静态可以通过类和实例调用，建议通过类调用；

@staticmethod
def 静态方法名([可选其他形参]):
	静态方法体
  
  
#参数可有可无，返回值可有可无

调用语法：
类内：通过类调用----------[结果对象] = 类名.静态方法名([实参序列])
							通过实例调用-------[结果对象] = self.静态方法名([实参序列])
类外：通过类调用----------[结果对象] = 类名.静态方法名([实参序列])
							通过实例调用-------[结果对象] = 对象名.静态方法名([实参序列])

——抽象方法：归属于抽象类的方法，没有方法体的方法，主要用于规范派生类对抽象基类方法的实现；抽象基类不能被实例化只能继承，派生类一旦继承抽象基类必须重写抽象方法，抽象方法不能通过抽象基类直接调用；

创建语法：
from abc import abstractmethod，ABCMeta
class 抽象类名(object, metaclass =  ABCMeta):


@abstractmethod
def 抽象方法名(self)
	pass     #抽象方法没有方法体，规定为pass

——魔术方法：解释器标准库预先定义的方法，内置方法。魔术方法不显示调用，当python代码执行固定某逻辑，自动触发魔术方法的调用；方法名均有__魔术方法名__格式构成；

产看定义好的内置方法，dir()即dir(class or object)

__call__

常用魔术方法：__new__(cls,*args,**kwargs)，构造方法，返回类创建的实力对象；__del__(self)，析构方法，回收当前类的实例对象；引申：一个对象的生命周期：__new__,__init__,__del__，先构造再初始化最后析构；

4.对象成员管理函数

——hassattr(object,name)，检索object中是否包含名为name的属性或方法，存在返回True，不存在返回False；

——getattr(object,name,default = None)，返回object中名为name的成员（属性或方法）default不指定时检索不存在时会报错；

——setattr(object,name,value)，将指定成员是指为value；