面向对象(类，属性，str类)及其特性

面向对象
面向过程：侧重于怎么做
面向对象：侧重于谁来做
1.确定职责–要做的事情（方法）
2.对象内部封装不同方法（多个）
3.不同对象调用不同方法
类：相当于模板，所有的对象都是根据这个模板创建出来的
类只需要有一个，对象可以有多个
类：属性（信息）和方法（你能干什么）
对象：self，那一个对象调用的方法，就是对那个对象的调用
1.类名
2.属性
3.方法

1.如何定义类
2.创建对象的过程称为实例化，把抽象的对象具体化

#类 模板
class Dog()
##属性：类中变量
name = ‘tom’
age=3
def eat(self):
print(‘小狗吃了’)
def sleep(self):
print(‘小狗睡了’)
##实例化：通过类创建对象
dog1=Dog()
dog2=Dog()
dog1.eat()
dog1.sleep()
类和属性
class People():
#构造方法
def init(self):
print(‘self’,self)
p1 = People()
print(‘p1’,p1)
封装
面向对象编程的三大特性：封装性，多态性，继承性
#封装就是将同一类型的东西放在一起，通过self.xxx去调用
class People():

	def __init__(self,name,age):
			#类的self实质就是对象本身
			#self是对象，name是属性，self.name就是将对象和属性封装在一起
			self.name = name
			self.age = age
	def run(self):
			print('%s正在跑步' %(self.name))

p1=People(‘阿呆’，3)
p1.run()

p2=People(‘哥哥’，5)
p2.run()

继承
定义一个类，可以从现有的某个类继承
新的类称为子类，扩展类（Subclass）,被继承的称为父类，基类，超类(Baseclass,Superclass)

##如何实现继承

##继承的工作机制是什么
class Father():
def init(self,name,age):
#构造方法在实例化对象时自动实现
self.name = name
self.age = age

		def eat(self):
				print('%s正在吃' %(self.name))
		def sleep(self):
				print( '%s正在睡' %(self.name))
class Son(Father):
				
		def eat(self):
				Father.eat(self)
				print((self.Son).eat)
				print('%s倒立吃饭' %(self.name))
		#pass

father = Father(‘老李李’，65)
son =(‘老李’，38)
#son.eat()

##实例化对象默认执行构造方法，子类没有的方法会继承父类
##调用父类方法
son.eat()

##继承拥有传递性，子类可以继承父类的属性和方法

class Animal():
		def eat(self):
				print('eat')
		def drink(self):
				print('drink')
		def sleep():
				print('sleep')
class Cat(Animal):
		def yell(self):
			print('喵')
class Jiqimao(Cat):
		def speak(self):
				print('i can speak')
jim = Jiqimao()
jqm.speak()
jqm.sleep()

class A():
		def test(self):
				print('a --- test 方法')
		def demo(self):
					print('b---demo方法')
class B():
		def test(self):
				print('a --- test 方法')
		def demo(self):
					print('b---demo方法')
class C():
		def test(self):
				print('a --- test 方法')
		def demo(self):
					print('b---demo方法')
c= C（）
c.test()
c.demo1()

str方法

返回值必须为字符串

class People():

	def __init__(self,name)：
			self.name = name
	
	def __str__(self):
			##必须返回一个字符串
			return '我是%s' %(self.name)

p1 = People(‘老李’)
print(p1)

class jiaju():
    def __init__(self,name,area):
        self.name = name
        self.area = area
    def __str__(self):
        return  '我是%s,area is %.2f ping mi' %(self.name,self.area)

class house():
    def __init__(self,type,area):
        self.type = type
        self.area = area
        self.free_area = area
        self.item_list = []

    def __str__(self):
        return('house type: %s \n area:%.2f[shengyu: %.2f] \n jiaju:%s ') %(self.type,self.area,self.free_area,self.item_list)
    def add_item(self,item):
        if item.area > self.free_area:
            print('%s area is too big,can not input' %item.name)
            return False
        self.item_list.append(item.name)
        self.free_area -= item.area
bed = jiaju('bed',4)
chest = jiaju('chest',2)
table = jiaju('table',1.5)
myhouse = house('er shou fang',2)
myhouse.add_item(bed)
myhouse.add_item(table)
print(myhouse)

多态性

开源（对扩展开放）：允许子类方法重写
闭源（对修改封闭）：不修改，直接继承父类方法
class Student():
def get_score(self):
print(‘获取学生成绩’)
class Chinese():
def get_score(self)
print(‘获取语文成绩’)
def Math():
def get_score(self):
print(‘获取数学成绩’)
student1 =student()
student 2 =Chinese()
student3 = Math()
student1.get_score()
student2.get_score()
student3.get_score()