|
1.面向对象用语：
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
数据成员(属性）：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个属性和方法。
2.类的创建
class Student(object):
def __init__(self, name, sex, height):
self.name = name
self.sex = sex
self.height = height
print("my name is {},sex is {},height is {}".format(name, sex, height))
def Gostudy(self):
print("go to school")
stu1 = Student("tom", "男", 1.80 )
stu1.Gostudy()
init()函数:两个下划线开头的函数是声明该属性为私有，不能在类的外部被使用或访问,支持带参数类的初始化，也可为声明该类的属性（类中的变量）。__init__函数的第一个参数必须为self，后续参数为自己定义。
__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
__init__方法(构造方法)：无需直接调用，生成实例对象的时候自动调用。
有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去.
在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别.
注：
name 普通变量
__name 私有变量，无法通过外部访问
name 特殊变量，可以通过类class访问
Self指向类本身。可以理解为，通过self.name = name的操作，将数据封装在类里面，调用时直接通过类Student去进行调用。若不进行self.name = name的操作，类的实例无法调用name。
2.面向对象的三大特征
封装：
类里面不光有属性还有方法。这种将属性通过方法直接在类内部操作的形式叫做封装。这里的封装是把属性封装在类内部。这样对类形成了一种“黑盒”状态，我们不需要知道类内部是什么样的。只要对对象进行操作就可以。 比如数据访问限制，既想将数据保护起来(设置私有属性:self.__属性名 self.__方法名)，又想在一定程度上对数据进行操作。这里就可以用到这个特性，我们可以在类中，设定一个方法，getName()来得到数据，setName()来设置数据。
注:父类的私有属性和私有方法,子类无法对其进行修改,只能修改父类属性、方法的类型或者子类对其父类的方法进行重写。
class Person(object):
def __init__(self, name):
self._name = name
def getName(self):
return self._name
def setName(self, name):
self._name = name
tom = Person("tom")
print(tom.getName())
继承：
面向对象中的继承就是继承的类直接拥有被继承类的属性而不需要在自己的类体中重新再写一遍，其中被继承的类叫做父类、基类，继承的类叫做派生类、子类。在python3中如果不指定继承哪个类，**默认就会继承Object类，而继承了Object类的类就叫做新式类，**而在python2中如果不指定继承哪个类也不会默认去继承Object类，而没有继承Object类的类就叫做经典类。经典类和新式类的不同就在于对方法的搜索顺序不同， 经典类是深度优先 即先找自己类内，如果没有就找左边第一个父类，没找到继续从这个父类的父类中找依次类推直到找到最上一级的父类也没找到再找左边第二个父类，然后再重复之前的过程，直到所有父类找一遍没找到就报错；**而 新式类是广度优先 ，当下一个类可以通过其他类找到时就先不去找它，而是找继承关系中与它的子类同级的其他类，依次类推直到最后找到object类没有找到指定方法就报错。**通过类名.mro() 查看新式类继承中的属性搜索顺序。
单继承与多继承:
在其他语言中只支持单继承即class 类名(父类名)，而python支持多继承，用逗号将多个父类隔开即class 类名(父类名1,父类名2,…)继承多个父类的第一个父类
class Father(object):
def eat(self):
print("苹果")
class Mother(object):
def eat(self):
print("草莓")
class Child(Father, Mother):
def test(self):
return self.eat()
tom = Child()
tom.eat()
继承与抽象:
抽象就是把一类事物的共有特性提取出来，继承则是把父类的属性拿过来并且还拥有自己的属性。抽象是包含的范围越来越大，共性越来越少，继承则是包含的返回越来越小，共性越来越多。我们定义父类的过程就是抽象，定义子类的过程就是继承。
重写:
我们把子类有而父类没有的方法叫做子类的派生方法，而父类有子类也有的方法叫做对父类方法的重写，因为按照类方法的搜索顺序一个方法如果在子类中有就不会再从父类中找了，结果就是父类中的方法无法调用了，如果既想执行父类中的方法同时在子类中又能定义新功能，就需要先把父类中的这个方法单独继承过来，在python3中可以使用super函数来实现， super().父类方法名(除self外的其他参数) ，其实在super函数中还需要传入子类名和子类对象（在类中用self）,但是我们使用时不需要特意去传，除非在类外单独调用父类的方法。注意在继承父类方法时父类的参数除了需要在父类的方法中传递还需要在子类重写的方法中传递。
class Animal(object):
def __init__(self, name, age):
self.name = name
self.age = age
class Person(Animal):
def __init__(self, name, age, emtion):
super(). __init__(name, age)
self.emtion = emtion
def test(self):
print("name:{},age:{},emtion:{}".format(self.name, self.age, self.emtion))
tom = Person("tom", 18, "单身狗")
tom.test()
super().init() 的作用就是继承父类的init，并且可以修改，如果不加这句话，那么就是无法继承。除非子类不定义__init__()。
多态：在python中，不同的对象调用同一个接口，表现出不同的状态，称为多态。
多态的实现必须满足两个前提条件:
1.继承：多态一定是发生在子类和父类之间
2.重写：多态子类重写了父类的方法
错误示例：没有继承关系，也没有重写
class Duck():
def who(self):
print("I am a duck")
class Dog():
def who(self):
print("I am a dog")
class Cat():
def who(self):
print("I am a cat")
if __name__ == "__main__":
duck=Duck()
dog=Dog()
cat=Cat()
duck.who()
dog.who()
cat.who()
改正
class Animal():
def who(self):
print("I am an Animal")
class Duck(Animal):
def who(self):
print("I am a duck")
class Dog(Animal):
def who(self):
print("I am a dog")
class Cat(Animal):
def who(self):
print("I am a cat")
if __name__ == "__main__":
duck=Duck()
dog=Dog()
cat=Cat()
duck.who()
dog.who()
cat.who()
小结：多态中不同的子类对象调用相同的父类方法，会产生不同的执行结果，这里的多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。
|