python面向对象一

面向对象技术简介
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

一个简单的面向对象
class Person:
	home = ‘地球’   #静态属性/类变量
	def __init__(slef,name,age)   #构造函数
	'''这个函数时类在实例化时，最先执行的函数，实例化会给参数赋值'''
		self.name = name   #实例变量
		self.age = age
	
	def eat(slef):  #动态属性
		print('%s is eat..')

#现在我就开始实例类
#吧类变成一个具体对象的过程交实例化
p1 = Person('couding',18)
p2 = Person('yangmi',50)
	

***组合用法。***    ***#一个类的对象作为另一个类对象的属性***


定义两个类，一个是游戏人物，一个是武器。
class Gamer:
	'''人物类'''
	def __init__(self,name,ad,hp)
		self.name = name
		self.ad = ad
		self.hp = hp
	def attack(self)
		'''使用拳头攻击'''
		print('\033[1;33m%s被%s攻击了,你收到了%s点攻击,现在你还有%s滴血\033[0m')
	def equip_werpon(self,wea)
	'''装备武器的功能，给人物装备一个带有武器的属性'''
		self.wea = wea

class Weapon:
	'''武器类'''
	def __init__(self,name,ad)
		self.name = name
		self.ad = ad
	def fight(self,p1,p2):
		'''使用武器进行攻击'''
		p1.ad = p1.ad + self.ad
		print('%s用%s打了%s一下，%s受到了%s点攻击，%s还剩下%s滴血..' %(p1.name,self.name,p2.name,p2.name,p1.ad,p2.name,p2.hp-p1.ad))
p1 = Gamer('盖伦',20,500)
p2 = Gamer('亚索',50,200)
w1 = Weapon('砍刀',70)
w2 = Weapon('狼牙棒',100)
下面我给压缩装备一个武器
p1.equip_weapon(w1)   #给盖伦这个人物装备上砍刀
p1.wea.fight(p1,p2)  #给fight传参数，self参数，是已经自动传进去了
# 如果是实例化的对象这个实例本身调用这个方法那么self自动就是对象本身
# 如果是类名调用，那么self 要传参数

继承简单用法：
面向对象有三大特性：继承，多态，封装。   在python中没有多态这个概念。后面再细说
下面说说继承的简单用法。
python中有单继承和多继承，多继承是python特有
下面我定义两个类。

class Animal:
	def __init__(self,name,sex,age):
    	self.name = name
        self.sex = sex
        self.age = age

    def eat(self):
        print("%s在吃饭...." %self.name)
        
class Cat(Animal):
	def __init__(self,name,sex,age,miao):
		super(Cat,self).__init__(name,sex,age)
		self.miao = miao
	def miaow(self):
		print('小猫\033[1;33m%s\033[0m在喵喵叫...' %self.name)
	
	def cat_eat(self):
		print('%s is eat food...' %self.name)

class Brid(Animal):
	def __init__(self,name,sex,age,wing):
		super().__init__(name,sex,age)
		self.wing = wing
	def brid_wing(self):
		print('%s flying...' %self.name)
a = Animal('Jerry','man',20)
p1 = Cat('Tom','man',20,'杰瑞你别跑')
w1 = Brid('八哥','man',15,'飞呀飞')
Animal.eat(p1)   #直接调用父类的类方法
p1.eat(p1)     #继承父类后调用父类的方法
a.eat()
# 初识继承：子类及子类实例化的对象，可以访问父类的任何变量变量和方法
#     类名可以访问父类的所有内容
#     子类实例化的对象也可以访问父类所有内容
# 只执行父类的方法：子类中不要定义与父类同名的方法   (当然也可以直接调用父类名来调类方法。但是必须要穿参数。)
# 只执行子类的方法：在子类创建这个方法
# 既要执行子类的方法，又要执行父类的方法

继承2........
# 实例化一个人类的对象，让其只封装皮肤属性。
# 实例化一个人类的对象，让其封装姓名，性别，年龄，皮肤四个属性。
# 实例化一个狗类的对象，让其只封装毛色属性。
# 实例化一个狗类的对象，让其封装姓名，性别，年龄，毛色四个属性。
# 实例化一个人类的对象，让其只执行父类的eat方法（可以对人类代码进行修改）。
# 实例化一个狗类的对象，让其既执行父类的eat方法，又执行子类的eat方法。
class Animal:
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
    	print("%s 在吃饭......."%self.name)

class Dog(Animal):
'''定义狗类，不同的是有毛发颜色.........'''
    def __init__(self,name,sex,age,colour):
        super().__init__(name,sex,age)
        self.colour = colour

    def eat(self):
        print('%s 狗正在吃饭...'%self.name)
class Person(Animal):
    def __init__(self,name,sex,age,skin):   #self 接受了 niao 这个对象

        super().__init__(name,sex,age)
        self.skin = skin

    def eat(self):
        print('\033[1;33m%s 人正在吃饭....\033[0m'%self.name)
p1 = Person('小福贵','man',20,'yelloer')
d1 = Dog('比熊','man',7,'blue')
p1.eat()

***继承三***
----------------------很重要----------------------
#代码会运行什么呢
class Parent:
    def func(self):
        print('in Parent func')

    def __init__(self):
    	print('我要运行in son func 了')
        self.func()

class Son(Parent):
    def func(self):
        print('in Son func')

son1 = Son()
答案是 '''in Son func''' 因为 son1 它先实例化在自己的类中没有找到 __init__ 方法，所以就去父类里面找找到后运行，这时就会将Son传给self 所以 __init__ 构造方法运行的实际是 Son.func。