类和对象全解2(python)

1. 以后定义属性的时候，不要让外界直接用，而是需要定义一个方法。示例如下：

class Dog:
    def set_age(self, new_age):
        if new_age > 0 and new_age <= 100:
            self.age = new_age
        else:
            self.age = 0

    def get_age(self):
        return self.age

dog = Dog()
#dog.age = -10
#dog.name = "小白"
#print(dog.age)

dog.set_age(-10)
age = dog.get_age()
print(age)

#dog.get_age()
#dog.get_name()

2. 私有方法

class Msg:

    #私有方法
    def __send_msg(self):
        print("-----正在发送短信-----")

    #公有方法
    def send_msg(self, new_money):
        if new_money > 10000:
            self.__send_msg()
        else:
            print("余额不足，请先充值，再发送短信")

msg = Msg()
msg.send_msg(10000000)

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
-----正在发送短信-----

Process finished with exit code 0

这种开发的思想，比如开发一个发送短信的功能。不能直接让你调用这个私有的函数，我得先验证你的条件，如果满足就调用，不满足就不调用。换句话说，在实际开发中，如果一个函数前面有两个下划线，就意味着这个方法一般比较重要，不想让外面直接用。而是需要先调用一个方法也就是send_msg()，相当于先去验证。如果验证通过了，然后在方法里面self.__send_msg()再调用真正核心的方法。

3. __del __ 方法

class Dog:
    def __del__(self):
        print("-----英雄over-----")


dog1 = Dog()
dog2 = dog1

del dog1
print("=================")

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
=================
-----英雄over-----

Process finished with exit code 0

此处指的注意的是，最下面的先打印，而del函数里面的之后打印，这是为什么呢？此外重新改一下就会发现结果会发生变化

class Dog:
    def __del__(self):
        print("-----英雄over-----")


dog1 = Dog()
dog2 = dog1

del dog1
del dog2
print("=================")

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
-----英雄over-----
=================

Process finished with exit code 0

这是因为，如果使用程序引用计数来描述这个步骤的话，当执行"dog1 = Dog()"之后，计数为1，当执行"dog2 = dog1"之后，计数为2。而当执行"del dog1"之后，计数减1，当执行"del dog2"之后，计数归零。此时，就要调用"__del __"函数，执行上面的print，之后再执行下面的print
而第一个程序中，在执行完下面的print之后，程序准备结束并把内存信息归零的时候，此时执行"__del __"函数，所以会出现先print下面的信息，再print函数里面的信息的情况。
以上的知识点可以用于比如说英雄联盟里面，在英雄被击杀之后，需要调用一个类似于喊叫，倒地的程序。

4. 测量一个对象引用计数的方法

>>> import sys
>>> class T:
    pass

>>> t = T()
>>> sys.getrefcount(t)
2
#此处我们发现，数量一定比实际的多一个
>>> tt = t
>>> sys.getrefcount(tt)
3
>>> del tt
>>> sys.getrefcount(t)
2
>>> del t
>>> sys.getrefcount(t)
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    sys.getrefcount(t)
NameError: name 't' is not defined
>>> 

5. 继承

#继承只需要在子类的class里面插入父类的名称就可以使用父类的函数功能了
#但是需要注意的是，dog只能调用Dog()和Animal里面的功能，不能调用Cat()里面的功能，反之亦然
class Animal:
    def eat(self):
        print("---eat---")

    def drink(self):
        print("---drink---")

    def sleep(self):
        print("---sleep---")

    def run(self):
        print("---run---")

class Dog(Animal):
    def bark(self):
        print("---shout---")

class Cat(Animal):
    def catch(self):
        print("--catching---")

dog = Dog()
dog.eat()
dog.bark()

tom = Cat()
tom.eat()
tom.catch()

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
---eat---
---shout---
---eat---
--catching---

Process finished with exit code 0

还有一个神奇的功能，如果想要定义一个啸天犬类能够继承Dog的功能，代码如下

class Animal:
    def eat(self):
        print("---eat---")

    def drink(self):
        print("---drink---")

    def sleep(self):
        print("---sleep---")

    def run(self):
        print("---run---")

class Dog(Animal):
    def bark(self):
        print("---shout---")

class Xiaotianquan(Dog):
    def fly(self):
        print("---fly---")

xx = Xiaotianquan()
xx.eat()
xx.bark()
xx.fly()

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
---eat---
---shout---
---fly---

Process finished with exit code 0

实现一层继承一层的功能，等于是将一个大类细分成很多个小类

6. 重写
   如果说定义的最小子类Xiaotianquan()的bark()函数实现的跟Dog()不一样，那么我们就可以重写一个函数实现一个新的功能。
   如下的代码就是重写一个bark()的功能：

class Animal:
    def eat(self):
        print("---eat---")

    def drink(self):
        print("---drink---")

    def sleep(self):
        print("---sleep---")

    def run(self):
        print("---run---")

class Dog(Animal):
    def bark(self):
        print("---shout---")

