Python基础day09面向对象2(上)

大石头的笔记
148 阅读6分钟
私有属性


如果有一个对象，当需要对其进行修改属性时，有
2种方法


·
对象名
.属性名 = 数据 ---->直接修改


·
对象名
.方法名() ---->间接修改



为了更好的保存属性安全，即不能随意修改，一般的处理方式为


·
将属性定义为私有属性


·
添加一个可以调用的方法，供调用


[Python]
纯文本查看
复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
class People(object):
def __init__(self, name):
self.__name = name
def getName(self):
return self.__name
def setName(self, newName):
if len(newName) >= 5:
self.__name = newName
else:
print("error:名字长度需要大于或者等于5")
xiaoming = People("dongGe")
print(xiaoming.__name)



[Python]
纯文本查看
复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
class People(object):
def __init__(self, name):
self.__name = name
def getName(self):
return self.__name
def setName(self, newName):
if len(newName) >= 5:
self.__name = newName
else:
print("error:名字长度需要大于或者等于5")
xiaoming = People("dongGe")
xiaoming.setName("wanger")
print(xiaoming.getName())
xiaoming.setName("lisi")
print(xiaoming.getName())



总结
·
Python中没有像C++中public和private这些关键字来区别公有属性和私有属性


·
它是以属性命名方式来区分，如果在属性名前面加了
2个下划线'__'，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）。
[size=21.3333px]


私有方法


[Python]
纯文本查看
复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Dog:
def __init__(self, new_age):
# 定义了一个私有属性
self.__age = new_age
def set_age(self, new_age):
if new_age > 0 and new_age < 20:
self.__age = new_age
def get_age(self):
return self.__age
# 定义了一个私有方法
def __sit_down(self):
print("坐下了.......")
print("年龄是:%d" % self.__age)
def sit_down(self, host_name):
if host_name == "主人":
self.__sit_down() # 调用另外一个方法的时候,需要写上self
wang_cai = Dog(1)
wang_cai.set_age(-2)
result = wang_cai.get_age()
print(result)
wang_cai.sit_down("主人")
wang_cai.sit_down("东哥")



__del__()
方法


创建对象后，
python解释器默认调用
__init__()
方法；


当删除一个对象时，
python解释器也会默认调用一个方法，这个方法为
__del__()
方法


[Python]
纯文本查看
复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import timeclass Animal(object):
# 初始化方法
# 创建完对象后会自动被调用
def __init__(self, name):
print('__init__方法被调用')
self.__name = name
# 析构方法
# 当对象被删除时，会自动被调用
def __del__(self):
print("__del__方法被调用")
print("%s对象马上被干掉了..."%self.__name)
# 创建对象
dog = Animal("哈皮狗")
# 删除对象del dog
cat = Animal("波斯猫")
cat2 = cat
cat3 = cat
print("---马上 删除cat对象")del cat
print("---马上 删除cat2对象")del cat2
print("---马上 删除cat3对象")del cat3
print("程序2秒钟后结束")
time.sleep(2)


结果
:


file:////tmp/wps-Mr.cat/ksohtml/wpsq6FutS.png


总结


·
当有
1个变量保存了对象的引用时，此对象的引用计数就会加1


·
当使用
del删除变量指向的对象时，如果对象的引用计数不会1，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除


[size=21.3333px]


继承介绍以及单继承


1. 继承的概念


在现实生活中，继承一般指的是子女继承父辈的财产，如下图



搞不好
,结果如下..


file:////tmp/wps-Mr.cat/ksohtml/wpscJOLdo.png


在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物；


同理，波斯猫和巴厘猫都继承自猫，而沙皮狗和斑点狗都继承足够，如下如所示：


file:////tmp/wps-Mr.cat/ksohtml/wpsu97gQb.png



2. 继承示例


[Python]
纯文本查看
复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 定义一个父类，如下:class Cat(object):
def __init__(self, name, color="白色"):
self.name = name
self.color = color
def run(self):
print("%s--在跑"%self.name)
# 定义一个子类，继承Cat类如下:class Bosi(Cat):
def setNewName(self, newName):
self.name = newName
def eat(self):
print("%s--在吃"%self.name)
bs = Bosi("印度猫")
print('bs的名字为:%s'%bs.name)
print('bs的颜色为:%s'%bs.color)
bs.eat()
bs.setNewName('波斯')
bs.run()


运行结果
:


file:////tmp/wps-Mr.cat/ksohtml/wpst1zkMJ.png


说明：


·
虽然子类没有定义
__init__
方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建
Bosi的对象，就默认执行了那个继承过来的
__init__
方法


总结
·
子类在继承的时候，在定义类时，小括号
()中为父类的名字


·
父类的属性、方法，会被继承给子类



3. 注意点


[Python]
纯文本查看
复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class Animal(object):
def __init__(self, name='动物', color='白色'):
self.__name = name
self.color = color
def __test(self):
print(self.__name)
print(self.color)
def test(self):
print(self.__name)
print(self.color)
class Dog(Animal):
def dogTest1(self):
#print(self.__name) #不能访问到父类的私有属性
print(self.color)
def dogTest2(self):
#self.__test() #不能访问父类中的私有方法
self.test()
A = Animal()#print(A.__name) #程序出现异常，不能访问私有属性
print(A.color)#A.__test() #程序出现异常，不能访问私有方法
A.test()
print("------分割线-----")
D = Dog(name = "小花狗", color = "黄色")
D.dogTest1()
D.dogTest2()



·
私有的属性，不能通过对象直接访问，但是可以通过方法访问


·
私有的方法，不能通过对象直接访问


·
私有的属性、方法，不会被子类继承，也不能被访问


·
一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用
[size=21.3333px]


单继承


[Python]
纯文本查看
复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Animal:
def eat(self):
print("-----吃-----")
def drink(self):
print("-----喝-----")
class Dog(Animal):
"""
def eat(self):
print("-----吃-----")
def drink(self):
print("-----喝-----")
"""
pass
class Cat:
pass
wang_cai = Dog()
wang_cai.eat()
wang_cai.drink()



在子类中添加新功能


[Python]
纯文本查看
复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Animal:
def eat(self):
print("-----吃-----")
def drink(self):
print("-----喝-----")
class Dog(Animal):
def bark(self):
print("-----汪汪叫------")
class Cat(Animal):
def catch(self):
print("----捉老鼠----")
wang_cai = Dog()
wang_cai.eat()
wang_cai.drink()
wang_cai.bark()
jia_fei = Cat()
jia_fei.eat()
jia_fei.drink()
jia_fei.catch()



多层继承


[Python]
纯文本查看
复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Animal:
def eat(self):
print("-----吃-----")
def drink(self):
print("-----喝-----")
class Dog(Animal):
def bark(self):
print("-----汪汪叫------")
class XTQ(Dog):
"""定义了一个哮天犬 类"""
pass
class Cat(Animal):
def catch(self):
print("----捉老鼠----")
xtq = XTQ()
xtq.eat()
xtq.bark()

更多免费技术资料可关注：annalin1203

avatar
文章
阅读
粉丝