面对对象编程基础之核心知识梳理二
文章目录五、核心知识梳理2.面对对象继承2.1 父类与子类2.2 在python中继承的一些特点3.面向对象之成员归属4.面向对象之类成员的静态字段与普通字段5.面向对象之成员访问总规则6.面向对象类成员之静态方法与类方法7.面向对象类成员之特性8.面向对象类成员梳理9.面向对象之成员修饰符9.1 成员修饰符9.2 静态字段9.3 普通字段
五、核心知识梳理
2.面对对象继承
2.1 父类与子类
这里发现参数值改变了。
作者：匡夆
例子
class animals:
def eat(self):
return self.obj_name + '吃饭'
def drink(self):
return self.obj_name + '喝东西'
class cat(animals):
# class 派生类名（基类名）: //... 基类名写在括号里，基本类是在定义的时候，在元组职中指明的。
def __init__(self, name):
self.obj_name = name
def action(self):
return (self.obj_name + '这只猫很乖')
class dog(animals):
def __init__(self, name):
self.obj_name = name
def action(self):
return (self.obj_name + '这只狗很调皮')
o = cat('喵喵')
print (o.action())
print (o.eat())
print (o.drink())
print ('=========')
o = dog('吠吠')
print (o.action())
print (o.eat())
print (o.drink())
1.在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
2.在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
3.python总是首先找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类逐个查找（现在本类中查找调用的方法，找不到才去基类中找）
4.如果在继承元组中列了一个以上的类，那么它就被称作“多重继承”
3.面向对象之成员归属例子
class reflect:
def __init__(self,name):
self.name = name
def show(self):
print ('haha')
obj = reflect('test_name')
a = hasattr(obj, 'name') # 从对象中查找对象的成员
b = hasattr(obj,'show') # 从对象中查找类的成员
c = hasattr(reflect,'name') # 从类中查找对象的成员
d = hasattr(reflect,'show') # 从类中查找类的成员
print (a)
print (b)
print (c)
print (d)
1.通过反射的方式，从类中查找成员，只能找到类里的成员，不能找对象中的成员
2.通过反射的方式，从对象中查找成员，既能找到类里的成员，也能找到对象中的成员
4.面向对象之类成员的静态字段与普通字段例子
普通字段：
class province:
def __init__(self,name):
self.s_name = name #普通字段
def guangdong(self):
country = 'china'
return self.s_name + '_' + country
def guangxi(self):
country = 'china'
return self.s_name + '_' + country
obj= province('广东')
print (obj.guangdong())
静态字段：
class province:
country = 'china' # 静态字段
def __init__(self,name):
self.s_name = name
def guangdong(self):
return self.s_name + '_' + self.country
def guangxi(self):
country = 'china'
return self.s_name + '_' + self.country
obj= province('广东')
print (obj.guangdong())
这时country全局有效
例子
class province:
country = 'china' # 静态字段
def __init__(self,name):
self.s_name = name
def guangdong(self):
return self.s_name + '_' + self.country
def guangxi(self):
country = 'china'
return self.s_name + '_' + self.country
obj= province('广东') # 将类province实例化成一个对象obj
print (obj.guangdong()) # 通过对象obj去访问类province中的方法guangdong（）
print (province('广东').guangdong()) # 通过类province去访问类中的方法guangdong（）
print (province.country)# 通过类去访问类中的字段
print (province('广东').guangdong())
例子
class province:
country = 'china' # 静态字段
def __init__(self,name):
self.s_name = name
def guangdong(self):
return self.s_name + '_' + self.country
def guangxi(self):
country = 'china'
return self.s_name + '_' + self.country
@staticmethod
def static_method():
return 'static'
obj= province('广东') # 将类province实例化成一个对象obj
print (province.static_method()) # 通过类访问静态方法，建议使用！
print (obj.static_method()) # 通过对象访问静态方法，不建议使用！
print (obj.guangdong())# 通过对象访问普通方法
总结
通过类访问的：静态字段、静态方法
通过对象访问：普通字段、类的方法
在静态方法中，是没有self这个参数的，也就是说，可以给静态方法传递任意多个参数。
7.面向对象类成员之特性特性：即为将方法伪造成一种字段
1.例子
class test:
def __init__(self,name):
self.s_name = name
def start(self):
return self.s_name + '_001'
@property
def end(self):
return self.s_name + '_002'
obj = test('mangguo')
ret1 = obj.start() # 方法前未有@property的，在执行该方法时，需要加上括号()
ret2 = obj.end # 方法前有@property的，在执行该方法时，需要不需要加上括号()
print (ret1,ret2)
2.例子
class test:
def __init__(self,name):
self.s_name = name
def start(self):
return self.s_name
obj = test('mangguo') # 类实例化成一个对象
print (obj.s_name) # 获取对象中的字段
obj.s_name = '123' # 修改对象中的字段
print (obj.s_name) # 获取对象中的字段，发现字段已经被成功修改
3.例子
class test:
def __init__(self,name):
self.s_name = name
@property # 通过property将方法的伪装成一个字段(即为特性)
def start(self):
return self.s_name
@start.setter # 通过@方法名.setter对伪装的字段进行修改
def start(self,value):
# print(value) # 输出修改后的值
self.s_name=value
obj = test('mangguo') # 类实例化成一个对象
print (obj.start) # 通过对象名.方法名的方式访问字段
obj.start = 'pro_change' # 通过对象名.方法名的方式修改字段，通过类名.方法名='xxx'的方式修改字段
print (obj.start) # 获取对象名.方法名的方式访问字段
从结果可以看出这里发现参数值改变了。
面向对象的成员包括三部分：字段，方法，特性
普通字段：当需要每个对象都自己保存一个字段并且保存的字段不同
静态字段：当需要每个对象都有同一份数据
静态方法：静态方法与对象无关，无需使用对象封装的内容，因为静态方法时通过类进行调用而非使用对象进行调用，也就是说，想要不去访问对象中的内容，就使用静态方法。
类方法：与静态方法类似，不同的是类方法是会将类名传递进来。
普通方法：普通方法一般都是通过对象进行调用，当需要使用对象中的内容时，可以使用普通方法。
特性：普通特性，将一个方法伪装成一个字段进行访问。
使用类调用的有：静态字段，静态方法
使用对象调用的有：普通字段，普通方法，类方法
（有self，对象调用）
（无self，类调用）
9.面向对象之成员修饰符 9.1 成员修饰符修饰符：就是对成员加上一些标签，对成员做一些约束
修饰符分类：
私有修饰符和共有修饰符
例子
9.2 静态字段class test:
class_para = 'abc'
__class_para_01 = '__abc' # 注意在静态字段class_para_01前面有两个下划线__
def __init__(self,name):
self.s_name = name
def test_func(self):
print (self.s_name)
def test_func01(self):
return test.__class_para_01 # 返回被修饰符修饰的成员class_para_01的值
obj = test('haha') # 实例化一个类
print (test.class_para) # 输出abc
print (obj.test_func01()) # 输出__abc
print (test.__class_para_01) # 报错
class test:
class_para = 'abc'
def __init__(self,name):
self.__s_name = name
def test_func(self):
return self.__s_name # 返回通过修饰符进行修饰的普通字段
obj = test('abc')
print (obj.test_func())
class test:
class_para = 'abc'
def __init__(self,name):
self.__s_name = name
def test_func(self):
return self.__s_name # 返回通过修饰符进行修饰的普通字段
obj = test('abc')
print (obj.__s_name) # 直接打印对象中的普通字段
作者：匡夆
