百木园
oop面向对象的程序开发
用几大特征表达这一类事务称为一个类,类更像是一张图纸,表达的是一个抽象概念
对象是类的具体实现,更像是由这种图纸产出的具体物品,类只有一个,但对象可以通过这个类实例化出多个
对象是类的实例,类是对象的模板
*类中的成员只有方法和属性,不要裸露的把判断和循环直接写在类中,而是用方法包起来
(1)类的定义
# 1 class Car: pass # 2 推荐 class Car(): pass # 3. class Car(object): pass
(2)类的实例化
class Car(): pass obj = Car() print(obj)
(3)类的基本结构
class Car(): # 成员属性 color = \"白色\" # 成员方法 def didi(): print(\"小车会嚓嚓的叫\") # 语法上不报错,但是严禁使用,破坏了类中的结构,不要裸露的把判断和循环直接写在类中,而是用方法包起来 class Car(): if 5 ==5 : print(11223344)
(4)类的命名
\"\"\"类的命名 : 推荐使用大驼峰命名法,每个单词的首字母都要大写\"\"\" \"\"\" mycar => MyCar zhangbaozhang => ZhangBaoZhang \"\"\"
封装:对类中成员属性和方法的保护,控制外界对内部成员的访问,修改,删除等操作
继承:一个类除了自身所拥有的属性方法之外,还获取了另外一个类的成员属性和方法
多态:不同的子类对象,调用相同的父类方法,产生不同的执行结果
面向对象的封装 - 对象的操作
封装:
1.私有 : 在类内可以互相访问,在类外不能访问
2.公有 : 在类内或者类外都可以访问
类中成员:
1.成员属性
2.成员方法
绑定方法:
1.绑定到对象 : 当对象去调用类中成员方法时,系统会默认把该对象当成参数传递给该方法
2.绑定到类 : 当对象或者类去调用类中成员方法时,系统会默认把该类当成参数传递给该方法
使用方式:
对象.成员属性
对象.成员方法
class MyCar(): # 公有属性 logo = \"布加迪威龙\" # 私有属性 __price = \"2000万\" # 公有方法 def run(self): print(\"百公里油耗300L,logo={} , price={}\".format(self.logo, self.__price)) # 私有方法 def __info(self): print(\"车主信息保密,据说是某个房地产大佬的儿子\") # 实例化对象(类的实例化) obj = MyCar() # (1)实例化的对象访问成员属性和方法 # 公有 print(obj.logo) obj.run() # 私有 (私有成员无法在类外访问,类内可以) # obj.__price error # obj.run() # obj.__info() error #(2)实例化的对象动态添加公有成员属性 obj.color = \"尿黄色\" obj.logo = \"五菱宏光\" print(obj.color) print(obj.logo) # __dict__ 获取类对象的内部成员 print(obj.__dict__) print(MyCar.__dict__) #(3)实例化的对象动态添加公有成员方法 # 1.无参方法 def dahuangfeng(): print(\"请加我大黄蜂\") obj.dahuangfeng = dahuangfeng obj.dahuangfeng() # 2.有参方法 # 基本版 def qingtianzhu(name): print(\"请叫我一柱擎天么,{}\".format(name)) obj.qingtianzhu = qingtianzhu obj.qingtianzhu(\"擎天柱\") # 升级版 def qingtianzhu(obj,name): print(\"请叫我一柱擎天么,{},我的颜色是{}\".format(name,obj.color)) obj.qingtianzhu = qingtianzhu obj.qingtianzhu(obj,\"擎天柱\") # 究极版 \"\"\"如果要创建绑定方法,参数的顺序,self对象本身要放到第一位.\"\"\" def qingtianzhu(obj,name): print(\"请叫我一柱擎天么,{},我的颜色是{}\".format(name,obj.color)) import types # 创建绑定方法,系统自动把该对象当成参数传递给方法; # types.MethodType(方法,对象) => 绑定方法 res = types.MethodType(qingtianzhu,obj) print(res) obj.qingtianzhu = types.MethodType(qingtianzhu,obj) obj.qingtianzhu(\"擎天柱\") # 3.lambda表达式 obj.weizhentian = lambda : print(\"我是威震天\") obj.weizhentian()
View Code
面向对象的封装 - 类的操作
使用方式:
类.成员属性
类.成员方法
class MyCar(): # 公有成员属性 platenum = \"京A7758BB\" # 私有成员属性 __earning = \"月收入6000\" # 公有成员方法 def car_info(): print(\"牌照信息可以公开\") print(\"<======>\") MyCar.__money_info() # 私有成员方法 def __money_info(): print( \"收入信息保密\" , MyCar.__earning ) # (1)定义的类访问公有成员属性和方法 print(MyCar.platenum) MyCar.car_info() # MyCar.__money_info() error # (2)定义的类动态添加公有成员属性 MyCar.oil = \"1000L\" print(MyCar.oil) print(MyCar.__dict__) # (3)定义的类动态添加公有成员方法 # 1.无参方法 def car_light(): print(\"我是造车灯的方法\") MyCar.car_light = car_light MyCar.car_light() # 2.有参方法 def car_engine(name): print(\"我是造{}发动机的方法\".format(name)) MyCar.car_engine = car_engine MyCar.car_engine(\"三缸发动机\") # 3.lambda表达式 MyCar.luntai = lambda : print(\"我是造轮胎的方法\") MyCar.luntai() # 对比 对象和类之间的不同 \"\"\" 1.类中的无参方法默认只能类来调用,对象无法调取 2.对象可以调用类中的成员,反过来,类不能调用对象中的成员 3.每创建一个对象都会在内存中占用一份空间,对象之间是彼此独立的; \"\"\" obj = MyCar() # obj.car_info() error MyCar.car_info() obj.price = \"10万\" print(MyCar.price)
View Code
私有的: private
在本类内部可以访问,类的外部不可以访问.(python中 属性或者方法前面加上两个下划线__)
公有的: public
在本类的内部和外部都可以访问.
在其他高级语言当中,如java php c++等语言,有三个等级 private public protected
私有成员的改名策略 [_类名__成员名]
对象的相关操作
(1)实例化的对象访问公有成员属性和方法
(2)实例化的对象动态添加公有成员属性和方法
(3)实例化的对象删除公有成员属性和方法
类的相关操作
(1)定义的类访问公有成员属性和方法
(2)定义的类动态添加公有成员属性和方法
(3)定义的类删除公有成员属性和方法
普通方法: 没有任何参数传递,只能类调用
绑定方法: 把默认传参的方法叫做绑定方法,绑定到对象(默认传对象),绑定到类(默认传类)
非绑定方法:静态方法(无需传任何参数,对象和类都能调用)
私有的：只能载类或者对象的结构中访问
公有的：可以载任何位置访问
受保护：可以载当前类或者对象 和子类或者子类对象中访问
类内 子类中 类外部
公有的： √ √ √
私有的： √ X X
受保护： √ √ X (python语言不支持)
1.如何在类外访问私有成员
class Plane(): # 公有成员 captian = \"赵沈阳\" # 私有成员 __air_sister = \"3名空姐\" # 公有绑定方法 def fly(self): print(\"飞机要非要平流层,才能减少震动\",self.__air_sister) # 私有绑定方法 def __age(self): print(\"空姐年龄保密\") # 公有无参方法 def fly2(): print(\"航天飞机飞到天空层,翱翔太空\") # 私有无参方法 def __earn(): print(\"机长的收入保密\") def pub_get1(self): print(self.__air_sister) self.__age() def pub_get2(): print(Plane.__air_sister) Plane.__earn() # 实例化对象 obj = Plane() # 方法一.访问私有成员 (不推荐) # python私有化: 采取了改名策略 => _类名 + __air_sister # print(obj.__air_sister) print(obj._Plane__air_sister) print(Plane.__dict__) \"\"\" {\'__module__\': \'__main__\', \'captian\': \'赵沈阳\', \'_Plane__air_sister\': \'3名空姐\', \'fly\': <function Plane.fly at 0x7f2774616158>, \'_Plane__age\': <function Plane.__age at 0x7f27746161e0>, \'fly2\': <function Plane.fly2 at 0x7f2774616268>, \'_Plane__earn\': <function Plane.__earn at 0x7f27746162f0>, \'__dict__\': <attribute \'__dict__\' of \'Plane\' objects>, \'__weakref__\': <attribute \'__weakref__\' of \'Plane\' objects>, \'__doc__\': None} \"\"\" # 方法二.访问私有成员 (使用类中的公有方法,间接访问私有成员) (推荐) obj = Plane() obj.pub_get1() Plane.pub_get2()
View Code
2.使用类对象删除相应的成员
1.对象可以访问类中的公有成员,但是无权修改或者删除该类中的成员
2.对象在访问成员时,优先访问该对象自己的成员,如果没有在访问类的,类如果也没有直接报错;
# 删除对象成员属性 obj.captian = \"赵世超\" del obj.captian print(obj.captian) # 删除对象成员方法 obj.basketball = lambda : print(\"我的私人飞机可以在天上打篮球\") print(obj.__dict__) obj.basketball() del obj.basketball print(obj.__dict__) # obj.basketball() error # 删除类中成员属性 del Plane.captian print(Plane.__dict__) # Plane.captian # print(obj.captian) error # 删除类中成员方法 del Plane.fly2 # Plane.fly2() error # 注意: 对象无法调无参方法!! 返回来,类可以调用对象的绑定方法么? 可以!! Plane.fly(obj)
View Code
来源：https://www.cnblogs.com/shuaiyao666/p/16049472.html
本站部分图文来源于网络，如有侵权请联系删除。