一、封装名可名
（1）定义：封装就是指隐藏对象中一些不希望外部所访问的属性和方法，即为保证安全
（2）概念：指的是在设计类时，不对外提供，隐藏起来，提供公共方法以外的方法（就是把属性和方法封装到一个抽象的类中）
（3）封装相当于一个抽象的盒子，将事务相关的属性和方法封装在一个类中，在调用类创建实例，不用关心内部代码的实现细节，只要调用结果就可以。
（4）封装的优点：
A. 封装数据，可以很好的保护隐私（将不需要对外提供的内容都隐藏起来）
B.封装方法主要原因是隔离复杂度
c.提高代码的复用性
D.隐藏对象的属性和实现细节，提供公共方法对齐访问
（4）python类的封装有两种：
A. 公有（共用）
类中的变量和方法，他们名称前没有下划线，公有的变量和方法在类的外部，内部，以及子类都可以使用
B.私有
在类总的变量和方法系，下划线开头命名，则改变量或方法系啊，下划线开头命名，则改变变量或方法为私有，私有变量和方法，只能在本类内部使用，类的尾部以及子类都无法使用

（5）私有属性：
格式:
___属性名=值在类的外部不能使用（对象不能调用属性）
（6）私用化封装后的限制
A.类可以方法
B.类外，对象为不可以访问
C.子类和子类对象不可访问

======================================================
公有
（1）数据封装：
class gs():
def init(self,name,age):
self.name=name
self.age=age
（2）
class gs():
def init(self,name,age):
self.name=name
self.age=age
def zy(self): #方法封装
print(self.name+‘搬砖’)
===========================
私有方法：
(1) 在方法的前面加上___
class Gs():
def init(self,name,age):
self.name=name
self.age=age
def _zy(self): #方法封装
print(self.name+‘搬砖’)
if name == ‘main’:
s=Gs(‘wy’,18)
s.zy()
（2）在实例变量的前面加上
class Gs():
def init(self,name,age):
self.__name=name
self.__age=age
def setname(self,newname): #方法封装
self.__name=newname
def getname(self):
print(self.__name)
if name == ‘main’:
s=Gs(‘wy’,18)
print(s.__name)

==============================
（1）getname 获取名
用于实例化对象设置修改类属性的方法
（2）setname设置名字
用于实例化对象获取修改类属性的方法
class Gs():
def init(self,name,age):
self.__name=name
self.__age=age
def setname(self,newname): #方法封装
self.__name=newname
def getname(self):
print(self.__name)
if name == ‘main’:
s=Gs(‘wy’,18)
s.setname(‘jx’)
s.getname()

=======================================================

1、继承：类的继承是面向对象程序设计的一个重要思想，继承时子类可以继承父类的内容，包括成员变量和成员函数。
2、在继承中一个类被另外一个类继承这个类称之为父类也称之为基类，则另外一个类则为子类也称之为派生类。
案例一：单个继承
class F(object):
def int(self):
pass
def car(self):
print(‘豪车’)
def fz(self):
print(‘别墅’)
def ck(self):
print(“存款1个亿”)
class son(F):
def init(self):
pass
def sy(self):
print(“无业游民”)
def ds(self):
print(‘单身’)
def diaos(self):
print(‘屌丝’)

if name == ‘main’:
# f=F()
# f.car()
# f.ck()
# f.fz()
s=son()
# s.diaos()
# s.ds()
# s.sy()
s.ck()
s.ds()
s.fz()
s.car()
s.sy()
s.ds()

案例二：多个继承
class F(object):
def int(self):
pass
def car(self):
print(‘豪车’)
def fz(self):
print(‘别墅’)
def ck(self):
print(“存款1个亿”)
class m(object):
def int(self):
pass
def tian(self):
print(‘田’)
def di(self):
print(‘地’)
def kuang(self):
print(“旷”)
class son(F,m):
def init(self):
pass
def sy(self):
print(“无业游民”)
def ds(self):
print(‘单身’)
def diaos(self):
print(‘屌丝’)

if name == ‘main’:
# f=F()
# f.car()
# f.ck()
# f.fz()
s=son()
# s.diaos()
# s.ds()
# s.sy()
s.ck()
s.ds()
s.fz()
s.car()
s.sy()
s.ds()
s.tian()
s.di()
s.kuang()
=========================================
多态;
1、多态是以继承和重写父类方法为前提，对所有子类实例化产生的对象调用相同的方法，执行产生不同的执行结果
2、例如同样是人，但是当问起一个人的职业时会有不同的结果，可能是软件测试工程师，可能是HR
3、一个对象的属性和行为不是由他所继承的父类决定的，而是由其本身包含的属性和方法决定的
4、多条的优点：
A.增加程序的灵活性
B.增加程序的可拓展性

======================================
案例1: 理解多态
class wb():
def init(self,a,b):
self.a=a
self.b=b
def xs(self):
print(self.a+self.b)
if name == ‘main’:
f=wb(‘中国’,‘牛逼’)
f.xs()

案例2: 理解多态
class Animal(object):
def talk(self):
print(‘我是动物’)
class Cat(Animal):
def talk(self):
print(‘喵喵’)
class Dog(Animal):
def talk(self):
print(‘汪汪’)
if name == ‘main’:
b=Animal()
b.talk()
c = Cat()
c.talk()
s=Dog()
s.talk()
案例3：
class Animal(object): #定义一个类
def talk(self):
print(‘我是动物’)
class Cat(Animal): #定义一个类，重写父类
def talk(self):
print(‘喵喵’)
class Dog(Animal): ##定义一个类，重写父类
def talk(self):
print(‘汪汪’)
class r(object):
def rx_j(self,Animal):#传入不同对象，执行不同代码，不同的talk只要接收父类对对象，就能接收子类对象
print(Animal.talk())
if name == ‘main’: