初识面向对象（理论1）

一：类和对象

类就是一类事物

对象：具体的事物

好比人是一类，而具体叫某某名字的是对象

在python中，用变量表示特征，用函数表示技能，于是具备相同特征和技能的一类事物就是‘类’，对象是则是这一类事物中具体的一个。

一：初识

声明一个类  class小写。类名大写加：，（）可写可不写

class Person:   #定义一我的类      Person是类名
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人均可以走路，也就是有一个走路方法，也叫动态属性
        print("person is walking...")

类的两种做用：属性引用和实例化

一：属性引用（类名.属性）

class Person:  # 定义一我的类
    role = 'person'  # 人的角色属性都是人

    def walk(self):  # 人均可以走路，也就是有一个走路方法
        print("person is walking...")

print(Person.role)  # 查看人的role属性
print(Person.walk)  # 引用人的走路方法，注意，这里不是在调用

二：增强版（类做用，理论知识）

class Person:    # 类名 Person
    role = '人'  # 类的静态变量 是全部的对象共享的一个属性
    def attack(self):pass
print(Person.role)   # 类提供给咱们的调用方式
print(Person.attack)
Person.role = '中国人'
print(Person.role)
Person.attack()   # 报错
print(Person.__dict__) # 存储方式
print(Person.__dict__['role'])
print(Person.__dict__['attack'])
Person.__dict__['role'] = '人'

类只有两个做用:
    1.使用类中的名字
        查看类中的名字:
        类名.变量名                # 能够修改变量的值
        类名.__dict__['变量名']   # 不能修改
    2.创造对象  实例化对象
        对象就是实例,一个实际的例子
        对象 = 类名()
class Person:    # 类名 Person
    role = '人'  # 类的静态变量 是全部的对象共享的一个属性
    def __init__(self,name,sex,aggr,hp):  #{}
        self.name = name
        self.sex = sex
        self.aggr = aggr
        self.hp = hp
    def attack(self):
        print(self.name)
        print(self.sex)

obj1 = Person('alex','female',250,1)
obj2 = Person('egon','male',500,2)
print(obj1.name,obj1.sex,obj1.aggr,obj1.hp)
print(obj2.name,obj2.sex,obj2.aggr,obj2.hp)
print(obj1.__dict__)
print(obj2.__dict__)
print(obj1)
Person.attack(obj1)  # 调用一个类中的方法了
obj1.attack()
对象的具体:
    内存地址的不一致
    不一样的对象 属性的值应该不一样

类名(参数)
    创造一个空对象 : self
    调用__init__方法 : 初始化方法
    把参数传给__init__方法
    完成init方法中的代码
    自动将self返回给实例化的地方

self就是对象

调用类中的方法 :
    类名.方法名(对象)
    对象名.方法名()

三：总结

