# 1.编写类:
# class OBJ: #定义类名
# def __init__(self,name): #构造法法 实例化对象时可以向其中传参
# self.name = name
# def func(self): #定义类中的方法,第一个参数self表示实例化对象后的对象
# pass
# obj = OBJ("obj1") #实例化类OBJ的对象obj,传入name参数obj1
# print(obj.name) #查看对象obj的name数据
# obj.func() #用obj调用在定义OBJ类时候定义好的方法func
# 2.
# 面向对象的三大特征:封装,继承,多态
# 封装:1.将类中的方法封装起来方便其他地方调用
# 2.以对象的形式对数据进行封装,打包起来方便其他地方调用
# 继承: 派生类可以调用基类中的方法,数据等
# 可以多重继承(方法,数据现在对象本身的类中进行寻找,若没找到,从左到右依次从基类中进行查找,使用找到的第一个)
# 多态: 可以向参数中传递多种数据类型,Python本身自带多态
# 3.
# class A:
# def func(self,a1):
# print(a1)
# a = A()
# a.func(a1=2)
# 4.
# 在类中的函数被称为方法,方法中第一个参数为实例化后对象本身(self),除此之外没有其他区别.
# 5.
# 在实例化一个类的对象是自动被执行的一种方法__init__(self),可以实现用对象将数据进行封装.实例化对象时需要给出构造房中所需要的参数.也成初始化.
# 6.
# 定义类时其中的self参数为实例化对象后的对象本身
# 7.
# class Person:
# def __init__(self,name,age,gender):
# self.name = name
# self.age = age
# self.gender = gender
# obj = Person("徐建",20,"男")
# 以上代码体现了面向对象的三大特征之一:封装
# 8.
# class Message:
# def email(self):pass
# def msg(self):pass
# def wechat(self):pass
# 以上代码体现了面向对象的三大特征之一:多态
# 9.
# class Foo:
# def func(self):
# print('foo.func')
# obj = Foo()
# result = obj.func()
# print(result) # 此行输出None,函数没有return 所以默认返回值为None
# 10. 求圆的周长,面积:
# class Circle:
# def __init__(self,R):
# self.R = R
# def Area(self):
# return 3.14*self.R**2 #求圆的面积 πR**2
# def Per(self):
# return 3.14*self.R*2 #求圆的周长 2πR
# Q = Circle(9)
# print(Q.Area())
# print(Q.Per())
# 11. 面向对象中为什么要有继承?
# 避免重写代码,提高代码的重用性
# 12. Python多继承时,查找成员的顺序遵循什么规则?
# 先从对象本身的类中进行寻找,若没找到,从左到右一次对继承的基类中进行寻找,使用找到的第一个
# 13.
# class Base1:
# def f1(self):
# print('base1.1')
# def f2(self):
# print('base1.f2')
# def f3(self):
# print('base2.f3')
# self.f1()
# class Base2:
# def f1(self):
# print('base2.f1')
# class Foo(Base1,Base2):
# def f0(self):
# print('foo.f0')
# self.f3()
# obj = Foo()
# obj.f0()
# """
# 以上代码执行结果如下:
# foo.f0
# base2.f3
# base.1
# """
# 14.
# class Base:
# def f1(self):
# print('base.f1')
# def f3(self):
# self.f1()
# print('base.f3')
# class Foo(Base):
# def f1(self):
# print('foo.f1')
# def f2(self):
# print('foo.f2')
# self.f3()
# obj2 = Base()
# obj2.f2()
# 以上代码没有执行结果,obj2 为Base类的实例化对象,并没有f2方法.
# 1.面线对象的三大特征:
# 封装: 将类中的方法进行打包,封装.方便在其他地方调用
# 以对象的形式将数据进行打包封装,以方便在其他店方获取使用对象的数据.
# class Foo:
# def __init__(self,name,age):
# self.name = name
# self.age = age
# def sleep(self):
# print("睡觉")
# obj = Foo("徐建","20") #实例化对象,将姓名和年龄封装到对象中.
# print(obj.name) #徐建
# obj.sleep() #睡觉 对象obj可以调用类中定义好的方法sleep
# 继承: 当要创建多个类,并且多个类中有相同的方法时,可以使用类的继承,派生类可以集成调用基类中的方法.
# 多继承：调用方法时现在对象本身的类中进行寻找，如没有找到，则从做到右依次在继承的基类中进行寻找，使用找到的第一个方法，数据.
# class Foo:
# def __init__(self,name,job):
# self.name = name
# self.job = job
# def play(self):
# print("play~!")
# class Man(Foo):
# def play(self):
# print("play the game!")
# class Women(Foo):
# def spend(self):
# print("are you demon?")
# A = Man('AA','IT')
# B = Women('BB','Teacher')
# print(A.name) #AA Man类的对象A 继承了基类Foo中的构造方法.
# A.play() #play the game! Man类的对象A 调用paly方法时没有使用基类中的play方法.使用自己本身定义的play方法.
# print(B.job) #Teacher Women类的对象B 继承了基类Foo中的构造方法.
# B.play() #play~! Women类的对象B 调用play方法时本身中没有play方法.去基类中寻找.使用基类中的play方法.
# B.spend() #are you demon? ^^
# 多态: 无论传入的是什么参数,只要是Foo类即可调用func方法.
# class Foo:
# def func(self,XX):
# print("xx")
# A = Foo()
# A.func("BBB")
# 2.面向对象变量分几种?
# - 字段(实例变量):访问时使用对象访问字段
# class Foo:
# def __init__(self,name,age,weight):
# self.name = name
# self.age = age
# self.__weight = weight
# @property
# def CHweight(self):
# return int(self.__weight.upper().strip('KG'))*2 #在内部可以访问私有字段weight.
# A = Foo('AA','18','60kg')
# print(A.name,A.age) # AA 18 使用对象访问字段
# print(A.CHweight) # 120
# print(A.__weight) # 报错. 私有字段,在外部无法进行访问.
# - 静态字段(静态变量):访问时使用类访问静态字段
# class Person(object):
# eyes = 2
# mouth = 1
# __edu = 12
# def __init__(self,name,age):
# self.name = name
# self.age = age
# A = Person('AA','18')
# A.eyes = 3 # 可以通过赋值修改对象对应的类的静态字段,但不影响类本身,类本身的静态字段不会发生改变.
# # A.__edu # 报错.私有静态字段无法再外部进行访问.
# print(A.eyes)
# print(Person.eyes) # 2 使用类访问静态字段
# 3.面向对象中方法有哪几种?
# - 实例方法:通过实例对象.由对象进行调用.
# class Foo:
# def func(self):
# print("实例方法~")
# A = Foo()
# A.func() #实例方法~
# - 静态方法:编写时在方法上方加上装饰器@staticmethod,参数可有可无,调用时类和对象都可以进行调用(对象.方法、类.方法)
# class Foo:
# @staticmethod
# def func(XXX):
# print(XXX)
# @staticmethod
# def func1():
# print('hah')
# A = Foo()
# Foo.func1() #hah 通过类直接调用func1方法.
# A.func1() #hah 通过对象调用func1方法.
# A.func('func') #func 静态方法参数可有可无.
# - 类方法:编写时在方法上方加上装饰器@classmethod,第一个参数cls默认传入类,调用时用类进行调用,默认传入当前类.
# list = []
# class Foo:
# @classmethod
# def func(cls):
# for i in range(2):
# i = cls
# list.append(i)
# class Foo2(Foo):
# def fun(self):
# pass
# Foo.func()
# Foo2.func()# 使用类调用方法.默认想第一个参数cls传入调用此方法的类
# print(list)# [<class '__main__.Foo'>, <class '__main__.Foo'>, <class '__main__.Foo2'>, <class '__main__.Foo2'>]
# 4.面向对象中的属性有什么? 通过方法改造出来的,在方法上加上@property使对象无需调用方法(不用加括号)即可拿到方法的返回值.伪装的像一个字段.(也有私有和公有之分)
# class Foo(object):
# def __init__(self):
# pass
# @property
# def func(self):
# return 1
# A = Foo()
# print(A.func)
# 5.简述静态方法和类方法的区别:静态方法可以用对象调用也可以用类调用,而且参数可有可无.类方法只能用类进行调用,而且至少一个参数cls(传入调用方法的类)
# 6.面向对象的方法中那个无需传参数:静态方法参数可有可无
# 7.面向对象中的公有和私有成员编写和调用时的区别: 编写时:私有成员名称前需加'__',调用时:类的外部无法调用私有成员,只能内部调用,公有成员何处都可以调用.