面向对象的三大特性

本文主要是介绍面向对象的三大特性，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

• 继承下的派生实际应用
  • 派生类使用前
  • 进行解决问题的操作（字符串、派生类应用）
• 面向对象三大特性之封装
  • property
• 面向对象三大特性之多态
• 面向对象之反射
• 反射实际案例

继承下的派生实际应用

派生类使用前

import datetime
import json
d1 = {'t1': datetime.datetime.today(), 't2': datetime.date.today()}
res = json.dumps(d1)
print(res)
'''
TypeError: Object of type 'datetime' is not JSON serializable
json不能序列化python所有的数据类型 只能是一些基本数据类型
    json.JSONEncoder
'''

如何让json能够序列化python中其它的数据类型呢

进行解决问题的操作（字符串、派生类应用）

手动字符串转换

import datetime
import json
d1 = {'t1': str(datetime.datetime.today()), 't2': str(datetime.date.today())}
res = json.dumps(d1)
print(res)

使用派生来进行方法的扩展修改

# 我们通过查看json源码发现报错的方法叫default，将父类中的default方法拿过来扩展修改，来满足我们的需求，序列化我们要处理的数据
import datetime
import json


class MyJsonEncoder(json.JSONEncoder):
    def default(self, o):
        # 形参o就是即将要被序列化的数据对象
        """将o处理成json能够序列化的类型即可"""
        if isinstance(o, datetime.datetime):
            return o.strftime('%Y-%m-%d %X')
        elif isinstance(o, datetime.date):
            return o.strftime('%Y-%m-%d')
        return super().default(o)  # 条件都不成立调用父类


d1 = {'t1': datetime.datetime.today(), 't2': datetime.date.today()}
res = json.dumps(d1, cls=MyJsonEncoder)
print(res)

面向对象三大特性之封装

# 封装的含义
将类中的某些名字'隐藏'起来 不让外界直接调用
隐藏的目的是为了提供专门的通道去访问 在通道内可以添加额外的功能
# 代码实操
class Student(object):
    school = '清华大学'
    __label = '逆来顺受'  # 由于python崇尚自由 所以并没有真正的隐藏 而是自动转换成了特定的语法

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def choose_course(self):
        print('%s正在选课' % self.name)


stu1 = Student('jason', 18)
print(stu1.school)
print(stu1.name)
print(stu1.age)
# print(stu1.__label)  # AttributeError: 'Student' object has no attribute '__label'
print(Student.__dict__)  # 查看类里面的内容  可以看到__label 在里面是_Student__label的形式
# print(Student._Student__label)  # 对于守规则的人来说，不会这么写
# print(stu1._Student__label)
'''
在变量名前面加双下划线__是用来封装名字的
只有在类定义阶段，才能对内容进行封装
在类中封装其实也不是绝对的 仅仅是做了语法上的变形而已  __变量名  >>>  _类名__变量名
不能直接用_类名__变量名这个语法去直接访问(要做到遵守规则)
封装的数据要通过特定的通道(接口)去访问
'''


class Student(object):  # 默认写法 为了兼容python2
    __school = '清华大学'

    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def check_info(self):
        print("""
        学生姓名:%s
        学生年龄:%s
        """ % (self.__name, self.__age))

    def set_info(self, name, age):
        if len(name) == 0:
            print('用户名不能为空')
            return
        if not isinstance(age, int):
            print('年龄必须是数字')
            return
        self.__name = name
        self.__age = age


stu1 = Student('king', 18)
stu1.check_info()
stu1.set_info('jasonNB', 28)
stu1.check_info()
stu1.set_info('123', 123)
stu1.check_info()

'''
将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，
接口之上可以附加额外的逻辑来对数据的操作进行严格地控制
目的是为了隔离复杂度，例如ATM程序的取款功能，该功能有很多其他功能组成
比如插卡、身份认证、输入金额、打印小票、取钱等，而对开发者来说,只需要开发取款这个功能接口即可,
其余功能我们都可以隐藏起来
'''

property

# property 将方法伪装成数据
'''
有时候很多数据需要经过计算才可以获得
但是这些数据给我们的感觉应该属于数据而不是功能
eg: BMI指数>>>:应该属于人的数据而不是人的功能
'''


class Person(object):
    def __init__(self, name, height, weight):
        self.__name = name
        self.height = height
        self.weight = weight

    @property
    def BMI(self):
        # print('%s的BMI指数是:%s' % (self.name, self.weight / (self.height ** 2)))
        return '%s的BMI指数是:%s' % (self.__name, self.weight / (self.height ** 2))


p1 = Person('jason', 1.83, 77)
# p1.BMI()  # 22.9
print(p1.BMI)
p2 = Person('eason',1.90,85)
# p2.BMI()  # 23.5
print(p2.BMI)
p3 = Person('xd',1.85,100)
# p3.BMI()  # 29.2
print(p3.BMI)
p4 = Person('xd',1.5,34)
# p4.BMI()  # 15.1
print(p4.BMI)

面向对象三大特性之多态

# 什么是多态
一种食物的多种形态
eg:
    水 固态 液态 气态
    	动物   猫、狗、猪

# 多态性
class Animal(object):
    def speak(self):
        pass


class Cat(Animal):
    def miao(self):
        print('喵喵喵')


