菜菜学习第七天--面向对象

一、什么是面向对象

面向对象就是模拟人认知整个世界的行为，进行分类处理的过程

面向对象的编程：
|-- 定义类
	|-- 抽出类的静态特征：特别多
	|-- 动态行为动作

二、类和对象

类：对一类相同或者相似事物的总称
	两大成员：    属性      方法
	|--静态的特征：颜色、体重、肤色、皮毛、年龄
	|-- 动态的行为：函数
对象：指的就是一个类中的具体案例，实例

类是模板，对象就是模板拓出来一个真实的案例

三、python如何定义类 如何创建对象（重点）

定义类：
	class 类名称(object):
		def __init__(self):
			self.属性名称 = 属性值
		#一般使用一个函数来描述类的一个动态行为
		def speak(self):
				#行为动作！！
如何构建对象：
	对象名称 = 类名称() 	#初始化对象，构建对象

"""
在python中，定义类使用关键字是class
python中类名称定义规则和其他编程语言一致，遵循的是大驼峰
"""
#class User:
#这两种写法在python3中一致，上面的写法其实就是下面的写法
#也就是python默认定义的任何类都是object类的子类
#class User:   #class User(object):
class User(object):


	#重写方法 __init__
	#self参数干什么用的，能不能去掉？
	#self 这个参数必须存在，名字任意
	def __init__(self):
		#init 初始化函数中，定义类的静态特征
		self.username = "小小"
		self.age = 16
		self.gender = "女"
		
#构建对象
u = User()
print(u.username)
#调用属性，修改对象的属性值
u.username = "豆豆"
print(u.username)

#对象的属性，应该是在对象创建的时候，初始化出来
class Dog(object):

	def __init__(self， name, color, age):
		#self.xxx  指的是类的静态属性
		self.name = name
		self.color = color
		self.age = age
#创建对象
dog1 = Dog("大豆"，“黄色”， 3)
print(dog1.name)
print(dog1.color)
print(dog1.age)


class Cat(object)：
	
	
	def __init__(self, name, gender, color):
		self.name = name
		self.gender = gender
		self.color = color
	
	#猫不仅仅有静态属性，还有动作
	def speak(self):
		#在类的方法中，可以直接访问到类的任何属性和方法
		print("喵喵喵")
		print("喵，我叫{}".format(self.name))
	
	def eat(self,food):
		print("本喵正在吃饭")
		print("食物是--{}".format(food))
	
	#也可以有返回值
	def add(self, x, y):
		return x+y
	
	def __str__(self):
	"""快速在控制台上查看对象的属性"""
	"""这个是一个默认的魔法方法"""
		return "【"+self.name +", age="+ str(self.age) +", gender="+ self.gender +"】"

mimi = Cat("大豆"，"母","黄色")

调用猫的speak方法
mimi.speak()
mimi.eat("精品喵粮")
#有返回值，需要接   res
res = mimi.add(10,20)
print(res)

mimi.gender = "公"
mimi.name = "达达"

使用面向对象求圆的面积和周长：

import math


class Circle(object):
	
	
	def __init__(self, r):
		self.r = r
	
	def get_area(self):
		return math.pi*self.r*self.r

	def get_cal(self):
		return math.pi*self.r*2

if  __name__ == '__main__':
	#main函数  做测试的，这里面的代码不会导入到其他模块中
	r = int(input("请输入圆的半径"))
	#创建一个圆，将半径传过来
	c1 = Circle(r)
	area = c1.get_area()
	cal = c1.get_cal()
	print("半径为{}的圆的周长是{},面积是{}".format(r, cal, area))

求三角形的面积和周长：

import math

#创建三角形类   三边
class Triangle(object):

	def __init__(self, x, y, z):
		self.x = x
		self.y = y
		self.z = z

	#求周长
	def get_cal(self):
		return self.x + self.y + self.z
	
	#求面积
	def get_area(self):
		#先求出三角形的周长
		p = self.get_cal() / 2
		return math.sqrt(p*(p - self.x)*(p - self.y)*(p - self.z))
		
