面向对象概念/私有属性/私有方法及相应练习题

过程：类似于函数，只能执行，但是没有返回值
函数：不仅能执行，还可以返回结果
面向过程和面向对象
1.面向过程的特点
注重过程，不注重职责分工
如果需求复杂，代码会变得很复杂
开发复杂的项目，没有固定的套路，开发难度很大！

2.面向对象的特点
	注重对象和职责，不同的对象承担不同的职责
	更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供固定的套路
	需要在面向过程的基础上，在学校一些面向对象的语法

类与对象
类的概念
1.将具有共同特征以及共同行为的一组对象进行抽象，抽象出来的东西，就有一个概念：类
2.类就相当于制造盖楼使用的设计图
对象的概念
某一个具体的存在，看得见的，摸的着的
练习： 区分类与对象
奥迪汽车 （类）
张三停在车库的奥迪A8（对象）
雅迪 （类）
人 （类）
咱班坐在xx的xx （对象）
笔记本 （类）

类的组成：
类名
属性：（静态） 一组数据
方法：（动态）运行调用的函数

类的定义
语法
class 类名:
案例：
class Person:
如：自我介绍方法
def introduce(self):
print(“我的名字叫:%s,今年%d岁了”%(self.name,self.age))

注
 也有类似使用(新式类，手动指明了父类为谁)
class Person(object):
     def xxxx():

创建对象
封装好类，等于是画好了图纸，下边就
可以开始根据图纸进行一座座楼房的建造了
语法格式：
对象名 = 类名()
p = Person()

案例：

class Person:
    		# 自我介绍方法
		def introduce(self):
            		print("我的名字叫:%s,今年%d岁了"%(self.name,self.age))
	# p = Person('ss',12)
	# 创建对象
	p = Person()
	# 添加属性，并给属性赋值
	p.name = '陈独秀'
	# 如果在这调用方法，会报错，因为在方法的调用中，访问了age属性，但是，目前对象中还没有该属性
	# p.introduce()
	# 添加属性，并给属性赋值
	p.age = 30
	# 调用对象的方法
	p.introduce()

注意：
对象包含属性和方法两部分
第一次p.name 是给对象添加属性，之后再访问，则是修改属性的值

__init__方法（初始化方法）:当创建对象时，自动调用此方法
  __init__引入
因为每次创建对象，都需要手动添加属性，创建多个对象，这些操作要进行多次，
那么有没有简便的方式，创 建每一个对象，都自动包含了这些属性

def __init__(self):
        	self.name='大黄'
        	self.age = 2
    	def showInfo(self):
        	print('name:%s,age：%d'%(self.name,self.age))
	# 创建对象之后，没有手动添加属性
	dog = Dog()
	# 调用对象方法没有报错，说明已经对象中已经包含了name跟age两个属性
	dog.showInfo()	

思考：
属性的值是固定的，能不能创建对象时，
直接完成赋值，答案，可以.

自定义参数的使用

class Dog:
	#给__init__方法增加参数，第一个self为默认参数，python解释器自动传递值
    		def __init__(self,name,age):
        		self.name = name
        		self.age = age
    		def showInfo(self):
        		print('name:%s,age：%d'%(self.name,self.age))
	# '大黄'与 2分别是name与age的实际参数
	dog = Dog('大黄',2)
	dog.showInfo()

练习：
完成一个Student类的封装，包含属性：name,age,gender 方法：study()，eat()
创建对象并直接赋值(通过__init__方法完成)，调用方法测试

class student:
      def __init__(self,name,age,gender):
            self.name=name
            self.age=age
            self.gender=gender
            print('姓名：{0}  年龄：{1}  性别：{2}'.format(self.name,self.age,self.gender))
      def study(self):
            print('{0}正在学习'.format(self.name))
      def eat(self):
            print('{0}正在吃东西'.format(self.name))
p=student('阿哥','22','男')
p.study()

练习：

"""
1.小明体重75.0公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西体重增加1公斤

"""
#小明是个人，定义一个叫Person的类
class Person:
      def __init__(self,name,weight):
            self.name=name
            self.weight=weight
      #定义一个跑步的方法
      def run(self):
            self.weight -=0.5
      def eat(self):
            self.weight +=1
      def  __str__(self):
            return '%s的体重现在是%s'%(self.name,self.weight)
xiaoming=Person('小明',75)
xiaoming.run()
xiaoming.eat()
print(xiaoming)

在python中，有一些内置好的特定的方法，这些方法在进行特定的操作时会自动被调用，称之为魔法方法

定义__str__()方法：

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def showInfo(self):
        print('name:%s,age：%d' % (self.name, self.age))
    def __str__(self):
        # 使用'+'只能拼接字符串
        message = "我的名字:" + self.name + ",我的年龄:" + str(self.age)
        return message
