python类和对象（7）

来源：互联网发布：c语言主函数作用编辑：程序博客网时间：2024/06/07 22:36

面向过程：根据业务逻辑从上到下写代码

面向对象：对函数进行分类和封装，让开发“更快更好更强…

面向对象三大特性

面向对象的三大特性是指：封装、继承和多态

万事万物皆对象

类的定义：具有相同属性和行为的一组对象的集合

类: 指的是类型

对象: 指的是该类型下的具体哪一个

类是对象的抽象，对象是类的具体

类一个对象多个

比如人类：

人
属性

年龄

性别

身高

....

行为

吃饭

睡觉

跑步

Python中类的定义人类

class People():

  #属性
    age=22
    sex='男'
    name="张三"

    #跑步的行为
    defrun(self):
        print(self.name,"在跑。。。")

    #吃饭的行为
    defeat(self):
        print(self.name,"在吃饭。。。")

#创建对象
people1 =People()
#调用属性
people1.name='张三'
people1.age=22
#通过对象调用方法
people1.run()
people1.eat()

但是可以这样调用People.name='张三' 和people1.name='张三'
区别在哪里？如下

静态属性和实例属性

静态属性属于类，实例属性属于对象

class People():
    # 静态属性
    name = "张三"

    # 实例属性
    defeat(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 父类的引用指向子类的对象。

私有属性（访问权限修饰符）

实例的变量名如果以 __ 开头，就变成了一个私有变量

（private），只有内部可以访问，外部不能访问，

但是这个不是绝对的，只是一种编码方式，可以通过 dir()查看私有属性，直接访问

使用 dir()

获得一个对象的所有属性和方法，可以使用 dir()函数，它返回

一个包含字符串的 list，

动态语言和静态语言

Python 动态语言

Java c#,静态语言

阅读全文

0 0