Python 面向对象编程的核心概念知识点简介

矫情吗；* 2022-12-28 04:18 176阅读 0赞

本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,如有问题请及时联系我们以作处理。

以下文章来源于 无量测试之道 ，作者： 无量测试之道

![a35afb270dc3d8731157ad2ed94af616.png][]

# **面向对象编程的核心概念：封装，抽象，多态、继承、组合** #

# **封装：** #

第一个概念：在面向对象编程中，对象将变量和方法集中在一个地方，即对象本身。

第二个概念：指的是隐藏类的内部数据，避免客户端代码直接进行访问。

class Data:
        def __init__(self):
            self.list1=[22,33,44,55,66]
    
        def chang_list(self,index,num):
            self.list1[index]=num
    
    data1=Data()
    data1.list1[0]=100
    print(data1.list1)
    
    data2=Data()
    data2.chang_list(0,100)
    print(data2.list1)

# **抽象：** #

它是指剥离事物的诸多特性，使其只保留最基本的物质的过程。在面向对象编程中，使用类进行对象建模时就会用到抽象的技巧。

import abc
    class Animal(metaclass=abc.ABCMeta):
        @abc.abstractmethod #抽象的对象方法
        def sound(self):
            pass
        @abc.abstractclassmethod#抽象的类方法
        def test1(cls):
            pass
        @abc.abstractstaticmethod#抽象的静态方法
        def test2(self):
            pass
    
    class Dog(Animal):
        def sound(self):
            print("wang wang")
    
        @classmethod
        def test1(cls):
            print("class of method")
    
        @staticmethod
        def test2():
            print("static of method")
    
    dog=Dog()
    dog.sound()
    dog.test1()
    Dog.test1()
    dog.test2()
    Dog.test2()

# **继承：** #

1)、将公共的属性和方法放到父类中，自己只考虑特有的属性和方法。

2)、覆盖父类的方法即重写父类方法，在运行中只会调用子类中重写的方法不用调用父类中的方法。

3)、子类拥有一个父类叫作单继承，子类可以拥有多个父类，并且具有所有父类的属性和方法。

class Student:
        def study(self):
            print("学生要学习")
        def practice(self):
            print("学习完成要练习")
    
    class HighStudent(Student):
        def study_compute(self):
            print("高中同学还要学习计算机")
    
    hs=HighStudent()
    hs.study()
    hs.practice()
    hs.study_compute()

# **多态：** #

1)、指的是为不同的基础形态（数据类型）提供着接口的能力，接口指的是函数和方法。

2)、顾名思义，多态就是多种表现形态的意思，它是一种机制，一种能力，而非某个关键词。它在类的继承中得以实现，在类的方法调用中得以体现。

3)、多态意味着变量并不知道引用的对象是什么，根据引用对象的不同表现不同的行为方式。

4)、多态以封装和继承为前提，不同的子类对象调用相同的方法，产生不同的执行效果。它可以增加代码的灵活度，以继承和重写父类的方法为前提，调用方法不会影响到类的内部设计

class Animals(object):
        def __init__(self,name):
            self.name=name
        def eat(self):
            print(self.name+" is eating")
    class Cat(Animals):
        def __init__(self,name):
            super(Cat, self).__init__(name)
    class Pig(Animals):
        def __init__(self,name):
            super(Pig, self).__init__(name)
    
    class Person():
        def feedAnimal(self,animal):
            animal.eat()
    
    cat=Cat("tom")
    pig=Pig("peiqi")
    tony=Person()
    tony.feedAnimal(cat)
    tony.feedAnimal(pig)

# **组合:** #

1)、通过组合技巧将一个对象作用变量保存在另一个对象中，可以模拟拥有关系。

2)、它是一种将对象或类组合成更复杂的数据结构或构件实现的方法。

3)、在组合中，一个对象可用于调用其他模块中的成员函数，这样一来，无需通过继承就可以实现基本功能的跨模块调用。

class Monkey():
        def __init__(self,name,owner):
            self.name=name
            self.owner=owner
    
    class Persons():
        def __init__(self,name):
            self.name=name
    
    mike=Persons("mike")
    mickMouse=Monkey("goldeMonkey",mike)
    print(mickMouse.owner.name)
    
    class A(object):
        def a1(self):
            print("a1")
    class B(object):
        def b1(self):
            print("b1")
            A().a1()
    bb=B()
    bb.b1()

**总结：**

**今天和大家分享的是面向对象编程的核心概念：封装，抽象，多态、继承、组合，可以结合代码示例本地去运行着感受这些概念的含义。**

[a35afb270dc3d8731157ad2ed94af616.png]: /images/20221120/b3adc454ee1347ff8820d461c61b01b8.png