if __name__ == '__main__':
	a = float(input("请输入三角形的第一个边长：")
	b = float(input("请输入三角形的第二个边长：")
	c = float(input("请输入三角形的第三个边长：")
	
	#判断边是否合法
	# 1、三边必须大于0         2、两边和大于第三边

	t = Triangle(a,b,c)
	print("三角形的周长是{},面积是{}".format(t.get_cal,t.get_area))
	

学员管理：

class Student(object):
	
	def __init__(self,math,chinese,english):
		self.math = math
		self.chinese = chinese
		self.english = english
		
	
	def if_score(self,score):
		
		if score >= 90 and score <= 100:
			return "A"
		elif score >= 80 and score < 90:
			return "B"
		elif score >= 70 and score < 80:
   			return "C"
   		elif score >= 60 and score < 70:
   			return "D"
   		elif score < 60 and score >= 0:
   			return "E"
   		else:
   			return "ERROR"

students = []
for i in range(1,11):
	math = float(input("请输入第%s个学生的数学成绩" %i))
	c = float(input("请输入第%s个学生的语文成绩" %i))
	eng = float(input("请输入第%s个学生的英语成绩" %i))
	#构建对象
	stu = Student（math, c, e)
	msg = stu.if_score(stu.math)
   		

四、面向对象三大特征
面向对象的编程都具有三大特征：
1、封装
2、继承
3、多态

封装：
	1、类将属性和方法封装成了一个整体
	2、面向对象中的封装，指的是：
		将属性私有化，提供公开方法去访问和赋值的这种
		getter setter
封装学完之后：
	以后定义类
		属性必须私有化  __属性名称
		一定要提供对应的setter和getter
	那么外界就只能通过get和set来访问和设置类的属性了
	3、Python的几种封装的写法
		1）直接私有化属性，提供getter和setter
		2）直接私有化属性，提供getter和setter，引入了property的全局函数
		3）使用property装饰器完成封装

#封装
class User:
	
	def __init__(self,name,age):
		#在python中，使用 【__属性名称】 来私有化属性
		#一旦属性被私有化了，外界就无法访问了
		#即封装
		self.__name = name
		self.__age = age
	
	#类的公开方法
	def get_name(self):
		return self.__name
	
	def set_name(self, name):
		self.__name = name

	def get_age(self):
		return self.__age

	def set_age(self,age):
		self.__age = age
	
	def __str__(self):
		return self.__name + str(self.__age)
		
	"""	
	第二种
	#在定义的类里面使用property全局函数，将封装后的属性进一步的操作
	#给外界造成一个错觉：没有封装
	#一定是先get，再set，是引用传递，不是调用
	name = property(get_name, set_name)
	"""	
	
if __name__ == '__main__':
	u1 = User("张三"，18)
	#print(u1)
	print(u1.__name)
	#当属性私有化后，直接在外界访问或者赋值都无法成功
	#u1.__name = "豆豆"
	#print(u1.__name)
	
	#通过类提供的公开的方法来访问和赋值
	print(u1.get_name())
	u1.set_name("豆豆")
	print(u1)
	
	"""
	#注意：以下的内容都是私有化，两种不同的写法
	u1.name = "喵喵"
	print(u1.name)
	"""	

class Admin(object):
	
	def __init__(self, username, nickname, ty):
		#封装属性，私有化属性
		self.__usernae = username
		self.__nickname = nickname
		self.__ty = ty
	
	def get_username(self):
		return self.__username
	
	def set_username(self, username):
		self.__username = username

	def get_nickname(self):
		return self.__nickname

	def set_nickname(self, nickname):
		self.__nickname = nickname

	name = property(get_nickname, set_nickname)
	
	#注解 annotation 装饰器
	@property
	def ty(self):
		return self__ty
	
	@type.setter
	def ty(self, type):
		self.__ty = ty

if __name__ == '__main__':
	#实例化Admin的对象
	admin = Admin("admin","超级管理员"，1)
	
	print(admin.get_username())
	#修改username
	admin.set_username("小豆")
	print(admin.get_username())

	print("*"*20)
	print(admin.get_nickname())
	print(admin.nickname)
	admin.nickname = "永久管理员"
	print(-admin.nickname)
	
	print("---封装的第三种写法，使用@property装饰器，完成封装---"
	print(admin.ty)
	admin.ty = 123
	print(admin.ty)

继承：
模拟人认知整个世界的这种方式
继承  子代继承父代的财富或知识......

面向对象是在模拟人类的实现，所以也有继承关系

类与类之间的继承关系

当一个类，继承其他类（父类、超类），那么他就拥有了继承父类一些方法和属性
	公开的方法和属性可以继承
	私有的方法和属性不能被继承

如果我们继承了父类的方法和属性，如果这些方法和属性满足我们使用，直接调用即可；
但是，如果某个方法或者属性不满足我们的需求
	|-- 重写（覆盖）代码   override

函数的重载（overload）
	函数名称相同，函数参数个数参数类型不同
	当我们调用的时候，会自动的执行对应的函数现象----函数的重载
	
1、python是没有函数重载的

class RichMan(object):

	def __init__(self，money,company,assistant):
		self.money = money
		self.company = company
		self.__assistant = assistant
		
	def say(self):
		print("我是富豪，我很有钱")

class Animal(object):
		
	def tell(self):
		print("我是一个动物")


#表示Son类继承RichMan这个类
#富人类中的所有公开的方法和属性都被Son继承
#python是支持多继承的！！！
class Son(RichMan， Animal):

	def __init__(self, name):
		super().__init__(1000, "百度", "小王")			
		self.__name = name
	
	def get_name(self):
		return self._name

	def set_name(self, name):
		self.__name = name
			
	#当儿子感觉say已经不满足自己使用了
	def say(self):
		#覆盖、重写
		prin("我不喜欢钱，对钱不感兴趣")
	
	
if __name__ == '__main__':
	r = RichMan()
	print(r.company)
	print(r.money)

	s = Son()
	print(s.money)
	print(s.company)
	s.say()

	s = Son("Tom")
	print(s.get_name())
	s.get

关键字  super关键字
	面向对象中，如果我们想在子类中调用方法或者属性
	必须使用super关键字
1、一旦面向对象中存在继承
	我们如果直接创建子类，初始化顺序
	首先调用父类的初始化函数 ---》之后再调用自己的
2、在子类中调用父类的属性和方法
	使用super关键字完成
注意：正常而言，一般父类中很少需要初始化属性


多态：
	在继承的基础上，父类引用指向子类实例（对象）的现象，叫做多态。
	父类可以调用子类方法！！！

	在python这些弱类型语言，天生支持多态