class Xiaotianquan(Dog):
    def fly(self):
        print("---fly---")
    
    #在此处等于是重写bark()的功能，让它不再使用Dog()里面的函数
    def bark(self):
        print("---LOL---")

xx = Xiaotianquan()
xx.eat()
xx.bark()
xx.fly()

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
---eat---
---LOL---
---fly---

Process finished with exit code 0

如果想要调用被重写的方法，有两种操作

class Animal:
    def eat(self):
        print("---eat---")

    def drink(self):
        print("---drink---")

    def sleep(self):
        print("---sleep---")

    def run(self):
        print("---run---")

    def bark(self):
        print("---测试一下---")

class Dog(Animal):
    def bark(self):
        print("---shout---")

class Xiaotianquan(Dog):
    def fly(self):
        print("---fly---")

    #在此处等于是重写bark()的功能，让它不再使用Dog()里面的函数
    def bark(self):
        print("---LOL---")

        #第一种调用被重写的父类的方法
        #Dog.bark(self)

        #第二种方法
        super().bark()

xx = Xiaotianquan()
xx.eat()
xx.bark()
xx.fly()

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
---eat---
---LOL---
---shout---
---fly---

Process finished with exit code 0

经过测试发现，这两种调用的方法都是只能调用上一层的同名函数bark()的功能，我在Animal这个class里面也谢了一个bark()的函数作为测试，发现并没有调用。

7. 私有方法、私有属性在继承中的表现
   第一种：

class A:
    def __init__(self):
        self.num1 = 100
        self.__num2 = 200

    def test1(self):
        print("---test1---")

    def __test2(self):
        print("---test2---")

class B(A):
    pass

b = B()
b.test1()
#b.__test1() #私有方法并不会被继承
print(b.num1)
#print(b.__num2) #私有属性并不会被继承

第二种：

class A:
    def __init__(self):
        self.num1 = 100
        self.__num2 = 200

    def test1(self):
        print("---test1---")

    def __test2(self):
        print("---test2---")

    def test3(self):
        self.__test2()
        print(self.__num2)

class B(A):
    pass

b = B()
#b.test1()
#b.__test1() #私有方法并不会被继承
#print(b.num1)
#print(b.__num2) #私有属性并不会被继承
b.test3()

得到结果：

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
---test2---
200

Process finished with exit code 0

第三种：

class A:
    def __init__(self):
        self.num1 = 100
        self.__num2 = 200

    def test1(self):
        print("---test1---")

    def __test2(self):
        print("---test2---")

    def test3(self):
        self.__test2()
        print(self.__num2)

class B(A):
    def test4(self):
        self.__test2()
        print(self.__num2)

b = B()
#b.test1()
#b.__test1() #私有方法并不会被继承
#print(b.num1)
#print(b.__num2) #私有属性并不会被继承
#b.test3()
b.test4()

如果是像第二种那样，在B的父类A里面调用test3()的函数，而test3()函数里面调用私有属性和私有方法，那么是可以得到结果的。
但是如果像第三种那样，在子类里面创建一个新的test4()，试图在这个函数里面调用父类里面的私有属性和私有方法，那么就是不被允许的。
专业一点来说，就是，如果调用的是父类中的公有方法，则可以在这个公有方法中访问父类中的私有属性和私有方法；但是如果在子类中实现了一个公有方法，那么这个方法是不能够调用继承的父类中的私有方法和私有属性。

8. 多继承

class Base:
    def test(self):
        print("----Base")

class A(Base):
    def test1(self):
        print("----test1")

class B(Base):
    def test2(self):
        print("----test2")

#如果想要C()继承A()和B()两个父类的函数功能，那么只需要在括号里面把二者添加上就可以了
#当然，它本来就可以调用Base里面的函数功能
class C(A, B):
    pass

c = C()
c.test1()
c.test2()
c.test()

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
----test1
----test2
----Base

Process finished with exit code 0

关于多继承的调用

class Base:
    def test(self):
        print("----Base")

class A(Base):
    def test(self):
        print("----A")

class B(Base):
    def test(self):
        print("----B")

class C(A, B):
    def test(self):
        print("----C")

c = C()
c.test()

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
----C

Process finished with exit code 0

值得注意的是，如果C里面有test()，那么它就会在调用完C之后就停止了；如果C里面没有test()，那么它就只会调用A的而不会A和B都调用，这里面可以用"print(C.__mro __)"来查看它实现的路径

9. 多态

class Dog(object):
    def print_self(self):
        print("Hello world")

class Xiaotq(Dog):
    def print_self(self):
        print("Oh ha you")

def introduce(temp):
    temp.print_self()


dog1 = Dog()
dog2 = Xiaotq()

introduce(dog1)
introduce(dog2)

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
Hello world
Oh ha you

Process finished with exit code 0

多态的含义就是，当你写完程序之后，我仅仅知道你是调用一个方法"temp.print_self()"，但是我不确定它到底是调用基类的还是子类的。但是真正在程序执行的时候，我才根据当前的对象是谁，我才确定到底是调用Xiaotq()里面的方法还是调用Dog()里面的方法，这就是多态。