面对对象1

面向过程 与 面向对象：

面向过程

　　~面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。

优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。

缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

面向对象

　　~面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。

优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，这个游戏就失去平衡。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。

一 类和对象

　1 什么是类：一堆事物中拥有的共同功能和属性，比如说人类，动物类等等

　2 什么是对象：在类下面的调用者就是对象，比如说动物是一类，他下面的对象有猪，狗，猫等等

在python中以为皆为对象，而类型的本身就是一个类

二 创建类和对象

**基本格式：

class 类名:
    类属性 = ‘‘    #类属性、静态属性
    def __init__(self,参数1,参数2):
        self.a = 参数1
        self.b = 参数2

    def 方法(self):pass

参数1 = 1
参数2 = 2
对象名 = 类名(参数1,参数2)   #实例化

#类名
#类名.类属性
#类名.类方法  #但不能调用

#对象名
#对象名.对象属性  类属性
#对象名.方法()    调用方法，方法也叫动态属性

**创建对象和调用类

对象=类名（这里写上你对应的参数值，self不用传值）
调用方法：
对象.函数名（）

 在这里每一个类里面都必须要有一个__init__(self)这个函数的功能。他的功能是实例化一个对象

　类属性属于静态属性，而函数属性就属于动态的属性

类：类名.类属性

　　类名.类方法    (但不能调用)

对象：对象名.对象属性  对象名.类属性

　　　对象名.方法()   （调用方法，也叫做调用动态属性） 

例子

class People:
    def __init__(self,name,age,sex=‘男‘):
        self.name=name
        self.age=age
        self.sex=sex
    def kanchai(self):
        print(‘%s,%s岁,%s，上山去砍柴‘%(self.name,self.age,self.sex))
        print(‘%s,%s岁,%s，开车去东北‘ % (self.name, self.age, self.sex))
        print(‘%s,%s岁,%s，最爱大保健‘ % (self.name, self.age, self.sex))
dui1=People(‘小明‘,18)
dui5=People(‘老王‘,80)
dui1.kanchai()
dui5.kanchai()

输出结果

小明,18岁,男，上山去砍柴
小明,18岁,男，开车去东北
小明,18岁,男，最爱大保健
老王,80岁,男，上山去砍柴
老王,80岁,男，开车去东北
老王,80岁,男，最爱大保健

class People:
    def __init__(self,name,sex,aggr):
        self.name=name
        self.sex=sex
        self.aggr=aggr
        self.blood=20000
    def attack(self,person):
        print(‘%s attack %s‘%(self.name,person.name))
        person.blood-=self.aggr
        print(person.blood)
alex=People(‘alex‘,‘female‘,10000)
egon=People(‘egon‘,‘male‘,20000)
alex.attack(egon)
egon.attack(alex)

输出结果

alex attack egon
10000
egon attack alex
0

class People:
    def __init__(self,name,aggr,sex = ‘男‘):
        self.name = name
        self.aggr = aggr
        self.blood = 20000
    def attack(self,dog):
        print(‘%s attack %s‘%(self.name,dog.name))
        dog.blood -= self.aggr
        print(dog.blood)
class Dog:
    def __init__(self,name,aggr,sex = ‘公‘):
        self.name = name
        self.aggr = aggr
        self.blood = 20000
    def yao(self,person):
        print(‘%s yao %s‘%(self.name,person.name))
        person.blood -= self.aggr
        print(person.blood)
alex = Dog(‘alex‘,1000)
egon = People(‘egon‘,10000)
alex.yao(egon)
egon.attack(alex)

输出结果

alex yao egon
19000
egon attack alex
10000

 什么叫做面向对象之间的交互：在多个面向对象之间互相的调用，就叫在面向对象的交互

计算面积和周长：

from math import pi
class Ciecle:
    def __init__(self,r):
        self.r = r
    def area(self):
       return pi*self.r**2
    def round(self):
        return 2*pi*self.r
c1 = Ciecle(10)
print(c1.area())
print(c1.round())

输出结果

314.1592653589793
62.83185307179586