Python-类属性、实例属性、面向对象的特征

类属性、实例属性

类属性：

在类的属性中，分为公有类属性和私有类属性
公有类属性：所有对象都可访问
私有类属性：只能在类内部访问，不能通过实例对象访问

class Person(object):
    name = "flyflywin" #公有类属性
    __age = 24 #私有类属性

    def age(self):
        self.__age = 20
        print(self.__age)
fly = Person()
#Person.name = "andy"
#del Person.name
#fly.name = "jack"
#del fly.name  #删除实例属性
print(fly.name)
fly.age()
print(Person.name)

实例属性（对象属性）：

通过实例（对象）去修改类属性：
del()方法
创建对象后，Python解释器默认调用__init__()方法。当删除一个对象时，Python解释器也会默认调用一个方法，这个方法为__del__()方法。在Python中，对于开发者来说很少会直接销毁对象(如果需要，应该使用del关键字销毁)。Python的内存管理机制能够很好的胜任这份工作。也就是说,不管是手动调用del还是由Python自动回收都会触发__del__方法执行。

class Person(object):
    def __init__(self,name):
        self.name = name
    def __del__(self):
        print("实例对象%s"%self.name,id(self))
        print("python解释器开始回收%s对象了"%self.name)


print("类对象",id(Person))
zhangsan = Person("张三")
print("实例对象张三：",id(zhangsan))

print("-"*50)
lisi = Person("李四")
print("实例对象李四：",id(lisi))

#如果还是不清晰，请注释两个del看结果
class Test:
    def __del__(self):
        print("英雄谢幕...")

t = Test()
c = t
del t
del c
print("------------")

面向对象的四大特征

抽象

忽略一个主题中与当前目标无关的东西,专注的注意与当前目标有关的方面.(就是把现实世界中的某一类东西,提取出来,用程序代码表示,抽象出来的一般叫做类或者接口).
抽象并不打算了解全部问题,而是选择其中的一部分,暂时不用部分细节.抽象包括两个方面,一个数据抽象,二是过程抽象.
数据抽象 -->表示世界中一类事物的特征,就是对象的属性.比如鸟有翅膀,羽
毛等(类的属性)
过程抽象 -->表示世界中一类事物的行为,就是对象的行为.比如鸟会飞,会叫
(类的方法)

封装

属性，方法----》封装类
有些时候我们不希望把对象的属性公开，就可以把它设为私有，Python并没有像其他语言对成员的权限控制系统，如private，默认情况下，Python的所有属性都是公有的，可以被访问到，要设成私有，则在前面加双下划线。

继承

继承可以使子类拥有父类的属性和方法，并且可以重写这些方法，加强代码的复用性Python中子类可以有多个父类，但是不建议这样使用，一般会产生重复调用的问题，Super().方法名，可以调用父类的方法（不用传参，作用是调用父类的方法，传的是子类实例的值）

多态

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承,Python里面不依赖继承）。指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式

封装

面向对象三大特征–封装：
面向对象的程序设计中，某个类把所需要的数据（也可以说是类的属性）和对数据的操作（也可以说是类的行为）全部都封装在类中，分别称为类的成员变量和方法（或成员函数）。这种把成员变量和成员函数封装在一起的编程特性称为封装。 ➢ 公有成员变量和私有成员变量：Python中用成员变量的名字来区分是公有成员变量或者是私有成员变量。Python中，以两个下划线‘__’开头的变量都是私有成员变量，而其余的变量都属于公有成员变量。其中，私有的成员变量只能在类的内部访问，而共有的公有的成员变量可以在类的外部进行访问

公有方法和私有方法：

类的方法是对类行为的封装。
类的方法也分为公有方法和私有方法。
类的私有方法只能通过对象名（在类内部也就是self）在类的内部进行访问。
而公有方法可以在类的外部通过对象名进行访问。
同样，公有的成员方法和私有的成员方法也是通过名字来区分的，双下划线‘__’开头的方法是私有成员方法。

私有方法：只能在类的内部进行访问，对象无法访问。
私有属性：提高代码安全性，不允许别人随意修改。

#私有方法
class Test(object):
    def __test2(self):
        print("私有方法__test2")
    def test(self):
        print("普通方法test")
    def _test1(self):
        print("普通方法_test1方法")
        self.__test2()
t = Test()
t.test()
t._test1()

#私有方法应用
class Test(object):
    def __send_msg(self):
        print("正在发送短信")
    def send_msg(self,new_money):
        if new_money >= 10000:
            self.__send_msg()
        else:
            print("余额不足")
t = Test()
t.send_msg(1000)
t.send_msg(10000)

继承

继承的概念：
在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物。

重写父类方法与调用父类方法：
所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法
使用super调用父类的方法：可以直接调用父类方法，不需要通过 父类名.父类方法名 的方式

class Animal:
    def eat(self):
        print("----吃----")
    def drink(self):
        print("----喝----")
    def sleep(self):
        print("----睡觉----")
    def run(self):
        print("----跑----")
class Dog(Animal):
    def call(self):
        print("----旺旺叫----")
class Cat(Animal):
    def call(self):
        print("-----喵喵叫----")
tom = Cat()
tom.eat()
tom.call()

#多层继承
class Animal:
    def eat(self):
        print("----吃----")
    def drink(self):
        print("----喝----")
    def sleep(self):
        print("----睡觉----")
    def run(self):
        print("----跑----")
class Dog(Animal):
    def call(self):
        print("----旺旺叫…………")
class XiaoTq(Dog):
    def fly(self):
        print("----飞----")

dog = XiaoTq()
dog.call()
dog.eat()
dog.fly()

#多层继承
class Base(object):
    def test(self):
        print("---Base---")
class A(Base):
    def test(self):
        print("---A---Test1---")
class B(Base):
    def test(self):
        print("---B---Test2---")
class C(A,B):
    def test(self):
        print("---C----")

c = C()
c.test()
print(C.__mro__)
#可以查看c继承的过程，一般是就近原则

class Animal(object):
    def sayHello(self):
        print("hello---0")

class Cat(Animal):
    def sayHello(self):
        #print("hello---1")
        super().sayHello()

class bsCat(Cat):
    def sayHello(self):
        #print("hello---2")
        super().sayHello() #super调用父类方法

cat = bsCat()
cat.sayHello()

多态

多态的定义：
所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态。
多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）。
当子类和父类都存在相同的print_self()方法时，我们说，子类的print_self()覆盖了父类的print_self()，在代码运行的时候，总是会调用子类的print_self()。这样，我们就获得了继承的另一个好处：多态。

#多态
class Dog(object):
    def print_self(self):
        print("大家好，我是x，请大家多多关照！！")

class XiaoTq(Dog):
    def print_self(self):
        print("我是你们的老大，我是哮天犬。")

#定义一个执行函数
def aa(obj):
    obj.print_self()

dog = Dog()
aa(dog)
dog1 = XiaoTq()
aa(dog1)