目录
①__XX__()函数叫做魔法方法，指的是具有特殊功能的函数
③__str__() --------- 类似Java语言中的toString()方法
一，封装
1，类和对象
Java和python都是面向对象的语言
①创建类，语法
class 类名:
代码
②实例化对象
对象名 = 类名( )
③调用类属性和方法语法
对象名.属性；
对象名.方法()
一个函数定义在类里面叫方法
2，self
self指的是调用该函数的对象
函数中默认参数self，该默认的参数self指的是调用该函数的对象
案例1：self和对象的内存地址是否一致？
案例2：如果是多个对象，调用同一个函数，self地址是否一致？
3，属性
①类属性
a，可以通过类名或者对象访问，写在类里面
语法： 变量名 = 变量值
b，修改类属性
类属性的修改，只能通过类修改，不能通过对象修改
语法：类名.变量名=变量值
注意：如果通过对象对属性进行重新赋值，实际上是给该对象又重新定义了一个属性名一样的变量
②添加对象属性
a，类外面添加对象属性
语法： 对象名.属性名 = 值 （注意：该种方式添加的属性，只能属于该对象的）
b，类里面添加对象属性
语法： 变量名 = 变量值 （注意：该种方式添加的属性，属于所有类对象的）
c，__init__()方法中添加对象属性
语法：self.属性名 = 值 （用在__init__()初始化方法中）
③获取对象属性
a，类外面获取对象属性，语法：对象名.属性名
b，类里面获取对象属性，语法：self.属性名 （用在函数中）
④私有属性和私有方法
a，设置私有属性和方法
在属性名和方法名前面加两个下划线__
定义为私有属性和私有方法，不能被子类继承
b，获取和修改私有属性的值
获取，定义getXXX()
修改，定义setXX()
4，方法
①类方法
用装饰器@classmethod标识
②静态方法
用装饰器@staticmethod标识
5，魔法方法
①__XX__()函数叫做魔法方法，指的是具有特殊功能的函数
②__init__()
a，__init__()：初始化对象
在创建一个对象时默认被调用，不需要手动调用
b，带参数的__init__()方法
③__str__() --------- 类似Java语言中的toString()方法
a，print输出对象时，默认打印的是对象在内存中的地址
b，如果类中定义__str__方法，则会打印__str__方法中的内容
二，继承
1，单继承
父类，class 父类(object):
子类，class 子类(父类):
2，多继承
子类，class 子类(父类1，父类2)
注意，如果一个类继承多个父类，优先继承父类1的同名属性和方法
3，查看一个类的继承关系
类.__mro__
4，子类重写父类的同名属性和方法
注意，如果子类重写了父类的同名属性和方法，则会调用子类中的同名属性和方法
5，子类调用父类的同名属性和方法
在子类的同名方法中调用语法，父类类名.方法(self)
super()，调用父类方法，super().方法()
（适用于 单继承）
三，多态
1，概念
多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行效果
2，步骤
a，定义父类，提供父类方法
b，定义子类，重写父类方法
c，传递子类对象给调用者，返回不同的结果
四，完整代码如下
# 面向对象的语言
#定义类
# Java class Person{ }
# python 首字母需要大写
class Student:
name='小宝'
sex:str
age=20
def say(self):
# self这个参数是当前这个对象，不需要自己传参
# 可以通过self去取得自身携带的一些东西，如属性
print("hello",self)
# 实例化
# java new Student()
# python
s=Student()
s2=Student()
#打印s 肯定是内存地址
# print(s)
# s.say()
# name 实例属性
s.name="张三"#添加了一个实例属性name 值是张三
Student.name="haha"#修改了类属性
# s有几个name属性？ 【name类属性】【name实例属性】
del s.name #删除了name实例属性
# s.birth='2021-1-1'#不会报错，python是弱类型，对变量没有类型限制，对对象没有属性限制
print(s.name)
print(s2.name)
class Student:
# 1.私有化属性
__name:str
__age:int
# 构造函数
# def __int__(self):
# pass
# 构造函数
def __init__(self,name:str="",age:int=0):#这里的str与int只是需要的类型，给其他类型也不会报错
self.__name=name
self.__age=age
#2,提供get/set
def get_name(self):
return self.__name
def set_name(self,name:str):
return self.__name
def __str__(self):
return f"名字{self.__name},年龄{self.__age}"
# def __set_name__(self, owner, name):
@staticmethod
def say():
print("hello")
@classmethod
def test(cls):
cls.__name='xxx'
Student.test()
s1=Student("小宝",20)
s2=Student()
s3=Student(name="小黑")
s4=Student(age=21)
# print(s.get_name())
print(s1)
print(s2)
print(s3)
print(s4)
Student.say()
import random
# java类都直接或者间接继承object
# python类都直接或者间接继承object
# 如果属性或方法已经冲突，拿前面的
class Parent(object):
name='张三 '
def cook(self):
print("正在煮饭[辣椒炒肉]")
class Mother(object):
def cook(self):
print("正在煮饭[红烧肉]")
# class Son(Mother,Parent):
# pass
# class Son(Parent,Mother):
# pass
class Son(Mother,Parent):
def cook_test(self):
super(Son,self).cook()
print("正在煮饭[茄子豆角]")
# s=Son()
# # print(Parent.mro())
# # print(Son.mro())
# s.cook()
# s.cook_test()
# print(Son.mro())
# print(Son.__mro__)
#
# random.randint()
class Cs():
def cook(self):
pass
class Parent(Cs):
def cook(self):
print("正在煮饭[辣椒炒肉]")
class Mother(Cs):
def cook(self):
print("正在煮饭[红烧肉]")
class Son(Mother,Parent):
def cook_test(self):
super(Son,self).cook()
print("正在煮饭[茄子豆角]")
# # 需要一个厨师
# def mai_fan(chushi:Cs):
# # 断言----会抛出异常
# assert isinstance(chushi,Cs)
# chushi.cook()
# 需要一个厨师
def mai_fan(chushi:Cs):
# 断言----会抛出异常
if isinstance(chushi,Cs) == True:
chushi.cook()
else:
print("你当前不是厨师")
c1=Parent()
c2=Mother()
c3=Son()
mai_fan(c1)
mai_fan(c2)
mai_fan(c3)
