python-面向对象-类

1、类和对象间的关系

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例

2、类的组成

2.1、类名称：所描述事物的名称，首字母大小
2.2、类属性：所描述事物的特征
2.3、类方法：所描述事物的行为
 class Name:
	类属性
	类方法：构造方法_init_()和析构方法_del_方法

class Dog(object):
	#类属性
	name='旺财'
	color='黄色的'
	#类方法
	def bark(self,adv):
		#类的实例属性（类方法中定义的属性）
		self.adv=adv
		return f"{self.adv}汪汪叫!"
	def jump(self):
		return f"{self.adv}跳起来"

3、创建对象

实例化对象名=类名()

dog1=Dog()
dog1.bark("欢快的")
'欢快的汪汪叫!'

dog1.color+dog1.name+dog1.bark("欢快的")
'黄色旺财欢快的汪汪叫!'
dog1.jump() #因为Dog里有self.adv=adv
'欢快的跳起来'

4、类的属性与方法

4.1类的方法

在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数

4.1.1、构造方法

构造方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

class Dog(object):
	#类属性
	def __init__(self,name,color):#def __init__(self,name=‘旺财’,color=‘黄色’)默认值
		self.color=color 
		self.name=name
	#类方法
	def bark(self,adv):
		#类的实例属性（类方法中定义的属性）
		self.adv=adv
		return f"{self.color}{self.name}{self.adv}汪汪叫!"
	def jump(self):
		return f"{self.color}{self.name}{self.adv}跳起来"
	def __del__(self):
		print(f"{self.color}{self.name}对象已删除")
	def __str__(self):
		return f"这是Class Dog类别的对象：{self.color}{self.name}"
	
dog2=Dog('黄色的','旺财')
dog2.bark("欢快的")
'旺财黄色的欢快的汪汪叫!'

4.1.2、析构方法

析构函数 del ，__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行

def __del__(self):
	print(f"{self.color}{self.name}对象已删除")
del dog2

4.1.3、str方法

触发条件：
（1）、使用print语句输出对象
（2）、对类对象使用str函数

	def __str__(self):
		return f"这是Class Dog类别的对象：{self.color}{self.name}"
	print(dog2)
	这是Class Dog类别的对象：旺财黄色的
	#若没有初始化str方法，则调用print(dog2)，
	#返回的是<__main__.Dog object at 0x000000000593FE80>

4.2、类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

4.3、类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods

说明：私有属性和方法不支持直接通过对象名.属性名/对象名.方法名直接使用
在开发和调试阶段，可通过下列方式调用：对象名称._类名__私有方法(__私有属性)

class Student(object):
    def __init__(self,name,score):
        self.name=name
        self.setScore(score)
    def setScore(self,score):
        if 0<score<100:
            self.__score=score 
        else:
            print(f"{self.name}成绩有误")
    def __str__(self):
        return "姓名："+str(self.name)+"\n成绩"+str(self.__score)
    def show(self):
    	return "公有方法可通过\对象名.方法名'直接使用"
    def __pshow(self):
    	return "私有方法不可通过\对象名.方法名'直接使用"
stu=Student("小米",90)
print(stu)
姓名：小米
成绩90

stu.__score=20
print(stu)
姓名：小米
成绩90   #成绩未修改

stu.__pshow()
报错：AttributeError: 'Student' object has no attribute '__pshow'

4.4、单下划线、双下划线、头尾双下划线说明：

• foo: 定义的是特殊方法，一般是系统定义名字 ，类似 init() 之类的。

• _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

• __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

5、类的继承

• 面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。
• 通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。

类的继承特点：

1、Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到父类中逐个查找。（先在本类中查找调用的方法，找不到才去父类中找，继承多个父类，从左往右依次）。

class Student(object):
    def __init__(self,name,grade):
        self.name,self.grade=name,grade
    def show(self):
        print(f"我是学校的一名学生\n姓名：{self.name},年级：{self.grade}")
        
