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