面对对象编程基础之核心知识梳理二

五、核心知识梳理

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())

2.2 在python中继承的一些特点

• 在python中继承的一些特点：

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.通过反射的方式，从类中查找成员，只能找到类里的成员，不能找对象中的成员

扫描二维码关注公众号，回复： 9714240 查看本文章

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全局有效

• 静态字段存在的意义：将每一个对象里重复的东西只在类里面保存一份即可

5.面向对象之成员访问总规则

例子

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())

6.面向对象类成员之静态方法与类方法

• 静态方法：通过类去访问
• 普通方法：通过对象访问

例子

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) # 获取对象名.方法名的方式访问字段

• 从结果可以看出
  这里发现参数值改变了。
  

8.面向对象类成员梳理

面向对象的成员包括三部分：字段，方法，特性

普通字段：当需要每个对象都自己保存一个字段并且保存的字段不同

静态字段：当需要每个对象都有同一份数据

静态方法：静态方法与对象无关，无需使用对象封装的内容，因为静态方法时通过类进行调用而非使用对象进行调用，也就是说，想要不去访问对象中的内容，就使用静态方法。

类方法：与静态方法类似，不同的是类方法是会将类名传递进来。

普通方法：普通方法一般都是通过对象进行调用，当需要使用对象中的内容时，可以使用普通方法。

特性：普通特性，将一个方法伪装成一个字段进行访问。

使用类调用的有：静态字段，静态方法

使用对象调用的有：普通字段，普通方法，类方法

（有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) # 报错

9.3 普通字段

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) # 直接打印对象中的普通字段