class Dog(Animal):
    def wang(self):
        print('汪汪汪')


class Pig(Animal):
    def heng(self):
        print('哼哼哼')


'''
上述场景下 虽然体现了事物的多态性 但是并没有完整的体现出来
因为现在不同的形态去叫 需要调用不同的方法 不够一致
    
    只要你是动物 那么你想要说话 就应该调用一个相同的方法 这样便于管理
'''

# 体现多态性
class Animal(object):
    def speak(self):
        pass


class Cat(Animal):
    def speak(self):
        print('喵喵喵')


class Dog(Animal):
    def speak(self):
        print('汪汪汪')


class Pig(Animal):
    def speak(self):
        print('哼哼哼')


c1 = Cat()
d1 = Dog()
p1 = Pig()
c1.speak()
d1.speak()
p1.speak()
'''
其实以前对于计算元素个数用到的len也体现了多态性，不管什么数据要去测量元素个数都是同一个方法名
'''
# s1 = 'hello world'
# l1 = [1, 2, 3, 4]
# d1 = {'name': 'jason', 'pwd': 123}
# print(len(s1))
# print(len(l1))
# print(len(d1))
'''
多态性的好处在于增强了程序的灵活性和可扩展性，比如通过继承Animal类创建了一个新的类，
实例化得到的对象obj，可以使用相同的方式使用obj.speak()
面向对象的多态性也需要python程序员自己去遵守
虽然python推崇的是自由 但是也提供了强制性的措施来实现多态性
不推荐使用，自己遵守规则即可
'''
# import abc
# 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
# class Animal(metaclass=abc.ABCMeta):
#     @abc.abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法
#     def talk(self): # 抽象方法中无需实现具体的功能
#         pass
# class Person(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准
#     def talk(self):
#         pass
# p1=Person() # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化
'''
由多态性衍生出一个鸭子类型理论：
只要你看着像鸭子 走路像鸭子 说话像鸭子 那么你就是鸭子!!!
'''

# 鸭子类型的实战案例
'''
在linux系统中有一句话>>>:一切皆文件!!!
    内存可以存取数据
    硬盘可以存取数据
    ...
    那么多有人都是文件
'''


class Memory(object):
    def read(self):
        pass
    
    def write(self):
        pass
    
    
class Disk(object):
    def read(self):
        pass
    
    def write(self):
        pass
# 得到内存或者硬盘对象之后 只要想读取数据就调用read 想写入数据就调用write 不需要考虑具体的对象是谁

面向对象之反射

# 什么是反射
专业结束:指程序可以访问、检测和修改本身状态或者行为的一种能力
大白话:其实就是通过字符串来操作对象的数据和功能
    
# 发射需要掌握的四个方法
hasattr():判断对象是否含有字符串对应的数据或者功能
getattr():根据字符串获取对应的变量名或者函数名
setattr():根据字符串给对象设置键值对(名称空间中的名字)
delattr():根据字符串删除对象对应的键值对(名称空间中的名字)

# 反射实际应用
class Student(object):
    school = '清华大学'

    def get(self):
        pass


# 编写一个小程序 判断Student名称空间中是否含有用户指定的名字 如果有则取出展示
# print(Student.__dict__)
# guess_name = input('请输入你想要查找的名字>>>:').strip()
# # 不使用反射不太容易实现
# print(hasattr(Student, 'school'))  # True
# print(hasattr(Student, 'get'))  # True
# print(hasattr(Student, 'post'))  # False
# print(getattr(Student, 'school'))  # 清华大学
# print(getattr(Student, 'get'))  # <function Student.get at 0x10527a8c8>
#
#
# guess_name_one = input('请输入你想要查找的名字>>>:').strip()
# if hasattr(Student, guess_name_one):
#     target_name = getattr(Student, guess_name_one)
#     if callable(target_name):
#         print('类中有一个功能名字是%s'%guess_name,target_name)
#     else:
#         print('类中有一个数据名字是%s'%guess_name,target_name)
# else:
#     print('类中没有该名字')

# 根据字符串给对象设置键值对(名称空间中的名字)  添加数据、方法
setattr(Student,'level','贵族学校')
print(Student.__dict__)


def index():
    pass


obj = Student()
setattr(obj, '血量', 10000)
setattr(obj, '功能', index)
print(obj.__dict__)
# 根据字符串删除对象对应的键值对(名称空间中的名字)
delattr(obj, '功能')
print(obj.__dict__)

"""
什么时候使用反射 可以记固定的口诀
以后只要在业务中看到关键字 
对象 和 字符串(用户输入、自定义、指定) 那么肯定用反射
"""

反射实际案例

# 反射的案例
import settings
print(dir(settings))  # dir(settings)获取对象中所有可以使用的名字
print(getattr(settings, 'NAME'))


class FtpServer:
    def serve_forever(self):
        while True:
            inp = input('input your cmd>>:').strip()
            cmd, file = inp.split()
            if hasattr(self, cmd):  # 根据用户输入的cmd,判断对象self有无对应的方法属性
                func = getattr(self, cmd)  # 根据字符串cmd,获取对象self对应的方法属性
                func(file)

    def get(self, file):
        print('Downloading %s...' % file)

    def put(self, file):
        print('Downloading %s...' % file)


obj = FtpServer()
obj.serve_forever()

这篇关于面向对象的三大特性的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！