python——面向对象（中）

1.单继承

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

程序中便可以描述为猫和狗继承自动物。

同理，波斯猫和巴厘猫都继承自猫，而沙皮狗和斑点狗都继承自狗

# 定义一个父类，如下:

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()

虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法
子类在继承的时候，在定义类时，小括号()中为父类的名字父类的属性、方法，会被继承给子类私有的属性，不能通过对象直接访问，但是可以通过方法访问
私有的方法，不能通过对象直接访问私有的属性、方法，不会被子类继承，也不能被访问一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用

棧 主要运行的是函数   堆 主要存放的是对象
类：一些具有相同特征行为属性的对象的统称
对象：该类中的具体实例
类是对象的一种描述
在描述类的时候，

class Person:
	#在创建对象时 对对象进行初始化
    def __init__(self):
    	self.name="张三"
    	self.age=18
	def speak(self):
		print("哈哈")
#创建一个Person的对象
p=Person()
#如果在类的描述中 不存在属性的话
#属于动态添加属性
#将属性添加到该对象的所属空间中
#
#否则，更改属性
p.name="李四"
p.age=20
print(p.name)
print(p.age)
p1=Person()
print(p1.name)
prin(p1.age)

print("="*20)
class Dog:
    def __init__(self,typ,color):
        self.typ=typ
        self.color=color
        self.age=20
    def jiao(self):
        print("旺旺"+self.typ+self.color)
    def __str__(self):
    	return self.typ+self.color+str(self.age)
'''
1.开辟空间 分配地址
2.为对象进行初始化工作
'''
d=Dog("拉布拉多","黄色")
d.jiao()
d1=Dog("哈士奇"，"黑色")
d1.jiao()
print(d1)
#区别哪的函数调用，python中会自动指向调用的地址

面向对象与之前的面向过程比
优点：1.将数据和指令结合，方便操作
2.从编程思想上来说更加符合我们的实际思考习惯
比如：客户商品订单商家
如果没有对象怎么办？
那就创建对象创建好之后，就可以后面使用，一劳永逸

面向对象：三大特征
封装
random.random() 只需要获取随机值就行，就像吃饭付钱，不管厨师的操作
继承
多态

引入隐藏数据的原因：
如果属性没有私有化外界直接访问(取值，修改)

但是修改可能会改成错误数据会影响后续程序的执行
所以，不允许外界直接访问属性 __必须私有化

间接提供Setter Getter函数 __ 表示隐藏数据，外界只能读取，不能进行操作（是两个下划线呦）

class Person:
	def __init__(self):
		self.__age=10   #隐藏数据  已经被隐藏，不能被调用
	def getAge(self):   #p.__age
	#对外来说，访问不了，但对于get可以，可以间接引用
		return self.__age
	def setAge(self,age):
		if age<0 or age>150:
			print("非法数据")
			self.__age=0
		else:
		    self.__age=age  #p.__age=30

p=Person()
#这里面 不管是age 还是__age 都找不到
 # p.age=-20   编译正确，直接对age的值进行操作，有些冒险
#p.__age=-20   编译错误，显示找不到
#print(p.__age)  
p.__age=-20
p.setAge(30)
print(p.getAge())

为什么要删除对象？
如果对象不再被使用时，那么该对象就会被清理

class Person:
	def __init__(self):
		print("a person has created!")
	def __init__(self):
		print("a person has deleted!")
	def show(self):

p=Person()  #创建好下个对象后，此对象不再被使用
p=Person()
p1=Person()
del p1
print("="*20)
a=Person()  
# 执行完 del c 就会删除一个对象不再引用，就会被删除，默认垃圾回收机制
c=a
del a
#a.show()
del b
#b.show()
del c
#c.show()

关于继承：

继承 is a 从属

抽取多个类之间相同的部分时
注意所抽取出来的父类基类超类
继承从属关系是一个系列

面向对象编程都有父类如果没有明显写出表示object

class Person(object):
	def __init__(self,name,age):
		self.name=name
		self.age=age
	def eat(self):
		print(self.name+"在吃饭.....")

class Student(Person):
	def study(self):
	    print(self.name+"在学习....")

class Teacher(Person):
	def teach(self):
		print(self.name+"在上课.....")
p=Person("张三",18)
p.eat()  #可以
#p.study() #不可以
#p.teach() #不可以  是其子类
p1=Student("李梅",20)
p1.eat()
p1.study()
p2=Teacher("张雪峰")
p1.eat()
p1.teach()
p2.study()  #并没有在teacher里定义，错误
#注意：python 所有东西兼对象

下面，举个简单的栗子：
'''
class SortUtil:
	def sort():
		swipe(a,b)
	def __swipe(a,b):   
#属于排序类的算法，可能会被别的函数调用，不需要对外界调用，不是本质上的真正功能
su=SortUtil()
su.sort([])

python——面向对象（中）

猜你喜欢