面向对象-封装

一：创建类和对象
　　class f:
　　　　def bar(self):
　　　　　　print(‘bar‘)
　　　　def hello(self, name)
　　　　　　print(‘hello %s‘%name)
　　fobj = f()
　　fobj.bar() > ‘bar‘
　　fobj.hello(‘tom‘) >‘hello tom‘

ps:类中的第一个参数必须是self，类中定义的函数叫方法

#三大特性：封装、继承、多态
1.封装：
　　#将内容封装到某处
　　#从某处调用被封装的内容

例1：将内容封装到某处

解析：self是一个形式参数，当执行 fobj = F(‘tom‘,18)时，self等于fobj

例2：从某处调用封装的内容
调用封装的内容时，有两种情况：
　　#通过对象直接调用
　　#通过间接self调用

fobj = F(‘tom‘,18)
fobj.name >>> tom  调用fobj对象的name属性
fobj.age >>> 18　　调用fobj对象的age属性

class F:
　　def __init__(self,name,age)
　　　　self.name = name
　　　　self.age = age
　　def hello(self):
　　　　print(self.name)
　　　　print(self.age)
fobj = F(‘tom‘,18)
fobj.hello()
>>> tom
>>> 18

#类中所有双下划线开头的名称如__x都会在类定义时，自动变形成：_类名__x的形式
class A:
　　__B = 123 # _A__B
　　def __init__(self):
　　　　self.__T = 10  # 变成: self._A__T
　　def __foo(self):　　# 变成: _A__foo，这是一个私有方法
　　　　print(self.__T)
　　def test(self):
　　　　self.__foo()　　#只有在类内部，才能访问私有变量和方法，即 调用 _A__foo
a = A()
#a._A__N 可以在外部直接被访问到的
# self.__T、__foo(self) 这样的私有变量和方法是直接在外部访问的,但是可以通过__dict__来查看私有的变量

封装的意义：
　　1.封装数据：隐藏起来对外提供操作该数据的接口，这样可以确保操作属性的安全性
　　2.封装方法：目的是隔离复杂度，将复杂的实现过程进行隐藏，对外提供接口。ATM机就是一个很好的例子
　　

例子如下：
1.打印汽车有4个轮子
2.打印汽车是红色的
3.打印汽车牌子是奔驰

1.打印汽车有8个轮子
2.打印汽车是白色的
3.打印汽车牌子是宝马
#函数式编程：
def carr(num):
　　print(‘汽车有%s个轮子‘%num)
def color(col):
　　print(‘汽车是%s色‘ %col)
def brand(bran):
　　print(‘汽车牌子是%‘%bran)
调用：
carr(4)
color(‘红色‘)
brand(‘奔驰‘)

carr(8)
color(‘白色‘)
brand(‘宝马‘)

#面向对象编程
class F:
　　def __init__(self, carr, color, bran):
　　　　self.carr = carr
　　　　self.color = color
　　　　self.bran = bran
　　def carr(self):
　　　　print(‘汽车有%s个轮子‘%self.carr)
　　def color(col):1
　　　　print(‘汽车是%s色‘ %self.color)
　　def brand(bran):
　　　　print(‘汽车牌子是%‘%self.bran)
fobj1 = F(4,‘红色‘,‘奔驰‘)
fobj1.carr()
fobj1.color()
fobj1.brand()

fobj2 = F(8,‘白色‘，‘宝马‘)
fobj1.carr()
fobj1.color()
fobj1.brand()