面向对象编程opp(黑马学习笔记)---进阶部分(第一部分)

最新推荐文章于 2021-02-06 14:56:06 发布

Scan sprink

最新推荐文章于 2021-02-06 14:56:06 发布

阅读量196

点赞数

分类专栏： python黑马基础学习文章标签：类多态面向对象编程封装编程语言

本文链接：https://blog.csdn.net/qq_45599904/article/details/108031950

版权

python黑马基础学习专栏收录该内容

14 篇文章 2 订阅

订阅专栏

一、类创建的顺序

开发的时候的顺序，一般是被使用的类是先开发的
例如:开发一个房子类，但是我们需要知道房子里面有什么，比如家具，那么我们需要先开发家具类，然后再开发房子里

class HouseItem(object):

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

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

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总面积: .2%f[剩余: %.2f]\n家具:%s"
                %(self.house_type,self.area,
                  self.free_area,self.item_list))

    def add_item(self, item):

        print("要添加的是%s" %(item))
        #1.判读家具的面积
        if item.area > self.free_area:
            print("%s 的面积太大了，无法添加" % (item.name))

            return
        # 2. 添加家具到列表中
        self.item_list.append(item.name)

        # 3. 剩余面积
        self.free_area -= item.area


bed = HouseItem("席梦思", 40)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 1.5)

print(bed)
print(chest)
print(table)

my_home = House("俩室一厅", 60)
print(my_home)

#将创建的家具的对象都作为实际参数传递给add_item函数
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)

print("")

二、私有属性和方法

1.应用场景

在开发中，对象的某些属性或者方法不希望在外部使用，只希望在内部使用的时候，这些就是私有属性或者方法。

2.语法

在属性/方法前面加上两个_ 就可以定义为私有属性/方法

3.例子:

class Women(object):

    def __init__(self,name):
        self.name = name
        self.__age = 18 #定义一个私有属性

    def __print_message(self):
        print("我一点也不胖") #定义一个私有方法

    def print_messages(self):
        print("名字:" + self.name)
        self.__print_message() #在类内部我们调用和访问私有方法
        print(self.__age) #在类内部我们可以调用和访问私有属性


xiaomei = Women("小美")
print(xiaomei.name)
# print(xiaomei.age) #会报错,因为在类外部不可以直接访问私有属性和方法
xiaomei.print_messages()

4.注意

我们虽然不可以从外部直接调用类内部的私有属性/方法，但是我们可以利用内部来访问类的私有属性和方法
同时需要一点我们需要牢记住，我们可以在类的外部间接的调用和访问类内部的属性和方法，但是我们不要采用这种访问
具体的语法是

对象名._类名__属性名/方法名

例如:

class Women(object):

    def __init__(self,name):
        self.name = name
        self.__age = 18 #定义一个私有属性

    def __print_message(self):
        print("我一点也不胖") #定义一个私有方法

    def print_messages(self):
        print("名字:" + self.name)
        self.__print_message() #在函数内部我们调用和访问私有方法
        print(self.__age) #在函数内部我们可以调用和访问私有属性


xiaomei = Women("小美")
print(xiaomei.name)
# print(xiaomei.age) #会报错,因为在函数外部不可以直接访问私有属性和方法
print(xiaomei._Women__age) #采用间接的调用私有属性
xiaomei.print_messages()

三、继承和多态

1. 单继承

[1]特点

相同的代码不需要重复的编写
子类拥有父类的所有的属性和方法
继承具有传递性

[2]语法:

class 类名(父名):
	代码块

[3]相关的一些术语(这里举例子说明)

Dog是Animal子类，Animal是Dog的父类，Dog继承于Animal
Dog是Animal派生类，Animal是Dog的基类，Dog从Animal派生来的

[4]方法重写

当父类的方法无法满足需求时得重写

[5]例子

例子1

class Animal:

    def eat(self):
        print("吃")

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

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


class Dog(Animal):#继承Animal类

    def bark(self):
        print("汪汪")


