day30 Pyhton 面向对象 继承.装饰器

一面向对象相关

谈谈你对面向对象的理解

　　1.泛泛谈:什么情况下使用面向对象

　　2.针对面向对象的 封装 继承 多态一个一个的谈

　　3.根据你工作中的实际情况对应来举例子

封装

1.广义上:普遍的大家认为的封装,就是把一类相同属性和方法的事务抽象为一个类

　　把属性和方法封装在一个类中

　　是为了复杂的角色关系的程序中,能够把属于各个角色的方法分开

　　使得代码更加简洁 清晰(狗不能调用attack,人不能调用bite)

　狭义上:在类中,可以定义一些私有成员(静态属性,方法,对象的属性)

　　　　__私有的成员名,就定义为私有的了

　　　　不能在类的外部使用,也不能被继承,旨在保护类中的一些信息

　应该知道

　　为什么私有的成员不能在类的外部直接使用?

　　　　所有的私有成员,都是在创建的时候变异了,变成_类名__私有的成员名

　　为什么私有的成员可以直接在类的内部使用?

　　　　在类的内部使用私有成员的时候,类会自动的在这些成员的前面加上_类名

　　

　　什么情况下使用封装:

　　　　某一个属性(静态属性对象属性):不想被查看,不想被随意修改(只能看,但是不能(随意)改)

　　　　某一个方法: 不想被外部调用

　　不善于使用封装的概念,分不清楚什么情况下使用:

　　　　最好能够符合规范的开发

　　　　即使没有恰当的使用封装,也不影响我们实现代码的功能

二.

子类不能继承父类的私有方法

class Foo(object):
#     A = 123
#     __私有的静态变量 = 'ABC'   # _Foo__私有的静态变量
#     print('---> ',__私有的静态变量) # 在类的内部使用  _Foo__私有的静态变量
#
# class Son(Foo):
#     def func(self):
#         print('--> 1 ',Son.A) # 子类没有找父类,能找到
#         print('--> 2 ',Foo.__私有的静态变量) # 子类没有找父类,找不到"_Son__私有的静态变量"
type object 'Foo' has no attribute '_Son__私有的静态变量'
# # print(Foo.__私有的静态变量)
# Son().func()

子类的内部不能使用父类的私有方法

class Foo(object):
    def __func(self):    # self._Foo__func
        print('in foo')

class Son(Foo):
    def wahaha(self):
        self.__func()  # self._Son__func,不能在子类的内部使用父类的私有方法

s = Son()
s.wahaha()

class Foo(object):
    def __init__(self):
            self.__func()    # _Foo__func
            self.func()

    def __func(self):print('in Foo __func')  # _Foo__func

    def func(self):print('in Foo func')

class Son(Foo):
    def __func(self):print('in Son __func')   # _Son__func

    def func(self):print('in Son func')
Foo()._Foo__func()
Son()

# 调用私有的方法或者属性
    # 不需要考虑self是谁的对象
    # 只要是私有的方法或者属性,就一定是在调用的当前类中执行方法
# 当某个方法或者属性,不希望被子类继承的时候,也可以把这个方法属性定义成私有成员

三.三个装饰器方法
@classmethod

@property

@staticmethod

class A:
    __count = 0   # 隐藏了count属性
    def __init__(self,name):
        self.name = name
        self.__add_count()  # 每一次实例化的时候调
                            # 用私有方法来对__count进行累加
    @classmethod
    def __add_count(cls):  # 定义一个私有的方法
        # print(cls,A)
        cls.__count += 1      # 让这个方法只能在类的内部被使用

    @classmethod  # 被classmethod装饰器装饰的方法,都有一个默认的参数,这个参数就是当前类
    def show_count(cls):   # 定义一个普通方法,
        # print(cls,A)
        return cls.__count    # 让用户可以从外部查看__count的值

print(A.show_count())
alex = A('alex')
print(alex.show_count())
yuan = A('yuan')
print(A.show_count())

为什么有类方法
# 有的时候,
# 在类中会有一种情况,就是这个方法并不需要使用某一个对象的属性
# 因此 这个方法中的self参数是一个完全无用的参数
# show_count是一个查看类中属性的方法,这样的方法和某一个对象并没有直接联系

# 本质上 : 一个方法不用对象属性但是使用静态属性 -- 类方法@classmethod
# 某一个方法被创造出来,就是为了进行对静态变量进行操作
# 根本不涉及到对象
# 所以这个方法就应该被定义成 类方法(被@classmethod装饰)
# 调用这个类方法,可以使用对象调用,也可以使用类调用
# 但是这个方法的默认参数永远是当前类的命名空间,而不是对象的

# 如果一个类中的方法不用对象属性也不用静态属性 -- 静态方法@staticmethod
# 那实际上这个方法就是一个普通的函数
class User(object):
    @staticmethod
    def login(arg1,arg2):   # 是User类中的名字 函数的名字 login就是一个类中的静态方法,本质上就是一个函数
        print(arg1,arg2)
        return (arg1+arg2)
class Student(User):pass
class Manager(User):pass

ret = User.login(1,2)
print(ret)#3
a=Student.login(2,4)
print(a)#6
b=Manager.login(2,3)
print(b)#5

#               普通的方法               类方法                 静态方法
# 默认参数        self                    cls                   无
# 操作的变量      操作对象的属性          操作静态属性         既不操作对象属性,也不操作类的属性
# 所属的命名空间   类                       类                    类
# 调用方式        对象                   类/对象                类/对象
# 对应的装饰器     无                   @classmethod        @staticmethod

# 用哪一个命名空间中的名字,就定义不同的方法
# 只要用self 就是普通方法,只能用对象调
# 只要用cls  就是类方法,可以用类,可以用对象
# 啥也不用   就是静态方法,可以用类,可以用对象

# 私有的
# 私有的普通方法
# 私有的类方法
# 私有的静态方法

# 先定义类
# 写方法
# 写具体的方法中的代码
# 写完之后,发现没有用到self,那么如果用到类,就定义成类方法,如果啥也没用到,静态方法

# 先定义函数
# 写函数
# 写具体函数中的代码
# 写完之后,发现要挪进类里,如果啥也没用到,静态方法;如果用到类,就定义成类方法