接口类抽象类封装

接口类抽象类:

第一版,不好,没有统一化设计,第二版解决.

class QQ:def pay(self,money):print('您用qq支付了%s元' % money)class Ali:def pay(self,money):print('您用支付宝支付了%s元' % money)q1 = QQ()
q1.pay(100)
a1 = Ali()
a1.pay(200)

View Code

第二版 ,相安无事,此时来了一个野生程序员.完成了一个微信功能

class QQ:def pay(self,money):print('您用qq支付了%s元' % money)class Ali:def pay(self,money):print('您用支付宝支付了%s元' % money)class Wechat:def wechatpay(self,money):print('您用微信支付了%s元' % money)def pay(obj,money):obj.pay(money)  # q1.pay(100)

q1 = QQ()
a1 = Ali()
pay(q1,100)  # 统一化设计
pay(a1,200)
w1 = Wechat()
w1.wechatpay(500)

View Code

第三版,重新改版微信支付功能

class QQ:def pay(self,money):print('您用qq支付了%s元' % money)class Ali:def pay(self,money):print('您用支付宝支付了%s元' % money)class Wechat:def pay(self,money):print('您用微信支付了%s元' % money)def pay(obj,money):obj.pay(money)  # q1.pay(100)

q1 = QQ()
a1 = Ali()
pay(q1,100)  # 统一化设计
pay(a1,200)
w1 = Wechat()
pay(w1,500)

View Code

第四版,为了避免上述野生程序员可能发生的问题,我要制定一个规范.

class Payment:  # 抽象类,或者接口类:制定一个规范.def pay(self):passclass QQ(Payment):def pay(self,money):print('您用qq支付了%s元' % money)class Ali(Payment):def pay(self,money):print('您用支付宝支付了%s元' % money)class Wechat(Payment):def pay(self,money):print('您用微信支付了%s元' % money)def pay(obj,money):obj.pay(money)  # a1.pay(200)

q1 = QQ()
a1 = Ali()
pay(q1,100)  # 统一化设计
pay(a1,200)
w1 = Wechat()
pay(w1,500)

View Code

第五版 强制制定规范,如果未按照规范执行,就会报错.

from abc import ABCMeta,abstractmethodclass Payment(metaclass=ABCMeta):    # 抽象类 接口类  规范和约束  metaclass指定的是一个元类
    @abstractmethoddef pay(self):pass  # 抽象方法class QQ(Payment):def pay(self,money):print('您用qq支付了%s元' % money)def ret(self):print('支付失败....')class Ali(Payment):def pay(self,money):print('您用支付宝支付了%s元' % money)class Wechat(Payment):def pay(self,money):print('您用微信支付了%s元' % money)def pay(obj,money):obj.pay(money)  # a1.pay(200)

q1 = QQ()
a1 = Ali()
w1 = Wechat()
q1 = QQ()
a1 = Ali()
pay(q1,100)  # 统一化设计
pay(a1,200)
w1 = Wechat()
pay(w1,500)

View Code

用处: 在工作中,如果你要是规定几个类必须有一样的方法,
你要抽象类,制定一个规范,强制其有此方法.
python没有多态的概念,但是python崇尚鸭子类型.
定义变量的方法:
1,java c# 需要定义 类型. int i= 3
2,java c# 没有多继承的概念.
i = 1
i = 'alex'

鸭子类型: 它看着像鸭子,那么他就是鸭子.

str  list  tuple
str.index()
s1 = 'alex'
class Str:def index(self):passclass List:def index(self):passclass tuple:def index(self):pass

View Code

python中好多不同类但同名的方法不是强制规定,而是约定俗成,像上面这三种类,都同样据有index方法,而且功能相似,
则 他们三个互称为鸭子.

封装:
封装就是将一些属性或者方法(有用的信息)放置在一个空间中.
1,封装 对象的封装.

class Person:def __init__(self,name,age):self.name = nameself.age = age
p1 = Person('oldboy',1000)
p2 = Person('alex',10000)
print(p1.name)
print(p2.name)

View Code

2 封装(私有成员.)
类的结构分析:

