zoukankan      html  css  js  c++  java
  • python面向对象(封装)

    一. 封装

      隐藏对象的属性和实现细节,仅对外提供公共访问方式。

    好处 :

    1. 将变化隔离; 

    2. 便于使用;

    3. 提高复用性; 

    4. 提高安全性;

    封装原则:

          1. 将不需要对外提供的内容都隐藏起来;

          2. 把属性都隐藏,提供公共方法对其访问。

    私有变量和私有方法:

    私有变量:在python中用双下划线开头的方式将属性隐藏起来(设置成私有的)

    私有方法:在继承中,父类如果不想让子类覆盖自己的方法,可以将方法定义为私有的

    class A:
        STATIC = 'aaa'  # 静态变量
        __S = 'bbb'     # 私有的静态变量
        def wahaha(self):
            print(A.__S) # _A__S
    print(A.STATIC)
    print(A.__dict__)
    print(A._A__S)      # 在类的外面调用私有的变量
    a = A()
    a.wahaha()
    A.__B = 'ccc'   #在类的外部添加了一个静态变量
    print(A.__dict__)  #我们不能在一个类的外部创建一个"私有的"变量
    print(A.__B)
    
    class B:
        def __init__(self,name,pwd):
            self.name = name
            self.__pwd = pwd   # 也可以创建对象的私有属性
    
        def qqxing(self):
            self.__a = 'A'     # _B__a
    
        def get_pwd(self):
            print(self.__pwd)
    b = B('alex','alex3714')
    b.qqxing()
    
    print(b.name)
    print(b._B__pwd)  # 当在类外部的时候,我们也不能直接使用对象的私有属性
    b.get_pwd()
    
    class C:
        def __ppt(self):    # 私有的方法
            print('ppt')
            self.age = 83
        def open(self):
            self.__ppt()
            print('打开文件')
    c = C()
    c._C__ppt()   # 不能直接调用
    c.open()
    c.name = 'alex'
    print()
    私有de 静态变量 对象属性 方法
        私有的 只能在类的内部定义和使用
        __名字
        在类外部使用私有静态变量 _类名__私有的名字
        私有的名字 不能被子类继承
    class D:
        __DDD = 'ddd'     # _D__DDD
        AAA = 'aaa'
    
    class E(D):
        def qqxing(self):
            print(E.AAA)   #E._E__DDD
    
    e = E()
    e.qqxing()
    封装

    二. property

    将一个方法伪装成属性

    class Foo:
        def __init__(self,name):
            self.__name = name
        @property
        def name(self):
            return self.__name
        @name.setter
        def name(self,new_name):
            if type(new_name) == str:
                self.__name = new_name
        @name.deleter
        def name(self):
            del self.__name
    
    alex = Foo('alex')
    del alex.name
    print(alex.name)

    三. classmethod

    讲一个普通方法装饰为一个类方法

    class Goods:
        __discount = 0.8
        def  __init__(self,name,price):
            self.name = name
            self.__price = price
    
        @property
        def price(self):
            return self.__price*Goods.__discount
    
        @classmethod  #讲一个普通方法装饰为一个类方法
        def change_discount(cls,new_dis):  # 类方法
            cls.__discount = new_dis
    Goods.change_discount(1)
    cig = Goods('cigrette',20)
    print(cig.price)
    cig.change_discount(0.2)
    print(cig.price)

    四. staticmethod 

    装饰一个不需要self参数 也不需要cls参数的函数,即当做普通函数执行

    class Student:
        def __init__(self,name):
            self.name = name
    
        @staticmethod    #装饰一个不需要self参数 也不需要cls参数的函数
        def login(a,b,c):    # 普通的函数
            usr = input('username>>>')
            pwd = input('password>>>')
            if usr == 'alex' and pwd == '123':
                obj = Student(usr)
                return obj
    # 学生 login
    # 用户名  密码  属性
    ret = Student.login(1,2,3)
    print(ret)
  • 相关阅读:
    MySQL密码复杂度与密码过期策略介绍
    mysql 5.7安装密码校验插件validate_password
    MySQL安装控制插件(Connection-Control)--可有效的防止客户端暴力登录的风险(攻击)
    Liunx 无法杀掉reids进程解决方法
    Linux安装Kafka
    ZooKeeper安装及简单操作
    关于数组的算法题(一)
    集合框架方法(用于算法)
    Spring简答题(一)
    java选择题(三)
  • 原文地址:https://www.cnblogs.com/zhuzhaoyang/p/8544642.html
Copyright © 2011-2022 走看看