dog = Dog('大黄', 2)
# dog.showInfo()
# 这时候会打印__str__方法中return的数据
print(dog)

self 关键字的使用
可以理解为自己，类似与Java、C++中的this指针，表示对象自身
注意：
某个对象调用方法时，python解释器会把这个对象做为第一个参数，传递给self，也就是
哪个对象调用该方法，self表示的是谁
c

lass Dog:
      def __init__(self,name,age):
           # self作用，访问/添加属性
           self.name = name
           self.age = age
      def showInfo(self):
           print("name:%s,age:%d"%(self.name,self.age))
           # 直接访问当前类中其他方法会报错
           # shout()
           # 访问当前类中的其他对象方法
           self.shout()
      def shout(self):
           print("汪汪汪~")

    
 def printDog(dog):
     # 判断dog为Dog的类的对象(做容错处理，防止函数调用直接给一个字符串参数抛出异常)
      if isinstance(dog,Dog):
          print("是dog对象")
          # 函数中调用Dog类中的方法
            dog.showInfo()
    # 创建对象
 dog1 = Dog('大黄',2)
 dog2 = Dog('小黑',1)
 # 调用函数
 printDog(dog1)
 printDog(dog2)
 # 如果没有使用  isinstance(对象，所属类)，这行代码会导致报错
 printDog("123")

注意：对象存放的是类的内存地址，创建多个对象时，就有多个内存地址

__del__方法：
当对象从内存中销毁时，就会自动调用__del__方法
有时，我们希望一个对象离开时，在做一些事情时，__del__方法就用到了

__str__方法：
在Python中，使用print 输出对象变量时候，默认情况下，会输出这个变量的引用的对象
是由哪一个类创建的对象，以及在内存中的地址
如果在开发中，我们希望使用print输出对象变量时，能够打印自定义内容，就可以利用
__str__方法来实现自定义的内容的功能了
注意：必须返回一个字符串

一个对象的属性，可以使另一个类创建的对象，如果在定义属性时，不知道设置什么初始值，可以设置为None
1.None 关键字表示什么都没有
2.表示一个空对象，没有方法和属性，是一个特殊的常量
3.可以给None赋值给任何一个变量

练习:
“”"
1.士兵 许三多 有一把AK47
2.士兵可以开火
3.抢能够发射子弹
4.枪装填子弹 ----增加子弹数量

"""
#枪类
class Gun():
      def __init__(self,name):
            self.name=name
            self.count=0
      def add_count(self,count):
            #增加子弹
            self.count +=count
      def  shoot(self):
            #没射击一次子弹-1
            self.count -=1
            print("biu...")

#士兵类
class Shibing():
      def __init__(self,name):
            self.name=name
            self.gunname=None
      def open_gun(self,count):
            #判断许三多是否有枪，没有枪则跳出
            if self.gunname == None:
                  print("{0}还没有枪".format(self.name))
                  return
            self.gunname.add_count(count)
            print('{0}开始射击'.format(self.name,))
            self.gunname.shoot()
            
#枪的对象          
AK47=Gun('ak47')
#士兵的对象
xusanduo=Shibing('许三多')
#内存中gunname变量指向AK47类的内存地址.我们也可以理解成，gunname相当于AK47.
xusanduo.gunname=AK47
xusanduo.open_gun(10)
.

id可以查看变量的内存地址
is 可以比较俩个变量引用的对象是否一致
== 可以比较俩变量的值是否一致

私有属性或私有方法：
对象的某些属性或方法可能只希望在对象的内部使用，而不希望在外部访问到.

定义方式：
在定义属性或方法时，在属性名或者方法名前增加俩个下划线，定义的就是私有属性或方法.

案例：

“”"
私有属性和私有方法练习
“”"

class Women():
      def __init__(self,name):
            self.name=name
            self.age=18
      def securty(self):
            print("{0}的年龄是{1}".format(self.name,self.age))


zhangsan=Women('张三')
print(zhangsan.age)
zhangsan.securty()


class Women():
      def __init__(self,name):
            self.name=name
            self.__age=18
      def __securty(self):
            #在类的内部是可以访问对象的私有属性
            print("{0}的年龄是{1}".format(self.name,self.__age))

zhangsan=Women('张三')
#在类的外外界无法访问类的私有属性
print(zhangsan.__age)
#私有方法同样不允许在外界使用
zhangsan.__securty()	

注：
1.在类的内部是可以访问对象的私有属性
2.在类的外界无法访问类的私有属性和私有方法

私有属性或私有方法并非真正的在外界无法访问，我们可以在外界使用下面这种格式：
_类名__属性（方法）
单下划线 类名 双下划线 属性名或方法名