Python笔记_18_OOP面向对象_类的封装性_构造函数

OOP 面向对象的程序开发

用几大特征表达一类事物称为一个类,类更像是一张图纸,表达的是一个抽象概念
对象是类的具体实现,更像是由这图纸产出的具体物品,类只有一个,但对象可以通过这个类实例化出多个
对象是类的实例,类是对象的模板
*类中的成员只有方法和属性,不要裸露的把判断和循环直接写在类中,而是用方法包起来

1. 类的定义

# 1.
class MyClass:
	pass

# 2.推荐
class MyClass():
	pass
	
# 3.
class MyClass(object):
	pass

2. 类的实例化

class MyClass():
	pass
	
# 类的实例化,实例化对象
obj = MyClass() # obj 就是一个对象

3. 类的基本结构

只有成员方法 和 成员属性
对象.属性 , 对象.方法()

class MyClass():
	# 成员属性
	color = "天蓝色"
	# 成员方法
	def pa():
		print("我下生就会上树")
obj = MyClass()
print(obj.color)

语法上允许,但是一定不要这么写,class 和def不太一样
函数在调用时,才会触发里面的代码块
而类只要执行到这一行,就会触发了.

class MyClass():
	if 5 == 5:
		print(555)
		
# 改造
class MyClass():
	def func():
		if 5 == 5:
			print(555)

4. 类的命名:

在对类进行命名的时候,推荐使用大驼峰命名法.
对于类的命名参考变量命名方式

面向对象三大特征: 封装 继承 多态

• 封装:对类中成员属性和方法的保护,控制外界对内部成员的访问,修改,删除等操作
• 继承:一个类除了自身所拥有的属性方法之外,还获取了另外一个类的成员属性和方法
• 多态:不同的子类对象,调用相同的父类方法,产生不同的执行结果

类的封装性

公有的,在类外可以调用类的相关共有属性方法
私有的(前面开头加上 __ 两个下划线),在外类不可以调用类内的相关私有属性方法

绑定方法:
(1) 绑定到对象 (默认系统把对象当成参数传递)
(2) 绑定到类 (默认系统把类当成参数传递)
这两个参数,无论哪种,都是系统自己传递的,
但是参数需要我们自己定义好

class Car():
	# 公有属性
	logo = "特斯拉"
	# 私有属性
	__oil = "2.5L"
	
	# 公有方法
	def run(self):
		print("我的小车会跑")
		
	def jiao(self):
		print("我的%s小车会滴滴滴的叫" % (self.logo))
		
	# 私有方法
	def __oil_info(self):
		print("这是我的私有方法")
		
# 实例化对象
obj = Car()
print(obj)

对象的相关操作

1. 实例化的对象访问公有成员属性和方法

对象.属性
对象.方法()

• 调用公有成员属性

print(obj.logo)
# print(obj.__oil) # 私有的无法在类外调用

• 调用公有成员方法

系统自己会默认的把obj这个对象当成参数进行传递
传递给run这个方法,用self这个参数进行接收
self 这个词约定俗称这么写,是自定义的,代表本对象.

obj.run()
obj.jiao()
# obj.__oil_info() error 私有的不能够在类外调用

2. 实例化的对象动态添加公有成员属性

obj.color = "屎黄色"
print(obj.color)
# 查看obj这个对象的内部成员,使用__dict__
print(obj.__dict__)

类中得 成员属性 和 方法 可以给对象使用,
但是只有使用权,没有归属权,
类里面的成员属性方法只归类所有,
对象只能使用(获取) 不能够修改或者删除.
不归对象所有

3. 实例化的对象动态添加公有成员方法

• 添加无参方法

def func():
	print("我的汽车会变形,请叫我大黄蜂")

# 把func方法赋值给成员方法bianxing
obj.bianxing = func
obj.bianxing()
print(obj.__dict__)

• 添加有参方法

def qingtianzhu(name):
	print("请叫我"+name)

obj.qingtianzhu = qingtianzhu
obj.qingtianzhu("擎天柱")

# 改造1
def qingtianzhu(self,name):
	print("请叫我"+name,"我的颜色是"+self.color)
	
obj.qingtianzhu = qingtianzhu
obj.qingtianzhu(obj,"大擎天柱")

# 改造2 把qingtianzhu变成绑定方法(系统帮助我们传递对象)
import types
# MethodType(函数,对象) 要把那个函数作为对象的绑定方法
obj.qingtianzhu = types.MethodType(qingtianzhu,obj)
obj.qingtianzhu("大大擎天柱")

• 添加lambda表达式

obj.fangxiangpan = lambda : print("我是制造方向盘的方法")
obj.fangxiangpan()

类的相关操作

class MyCar():
	oil = "涡轮增压发动机1.5T"
	__price = "100万"
	
	# 公有普通方法 (只能类来调用)
	def oil_info():
		# 类.oil
		print("我的油耗信息:" +MyCar.oil)
	
	# 私有普通方法
	def __price_info():
		print("我的价格是保密的")
		
# obj = MyCar()
# obj.oil_info() 对象调用不了

1. 定义的类访问公有成员属性和方法

   类.成员属性
类.成员方法()
   无论是私有属性还是方法都无法在类外调用

