python篇 面向对象_面向对象以什么为核心

1. 面向对象

1.1.面向对象概念

面向对象程序设计以对象为核心，该方法认为程序由一系列对象组成。 类是对现实世界的抽象，包括表示静态属性的数据和对数据的操作，对象是类的实例化。 对象间通过消息传递相互通信，来模拟现实世界中不同实体间的联系。 在面向对象的程序设计中，对象是组成程序的基本模块

1.2.面向对象可能用到的知识点

---

python篇 函数定义
python篇 递归概念
python篇 流程语句
python篇 匿名函数

---

2.类和对象

什么是类？-------类别

类通过关键字class进行定义类

对象-------类的实例，是一个真实存在的事物

定义类的注意：
通过class关键字定义，类里面可以去包含属性，可是是多个

类名命名规范：遵循大驼峰法

"""
定义一个用户类
class User:旧时类
class User(object):新式类
这两种定义方式都可以，都是继承了object这个对象，但推荐使用新式类
"""
class User(object):
    #重写object __init__(self).初始化方法，用来初始化属性
    def __init__(self):
        self.name = "张三"
        self.age = 18
        self.gender = "男"

    def Study(self):
        print("我张三爱学习法律！！！")

if __name__ == "__main__":
    u = User()
    print(u.name)
    u.age+=1
    print(u.age)
    print(u.gender)
    u.Study()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.面向对象三大特征

3.1.封装

面向对象的封装特指，去将对象或者属性封装到一个类或者多个类中，需要使用的时候，通过对象调用对应的方法或者属性

class User(object):
    def __init__(self,username,age,gender,tel):
        self.__username = username
        self.__age = age
        self.__gender = gender
        self.__tel = tel

    def __str__(self):
        return "name = " + self.__username + ""

    def get_username(self):
        return self.__username

    def set_username(self,username):
        self.__username=username


u1 = User("张三","18","男","12222")
print(u1)
u1.set_username("李四")
print(u1.get_username())


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

get和set方法

第二种封装：property

class User(object):
    def __init__(self,username,age,gender,tel):
        self.__username = username
        self.__age = age
        self.__gender = gender
        self.__tel = tel

    def __str__(self):
        return "["+"name = " + self.__username + ',' + "age = " + self.__age + "]"

    def get_username(self):
        return self.__username

    def set_username(self,username):
        self.__username=username

    username = property(get_username,set_username)


u1 = User("张三","18","男","12222")
print(u1.username)
u1.username = "lisi"
print(u1)
# print(u1)
# u1.set_username("李四")
# print(u1.get_username())


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

第三种：通过装饰器@property 在get方法上进行装饰

class User(object):
    def __init__(self,username,age,gender,tel):
        self.__username = username
        self.__age = age
        self.__gender = gender
        self.__tel = tel

    def __str__(self):
        return "["+"name = " + self.__username + ',' + "age = " + self.__age + "]"
    @property
    def username(self):
        return self.__username

    @username.setter
    def username(self,username):
        self.__username=username

    # username = property(get_username,set_username)


u1 = User("张三","18","男","12222")
print(u1.username)
u1.username = "lisi"
print(u1)
# print(u1)
# u1.set_username("李四")
# print(u1.get_username())


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

3.2.继承

类和类之间存在继承关系

建立一个类，其中输入的object就是继承类

class User(object):
1

class RichMan(object):
    def __init__(self):
        self.money = 100000000
        self.company = "阿里巴巴"
    def tell_mottoo(self):
        print("我对钱不感兴趣")
    
class Son(RichMan):
    """继承里RichMan类"""
    pass
    
if __name__ == '__main__':
    s = Son() 
    s.money();
    print(s.company)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

子类可以继承父类的方法和属性。
但能继承所有吗？------不可以
注意：继承父类并不是所有方法和属性都能继承，只能继承公开的属性和方法，私有的属性和方法是不能被继承的

私有方法和属性：
在命名前面加上“——”双下划线，但如果加上后，初始化

3.3.多态

多态（python中并不是很重要）
指的是对象的多种状态，多态是基于继承的基础之上，父类引用指向子类实例的现象叫做多态

ArrayList a1 = new ArrayList()
List ls = new ArrayList()
1
2

注意：在若数据语言里因为不用去声明，数据类型，所以天生就支持多态

4.方法重写

方法的重写，继承里面可以实现
方法重写又叫方法覆盖（Override）:在继承基础之上，如果子类的方法，父类不能满足自己使用的时候，那么可以重写这个方法

注意：重写这个方法的时候，方法的名称、参数一定要和父类一致

下面为父类定义一个working,并重写

class RichMan(object):
    def __init__(self):
        self.money = 100000000
        self.company = "阿里巴巴"

    def tell_motto(self):
        print("我对钱不感兴趣")

    def __speak_english(self):
        print("他讲英语很厉害")

    def working(self):
        print("a")

class Son(RichMan):
    """继承里RichMan类"""
    def working(self):
        print("b")

if __name__ == '__main__':
    s = Son()
    # print(s.money)
    # print(s.company)
    s.working()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

E:\py\python.exe D:/python/pyc/学习/继承.py
b

Process finished with exit code 0

1
2
3
4
5

5.某公司面试题

重写和重载的区别
重载：函数名称相同，但是函数的参数个数获类型不同

Python中有没有方法的重载（Overload）？有没有方法的重写(Override)？

好像有重载

class RichMan(object):
    def __init__(self):
        self.money = 100000000
        self.company = "阿里巴巴"

    def working(self,x,y,z):
        print(x,y,z)

class Son(RichMan):
    """继承里RichMan类"""
    def working(self,x):
        print(x)

if __name__ == '__main__':
    s = Son()
    # print(s.money)
    # print(s.company)
    s.working(4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

python中有方法的重写，但没有方法的重载，但是可以实现方法的重载（装饰器）

继承的本质：实现代码的复用，class Son(self,RichMan,Object)
python是支持多继承：

如果a类是继承b类和c类,b和c同时有一个h(),请问a继承的是哪个h()?

答，就近原则，按照继承的顺序来找（广度优先）

class RichMan(object):
    def __init__(self):
        self.money = 100000000
        self.company = "阿里巴巴"

    def working(self):
        print("i am RichMan's son")

class Red(object):
    def working(self):
        print("i am red's son")

class Son(Red,RichMan):
    """继承里RichMan类"""
    # def working(self,name):
    #     print(name)

if __name__ == '__main__':
    s = Son()
    # print(s.money)
    # print(s.company)
    s.working()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

super关键字，是一个指针，指向父类

class RichMan(object):
    def __init__(self):
        self.money = 100000000
        self.company = "阿里巴巴"

    def working(self):
        print("i am RichMan's son")



class Son(RichMan):
    """继承里RichMan类"""
    def working(self):
        print("i am i")

    def test(self):
        # self.working()
        super().working()



if __name__ == '__main__':
    s = Son()
    # print(s.money)
    # print(s.company)
    s.test()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26