【面向对象】

面向过程 算法 操作细节
面向对象：宏观把控
面向过程和面向对象不是相互对立的，是相辅相成的。
支持面向对象的编程语言：C++,C#,Java,Python,Javascript

---

面向对象：

模拟现实世界，世界所有事物都可以看成对象，是真实存在的。
例如：张三
静态特征：姓名，年龄，性别，身份证号，电话号码。
动态特征（动作，行为，功能，能力等）：上课，请假，写作业，打游戏
对象就是静态特征和动态特征的结合体。
自然而然地对事物进行归类。具有相同静态特征和动态特征的对象，统称为类
类与对象的关系：
类是抽象的，对象是具体的。
类是集合，对象是个体。
类和对象不是整体和局部的关系。
类当做一种数据类型。有类型创建出来的对象，叫实例。
面向对象的思路：
1.抽象出类
2.抽象出静态特征：属性
抽象出跟业务相关的动态特征：方法：
3.创建对象–实例化对象
对象.属性 对象名.方法()
继承–重用代码
父类/基类/超类 （公共的属性和方法） 子类/派生类（特定的属性和方法）
子类 is a 父类 —表达的是类的本质
子类拥有和父类同样的方法，叫重写override
青出于蓝而胜于蓝
重载 overload 方法名相同，参数列表不同
python没有重载
继承 多继承-1个子类可以有多个父类
当多继承时，多个父类都有同样的方法，会按照继承列表依次查询（广度优先）
如果显式地写出继承谁，此类就是谁的子类，
如果没有写出继承谁，此类默认会去继承object
所有的类都是object的子类
传递性
多态–多种形态
在继承的基础上，重写，父类的引用指向子类的对象，----多态
python动态语言，不在乎数据类型，在乎有没有这样的行为，所以不一定要继承，不一定要重写，只要有方法就行.
浅拷贝–对象空间中的数据，不管是可变对象还是不可变对象都把其地址拷贝，或对其属性不新开空间
影响：拷贝后的对象，如果修改可变对象的属性，会影响回原对象；如果修改不可变对象，不会影响原对象

class Student:
	def __init__(self,name,age):
		self.name=name#实例属性
		self.age=age
	#实例方法
	def show(self):
		print(self.name+'\t'+str(self.age))
#实例化对象 对象名=类名(name,age)
stu=Student('张三',21)
print(stu.name)
stu.show()

面向对象练习

# 1、定义一个矩形类，求周长和面积
class JX:
    def __init__(self,l,w):
        self.l=l
        self.w=w
    def show(self):
        s=self.l*self.w
        p = (self.l + self.w) * 2
        print(s)
        print(p)
J=JX(10,29)
J.show()
# 2、自定义类，计算java，sql，web三门课的总成绩和平均分
class course:
    def __init__(self,java,sql,web):
        self.java=java
        self.sql=sql
        self.web=web
    def sum(self):
        return self.java+self.sql+self.web
    def avg(self):
        return (self.java+self.sql+self.web)/3
c1=course(80,85,90)
print(c1.sum(),c1.avg())
# 3、创建一个学生类，存储学生的姓名，python、c、java成绩，
# 然后定义一个列表存储5个学生，依次输入学生信息，
# 输出所有所有学生的信息，成绩以等级显示（90以上为A;80-90为B,60-80为C；60以下为D）
class student:
    def __init__(self,sname,python成绩,c成绩,java成绩):
        self.sname=sname
        self.python成绩=python成绩
        self.c成绩=c成绩
        self.java成绩=java成绩
    def print(self):
        if self.python成绩>90:
            self.python成绩="A"
        elif 90>=self.python成绩>80:
            self.python成绩="B"
        elif 80>=self.python成绩>60:
            self.python成绩="C"
        else:
            self.python成绩='D'
        if self.java成绩 > 90:
            self.java成绩 = "A"
        elif 90 >= self.java成绩 > 80:
            self.java成绩 = "B"
        elif 80 >= self.java成绩 > 60:
            self.java成绩 = "C"
        else:
            self.java成绩 = 'D'
        if self.c成绩 > 90:
            self.c成绩 = "A"
        elif 90 >= self.c成绩 > 80:
            self.c成绩= "B"
        elif 80 >= self.c成绩> 60:
            self.c成绩= "C"
        else:
            self.c成绩 = 'D'
        print(self.sname,self.python成绩,self.c成绩,self.java成绩)
stu1=student('张三',78,95,88)
stu2=student('李四',70,65,86)
stu3=student('王五',88,56,70)
stu4=student('赵六',84,84,76)
stu5=student('刘七',88,98,87)
lst=[stu1,stu2,stu3,stu4,stu5]
for i in lst:
    i.print()
4、继承练习
银行卡： 卡号、密码、姓名、余额
方法：取款
本行卡：
方法：取款、转账
其它行卡：
方法：取款（加收2元手续费）
实例化对象进行测试
class card:
    def __init__(self,no,psw,name,money):
        self.no=no
        self.psw=psw
        self.name=name
        self.money=money
    def withdraw(self,money):
        print(money)
        print('取款成功')
class bcard(card):
    def __init__(self,no,psw,name,money):
        super().__init__(no,psw,name,money)
    def withdraw(self,money):
        super().withdraw(money)
    def transfer(self):
        print('转账成功')
class qcard(card):
    def __init__(self, no, psw, name, money):
        super().__init__(no, psw, name, money)
    def withdraw(self,money):
        print('加收2元手续费用')
        super().withdraw(money)
b=bcard(2120,2589,'张三',1000)
b.withdraw(250)
b.transfer()
q=qcard(2521,2255,'张三',1000)
q.withdraw(200)
card1=card(2120,2584,'李四',1000)
card1.withdraw(20)
5、多态练习
主人Master:请好友吃饭，陪好友玩
好友Friend:
中国朋友：吃饺子，表演太极拳
美国朋友：吃披萨，踢足球
class Friend:
    def eat(self):
        pass
class Chinese(Friend):
    def eat(self):
        print('吃饺子')
    def play(self):
        print("打太极")
class American(Friend):
    def eat(self):
        print('吃披萨')
    def play(self):
        print("踢足球")
class Master:
    def Treat(self,f):
        f.eat()
        f.play()
P1=Chinese()
P2=American()
M1=Master()
M1.Treat(P1)
M1.Treat(P2)