#初始面向对象
'''
class Person:
    role = '人'   # 类的静态变量 是全部的对象共享的一个属性
    def __init__(self):
       pass
    def attack(self):
1.类：一类事务，如人，电脑等
 对象：一个具体的事务，如小明，小明的手机
2.定义一个类：class Person(): 类名 Person 首字母要大写 （）可写可不写
              在类中添加共用属性  role = '人'  类的静态变量 是全部的对象共享的一个属性
在调用时用 print(Person.role)
3.查看类中的名字：
3.1 print(Person.role) 类提供给咱们的调用方式  能够进行修改 如Person.role = '中国人'
3.2 print(Person.__dict__) 类提供的存储方式 会将类中的全部名字和方法均显示出来
print(Person.__dict__['role'])
4.类只有两个做用:
4.1.使用类中的名字
    查看类中的名字:1. 类名.变量名 # 能够修改变量的值
                  2.类名.__dict__['变量名']   # 不能修改
4.2.创造对象  实例化对象
    对象就是实例,一个实际的例子
    对象 = 类名()  #obj1=person()
5.实例化：
1.obj1 = Person('alex','female',1,250)  # 实例化 先创造对象 再初始化
print(obj1.name,obj1.sex,obj1.aggr,obj1.hp)
print(obj2.name,obj2.sex,obj2.aggr,obj2.hp)
print(obj1.__dict__)
2.调用__init__方法 : 初始化方法
    def __init__(self,name,sex,aggr,hp):  #方法 动态属性  内置的双下方法 self就是对象
        self.name = name    self理解为等于一个空字典，self={} self.name中name为key值，等号右边的为value值
        self.sex = sex    name，sex等均为属性
        self.aggr = aggr
        self.hp = hp
6.对象的具体:
print(obj1) #object at 0x000001B8F1378A90>
print(obj2) #object at 0x000001B8F1378AC8>
    1.内存地址的不一致
    2.不一样的对象 属性的值应该不一样
7.类名(参数)
    1.创造一个空对象 : self(即obj1）
    2.调用__init__方法 : 初始化方法
    3.把参数传给__init__方法
    4.完成init方法中的代码
    5.自动将self返回给实例化的地方 self就是对象
8.调用类中的方法 :
 def attack(self):  # 自定义方法
        print(self.name)
1.类名.方法名(对象) Person.attack(obj1）
2.对象名.方法名() obj1.attack()  def attack(self):self就是obj1
9.使用面向对象的步骤：
1.完成类
首先分析一下角色和类 类里面有哪些属性 init方法
再分析这个类中能有哪些行为 定义为方法
2.实例化
传参数获取实例化以后的对象
    1.首先创造对象,
    2.执行init方法
3.对象的调用：使用对象调用对象属性和类中的方法
对象名的做用:
    1.使用变量 对象名.属性名 obj1.name
    2.调用方法 对象名.方法名() obj1.attack()
'''
####人狗大战
class Person:    # 类名 Person
    role = '人'  # 类的静态变量 是全部的对象共享的一个属性
    def __init__(self,name,sex,aggr,hp):  #方法 动态属性  内置的双下方法
        self.name = name    # 对象属性 实例属性
        self.sex = sex
        self.aggr = aggr
        self.hp = hp
    def attack(self,dog):  # 自定义方法
        print('%s打了%s'%(self.name,dog.name))
        dog.hp -= self.aggr

class Dog:
    def __init__(self,name,kind,aggr,hp):
        self.name = name   # 对象属性
        self.kind = kind
        self.aggr = aggr
        self.hp = hp
    def bite(self,person):
        print('%s咬了%s'%(self.name,person.name))
        person.hp -= self.aggr
hei = Dog('小黑','teddy',260,10000)  # 实例化: 先创造对象 再初始化
alex = Person('alex','female',1,250)  # 实例化
egon = Person('egon','male',2,500)  # 实例化
alex.attack(hei)   # Person.attack(alex,hei)
egon.attack(hei)   # Person.attack(alex,hei)
print(hei.hp)
hei.bite(alex)
print(alex.hp)
#
# ##根据半径求圆面积##
# from math import pi
# class Circle:
#     def __init__(self,r):
#         self.r=r
#     def area(self):
#        return self.r**2*pi
#     def  perimeter(self):
#        return self.r*2*pi
# circle=Circle(5)
# print(circle.area())
# print(circle. perimeter())
# ###小明，老王###
# '''
# 小明,男,10岁,上山去砍柴
# # 小明,男,10岁,开车去东北
# # 小明,男,10岁,最爱大保健
# # 老张,男,90岁,上山去砍柴
# # 老张,男,90岁,开车去东北
# # 老张,男,90岁,最爱大保健
# # 老王,男,70岁,上山去砍柴
# '''
# class Person:
#     def __init__(self,name,sex,aggr):
#         self.name=name
#         self.sex = sex
#         self.aggr = aggr
#     def attack(self):
#         print("%s%s%s上山去砍柴"%(self.name,self.sex,self.aggr ))
#         print("%s%s%s开车去东北" % (self.name, self.sex, self.aggr))
#         print("%s%s%s最爱大保健" % (self.name, self.sex, self.aggr))
# obj1=Person("小明","男",10)
# obj1.attack()
# obj2=Person("老王","男",90)
# obj2.attack()
# obj3=Person("老张","男",75)
# ###方法二###
# class Person:
#     def __init__(self,name,sex,age):
#         self.name = name
#         self.age = age
#         self.sex = sex
#     def dirve(self):
#         print('%s,%s,%s岁,开车去东北'%(self.name,self.sex,self.age))
#     def climb(self):
#         print('%s,%s,%s岁,上山去砍柴'%(self.name,self.sex,self.age))
#     def hobby(self):
#         print('%s,%s,%s岁,最爱大保健'%(self.name,self.sex,self.age))
# ming = Person('小明','男',10)
# ming.dirve()
# ming.climb()
# ming.hobby()
# zhang = Person('老张','男',90)
# zhang.dirve()
# zhang.climb()
# zhang.hobby()