python中的面向对象

1.面向对象基本知识

面向过程：怎么做
面向对象：谁来做
1.确定职责 – 要做的事(方法)
2.对象内部封装不同方法(多个)
3.不同对象调用不同方法
类 对象
类：模板，对象都是根据这个模板创建出来的
类只需要有一个，对象可以有多个

类：属性(信息)和方法(你能干什么)
1.类名
2.属性
3.方法

举例：
1.

class Cat():
    def eat(self):
        print('%s爱吃鱼' %self.name)
    def drink(self):
        print('小猫要喝水')

tom = Cat()
tom.name = 'Tom'
tom.drink()
tom1 = Cat()
# print(tom1)
tom1.drink()
print(id(tom))
print(id(tom1))

2.

#1.如何定义类  class 类名(): pass
#2.类创建对象的过程称为实例化，把抽象的类具体化
# 对象名 = 类名(参数1、参数2...参数n)

#类：模板
class People():
    #属性：类中的变量
    name = '老李'
    age = 38

    #方法：类中的函数
    def eat(self):
        print('吃...')

    def sleep(self):
        print('正在睡...')

#实例化：通过类创建对象
p1 = People()
p2 = People()
# print(id(p1))
# print(id(p2))

print(p1.name)
print(p2.name)

p1.eat()
p2.eat()

2.类与对象

#对象：对象是现实世界或者思维世界中的实体在计算机中的反映
#它将数据以及这些数据上的操作封装在一起
#类：一类事物的统称，对象是类具体化的产物，也就是示例化
#不同的对象有什么不同的特点：比如年龄，性别

class Student():
    name=''
    age=0

    def do_homework(self):
        print('homework')

student1=Student()
student1.do_homework()
student2=Student()
student2.do_homework()
student3=Student()
student3.do_homework()
print(id(student1))
print(id(student2))
print(id(student3))

3.面向对象三特征之封装

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('老李',38)
p1.run()

p2 = People('老吴',36)
p2.run()

#封装就是把同一类型的东西放在一起，通过self.xxx去调用

4.面向对象三特征之继承

定义一个类，可以从现有的某个类继承
新的类称为子类、扩展类(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)
        super(Son,self).eat()
        print('%s倒立吃饭...' %(self.name))

father = Father('老老李',65)
son = Son('老李',38)

# son.eat()

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

class Animal():
    def eat(self):
        print('吃')

    def drink(self):
        print('喝')

    def sleep(self):
        print('睡')

class Cat(Animal):
    def yell(self):
        print('喵')

class Jiqimao(Cat):
    def speak(self):
        print('我会说话')


jqm = Jiqimao()
jqm.speak()
jqm.sleep()

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

class A():
    def test(self):
        print('A --- test 方法')
    def demo1(self):
        print('A --- demo1方法')

class B():
    def test(self):
        print('B --- test 方法')
    def demo(self):
        print('B --- demo方法')

class C(B,A):
    pass

c = C()
c.test()
c.demo1()

5.面向对象三特着之多态性

class Student():
    def get_score(self):
        print('获取学生成绩...')

class Chinese():
    def get_score(self):
        print('获取语文成绩...')

class Math():
    def get_score(self):
        print('获取数学成绩...')

student1 = Student()
student2 = Chinese()
student3 = Math()
student1.get_score()
student2.get_score()
student3.get_score()

对扩展开放：允许子类重写方法
对修改封闭：不修改，直接继承父类方法

6.面向对象方法

1.str方法

class People():

    def __init__(self,name):
        self.name = name

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

p1 = People('老李')
print(p1)

需求
1.小明体重75.0公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西体重会增加1公斤

需求
1.小明和小美都爱跑步
2.小美体重45.0公斤
3.小明体重75.0公斤
4.每次跑步都会减少0.5公斤
5.每次吃东西都会增加1公斤

class People():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight

    def __str__(self):
        return '我的名字叫%s，体重是%.2f' %(self.name,self.weight)

    def run(self):
        print('%s爱跑步' %(self.name))
        self.weight -= 0.5

    def eat(self):
        print('%s吃东西' %(self.name))
        self.weight += 1

xiaoming = People('小明',75)
xiaoming.run()
print(xiaoming)
xiaomei = People('小美',45)
xiaomei.eat()
print(xiaomei)

2.类属性方法

类属性：使用赋值语句在class关键字下定义
类方法：在类内部可以直接访问类属性或者其他类方法

class Student(object):
    count = 0

    def __init__(self,name):
        self.name = name
        Student.count += 1

    @classmethod
    def Show_Student_count(awda):
        print('学生数量为 %d' %(awda.count))

student1 = Student('小明')
Student.Show_Student_count()

3.静态方法

class Cat(object):

    @staticmethod
    def call():
        print('喵')

Cat.call()

4.私有属性和方法

class Women():

    def __init__(self,name):
        self.name = name
        self.__age = 18

    def __secret(self):
        print('%s的年龄是%d' %(self.name,self.__age))

lily = Women('lily')
# print(lily.name)
# print(lily.__age)
lily.__secret()           ##外部无法调用

class Student(object):

    def __init__(self,name,score):
        self.__name = name
        self.__socre = score

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__socre

    def set_score(self,score):
        self.__socre = score

tom = Student('Tom',89)
tom.set_score(90)
print(tom.get_score())
print(tom.get_name())

7.面向对象练习

1.士兵打枪
要求：
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量

分析：

