python——面向对象、类的有关操作

1、什么是面向对象：
—目的：企图用代码描述一个具体的事物，面向对象的方法主要是把事物给对象化，包括其属性和行为。
—比如说游戏里面的怪，就可以理解为一个对象，有攻击力、生命值、防御力等属性，也会有攻击玩家、释放大招等，就是对象的行为
—总体来说面向对象的底层还是面向过程，面向过程抽象成类，然后封装，方便使用就是面向对象，（万物皆对象）

2、什么是类：
—类是有着相同或者相近特征的事物的统称
—比如狗这一类，什么是狗，不知道，很难描述，但是看见二哈，我们就知道它是狗，同样泰迪、金毛都是狗
—分类是对事物的总结，概括，然后就有了类的概念

3、python中类的定义：
—类的命名方法：遵循大驼峰命名法（每个单词的首字母大写，比如：UserName）

# 定义类：

class 类名称[(父类名称, 父类名称)]:
	"""  python3开始，类只有新式类，也就是定义时，即便没有指定继承关系，则默认继承object """

	def __init__(self):
		""" 类的初始化，使用__init__作为方法名，其中__是两个下划线 """
# 定义属性
# 注意，self可以理解为一个指针，在类中，代指类本身，在对象中，代指对象本身
		self.属性名1 = 值
		self.属性名2 = 值
		......
		
		
# 创建对象
对象名称 = 类名称()
# 访问对象的属性
self.属性名 = 值# 修改对象的属性
print(self.属性名)# 打印属性的值

—类的定义练习：

class User(object):
    
    def __init__(self):
        self.name = "张三"
        self.age = 16
        self.gender = "男"
        self.email = "110@qq.com"
        self.tel = 120

    def speak(self):
        print(f'我的名字叫{self.name}，我今年了{self.age}')
        print("我的性别是{}，请打我的电话，号码是{}".format(self.gender, self.tel))


# 创建对象
u1 = User()
# 调用类的方法
u1.speak()
# 直接访问类的属性
print(u1.name)
print(u1.age)

u2 = User()
# 重新给属性赋值
u2.name = "李四"
u2.age = 23
u2.gender = "女"
u2.tel = "119"
u2.email = "120@qq.com"
u2.speak()

4、面向对象的三大特征：
—封装：
——什么是封装：
——封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问
——将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

—面向对象中的封装
——类具有封装，把属性和方法封装在独立的类
——将属性私有化，提供公开的方法来访问和设置的做法（也就是说让类的属性在类之外不能通过：对象名.属性名 的方式进行访问，只能通过类中的方法进行访问）

—封装的小栗子

class Person(object):

    def __init__(self):
        # 将属性私有化，在属性名前加两个下划线
        self.__name = "张三"
        self.__age = 16
        self.__gender = "男"

    def get_name(self):
    # def __get_name(self):这样写，将方法私有化
        return self.__name

    def set_name(self, name):
        self.__name = name

    def get_age(self):
        return self.__age

    def set_age(self, age):
        self.__age = age


if __name__ == '__main__':
    p1 = Person()
    # p1.name = "李四"这样代码会报错，因为name属性已经私有化，p1.__name也不可以访问
    print(p1.get_name())
    p1.set_name("刻晴(滑稽脸)")
    print(p1.get_name())

—如果属性私有化后还想通过 对象名.属性名 进行访问
——写法1：
——重新命名一个和属性同名的参数，参数值用property（方法名1，方法名2）进行赋值，方法名是一个引用，此时可以通过 对象名.属性名 进行访问

class Person(object):

    def __init__(self):
        # 将属性私有化
        self.__name = "张三"
        self.__age = 16
        self.__gender = "男"

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name

    def get_age(self):
        return self.__age

    def set_age(self, age):
        self.__age = age

    # 使用全局函数property完成二次封装
    name = property(get_name, set_name)# name已经不是原来的self.name了，相当于一个备份
    age = property(get_age, set_age)# age也不是原来的self.age了


if __name__ == '__main__':
    p1 = Person()
    print(p1.name)
    p1.name = "刻晴"
    print(p1.name)
    print(p1.get_name())

——写法2
——在对应的方法前加@property，同时将方法名改为和属性名一致

class Person(object):

    def __init__(self):
        # 将属性私有化
        self.__name = "张三"
        self.__age = 16
        self.__gender = "男"
        
#在方法名前面加@property，将方法名改为和属性名一致
    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, age):
        self.__age = age

    # 如果说，方法仅仅在类内部使用，建议私有化!!
    def __test(self):
        print("这个方法可以访问吗？")


if __name__ == '__main__':
    p1 = Person()
    print(p1.name)
    p1.name = "刻晴"
    print(p1.name)
    print(p1.age)
    p1.age = 18
    print(p1.age)

—继承：
——继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。
——优点：实现了代码的复用
——1、python是多继承实现机制
——2、如果多个父类中存在重名的方法时，自类对象调用时的顺序问题
———python2
——新式类：广度优先继承，写在前面的先继承，后面的后继承
——旧式类（经典类）深度优先继承，谁继承的层数深，就匹配谁
——python3：只有新式类

—继承的小栗子：

class Teacher(object):
    
    def say(self):
        print("我是老师呀")


class Student(object):

    def __init__(self):
        self.name = "小明"
        self.age = 18
        self.gender = "男"
        # 私有属性不能被继承
        self.__tel = "123456"

    def say(self):
        print("我是一名大一新生")

    def __test(self):
        print("有一些小秘密")

    def run(self):
        print("我要美美的干饭")


class Stu(Student, Teacher):
    """ Stu 类继承了Teacher，和Student，所以Stu就有了Teacher和Student可以被继承的所有属性和方法"""
    # 两个父类中有重名方法，按照继承顺序优先匹配，调用时会调用Student中的方法，不会调用Teacher中的方法

    def run(self):# 如果子类的方法，和父类同名，执行时会执行子类的方法，与代码匹配顺序有关
        for i in range(15):
            print("只有干饭，才是快乐")


if __name__ == '__main__':
    s = Son()
	
	# 访问子类的属性
    print(s.name)
    print(s.age)
    print(s.gender)

    s.say()
    s.run()

—重写（overwrite）|覆盖（override）
——子类继承来自父类的方法，发现不是很好，可能会重新写一个同名函数，实现更丰富的功能——重写
——覆盖，同名方法，优先匹配子类中的方法
重写（override）和重载(overload)的区别？
——重载，是对于同一件事情的不同处理办法。比如：print()方法，输入字符串就输出字符串，输入数字就输出数字，函数名称相同，参数类型或者个数不同
——python中不存在重载

—多态：
——事务的多种状态
——继承的基础上，父类引用指向子类实例的现象，叫做多态
——由于python中数据根据值来确定类型，故很难看到这种现象