class XiaoTianQuan(Dog):#继承Dog类

    def fly(self):
        print("我会飞")

xtq = XiaoTianQuan()
xtq.fly() #调用fly方法
xtq.bark() #继承了Dog的bark方法
xtq.eat() #继承了Animal的eat方法
xtq.drink() #继承了Animal的drink方法
xtq.sleep() #继承了Animal的sleep方法

例子2(方法重写)

class Animal:

    def eat(self):
        print("吃")

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

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


class Dog(Animal):#继承Animal类

    def bark(self):
        print("汪汪")

    def eat(self): #重写Animal中的eat方法
        print("Dog can eat everything")


huahua = Dog()
huahua.eat()
huahua.drink() #继承了父类的drink
huahua.bark()
huahua.sleep() #继承了父类的sleep

[6]方法重写的拓展

1. 语法

当父类提供的功能较少的时候，又不想大面积的改动，这时候我们需要用super().方法名(参数列表)来继承super类

2.例子

class Animal:

    def eat(self):
        print("吃")

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

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


class Dog(Animal):

    def bark(self):
        print("这是调用父类的bark:"+"汪汪")


class XiaoTianQuan(Dog):

    def fly(self):
        print("我会飞")

    def bark(self):

        # 针对子类特有的需求，编写方法
        print("神一样的叫.....")

        # 使用super方法进行原本父类的调用
        super().bark()

        print("fsdfsdfasdfsdf")


class Cat(Animal):

    def catch(self):
        print("老鼠")


xtq = XiaoTianQuan()

xtq.fly()

# 如果子类中重写了父类的方法则不会调用父类的方法
xtq.bark()

[7]对于父类/属性的私有方法的注意事项

子类不可以访问
子类可以间接在子类的内部通过访问父亲类的公有方法访问到父类的私有方法/属性
例子

class A:

    def __init__(self):
        self.num = 100
        self.__num = 200

    def __test(self):
        print("私有方法 %d %d" % (self.num, self.__num))


    def everything(self):
        self.__test()
        print("访问的是父类的num:%d" %(self.__num))

class B(A):

    def demo(self):
        # 在子类的对象方法中，不能访问父类的私有属性
        print("访问父类的私有属性 %d" % (self.__num2))

        # 不能调用父类的私有方法
        self.__test()


b = B()

b.everything() #通过访问父类的公有方法间接的访问到了父类私有属性和方法
# b.demo() #直接报错
 
# print(b.__num) #子类不能在外部访问到父类的私有方法
# print(b.__test) #子类不能在外部访问到父类的私有方法

2.多继承

[1]说明

类似于单继承，只是继承的父类是多个，这里不进行详细说明，直接上例子

class A:

    def test(self):
        print("test方法")


class B:

    def demo(self):
        print("demo方法")


class C(A,B):

    pass


c = C()

c.test()
c.demo()

[2]注意事项:

当继承于多个父类的时候我们需要注意同名的方法不建议多继承

3.多态

说明:

不同的子类对象调用相同的父类的方法产生不同的执行结果

优点：

可以增加代码的可见度
以继承与方法重写为前提
是调用方法的技巧，不会影响到类的内部设计

例子:

class Dog(object):

    def __init__(self,name):

        self.name = name

    def game(self):#这就是多态
        print("蹦蹦跳跳 %s" % (self.name))


class XiaoTianQuan(Dog):

    def game(self):
        print("飞上天玩....%s " %(self.name))
        super().game() #调用父类的game方法


class Person(object):

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

    def game_with_dog(self, dog):

        print("%s 和 %s 快乐的玩耍..." % (self.name, dog.name))

        # 让狗玩耍
        dog.game()

# 创建一个狗对象
# wangcai = Dog("旺财")
wangcai = XiaoTianQuan("飞天旺财")

# 创建一个人
xiaoming = Person("小明")

# 让小明和狗玩的方法
xiaoming.game_with_dog(wangcai)