面向对象

Posted 2020-11-23 hongfeng2019

面向过程:根据业务逻辑从上到下垒代码,所有的事都需要自己去处理．

引入函数，避免可重复使用代码．面向函数: 将某功能代码封装到函数中，以后直接调用，不需要再次编写

面向对象:先要写一个类, 对函数进行分类和封装，类里可以有很多函数,让开发“更快更好更强...”

像Java和C++等编程语言仅支持面向对象编程，而Python支持函数式编程和面向对象编程混用

 

列如:

# 函数式编程

def bar():

    print(‘bar‘)

bar()  # 直接调用函数

 

# 面向对象编程

class Foo:  # 创建类

   def  bar(self):  # 在类里面定义函数 这里self是一个特殊的参数 创建对象时Foo将自身传进来

       print(‘bar‘)                                  

 

obj = Foo()  # 创建一个对象

obj.bar()  # 由对象去访问类里面函数

 

#定义类

class Student:   #py2要加括号()

    note = "class information" #类属性,静态的.实例里可以调用类属性

    __privae = "this is private info"  #私有属性,只能在类内调用,不允许类外直接调用.接口技术

    def __init__(self,name,age,sex,class_,score):     #魔术方法，构造函数，做类定义的，self就是我

        self.name = name

        self.age = age                                       

        self.sex = sex

        self.class_ = class_   #这些叫实例属性,是动态的,随实例变化

    def detail(self):                 #这个函数在类内，叫方法

        print("your name is {}.format(self.name)")

    def get_score(self):

        if self.score >= 90:

            print("your score is A")

        if 60 < self.score < 90:

            print ("your score is B")

        if self.score < 60:

            print("your score is C")

    @staticmethod     #静态方法

    def static_():

        print("class note is {}".format(Student.note))

    @classmethod  #静态方法类名变了就出错.引入class的方法,类名改了还是可以调用.区别是cls

    def class_method(cls):

        print("class private info is {}".format(cls.__private))

 

#创建一个对象,这就叫实例化，s1相当就是self（我）的别名，别人叫得名字．

s1 = Student("hf",35,"male","python")      

实例化调用类s1的时候self就被替换成s1,s2时self被替换成s2.

实例化就是封装的过程

print(s1.name,s1.class)

s1.detail()　　　　＃实例方法，类实例化后才能调用的方法

s2 = Student("hong",25,"male","java",90)

s2.get_score()

s2.score = 95

s2.get_score()

#类属性直接调用,可不通过实例

#实例可以调用类属性

print (s1.note)

print (Student.note)

 

静态方法:

跟实例没什么关系,调用类里的信息,用类名.类属性

类方法:

静态方法类名变了就出错.引入class的方法,类名改了还是可以调用.区别是cls

 

1.1 继承:

一个类写了一个括号,带了个类名就表示是这个类的子类,继承这个类里面的特性

多态就是指子类的多种形态．

多态：

子类可以拥自己的方法

子类继承所有父类的方法

子类可以重写父类的方法

子类里的方法是最高等级的,如方法名相同会覆盖父类里的方法.这就是重写,是多态的一种

 

class Father:

    # def drink(self):

    #     print("father drinking")

 

    def smoke(self):

        print("father smoking")

 

    def earning(self):

        print("father earing 1000")

 

 

class Son1(Father):

    def drug(self):

        print("son1 method drug")

 

    def earning(self):

        print("son1 earing Nothing")

 

 

class Son1_wife:

    def cook(self):

        print("cooking meat")

 

    def drink(self):

        print("son1 wife drink double")

 

 

class Son2(Father):

    def song(self):

        print("son2 method song")

 

    def earning(self):

        print("son2 earning 2000")

 

 

class Gson(Son1, Son1_wife):

    def dance(self):

        pass

 

print("=======S1 info=========")

s1 = Son1()

s1.drug()

# s1.drink()

s1.earning()

print("=======S2 info=========")

s1 = Son2()

# s1.drink()

s1.earning()

s1.song()

print("======G1 info==========")

g1 = Gson()

g1.drink()

g1.drug()

g1.earning()

g1.dance()

 

#类初期了解,知道语法.半年后能自己写.

 

多继承:

深度优先:先找根,没有再找C

广度优先:先找C,没有再找根