class Person:mind = '有思想...'  # 第一部分:所有的公有静态变量,公有静态字段__level = '高等动物'  # 第一部分:私有静态变量,私有静态字段def __init__(self,name,age,sex): # 构造方法  # 第二部分 动态方法,方法(函数)self.name = name   # 公有对象属性self.age = ageself.__sex = sex  # 私有对象属性def func(self):   # 第二部分:普通方法print(666)def __func1(self):  # 第二部分:私有方法print(777)@staticmethod  #  静态方法def f2():pass@classmethod  # 类方法def f2(self): pass@property    # 属性def hex(self):pass

类整体分类:第一部分:  公有静态字段 mind = '有思想...' ,私有静态字段. __level = '高等动物'第二部分: 特殊方法(__init__(公有属性,私有属性),__str__...)普通方法  def func(self)私有方法  def __func1(self):类方法:@classmethoddef f2(self): pass静态方法:@staticmethod  #  静态方法def f2():pass属性:@property  # 属性def hex(self): pass
私有成员: 私有静态字段,私有属性,私有方法   在变量前+ __双下划线.

私有静态字段:

class Animal:__cloth = '皮毛'  # _Animal__clothclass Person(Animal):mind = '有思想...'  # 第一部分:所有的公有静态变量,公有静态字段__level = '高等动物'  # 第一部分:私有静态变量,私有静态字段  # _Person__leveldef __init__(self,name,age): # 构造方法  # 第二部分 动态方法,方法(函数)self.name = name   # 公有对象属性self.age = agedef func(self):print(self.__level)print(self._Animal__cloth)print(self.__cloth)

View Code

在类的外面访问: 私有静态字段是访问不到的.

p1 = Person('alex',1000)
print(p1.mind)
print(p1.__level)
print(Person.__level)
print(Person.__dict__)
print(Person._Person__level)

View Code

可以通过对象._类名__变量名  类名._类名__变量名 可以访问到,但是绝对不要这么访问.在类的内部: 私有静态字段是可以访问
p1 = Person('alex',1000)
p1.func()父类的私有静态字段,派生类可否访问? 不可访问.
p1 = Person('alex',10)
print(p1.__cloth)
p1.func()

私有方法:

class Animal:def __f1(self):print(1111)  # _Animal__f1class Person(Animal):mind = '有思想...'  # 第一部分:所有的公有静态变量,公有静态字段def __init__(self,name,age): # 构造方法  # 第二部分 动态方法,方法(函数)self.name = name   # 公有对象属性self.age = ageself.__sex = sexdef __func(self):  # _Person__func()print(666)def func1(self):self.__func()  # self._Person__func()def func2(self):self.__f1()  # self._Person__f1()

View Code

类外面访问不到.
p1 = Person('OLDBOY',1000)
p1.__func()  #
类内部可以访问.
p1 = Person('OLDBOY',1000)
p1.func1()
派生类中也是不能访问的.
p1.func2()
私有属性 也是类外部不能访问,派生类不能访问,只能在类内部访问.

class Animal:def __f1(self):print(1111)  # _Animal__f1class Person(Animal):mind = '有思想...'  # 第一部分:所有的公有静态变量,公有静态字段def __init__(self,name,age,sex): # 构造方法  # 第二部分 动态方法,方法(函数)self.name = name   # 公有对象属性self.age = ageself.__sex = sexdef __func(self):  # _Person__func()print(666)

View Code

总结: 对于私有成员来说,他加载到内存时,都会加上_类名__变量名,所以你在类的外部,或者派生类中都不可访问.
为什么设置私有成员?
有些变量,方法,属性,只在类内部进行使用即可,不便于(不允许)类外部或者派生类去调用.

class Person:def __init__(self,username,password): # 构造方法  # 第二部分 动态方法,方法(函数)self.usn = username   # 公有对象属性self.__pwd = self.__makepassword()def __makepassword(self):'''复杂的加密过程'''new_pwd = self.__pwd + '666'return new_pwd
p1 = Person('alex','123')
print(p1.__pwd)

View Code

面试题:

