python之封装和继承篇（python 如何封装）

# -*- coding: UTF-8 -*-

#封装是面向对象的三大特性
# 封装指的是隐藏对象中的一些不希望被外部所访问到的属性或方法
# 如何去隐藏一个对象的属性？
#   -将对象的属性名，修改为一个外部不知道的名字
# 如何获取（修改）对象中的属性？
#   -需要提供一个getter和setter方法，使外部可以访问到属性
#   - getter获取对象中指定属性（get_属性名）
#   - setter用来设置对象的指定属性（set_属性名）
# 使用封装，确实是增加了类定义的复杂程度，但是他也确保了数据的安全性
#   1，隐藏了属性名，使调用者无法随意的修改对象中的属性
#   2，增加了getter和setter方法，很好的控制的属性是否只读的
#       如果希望属性是只读的，则可以直接去掉setter方法
#       如果希望属性是不能被外部访问，则可以直接去掉getter方法。
#   3， 使用setter方法设置属性，可以增加数据的验证，确保数据的值正确性。
#   4，使用getter方法获取属性，使用setter方法设置属性
#       可以在读取属性和修改属性的同时做一些其他处理
#   4,

class Dog:
    def __init__(self, name, age):
        self.hidden_name = name
        self.hidden_age = age

    def say_hello(self):
        print('大家好，我是%s' % self.hidden_name)

    def get_name(self):
        return self.hidden_name

    def set_name(self, name):
        print('设置对象属性')
        self.hidden_name = name

    def get_age(self):
        print('获取对象属性')
        return self.hidden_age

    def set_age(self, age):
        if age > 0:
            print('设置对象属性')
            self.hidden_name = age



d = Dog('旺财', 8)
#d.say_hello()
d.set_name('小黑')
print(d.get_name())

# -*- coding: UTF-8 -*-

class Rectangle:
    def __init__(self, width, height):
        self.hidden_width = width
        self.hidden_height = height

    def get_width(self):
        return self.hidden_width

    def get_height(self):
        return self.hidden_height

    def set_width(self, width):
        self.hidden_width = width

    def set_height(self, height):
        self.hidden_height = height

    def get_area(self):
        return self.hidden_width * self.hidden_height

# r = Rectangle(5, 2)
# r.set_height(20)
# r.set_width(10)
# print(r.get_area())

#可以为对象的属性使用双下划线开头，__xxxx
#双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问。
# 其实隐藏属性只不过是python自动为属性改了一个名字
#   其实上将名字改为了，__类名__属性名，比如 __name ---> _Person__name
# class Person:
#     def __init__(self, name):
#         self.__name = name
#
#     def get_name(self):
#         return self.__name
#
#     def set_name(self, name):
#         self.__name = name
#
# p = Person('tom')
# # print(p.__name) #__开头的属性时隐藏属性，无法通过对象访问
# # p.__name = "lili"
# #p._Person__name = "lili"
#
# print(p.get_name())

#使用__开头的属性，实际上仍然可以在外部访问，所以这种方式我们一般不用
#   一般我们会将一些私有属性（不希望被外部访问的属性）以_开头
#   一般情况下，以_开头的属性都是私有属性，没有特性需求不要修改私有属性
class Person:
    def __init__(self, name):
        self._name = name

    def get_name(self):
        return self._name

    def set_name(self, name):
        self._name = name
p = Person("孙悟空")
print(p._name)

# -*- coding: UTF-8 -*-

class Person:
    def __init__(self, name, age):
        self._name = name
        self._age = age

    #  property装饰器，用来将一个get方法，转换为对象的属性
    # 添加为prperty装饰器以后，我们就可以将像调用属性一样使用get方法
    @property
    def name(self):
        print('get方法执行')
        return self._name

    #setter方法的装饰器：@属性名.setter
    @name.setter
    def name(self, name):
        print('setter方法执行')
        self._name = name

    @property
    def age(self):
        print('get方法执行')
        return self._age

    #setter方法的装饰器：@属性名.setter
    @name.setter
    def age(self, age):
        print('setter方法执行')
        self._age = age


p = Person("孙悟空", 28)

p.name = "猪八戒"
p.age = 23
print(p.name, p.age)

# -*- coding: UTF-8 -*-
#继承

#定义个类animal
#   这个类中需要两个方法：run(), sleep()

class Animal:
    def run(self):
        print("动物会跑。。")

    def sleep(self):
        print('动物会睡觉')

    # def bark(self):
    #     print()

#定义一个类：Dog
# 这个类中需要三个方法： run(),sleep(),bark()
class Dog:
    def run(self):
        print("狗会跑。。")

    def sleep(self):
        print('狗会睡觉')

    def bark(self):
        print('狗会叫')
#有一个类，能够实现我们需要的大部分功能，但是不能实现我们的全部功能
#如何让这个类实现我们的全部功能呢
#   1，直接修改这个类，在这个类中添加我们的需要功能
#       修改起来比较麻烦，并且会违反OCP规则
#   2，直接创建一个新的类
#       创建一个新的类比较麻烦，并且需要大量的进行复制粘贴，导致大量重复性代码
#   3，直接从Animal类中来继承她的属性和方法
#       继承是面向对象的三大特性
#       通过继承我们可以使一个类获取到其他类中的属性和方法
#       在定义类时，可以在类名后的括号中指定当前类的父类（超类，基类，supper）
#           子类（衍生类）可以直接继承父类汇总的所有的属性和方法
# 通过继承可以直接获取到父类的方法或属性，避免重复代码，并且也符合OCP规则
#所以我们经常需要通过经常对一个类进行扩展

class Dog(Animal):
    def bark(self):
        print('狗会叫')

class Hashiqi(Dog):
    def fansha(self):
        print('我是一只傻傻的哈士奇')

d = Dog()
h = Hashiqi()
h.fansha()
d.run()
d.sleep()
d.bark()
print(d)

flag = isinstance(d, Dog)
flag = isinstance(d, Animal)
print(flag)

#在创建类时，如果省略了父类，则默认父类为object
#   object是所有类的父类，所有都继承自object
class Person(object):
    pass

#issubclass() #检查一个类是否是另一个类的子类
print(issubclass(Animal, Dog))
print(issubclass(Dog, object))
print(issubclass(Person, object))

#isinstance()用来检查一个对象是否是一个类的实例
#如果这个类是这个对象的父类，也会返回true
#所有对象都是object的实例
print(isinstance(Dog, object))