面向过程:根据业务逻辑从上到下写代码
面向对象:对函数进行分类和封装,让开发“更快更好更强…
面向对象三大特性
面向对象的三大特性是指:封装、继承和多态
万事万物皆对象
类的定义:具有相同属性和行为的一组对象的集合
类: 指的是类型
对象: 指的是该类型下的具体哪一个
类是对象的抽象,对象是类的具体
类一个 对象多个
比如人类:
人
属性
年龄
性别
身高
....
行为
吃饭
睡觉
跑步
Python中类的定义人类
class People():
#属性
age=22
sex='男'
name="张三"
#跑步的行为
def run(self):
print(self.name,"在跑。。。")
#吃饭的行为
def eat(self):
print(self.name, "在吃饭。。。")
#创建对象
people1 =People()
#调用属性
people1.name='张三'
people1.age=22
#通过对象调用方法
people1.run()
people1.eat()
但是可以这样调用People.name='张三' 和people1.name='张三'
区别在哪里?如下
静态属性和实例属性
静态属性属于类,实例属性属于对象
class People():
# 静态属性
name = "张三"
# 实例属性
def eat(self, age):
self.age = age
# 访问实例属性
p1 = People()
p1.age = 32
print(p1.age)
# 访问静态属性
People.name = 'a'
print(People.name)
p2 = People()
p2.age = 31
print(p2.age)
# 访问静态属性
print(People.name)
内存图如下:
__init__
构造方法,通过类创建对象时,自动触发执行 ,是个特殊函数
创建对象时,给属性赋值
self 当前对象
class People():
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print(self.name,self.age)
p1 = People('张三',22)
p1.show()
p2 = People('张三2',12)
p2.show()
当程序执行p1 = People('张三',22) self 就是 p1
当程序执行p2 = People('张三2',12)self 就是 p2
封装
封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。
所以,在使用面向对象的封装特性时,需要:
- 将内容封装到某处
- 从某处调用被封装的内容
第一步:将内容封装到某处
class People():
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print(self.name,self.age)
p1 = People('张三',22)
p1.show()
p2 = People('张三2',12)
p2.show()
把数据张三,22,张三2,12分别封装到p1,p2 中
从某处调用被封装的内容
调用被封装的内容时,有两种情况:
- 通过对象直接调用
print(p1.name)
- 通过self间接调用
def show(self):
print(self.name,self.age)
面向对象的封装来说,其实就是使用构造方法将内容封装到 对象 中,然后通过对象直接或者self间接获取被封装的内容
二、继承
继承,面向对象中的继承和现实生活中的继承相同,即:子可以继承父的内容。
作用: 是面向对象语言中实现代码重用的重要手段之一,方便扩展。Java中只支持单根继承,即一个类只能有一个直接父类,python可以多重继承
例如:
猫可以:喵喵叫、吃、喝、拉、撒
狗可以:汪汪叫、吃、喝、拉、撒
如果我们要分别为猫和狗创建一个类,那么就需要为 猫 和 狗 实现他们所有的功能,如下所示:
class 猫:
def 喵喵叫(self):
print '喵喵叫'
def 吃(self):
# do something
def 喝(self):
# do something
def 拉(self):
# do something
def 撒(self):
# do something
class 狗:
def 汪汪叫(self):
print '汪汪叫'
def 吃(self):
# do something
def 喝(self):
# do something
def 拉(self):
# do something
def 撒(self):
# do something
上述代码不难看出,吃、喝、拉、撒是猫和狗都具有的功能,而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想,如下实现:
动物:吃、喝、拉、撒 (父类,基类)
猫:喵喵叫(猫继承动物的功能)
狗:汪汪叫(狗继承动物的功能)
代码如下:
class 动物:
def 吃(self):
# do something
def 喝(self):
# do something
def 拉(self):
# do something
def 撒(self):
# do something
# 在类后面括号中写入另外一个类名,表示当前类继承另外一个类
class 猫(动物):
def 喵喵叫(self):
print '喵喵叫'
# 在类后面括号中写入另外一个类名,表示当前类继承另外一个类
class 狗(动物):
def 汪汪叫(self):
print '喵喵叫'
所以,对于面向对象的继承来说,其实就是将多个类共有的方法提取到父类中,子类仅需继承父类而不必一一实现每个方法。
多重继承
如图
鸽子 (Pigeon) 蚂蚁 (Ant)一个是鸟类(Bird)一个是昆虫 Insect
但是都有飞的功能 可以定义一个飞行动物的类 AniFiy,让鸽子 (Pigeon)继承鸟类(Bird)和飞行动物的类 AniFiy ,蚂蚁 (Ant)继承昆虫 Insect和飞行动物的类 AniFiy
实现思路:
1 分别定义
Bird
属性 legNumber 行为egg();
Insect
属性 legNumber 行为 spawn();
2 定义
AniFiy 类有fiy()行为
3 定义
鸽子 (Pigeon)继承Bird ,AniFiy
蚂蚁 (Ant)继承Insect ,AniFiy
重写
子类不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。方法重写又称方法覆盖
实例(Python 3.0+)
#!/usr/bin/python3
class Parent:
# 定义父类 def myMethod(self):
print ('调用父类方法')
class Child(Parent):
# 定义子类
def myMethod(self):
print ('调用子类方法')
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
执行以上程序输出结果为:
调用子类方法
Super 调用父类函数
调用父类中的函数或者属性
Object基类
Python中所有的类的基类是Object,中间有常用的方法
多态
频繁修改代码,代码可扩展性、可维护性差。使用多态优化
多态:同一个类型,使用不同的实例而执行不同操作。方法重写是实现多态的基础
实现多态的必备条件
1 要有继承
2 要有重写
3 父类的引用指向子类的对象。
私有属性(访问权限修饰符)public private protected default
实例的变量名如果以 __ 开头,就变成了一个私有变量
(private),只有内部可以访问,外部不能访问,
但是这个不是绝对的,只是一种编码方式,可以通过 dir()查看私有属性,直接访问
使用 dir()
获得一个对象的所有属性和方法,可以使用 dir() 函数,它返回
一个包含字符串的 list,
动态语言和静态语言
Python 动态语言
Java c#,静态语言