class A:def __init__(self):   # 2, self = b1对象空间self.__func()   # 默认_A__func()  (私有属性必须把前面的类加上)  # 3, b1._A__func()             def __func(self):    # 4 , 默认_A__func()   b1._A__func()  print('IN    A')       # print(in A )
class B(A):def __func(self):print('IN     B')
b1 = B()    1, #B里面没有去A里面找       class A:def __init__(self):   # 2,self = b1对象空间self.func()      # 3,b1.func()  #b1里面有func函数,所有又去b1里面找def func(self):print('IN    A')
class B(A):def func(self):print('IN     B')    #  4 print(IN B)
b1 = B()   # 1,B没有去A里面找b1属性
# print(b1.name)
# print(b1.func)
print(b1.func)
print(b1.func())

View Code

抽象类接口类：
抽象类和接口类 —— 了解*
在python代码中 抽象类和接口类没有明显的区别
主要就是维持了一种规范
一切皆对象

a = 1
dic = {'k':'v'}
lst = [1,2,3]
def func():pass
print(type(func))len(lst)
print(dic.__len__(),len(dic))
def len(lst):return lst.__len__()
print(len)from abc import ABCMeta,abstractmethod
class Pay(metaclass=ABCMeta):@abstractmethoddef pay(self,money):pass    # 规范

View Code

多态：
python天生自带多态
什么是多态
java的多态是通过继承实现的

class Foo:pass
class list(Foo):pass
class dict(Foo):pass
class str(Foo):pass
def len(a):print(a)
len(1)

View Code

Python，动态解释型强类型语言
弱类型 1+'2'参数的数据类型也不需要指定
强类型 同类型之间可以做运算 参数的数据类型也需要指定
抽象类 ：
子类必须实现父类中的同名方法——规范代码在类的位置指定metaclass 是ABCMeta在指定的方法上面添加@abstractmethod装饰器
目的：规范所有继承这个类的子类 必须实现被@abstractmethod装饰器装饰的这个方法
特点：抽象类和接口类只能被继承不能被实例化

class WechatPay(Pay):def pay(self,money):print('微信支付了%s元'%money)class AliPay(Pay):def pay(self, money):print('支付宝支付了%s元' % money)class ApplePay(Pay):def pay(self,money):print('apple支付了%s元' % money)def payment(obj,money):
obj.pay(money)
wp = WechatPay()
payment(wp,100)     # 编程的习惯 —— 归一化设计
wp.pay(100)
ap = AliPay()
payment(ap,100)
ap.pay(100)app = ApplePay()
payment(app,100)

View Code

规范
接口类
python天生支持多继承，对于python来说抽象类和接口类没有区别
接口类是python特有的，因为python直接用类就可以实现接口的效果
python没有‘接口这种数据类型，java中有
java语言是不支持多继承的

from abc import ABCMeta,abstractmethod
class Walk_Animal(metaclass=ABCMeta):@abstractmethoddef walk(self):passclass Fly_Animal(metaclass=ABCMeta):@abstractmethoddef fly(self):passclass Swim_Animal(metaclass=ABCMeta):@abstractmethoddef swim(self):passclass Tiger(Walk_Animal,Swim_Animal):def walk(self):print('walk')def swim(self):print('swim')class Parrot:def walk(self):print('walk')def fly(self):print('fly')class Swan:def walk(self):print('walk')def fly(self):print('fly')def swim(self):print('swim')

View Code

封装：
封装 成一个函数
封装 成一个类
封装：面向对象的特性
class A:
私有静态属性：__静态属性 = 'aaa'#私有属性print(__静态属性)#__静态属性，_类名__名字
在一个变量之前 ，加上两个双下划线是有特殊意义的
加上了这个双下划线，这个变量就变成私有的
print(A.__静态属性) #报错 私有的名字不能在类的外部使用
print(A.__dict__)
print(A._A__静态属性)#从语法的角度上不允许你直接调用的
A.__wahaha = 'hahaha'#在一个类的外部是不可能定义一个私有的名字的
print(A.__dict__)

私有的对象属性：

class Room:def __init__(self,owner,id,length,width,height):self.owner = ownerself.id = idself.__length= lengthself.__width = widthself.__height = heightdef area(self):return self.__lenght*self.__width
r = Room('文杰',302,2,1.5,0.5)
print(r.area())

View Code

私有的方法：
不希望从外部去调用这个方法，不独立完成一个功能，而是类整体完成某个功能的一部分。不能被子类继承，在类的内部使用的时候自动变形：类__名字

class Student:对密码进行加密def __init__(self,name,pwd):self.name = nameself.__pwd = pwddef __getpwd(self):return self.__pwd[::-1]def login(self):self.__getpwd()
Student().__getpwd

View Code

面试题：

class A:def __init__(self):self.__func()   #self._A__func()def __func(self):print('A')
class B(A):def __func(self):print('B')
B()      # _B__func()class A:def __init__(self):self.__func()def __func(self):  #_A__funcprint('A')
class B(A):# def __func(self):#     print('B')def __init__(self):self.func()   # _B__func()
B()

View Code

名字：
公有的  在类的外部用  内部的 子类用
保护的  子类用  内不用
__私有的  在类的内部用

转载于:https://www.cnblogs.com/ls13691357174/p/9254005.html

接口类抽象类封装相关推荐

php 类接口的区别吗,PHP的接口类(interface)和抽象类(abstract)的区别
/** * 接口类:interface * 其实他们的作用很简单,当有很多人一起开发一个项目时,可能都会去调用别人写的一些类, * 那你就会问,我怎么知道他的某个功能的实现方法是怎么命名的呢,这个时候 ...
面向对象抽象类与接口类
############ 复习 ############### - 先抽象再继承 ########## 接口类与抽象类接口类继承有两种用途: 一:继承基类的方法,并且做出自己的改变或者扩展(代码 ...
面向对象的接口类以及鸭子类型
1.接口类,抽象类. 2.鸭子类型(Python多态)(Python三大特性之一)Python封装 1.接口类和抽象类只是在工作中书写的一种规范. class QQ: def pay(self,mo ...
day24-抽象类与接口类
接口类 1.继承有两种用途: 一:继承基类的方法,并且做出自己的改变或者扩展(代码重用) 二:声明某个子类兼容于某基类,定义一个接口类,接口类中定义了一些接口名(就是函数名)且并未实现接口的功能,子类 ...
023_接口类，抽象类，多态，鸭子类型，封装
1,接口类 1 class Wechat(): 2 def pay(self,money): 3 print('已经用微信支付了%s元'%money) 4 class Alipay(): 5 def ...
java基础-类-抽象类-接口（自学笔记）
一.类 class 定义:具有相同属性(特性)和方法(行为)的一类事物的抽象的总称例如:人类,动物,车,屌丝类.是一种类别,世界上所有的事物都可以分类,在计算机中java都能进行对应和体现类的三 ...
java 类抽象类接口_Java抽象类和接口
抽象类和接口一.抽象类和抽象方法对于抽象类,首先需要介绍抽象方法,而抽象类因抽象方法的存在而存在 1.抽象方法 (1)必要性: 有些父类方法不确定如何写方法体,但是对于继承它的子类又必须用到这个方 ...
接口和抽象类分别在什么时候使用？和其中我对基本功能在不断变化为什么使用抽象类而不使用接口类的理解
1.接口和抽象类分别在什么时候使用 2.对"如果基本功能在不断变化,那么就使用抽象类,如果使用接口,那么每次变更都需要相应的去改变实现该接口的所有类."这句话的理解请耐心看完列子 ...
java 中普通类继承，抽象类继承，接口类继承，子类一定要重写父类中的方法吗
一.简单总结,需要重写的有普通类继承抽象类,重写所有抽象类方法:(不包括普通方法) 普通类继承接口,重写所有接口方法.(不包括default关键字修饰的方法) 详解见下: 普通类继承,并非一定要重写 ...

接口类抽象类封装

接口类抽象类封装相关推荐

最新文章

热门文章

接口类抽象类 封装

接口类抽象类 封装相关推荐

最新文章

热门文章

接口类抽象类封装

接口类抽象类封装相关推荐