初闻面向对象

一.概述

面向过程:通过业务逻辑从上到下垒代码

函数式:将某功能代码封装到函数中,日后便无需重复编写,仅需调用函数即可

面向对象:对函数进行分类和封装,让开发"更快更好更强..."

二.函数式编程和面向对象的对比

# 请开发一个消息提醒的功能(邮件/短信/微信)

# 函数
def email(em,text):
    """
    发送邮件
    :return:
    """
    print(em,text)

def msg(tel,text):
    """
    发送短信
    :return:
    """
    print(tel,text)

def wechat(num,text):
    """
    发送微信
    :return:
    """
    print(num,text)


# 编写功能:假设用户购买外挂,然后给卢姥爷发送提醒;
if 1==1:
    msg('188888888','马飞飞购买了一个外挂')
    email('wuwukai@sb.com','马飞飞购买了一个外挂')
    wechat('xxxx','马飞飞购买了一个外挂')



# 面向对象
class Message:
    def email(self, em, text):
        """
        发送邮件
        :return:
        """
        print(em,text)

    def msg(self, tel, text):
        """
        发送短信
        :return:
        """
        print(tel,text)

    def wechat(self, num, text):
        """
        发送微信
        :return:
        """
        print(num,text)


# 编写功能:假设用户购买外挂,然后给卢姥爷发送提醒;
if 1==1:
    obj = Message()
    obj.email('wuwukai@sb.com', '马飞飞购买了一个外挂')
    obj.msg('188888888','马飞飞购买了一个外挂')
    obj.wechat('xxxx','马飞飞购买了一个外挂')

round 1

1.对比:

　　函数:定义简单/调用简单

　　面对对象:定义复杂/调用复杂　　好处:归类,将某些类似的函数写在一起

2.总结:

　　(1).函数式编程可能会比面向对象好

　　(2).Python中支持两种编程方式

　　(3).面向对象方式格式:

# 定义:
class 类名:                # 定义了一个类
    def 函数名(self):    # 在类中编写了一个"方法"


# 调用:
x1 = 类名()               # 创建了一个对象/实例化一个对象
x1.函数名()                # 通过对象调用其中一个方法

class Account:
    def login(self):
        user = input('请输入用户名:')
        pwd = input('请输入密码:')
        if user == 'alex' and pwd == 'sb':
            print('登录成功')
        else:
            print('登录失败')

obj = Account()
obj.login()

示例

# 打印
"""
完成以下功能:
    老狗/20岁/男/上山去砍柴
    老狗/20岁/男/开车去东北
    老狗/20岁/男/喜欢大宝剑
"""

# 函数版本:
def kc(name,age,gender):
    data = "%s,性别%s,今年%s岁,喜欢上山砍柴" %(name,gender,age)
    print(data)

def db(name,age,gender):
    data = "%s,性别%s,今年%s岁,喜欢开车去东北" %(name,gender,age)
    print(data)

def bj(name,age,gender):
    data = "%s,性别%s,今年%s岁,喜欢大宝剑" %(name,gender,age)
    print(data)


kc('老狗',20,'男')
kc('老狗',20,'男')
db('老狗',20,'男')
bj('老狗',20,'男')



# 面向对象:
class LaoGou:

    def __init__(self,name,age,gender): # 特殊的方法,如果 类名() ,则该方法会被自动执行 (构造方法)
        self.n1 = name
        self.n2 = age
        self.n3 = gender

    def kc(self):
        data = "%s,性别%s,今年%s岁,喜欢上山砍柴" %(self.n1,self.n3,self.n2)
        print(data)

    def db(self):
        data = "%s,性别%s,今年%s岁,喜欢开车去东北" %(self.n1,self.n3,self.n2)
        print(data)

    def bj(self):
        data = "%s,性别%s,今年%s岁,喜欢大宝剑" %(self.n1,self.n3,self.n2)
        print(data)

obj = LaoGou('老狗',20,'男')
obj.kc()
obj.db()
obj.bj()

round 2

3.总结:

(1).构造方法:

class Foo:
    
    def __init__(self,name):     # 构造方法,目的进行数据初始化.
        self.name = name 
        self.age = 18 