class Staff(object):
    def __init__(self,job_num,salary):
        self.job_num,self.salary=job_num,salary
    def show(self):
        print(f"我也是学校的一名职工\n工号：{self.job_num},薪水：{self.salary}")
        
#多继承
class JobGradeUpdate(Staff,Student):
    print("")
    
 #根据JobGradeUpdate子类继承时，Staff类在前
 p1=JobGradeUpdate("1224","23555")
 p1.show()
 我也是学校的一名职工
工号：1224,薪水：23555

2、如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法，或者不重写父类的构造方法。

class JobGradeUpdate(Staff,Student):
    def __init__(self,name,grade,job_num,salary,city):
        #父类继承的方法和实例化属性
        #重写了__init__ 时，实例化子类，就不会调用父类已经定义的 __init__
        Student.__init__(self,name,grade)
        Staff.__init__(self,job_num,salary)
        #子类新增的实例化属性
        self.city=city
    def show_all(self):
        #父类继承的方法
        Student.show(self)
        Staff.show(self)

3、在调用父类的方法时，需要加上父类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数	

class JobGradeUpdate(Staff,Student):
    def __init__(self,name,grade,job_num,salary,city):
        #父类继承的方法和实例化属性
        Student.__init__(self,name,grade)
        Staff.__init__(self,job_num,salary)
        #子类新增的实例化属性
        self.city=city
    def show_all(self):
        #父类继承的方法
        Student.show(self)
        Staff.show(self)
    
    p1=JobGradeUpdate("1224","23555","小明","二年级","北京") 
    p1.show_all() #此方法中Studen中show方法在前，优先加载Student
    我是学校的一名学生
	姓名：1224,年级：23555
	我也是学校的一名职工
	工号：小明,薪水：二年级

6、类的多态

• 定义：多态以封装和继承为前提，指父类的同一个方法在不同子类中具有不同的表现和行为
• 作用：用同一函数名实现多种不同的函数功能
• 条件：
  • 继承：多台一定发生在父类和子类之间
  • 重写：子类需要重写父类方法

class Animal(object):
    def shout(self):
        print("动物这样叫")
class Dog(Animal):
    def shout(self):
        Animal.shout(self)
        print("狗是汪汪叫")
class Cat(Animal):
    def shout(self):
        Animal.shout(self)
        print("猫是喵喵叫")
class Sheep(Animal):
    def shout(self):
        Animal.shout(self)
        print("羊是咩咩叫")
def fun(obj):
    obj.shout()
    
animal=Animal()
fun(animal)
动物这样叫

dog=Dog()
fun(dog)
动物这样叫
狗是汪汪叫

7、常用三种面向对象方法

7.1实例化方法(instancemethod)

class Student(object):
    #类属性
    name="wangmeng"
    grade="二年级"
    def __init__(self,name,grade):
        #实例化属性
        self.name,self.grade=name,grade
    def show(self):
        print(f"我是学校的一名学生\n姓名：{self.name},年级：{self.grade}")
        
stu=Student("小明","大二")
stu.show()
我是学校的一名学生
姓名：小明,年级：大二

7.2类方法（classmethod）

类中用@classmethon装饰器装饰的方法
1、类方法不同于实例方法，可以不实例化而直接调用类属性和方法
2、不同于实例方法，第一个参数不需要self参数，而是cls参数
3、类方法可以被子类继承

    @classmethod
    def show2(cls):
        print(f"我是学校的一名学生\n姓名：{cls.name},年级：{cls.grade}")
    Student.show2()
    我是学校的一名学生
	姓名：wangmeng,年级：二年级

7.3静态方法（staticmehod）

类中用@staticmethod装饰器装饰
1、逻辑上实现了类的某种功能，与类有一定关系，但不使用类的其他属性和方法
2、将静态方法加入类中主要是为了便于代码的管理和维护
3、可以直接用类名进行调用，也可以实例化后再调用
4、静态方法可以被子类继承

 @staticmethod
    def show3():
        print("静态方法")
  Student.show3()
  静态方法