面向对象编程技术从0总结(基础篇python–让你对基础技术有新的认识1)【万字总结】

        前言:(八股文)面向对象程序设计(Object Oriented Programming)作为一种新方法,其本质是以建立模型体现出来的抽象思维过程和面向对象的方法。模型是用来反映现实世界中事物特征的。任何一个模型都不可能反映客观事物的一切具体特征,只能对事物特征和变化规律的一种抽象,且在它所涉及的范围内更普遍、更集中、更深刻地描述客体的特征。通过建立模型而达到的抽象是人们对客体认识的深化。

应用开发

        面向对象程序设计(Object Oriented Programming,OOP)是一种计算机编程架构。OOP的一条基本原则是计算机程序由单个能够起到子程序作用的单元或对象组合而成。OOP达到了软件工程的三个主要目标:重用性、灵活性和扩展性。OOP=对象+类+继承+多态+消息,其中核心概念是类和对象。

b树

 

状态栏

 

WSA

开篇:(为了便于我们理解直接上手代码去进行阐述)

        现实生活中有多个实体,每个实体有不同的多个属性:最基础的方式,我们可以用字典去包含我们所需要的实体属性:

bootloader

#可以使用字典是存储个体属性
#       '  ':'  '---相当于赋值语句
dog1={
    'name':'tiger1',
    'd_type':'泰迪',
    'attack':18,
    'year':10
}
#该字典中包含了你所需要的狗的属性
#可以通过上述字典去调用一下方法
def bite(person_obj):
    person_obj.life_val-=30

        但是现实生活当中我们需要多个 个体去进行调用–所以我们衍生出了用公共函数去进行调用,减少重复代码(也可以说是创建模板也可以使用字典去进行类型匹配,也不必在函数当中去书写攻击力的代码)

Android线性布局

def Dog(name,d_type):
    dog1 = {
        'name': name,
        'd_type': d_type,
        #'attack': 18,
        'year': 10
    }
    return dog1
#可以将函数中生成的一组值进行返回
#创建实体
d1=Dog('tiger','泰迪')
d2=Dog('贝贝','柯基')
print(d1)

也可以使用字典去进行类型匹配,也不必在函数当中去书写攻击力的代码

linux

#例如:
attack={
    '泰迪':1,
    '柯基':2
}
#在函数中进行声明判断后即可以随时调用
def Dog(name,d_type):
    dog1 = {
        'name': name,
        'd_type': d_type,
        #'attack': 18,
        'year': 10
    }
    if d_type in attack:
        dog1["attack"]=attack[d_type]
    else:
        dog1["attack"]=15
    return dog1

d3=Dog('tiger','泰迪')
d4=Dog('贝贝','柯基')
print(d3,d4)

值得我们注意的是:

练手项目

#在函数中进行声明判断后即可以随时调用
def Dog(name,d_type):
    dog1 = {
        'name': name,
        'd_type': d_type,
        #'attack': 18,
        'year': 10
    }
    if d_type in attack:
        Dog["attack"]=attack[d_type]
    else:
        dog1["attack"]=15
    return dog1

d3=Dog('tiger','泰迪')
d4=Dog('贝贝','柯基')
print(d3,d4)

会导致:TypeError: 'function' object does not support item assignment

frida

原因就是因为: Dog["attack"]=attack[d_type] 该行代码中的 Dog["attack"]与方法名重复

scrcpy

 

最小生成树

 

Unity打包设置