print(MyCar.oil)
MyCar.oil_info()
# MyCar.__price_info() error  无法使用类来调用私有成员	

2. 定义的类动态添加公有成员属性和方法

• 公有属性

MyCar.logo = "中国一汽"
print(MyCar.logo)
# 使用__dict__ 查看类内的成员
print(MyCar.__dict__)

• 公有方法

#(1) 无参方法
def dahuangfeng():
	print("请叫我大黄蜂")
MyCar.dahuangfeng = dahuangfeng
MyCar.dahuangfeng()

#(2) 有参方法
def qingtianzhu(name):
	print("请叫我"+name)
MyCar.qingtianzhu = qingtianzhu
MyCar.qingtianzhu("一柱擎天")

#(3) lambda 表达式
MyCar.dog = lambda : print("我的车会坐下握手")
MyCar.dog()

如何访问私有成员

class Plane():
	# 公有属性
	captain = "马军强"
	# 私有属性
	__air_sister = "20个"

	# 公有绑定方法
	def fly(self):
		print("飞机会飞")
	
	# 公有普通方法
	def fly2():
		print("飞机会飞2")
		
	# 私有的绑定方法
	def __oil_info(self):
		print("飞机百公里油耗是100升")
		
	# 私有的普通方法
	def __oil_info2():
		print("飞机百公里油耗是100升")
		
	# 公有的绑定方法
	def pub_info(self):
		print(self.__air_sister)
		self.__oil_info()
		
	# 公有的普通方法
	def pub_info2():
		print(Plane.__air_sister)
		Plane.__oil_info2()

1. 如何访问类的私有成员?

利用公有方法调用类内的私有成员
私有成员在本类之内可以随便调用,在本类之外不能调用

# 实例化对象 方法一
obj = Plane()
obj.pub_info()

# 也可以使用类来调用 方法二
Plane.pub_info2()

2. 如果就想直接在类外调用私有成员,有办法么?

私有成员的改名策略:
_类名 + 私有成员 (没有真正的私有化,类外可以通过改名策略仍然调取.)

print(obj._Plane__air_sister)
Plane._Plane__oil_info2()

如何删除成员

1. 实例化的对象删除公有成员属性和方法

obj = Plane()
print(obj.__dict__)
print(obj.captain)

captain 成员属性归属于class Plane的,不是obj的
obj可以有使用权,没有所有权(不能够修改或者删除类内的属性)
如果对象有该属性方法,先优先调用该对象里面的成员,
如果没有,在调用类中的成员属性和方法
如果都没有,直接报错.

• 删除对象的属性

obj.captain = "熊卫华"
print(obj.__dict__)
print(obj.captain) 
del obj.captain
print(obj.captain) # obj自己的captain 被删除了

• 删除对象的方法

obj.fly111222 = lambda : print("我的飞机可以潜入海底")
obj.fly111222()
print(obj.__dict__)
# del obj.fly
# print(obj.__dict__)

2. 定义的类删除公有成员属性和方法

对象可以调用类中得公有成员属性方法
类不能调用对象的相关成员属性和方法
方向不可逆.
一个类可以产生多个对象,多个对象彼此之间,数据独立

• 删除类的成员属性

del Plane.captain
# print(Plane.captain) error
# print(obj.captain) error
# Plane.fly111222() error  类不能调用对象的方法

• 删除类的成员方法

del Plane.pub_info
# Plane.pub_info() error  不存在

魔术方法

详见 ： 其他魔术方法

__init__ 魔术方法

• 触发时机：实例化对象,初始化的时候触发
• 功能：为对象添加成员,用来初始化的
• 参数：参数不固定,至少一个self参数
• 返回值：无

1. 基本用法

class MyClass():
	def __init__(self):
		# print(1111)
		self.name = "张国成"

# 实例化对象  [类的实例化]
obj = MyClass()
print(obj.name)

2. __init__ 可以传递多个参数

class MyClass():
	def __init__(self,name):
		# self.name 这个name 是成员属性name
		# self.name = name 后面的name 是传进来的参数
		self.name = name

# 类的实例化  实例化对象
# 把参数传递到MyClass后面的这个括号里
obj = MyClass("陈广耀")
print(obj.name)

3. 综合案例
   类可以是一个,但对象可以是多个.对象之间彼此独立

class Children():
	def __init__(self,name,skin):
		self.name = name
		self.skin = skin
		
	def eat(self):
		print("小孩生下来的时候,手里拿了大串大腰子")
		
	def drink(self):
		print("小孩生下来,手里拿了两瓶啤酒")
		
	def beat_doudou(self):
		print("小孩生下来就喜欢打豆豆")

	def obj_info(self):
		print("小孩的姓名:{},小孩的肤色是{}".format(self.name,self.skin))
'''
同一个类产生了三个对象,但是每个对象彼此都是独立的
而且都可以调用类中的公有成员属性方法.
'''
child1 = Children("方贵权","黑色的")
child1.obj_info()
child1.eat()

child2 = Children("张国成","屎黄色")
child2.obj_info()
child2.drink()

child3 = Children("王宝强","绿色的")
child3.obj_info()
child3.beat_doudou()