面向对象

我是python小白

面向对象
设计类：

对象名：Wife（见名之意，首字母大写没其他遵循驼峰原则）
属性：sex age height weight faceValue（见名之意，其他遵循驼峰原则）
行为： 做饭  洗衣服 拖地 揉肩 捶腿（见名之意，其他遵循驼峰原则）
创建类*
类：一种数据类型，本身并不占内存空间，根所学过的number， boolean等类似，用类创建实例化对象（变量），对象占内存空间

格式：

class 类名(父类列表):

        属性

        行为

1. #一个简单的类（人类）
   
2. object:基类，超类，所有类的父类。一般没有合适的父类就写object
   
3. class Person(object):
   
4.     #定义属性(定义变量)
   
5.     name = ""
   
6.     age = 0
   
7.     height = 0
   
8.     weight = 0
   
9.     #定义方法（定义函数）
   
10.     #注意：方法的参数必须以self当第一参数
    
11.     #self代表类的示例（某个对象）
    
12.     def run(self):
    
13.         print("run")
    
14.     def eat(self, food):
    
15.         print("eat" + food)
    

复制代码

使用类实例化对象
格式：

对象名 = 类名(参数列表)

注意：没有参数，小括号也不能省略。

1. per1 = person()
   

复制代码

访问对象的属性与方法

1. per = person()
   
2. #访问属性
   
3. #格式：对象名.属型名
   
4. #赋值：对象名.属性名 = 值
   
5. per.name = "tom"
   
6. per.age = 18
   
7. print(per.name, per.age)
   
8. #访问方法
   
9. #格式：对象名.方法名(参数列表)
   
10. per.opemDoor()
    
11. per.fillElephant()
    
12. per.eat("apple")
    
13. #问题：目前来看person创建的所有对象属性都是一眼的
    

复制代码

对象的初始状态（构造函数）

1. #构造函数 __init__()在使用类创建对象的时候自动调用
   
2. #注意：如果不显示的写出构造函数，默认会在佛那个添加一个空的构造函数。
   
3. ##默认格式：
   
4. def __init__(self):
   
5.     pass
   
6. 
   

复制代码

self关键字：
self代表类的示例，而非类

那个对象调用方法，那么该方法中self就代表那个对象

1. #self代表类的示例，而非类
   
2. #那个对象调用方法，那么该方法中self就代表那个对象
   
3. self.__class__ 代表类名
   
4. #self 不是富案件自，换成其他的表示符也是可以的，但是帅的人都是用self
   

复制代码

析构函数

1. __del__() 释放对象自动调用
   
2. ##建立析构函数
   
3. def __del__()
   
4. ##手动释放
   
5. def 对象名
   
6. #注意：对象释放以后就不能再访问了
   
7. 
   
8. #在函数里定义的队形，会在函数借宿自动，这样可以减少内存空间的浪费
   
9. def func():
   
10.     per2 = Person("aa", 11,1,1)
    

复制代码

重写

1. #重写：将函数重写定义一遍
   
2. #__str__:在调用print打印对象自动调用，是给用户用的，，是一个描述对象的方法。
   
3. #__repr__():是给机器用的，在python解释器里面直接敲对象名在回车后调用的方法
   
4. #注意：在没有str时，且有repr，str = repr
   
5. class Person(object):
   
6.     def __str__(self):
   
7.         return "%s-%d-%d-%d"%(self.name, self.age,self.height, self.hight)
   
8. #优点：当一个对象的属性值很多，并且都需要打印，重写了__str__方法，简化了代码
   

复制代码

访问限制
如果压让的内部属性不被外部直接访问，在属性名前加两个下划线，在python中如果在属性前加两个下换线，那么这个属性就变成了私有属性。

int(pre__name)#外部不能使用
int(self.__name)#内部可以使用

1. #通过内部的方法，取修改的值
   
2. def setMoney(self, money):
   
3.     #数据的过滤
   
4.     if money < 0:
   
5.         money = 0
   
6.     self.__money = money
   

复制代码

继承
继承：有两个类，a类和b类，当我们说A类继承自B类的时候，那么A类就拥有B类中的所有的属性和方法

object类是说有类的父类，还可称为基类或者超类。

注意：继承者称为子类，被继承者称为父类。

继承作用：

1.简化了代码，减少冗余

2、提高了代码的健壮性

3.提高了代码的安全性

4、是多态的前提

继承的缺点：

耦合与内聚是描述类与类之间的关系，耦合越低，内聚性越高代码越好。

单继承的实现

1. class Person(object):
   
2.     def __int__(self, name, age):
   
3.         self.name = name
   
4.         self.age = age
   
5.       
   
6.     def run (self):
   
7.         print("run:)
   
8.      
   
9.     def eat(self, eat):
   
10.         print("eat" + eat)
    
11.               
    
12. #继承类
    
13. class Student(Person):
    
14.     def __init__(self, name, age, stuId):
    
15.         #调用父类中的__init__
    
16.         super(Student, self).__init__(name, age)
    
17.         #子类可以有一些独有的属性
    
18.         self.stuID = stuId
    

复制代码

多继承

1. from Father import Father
   
2. from Monther import Mother
   
3. class Child(Father, Mother):
   
4.     def __init__(self, money, money):
   
5.         F
   

复制代码