Python案例：面向对象

类的语法：
1.通过class来声明类
2.类的名字首字母大写
3.类里面先写类注释
4.类注释下面是类变量，类变量在类里面，可以给类里面的所有方法使用，但是使用的时候要声明“类名字.变量名”，必须要在变量名前面加上类名字，声明是类里面的变量，否则会
认为是全局变量，即类外面的变量
5.第一个构造方法基本都是__init__,目的是将类变量传递给实例变量来使用的，下面的其他方法在使用变量的时候，都是用的实例变量，而非类变量，
除非该类变量是写在类里面，方法外面的
使用方法：
1.使用类前，需要先将其实例化，生成一个实例化对象
2.接着通过该对象再去调用类里面的方法

'''面向对象'''


class bank():
    # 类变量
    aa = 'xiaoming'
    pw = '123456'
    str = ''

    def __init__(self, money, account, password):
        # 实例化之后才生效的变量，叫做实例变量
        self.__money = money
        self.__account = account
        self.__password = password

    def print_money(self):
        bank.__denglu(self)
        if bank.str == '登录成功':
            print('当前余额为{}'.format(self.__money))
        else:
            print('登录失败')

    def a(self, qian):
        # 写在方法里面的变量叫做局部变量，比如qian就是局部变量，只在该方法中有效，只有当实例化对象并且调用该方法的时候，该变量才生效。
        bank.__denglu(self)
        if bank.str == '登录成功' and self.__money > qian:
            self.__money -= qian
            print('当前取款金额为：{}，剩余金额为：{}'.format(qian, self.__money))
        else:
            print('登录失败')

    def b(self, qian):
        bank.__denglu(self)
        if bank.str == '登录成功' and qian > 0:
            self.__money += qian
            print('当前存款金额为{}，剩余余额为{}'.format(qian, self.__money))
        elif bank.str == '登录成功':
            print('存款金额异常')
        else:
            print('登录失败')

    def __info(self):
        print(self.__account)
        print(self.__password)

    def c(self):
        bank.__denglu(self)
        if bank.str == '登录成功':
            bank.__info(self)
        else:
            print('登录失败')

    def __denglu(self):
        if self.__account == bank.aa and self.__password == bank.pw:
            bank.str = '登录成功'
        elif self.__account == bank.aa and self.__password != bank.pw:
            bank.str = '密码错误'
        else:
            bank.str = '登录失败'


xiaoming = bank(10000, 'xiaoming', '123456')
xiaoming.a(1000)
xiaoming.b(5000)
xiaoming.print_money()
xiaoming.c()


class father():
    '''
    这个是父类
    '''

    def a(self):
        '''
        这个是a方法，打印父亲会的技能
        :return: 无
        '''
        print('老子会吃喝嫖赌抽')


class son(father):
    def a(self):
        print('对不起，我是警察')


# 继承，子类在生命的时候，在类参数里面写上父类的名字，就算子类里面没有写父类的方法，在实例化子类的时候，也可以直接使用父类所拥有的属性和方法，前提是该属性
# 和方法不是私有的。
f = father()
f.a()
s = son()
s.a()


# 方法重写，对从父类继承过来的属性和方法进行重新写的过程，就称之为方法重写。

# 多态，其实就是多个子类从同一个父类继承了属性和方法，并且每个子类都对父类的方法进行了重写，这个过程体现出来的就是多态
class son2(father):
    def a(self):
        print('我是卧底')


print(xiaoming.__dict__)
print(f.__doc__)
print(father.__name__)

if __name__ == '__main__':
    f = father

import random

print(random.random.__module__)
print(father.__module__)