Soldier                     Gun
-------------               -----------------
name                        model
gun                         bullet_count #子弹数量足够多才能完
成射击的动作
-------------               -----------------
__init__(self):                 __init__(self):
fire(self):                 (self,count):#装填子弹的
                            方法
                            shoot(self):

代码：

class Gun():

    def __init__(self,model):
        self.model = model
        self.bullet_count = 0

    def add_bullet(self,count):
        self.bullet_count += count

    def shoot(self):
        if self.bullet_count <= 0:
            print('%s没有子弹了...' %self.model)
        else:
            self.bullet_count -= 1
            print('%s...%s' %(self.model,self.bullet_count))

class Soldier():

    def __init__(self,name):
        self.name = name
        self.gun = None

    def fire(self):
        if self.gun == None:
            print('%s还没枪...' %self.name)

        self.gun.add_bullet(5)
        self.gun.shoot()

ak47 = Gun('AK47')
ak47.add_bullet(20)
ak47.shoot()

ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()

2.图书管理系统

要求：
图书管理系统
1.查询图书
2.增加图书
3.借阅图书
4.归还图书
5.退出系统
#书：书名、作者、状态、位置

C	谭浩强	未借出	ISO9001
python	guido	未借出	NFS8102
java	westos	未借出	PKI7844

class Book(object):

    def __init__(self,name,author,status,bookindex):
        self.name = name
        self.author = author
        self.status = status
        self.bookindex = bookindex

    def __str__(self):
        if self.status == 1:
            stats = '未借出'
        elif self.status == 0:
            stats = '已借出'
        else:
            stats = '未知状态'
        return '书名:《%s》 作者: %s 状态: <%s> 位置: %s' \
        %(self.name,self.author,stats,self.bookindex)

class BooKManager(object):
    books = []

    def Start(self):
        self.books.append(Book('c','谭浩强',1,'ISO9001'))
        self.books.append(Book('python','guido',1,'NFS8102'))
        self.books.append(Book('java','westos',1,'PKI7844'))

    def Menu(self):
        self.Start()
        while True:
            print("""
                    图书管理系统
        1.查询图书
        2.增加图书
        3.借阅图书
        4.归还图书
        5.退出系统
            """)

            choice = input('输入您的选择: ')
            if choice == '1':
                self.ShowAllBook()
            elif choice == '2':
                self.AddBook()
            elif choice == '3':
                self.BorrowBook()
            elif choice == '4':
                self.ReturnBook()
            elif choice == '5':
                print('欢迎下次使用...')
                exit()
            else:
                print('请输入正确选择！')
                continue

    def CheckBook(self,name):
        for book in self.books:
            if book.name == name:
                return book
        else:
            return None

    def ShowAllBook(self):
        for book in self.books:
            print(book)

    def AddBook(self):
        name = input('图书名称: ')
        self.books.append(Book(name,input('作者:'),1,input('存储位置:')))
        print('图书《%s》增加成功' %name)

    def BorrowBook(self):
        name = input('借阅图书名称: ')
        ret = self.CheckBook(name)
        print(ret)

        if ret != None:
            if ret.status == 0:
                print('书籍《%s》已经借出' %name)
            else:
                ret.status = 0
                print('书籍《%s》借阅成功' %name)
        else:
            print('书籍《%s》不存在' %name)

    def ReturnBook(self):
        name = input('归还图书名称: ')
        ret = self.CheckBook(name)

        if ret != None:
            if ret.status == 0:
                ret.status = 1
                print('书籍《%s》归还成功' %name)
                print(ret)
            else:
                print('书籍《%s》未借出' %name)
        else:
            print('书籍《%s》不存在' %name)

manage = BooKManager()
manage.Menu()

3.给房间安放家具

需求：
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具

2.家具有名字和占地面积，其中
床：占4平米
衣柜：占2平米
餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表

class Furniture():

    def __init__(self,name,area):
        self.name = name
        self.area = area

    def __str__(self):
        return '[%s]占地面积: %.2f' %(self.name,self.area)

# bed = Furniture('bed',4)
# print(bed)

class House():

    def __init__(self,house_type,area):
        self.house_type = house_type
        self.area = area
        #剩余面积
        self.free_area = area
        self.item_list = []

    def __str__(self):
        return ('户型: %s\n总面积: %.2f[剩余面积: %.2f]\n家具: %s'
                %(self.house_type,self.area,self.free_area,self.item_list))

    def add_item(self,item):
        #1.判断家具的面积
        if item.area > self.free_area:
            print('%s的面积太大，无法添加' %item.name)
            return False
        #2.添加家具
        self.item_list.append(item.name)
        #3.计算剩余面积
        self.free_area -= item.area

bed = Furniture('bed',4)
yigui = Furniture('yigui',200)
table = Furniture('table',1.5)

my_house = House('独门独栋',200)
my_house.add_item(bed)
my_house.add_item(yigui)
my_house.add_item(table)
print(my_house)

4.利用面向对象实现栈

class Stack():

    def __init__(self):
        self.stack = []

    def push(self,value):
        self.stack.append(value)
        return True

    def pop(self):
        #判断栈是否为空
        if self.stack:
            item = self.stack.pop()
            return item
        else:
            return False

    def top(self):
        if self.stack:
            return self.stack[-1]
        else:
            return False

    def length(self):
        return len(self.stack)

    def view(self):
        return ','.join(self.stack)

s = Stack()
s.push('1')
s.push('2')
item = s.pop()
print(s.view())