obj = Foo('娃哈哈')

# 通过构造方法,可以将数据进行打包,以后使用时,去其中获取即可.

示例一:

class Bar:
    pass 
obj = Bar()

示例二:

(2).应用

[1].将数据封装到对象中,以供自己在方法中调用

class FileHandler:
    def __init__(self,file_path):
        self.file_path = file_path
        self.f = open(self.file_path, 'rb')

    def read_first(self):
        # self.f.read()
        # ...
        pass

    def read_last(self):
        # self.f.read()
        # ...
        pass

    def read_second(self):
        # self.f...
        # ...
        pass
    
obj = FileHandler('C:/xx/xx.log')
obj.read_first()
obj.read_last()
obj.read_second()
obj.f.close()

View Code

[2].将数据封装到对象中,以供其他函数调用

def new_func(arg):
    arg.k1
    arg.k2
    arg.k6

class Foo:
    def __init__(self,k1,k2,k6):
        self.k1 = k1
        self.k2 = k2
        self.k6 = k6

obj = Foo(111,22,333)
new_func(obj)

View Code

4.实例练习:

"""
练习: 信息管理系统
    1. 用户登录
    2. 显示当前用户信息
    3. 查看当前用户所有的账单
    4. 购买姑娘形状的抱枕
"""

class UserInfo:

    def __init__(self):
        self.name = None

    def info(self):
        print('当前用户名称:%s' %(self.name,))

    def account(self):
        print('当前用户%s的账单是:....' %(self.name,))

    def shopping(self):
        print('%s购买了一个人形抱枕' %(self.name,))

    def login(self):
        user = input('请输入用户名:')
        pwd = input('请输入密码:')
        if pwd == 'sb':
            self.name = user
            while True:
                print("""
                    1. 查看用户信息
                    2. 查看用户账单
                    3. 购买抱枕
                """)
                num = int(input('请输入选择的序号:'))
                if num == 1:
                    self.info()
                elif num ==2:
                    self.account()
                elif num == 3:
                    self.shopping()
                else:
                    print('序号不存在,请重新输入')
        else:
            print('登录失败')

obj = UserInfo()
obj.login()

信息管理系统

(1).总结:

class Foo:
    def func2(self):
        print('func2')
    
    def func1(self):
        self.fun2()
        print('func1')
        
        
obj = Foo()
obj.func1()

三.面向对象代码如何编写

1.规则

class Foo:
    
    def __init__(self,name):
        self.name = name 
        
        
    def detail(self,msg):
        print(self.name,msg)
        
obj = Foo()
obj.detail()

2.什么时候写,如何写?

方式一:归类+提取公共值

(1).归类:

class File:
    def file_read(self,file_path):
        pass

    def file_update(self,file_path):
        pass

    def file_delete(self,file_path):
        pass

    def file_add(self,file_path):
        pass

class Excel:
    def excel_read(self,file_path):
        pass

    def excel_update(self,file_path):
        pass

    def excel_delete(self,file_path):
        pass

    def excel_add(self,file_path):
        pass

归类

(2).提取公共值:

class File:
    def __init__(self,file_path):
        self.file_path = file_path
        
    def file_read(self):
        pass

    def file_update(self):
        pass

    def file_delete(self):
        pass

    def file_add(self):
        pass

class Excel:
    def __init__(self,file_path):
        self.file_path = file_path
        
    def excel_read(self):
        pass

    def excel_update(self):
        pass

    def excel_delete(self):
        pass

    def excel_add(self):
        pass

提取公共值

方式二:在指定类中编写和当前相关的所有代码 + 提取公共值

class Message:
    def email(self):    
        pass 

class Person:
    def __init__(self,na, gen, age, fig)
        self.name = na
        self.gender = gen
        self.age = age
        self.fight =fig
        
    def grassland(self):    
        self.fight = self.fight - 10  
        
    def practice(self):
        self.fight = self.fight + 90   
        
    def incest(self):
        self.fight = self.fight - 666
        