面向对象的几个核心特征如下:(以下都是八股文,建议直接从我写的代码处进行理解!!

汽车电子

Class

yarn

一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性(variables(data))、共同的方法

blockchain

Object对象

awk 命令使用

一个对象即是一个类的实例化后实例,一个类必须经过实例化后方可在程序中调用,一个类可以实例化多个对象,每个对象亦可以有不同的属性,就像人类是指所有人,每个人是指具体的对象,人与人之前有共性,亦有不同

K210

Encapsulation封装

Android开发

在类中对数据的赋值、内部调用对外部用户是透明的,这使类变成了一个胶囊或容器,里面包含着类的数据和方法

实习

lnheritance继承

cocos2d

一个类可以派生出子类,在这个父类里定义的属性、方法自动被子类继承

毕业设计

Polymorphism多态

指针

多态是面向对象的重要特性,简单点说:"一个接口,多种实现”,指一个基类中派生出了不同的子类,且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现,这就是同一种事物表现出的多种形态。

春招

编程其实就是一个将具体世界进行抽象化的过程,多态就是抽象化的一种体现,把一系列具体事物的共同点抽象出来,再通过这个抽象的事物,与不同的具体事物进行对话。

内存越界

对不同类的对象发出相同的消息将会有不同的行为。比如,你的老板让所有员工在九点钟开始工作,他只要在九点钟的时候说:“开始工作"即可,而不需要对销售人员说:“开始销售工作”,对技术人员说:“开始技术工作”因为“员工”是一个抽象的事物,只要是员工就可以开始工作,他知道这一点就行了。至于每个员工,当然会各司其职,做各自的工作。

微信小程序支付

多态允许将子类的对象当作父类的对象使用,某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定

 

 

直接上代码吧:

1、什么是类?

def Dog(name,d_type):{



}

该部分其实就是一个类,类中定义了这些对象的都具备的属性、共同的方法

2、什么是对象?

说简单一点,对象就是实实在在的东西!!—实体

d3=Dog('tiger','泰迪')
d4=Dog('贝贝','柯基')

d3,d4相当于现实世界当中实实在在存在的实体,即就叫做对象!!

3、什么叫做实例化?

说简单一点就是模板调用的过程(类的调用过程)就叫做实例化!!–实例化之后产生的东西就叫做对象

4、什么是封装?

def Dog(name,d_type):
    dog1 = {
        'name': name,
        'd_type': d_type,
        #'attack': 18,
        'year': 10
    }
    if d_type in attack:
        Dog["attack"]=attack[d_type]
    else:
        dog1["attack"]=15
    return dog1

假设在这里我创建了一个狗类的方法和一个人类的方法,所谓封装可以简单的理解为:狗类的方法人理论上是不运行人去调用的!

多态和继承我会在后续代码中进行详细讲解!!

类的基本语法:

        1、为了编程的规范:python中类首字母应该大写

            直接就可以在类中定义属性
            像下面这种在类中直接定义的属性,叫做类属性、类变量(是所有对象都可以公共共享的一个属性)

            类中的方法:第一个参数必须是self(也可以是其他名字)—这里的self代表实例本身

class Dog:
    #直接就可以在类中定义属性
    # 像下面这种在类中直接定义的属性,叫做类属性、类变量
    d_type='泰迪'
    def hello(self):    #方法:第一个参数必须是self(也可以是其他名字)---这里的self代表实例本身
        print('Hello!,I am a',self.d_type)

             当类写完之后,我们需要对类进行实例化,将其变成一个真正的实体,对象—python中一切皆对象

       当我们实例化一个对象之后,就可以通过对象去调用类中的方法
'''
1、调用类中的方法: 实例.方法
2、调用类中的属性:  实例.属性
'''(#小写的f代表类属性,大写的F代表普通函数)
#当类写完之后,我们需要对类进行实例化,将其变成一个真正的实体,对象---python中一切皆对象
D1=Dog()    #生成了一个实例
D2=Dog()
#当我们实例化一个对象之后,就可以通过对象去调用类中的方法
D1.hello()
'''
1、调用类中的方法: 实例.方法
2、调用类中的属性:  实例.属性
'''
#小写的f代表类属性,大写的F代表普通函数
D1.d_type

问题:我们如何定义对象之间私有的属性(只属于自己的属性)?

答:定义初始化方法又叫做构造方法、构造函数,实例化时进行一些初始化工作(自动进行执行)

 

在类中定义初始化方法:

    def __init__(self,name,age,sex):#初始化方法,构造方法,构造函数,实例化时会自动执行,进行一些初始化工作
        #要想把name ,age 两个值,真正的存到实例种去,就要把2个值和实例去进行绑定--self存在意义
        self.name=name  #绑定参数值到实例中去
        self.age=age
        self.sex=sex    #相当于D.sex=" 雄性"

2、self用什么实际意义?

以上述代码进行举例:

要想把name ,age 两个值,真正的存到实例种去,就要把2个值和实例去进行绑定–self存在意义

#为了编程的规范:python中类首字母应该大写
class Dog:
    #直接就可以在类中定义属性
    # 像下面这种在类中直接定义的属性,叫做类属性、类变量
    d_type='泰迪'
    def hello(self):    #方法:第一个参数必须是self(也可以是其他名字)---这里的self代表实例本身
        print('Hello!,I am a',self.d_type,'My name is',self.name,'I am',self.age,'years!')
    def __init__(self,name,age,sex):#初始化方法,构造方法,构造函数,实例化时会自动执行,进行一些初始化工作
        #要想把name ,age 两个值,真正的存到实例种去,就要把2个值和实例去进行绑定--self存在意义
        self.name=name  #绑定参数值到实例中去
        self.age=age
        self.sex=sex    #相当于D.sex=" 雄性"


#当类写完之后,我们需要对类进行实例化,将其变成一个真正的实体,对象---python中一切皆对象
D1=Dog('贝贝',2)    #生成了一个实例
D2=Dog('tiger',10)
#当我们实例化一个对象之后,就可以通过对象去调用类中的方法
D1.hello()

'''
1、调用类中的方法: 实例.方法
2、调用类中的属性:  实例.属性
'''
#小写的f代表类属性,大写的F代表普通函数
D1.d_type
D1.sex='雄性'
print(D1.sex)

我们也可以直接在类的外部,运用实例化之后的对象进行创建  D1.sex='雄性' 相当于在初始化方法中添加sex属性,并用self进行实例化绑定

def __init__(self,name,age,sex):#初始化方法,构造方法,构造函数,实例化时会自动执行,进行一些初始化工作
        #要想把name ,age 两个值,真正的存到实例种去,就要把2个值和实例去进行绑定--self存在意义
        self.name=name  #绑定参数值到实例中去
        self.age=age
        self.sex=sex    #相当于D.sex=" 雄性"

实例属性又叫做成员变量

小总结:

                类属性,类变量,公共属性—–所有实例共享

                实例属性,实例变量,成员变量——-每个实例独享

1、类属性的改变,可以直接在外部进行修改,通过类名进行调用方法修改

2、实例属性,只能通过实例进行调用,而不能通过类进行调用

#类属性的改变,可以直接在外部进行修改,通过类名进行调用方法修改
Dog.d_type='柯基'
print(D1.d_type)
#实例属性,只能通过实例进行调用,而不能通过类进行调用
D1.name='小白'
D1.hello()

(实例属性只存在于实例的内存中,而在类中是无法找到的)

3、什么时候用实例属性?什么时候用类属性?

例如:

class Person:
    #nationlity='中国'
    def __init__(self,name,age,sex,nationlity):#构造函数
        self.name=name
        self.age=age
        self.sex=sex
        self.nationlity=nationlity

'''
放在构造函数当中,每个人的国籍都单独存了一份,但是如果14亿中国人,那么其数据量是非常大的,这样是不符合现实的
这个时候我们就不能将国籍放在构造函数当中去,而是作为一个类属性去进行创建
'''
P1=Person('小贝','18','男','中国')
P1=Person('小王','20','男','中国')
P1=Person('小李','21','男','中国')

放在构造函数当中,每个人的国籍都单独存了一份,但是如果14亿中国人,那么其数据量是非常大的,这样是不符合现实的
这个时候我们就不能将国籍放在构造函数当中去,而是作为一个类属性去进行创建

正确做法:将国籍作为一个类属性去进行创建

class Person:
    nationlity='中国'
    def __init__(self,name,age,sex):#构造函数
        self.name=name
        self.age=age
        self.sex=sex


'''
放在构造函数当中,每个人的国籍都单独存了一份,但是如果14亿中国人,那么其数据量是非常大的,这样是不符合现实的
这个时候我们就不能将国籍放在构造函数当中去,而是作为一个类属性去进行创建
'''
P1=Person('小贝','18','男')
P1=Person('小王','20','男')
P1=Person('小李','21','男')

4、实例对象去更改自己的属性,会对其他实例对象的国籍有影响吗?

答:并没有任何影响

实例也可以直接去更改属于自己的类属性国籍,对于其他属性并没有任何影响 —相当于,给P实例创建了一个新的实例属性

class Person:
    nationlity='中国'
    def __init__(self,name,age,sex):#构造函数
        self.name=name
        self.age=age
        self.sex=sex


'''
放在构造函数当中,每个人的国籍都单独存了一份,但是如果14亿中国人,那么其数据量是非常大的,这样是不符合现实的
这个时候我们就不能将国籍放在构造函数当中去,而是作为一个类属性去进行创建
'''
P1=Person('小贝','18','男')
P2=Person('小王','20','男')
P3=Person('小李','21','男')
print(P1.nationlity)

'''
实例也可以直接去更改属于自己的类属性国籍,对于其他属性并没有任何影响
---相当于,给P实例创建了一个新的实例属性
'''
P1.nationlity='美国'
print(P1.nationlity)
print(P3.nationlity)

 

 

 

 

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注