python面向对象编程

类的定义，属性，方法…

1.如何定义类 class 类名(): pass
2.类创建对象的过程称为实例化，把抽象的类具体化
对象名 = 类名(参数1、参数2…参数n)

类：模板

公有属性：类中的变量，可以在构造函数中传参赋值，也可以实例化对象去赋值
私有属性：不能直接使用,可以通过类里边的方法调用,或赋值给令一个公有属性
类属性:在class关键字下边直接定义,可以被类方法直接调用
公有方法：类中的函数
def __init__(self,…)构造方法
静态方法:只能通过类名进行调用
私有方法:不能调用
类方法:只能通过类名进行调用,可以访问类属性
实例化：通过类创建对象
class =class()

class People():
	def __init__(self,参数1,参数2,参数3...):
		初始化程序(不用调用，实例化之后，自动执行)
		self.name = 参数1		#属性赋值
	def __str__(self):
		#必须返回一个字符串，打印实例化对象输出返回值
	def fun1(self):
	.
	.
	.
#实例化一个对象
p1 = People()
p1.age = 20						#属性赋值
print(id(p1))					#打印p1的id
print(p1.name)					#打印属性
p1.fun1()						#调用方法

类属性,类方法

class Student(object):
    count = 0
    def __init__(self,name):
        self.name = name
        Student.count += 1
    @classmethod
    def Show_Student_count(self):
        print('学生数量为 %d' %(self.count))
student1 = Student('小明')
Student.Show_Student_count()

静态方法:

class Cat(object):
    @staticmethod
    def call():
        print('喵')
Cat.call()

类的封装，继承，多态

封装:封装就是把统一类的东西放在一起,通过self.xxx调用

def __init__(self,name,age):
    #类里的self实质就是对象本身
    #self是对象，name是属性，self.name就是将对象和属性封装在一起
    self.name = name
    self.age = age

继承:继承具有传递性，子类拥有父类的父类的属性和方法
定义一个类，可以从现有的某个类继承
新的类称为子类、扩展类(Subclass),被继承的称为父类、基类、超类
(Baseclass、Superclass)
实例化对象默认执行构造方法，子类没有的方法会调用父类的

如果在子类，父类中存在相同名字的方法，子类只能调用自己的方法，
可以通过super(Son,self).fun()/Father.fun()去调用父类方法

1. father类拥有Grandfather的属性和方法,son类拥有 Father,Grandfather的属性和方法

class Grandfather():
	def __init__(story):
		self.story = story
	def fun1():
		print(self.story)
class Father(Grandfather):
	def __init__(self,name,age):
		self.name = name
		self.age = age 
	def fun1(self):
		print(self.name)
		print(self.age)
class Son(Father):
	def __init__(self,sex)
		self.sex = sex
	def fun1(self):
		print(self.sex)

2.C有A和B的全部属性和方法，但当A和B中有相同的方法时，谁在前就用谁的方法

class A():
    def test(self):
        print('A --- test 方法')
    def demo1(self):
        print('A --- demo1方法')

class B():
    def test(self):
        print('B --- test 方法')
    def demo(self):
        print('B --- demo方法')

class C(B,A):
    pass

多态:
对扩展开放：允许子类重写方法
对修改封闭：不修改，直接继承父类方法

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def whoAmI(self):
        return 'I am a Person, my name is %s' % self.name

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def whoAmI(self):
        return 'I am a Student, my name is %s' % self.name

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
    def whoAmI(self):
        return 'I am a Teacher, my name is %s' % self.name

在一个函数中，如果我们接收一个变量 x，则无论该 x 是 Person、Student还是 Teacher，
都可以正确打印出结果：

def who_am_i(x):
    print x.whoAmI()

p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')

who_am_i(p)
who_am_i(s)
who_am_i(t)

运行结果：

I am a Person, my name is Tim
I am a Student, my name is Bob
I am a Teacher, my name is Alic