cang = Person('苍井井', '女', 18, 1000)    # 创建苍井井角色
dong = Person('东尼木木', '男', 20, 1800)  # 创建东尼木木角色
bo = Person('波多多', '女', 19, 2500)      # 创建波多多角色

dong.grassland()

View Code

四.面向对象的三大特性:封装/继承/多态

1.封装:

　　(1).将相关功能封装到一个类中:

class Message:
    def email(self):pass
    def msg(self):pass
    def wechat(self):pass

　　(2).将数据封装到一个对象中:

class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
        
obj = Person('娃哈哈',18,'女')

2.继承:为了提高代码重用性

# 基本写法
class SuperBase:
    def f3(self):
        print('f3')

class Base(SuperBase):  # 父类,基类
    def f2(self):
        print('f2')

class Foo(Base):        # 子类,派生类

    def f1(self):
        print('f1')

obj = Foo()
obj.f1()
obj.f2()
obj.f3()
# 原则:现在自己类中找,么有就去父类

基本使用

class Base1:
    def show(self):
        print('Base1.show')

class Base2:
    def show(self):
        print('Base2.show')

class Foo(Base1,Base2):
    pass

obj = Foo()
obj.show()

# 左边更亲

多继承

class Base:
    def f1(self):
        print('base.f1')

    def f3(self):
        self.f1() # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
        print('base.f3')

class Foo(Base):
    def f1(self):
        print('foo.f1')

    def f2(self):
        print('foo.f2')
        self.f3()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.


obj = Foo()
obj.f2()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
# foo.f2
# foo.f1
# base.f3

obj2 = Base()
obj2.f3()
# base.f1
# base.f3

例题演示:

class Base1:
    def f1(self):
        print('base1.1')
    def f2(self):
        print('base1.f2')

class Base2:
    def f1(self):
        print('base2.f1')

    def f2(self):
        print('base2.f2')

    def f3(self):
        print('base2.f3')
        self.f1()

class Foo(Base1,Base2):

    def f0(self):
        print('foo.f0')
        self.f3()
# 1. 多继承先找左边
# 2. self到底是谁,self是那个类的对象,那么就从该类开始找(自己没有就找父类)
obj = Foo()
obj.f0()

(1).总结:

　　[1].继承编写

　　　　class Foo(父类):

　　　　　　pass

　　[2].支持多继承(先找左/再找右)

　　[3].为什么要有多继承:提高代码的重用性

3.多态

多种形态或多种状态

鸭子模型,只要可以嘎嘎叫就是鸭子

# Python
#  由于python原生支持多态,所以没有特殊性.
class Foo1:
    def f1(self):
        pass 

class Foo2:
    def f1(self):
        pass 

class Foo3:
    def f1(self):
        pass 
        
        
def func(arg):
    arg.f1()
    
obj = Foo1() # obj= Foo2()   obj = Foo3()
func(obj)



# Java
class Son(list):
    pass

class Son1(list):
    pass

# 以后传参时,arg可以是:list类的对象/list任何子类的对象
public void func(list arg){
    print(arg)
}

# obj = list()
# obj = Son()
obj = Son1()
func(obj)

多态

posted @ 2018-08-27 17:03 骑驴老神仙阅读(204) 评论(0) 收藏举报

刷新页面返回顶部

骑驴老神仙

初闻面向对象

一.概述

二.函数式编程和面向对象的对比

1.对比:

2.总结:

3.总结:

(1).构造方法:

(2).应用

[1].将数据封装到对象中,以供自己在方法中调用

[2].将数据封装到对象中,以供其他函数调用

4.实例练习:

(1).总结:

三.面向对象代码如何编写

1.规则

2.什么时候写,如何写?

方式一:归类+提取公共值

(1).归类:

(2).提取公共值:

方式二:在指定类中编写和当前相关的所有代码 + 提取公共值

四.面向对象的三大特性:封装/继承/多态

1.封装:

(1).将相关功能封装到一个类中:

(2).将数据封装到一个对象中:

2.继承:为了提高代码重用性

(1).总结:

[1].继承编写

3.多态

公告

　　(1).将相关功能封装到一个类中:

　　(2).将数据封装到一个对象中:

　　[1].继承编写