面向对象

封装

 

 

士兵开枪.py

lass Gun():
    def __int__(self,model):
        # 枪的型号
        self.model = model

        #子弹的数量
        self.bullet_count = 0
    def add_bullet(self,count):
        self.bullet_count += count


    def shoot(self):
        # 1.判断子弹的数量
        if self.bullet_count <=0:
            print '%s 没有子弹' %self.model
            return

        # 2.发射子弹
        self.bullet_count -= 1

        # 3.提示发射信息
        print '%s 凸凸图 %d' % (self.model,self.bullet_count)



class Soldier():
    def __init__(self,name):
        self.name = name
        self.gun = None

    def fire(self):
        # 1.判断士兵有没有枪
        if self.gun == None:
            print '%s 还没有枪..' %self.name
            return
        # 2.高叫口号
        print 'go!!! %s' %self.name
        # 3.让枪装填子弹
        self.gun.add_bullet(50)
        # 4.让枪发射子弹
        self.gun.shoot()
# 1.创建枪的对象
ak47 = Gun('AK47')
ak47.add_buller(50)
ak47.shoot()

#2. 创建士兵

nan = Soldier('nan')
nan.gun = ak47
nan.fire()
print nan.gun

 

 

__str__.py

class Pot():
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return '我 %s' % self.name

rib = Pot('rib')
print rib

 

 

家具

class Home:

    def __init__(self,name,area):
        self.name = name
        self.area = area

    def __str__(self):
        return '%s  地方 %.2f' %(self.name,self.area)

# 1.建造家具
bed = Home('bed',10)

print bed

table = Home('table',40)

print table


class House():
    def __init__(self,house_type,area):
        self.house_type = house_type
        self.area = area
        #剩下面积
        self.free_area = area

        #家具名称列表
        self.item_list = []
    def __str__(self):
        return '户型:%s\n总面积:%.2f[剩下:%.2f]\n家具:%s' % \
               (self.house_type,self.area,self.free_area,self.item_list)

    def add__item(self,item):

        print '要添加 %s' % item

        # 1.判断家具的面积
        if item.area > self.free_area:
            print '%s 的面积太大，无法添加' % item.name
        # 如果不满足，下面的代码就不执行
        return

        # 2.将家具的名称添加到列表中
        self.item_list.append(item.name)

        # 3.计算剩下的面积
        self.free_area -= item.area



my_home = House('两室一方',100)


my_home.add__item(bed)

my_home.add__item(table)

print my_home

 

 

封装.py

class Run():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def __str__(self):
        return '我的名字叫 %s 体重是 %2f' (self.name,self.weight)
    def eat(self):
        self.weight += 1
        print '%s 爱跑步'    % self.name


tom = Run('tom',75.0)
tom.eat()
print tom

 

多态

class Dog(object):
    def __init__(self,name):
        self.name = name
    def game(self):
        print '%s 跑步'     %self.name




class Xiaotianquan(Dog):
    def game(self):
        print '%s 飞到天上玩' % self.name




class Person(object):
    def __init__(self,name):
        self.name = name
    def game_with_dog(self,dog):
        print '%s 和 %s 快乐的玩' % (self.name,dog)

        dog.game()
# 1.建造一个狗对象
wangcai = Dog('王才')
# 2.建造一个人对象
xiaoming = Person('小明')
# 让小帝和狗玩
xiaoming.game_with_dog(wangcai)

 

 

 

 

私有属性和私有方法

01 py

class Men():
    def __init__(self,name):
        self.name = name
        self._age = 18

    def secret(self):
        print '%s 的年龄是 %d' % (self.name,self._age)

nan = man('nan')
print nan.age
nan.secret()

 

02.py

class A(object):
    def __init__(self):
        # 在初始化方法中定义了两个属性，一个共有属性，一个私有属性
        self.nm1 = 100
        self._num2 = 200
        # 定义私有方法
    def _test(self):
        print '私有方法 %d $d' (self.nm1,self._num2)

    def test(self):
        print '%d' % self._num2
        self._test()


class B(A):
    def demo(self):
        #在子类的方法中，不能调用父类的私有属性
        print '访问父类的私有属性 %d' % self._num2
        #在子类的方法中，不能调用父类的私有方法
        self._test()
        pass

# 建造了一个子类对象
b = B()
print  b
print b._num2
b._test

类的属性

类属性-类方法

 

综合应用.py

 

类属class Game(object):
    score_count = 0


    def show_score_count(cls):
        score.count += 1
    def __init__(self,name):
        self.name = name
        # 让类属性的值+1

    @classmethod
    def show_help():
        print '!!!!!'

    @classmethod
    def show_top_score(cls):
        print '历史记录 %d' % cls.top_score

    def star_game(self):
        print






"""

案例小结:
1.案例方法：方法内部需要访问实例属性
2.类方法：方法内部只需要访问类属性
3.静态方法：方法内部不需要访问实例属性和类属性
又需要访问类属性
提问：如果方法内部，要访问实例属性，应该定义实例方法
应该定义实例方法
因为，类只有一个，在实例方法的内部可以使用
"""

综合应用2.py

class Game(object):
    @classmethod


    def __init__(self,name):
        self.name = name
        # 让类属性的值+1
    def show_help(self,show_help):
        print ''

 

02.py

class Toy(object):
    count= 0
    @classmethod
    def show_toy_count(cls):
        #cls.coun:在类方法的内部，访问当前的类属性
        print '玩具对象的数量 %d' % cls.count

    def _init_(self,name):
        self.name = name
        Toy.count +=1


#创建玩具对象
toy1 = Toy('乐高')
toy2 = Toy('玩具车')
toy3 = Toy('玩具熊')

#调用类方法
Toy.show_toy_count()

# 在方法的内部，可以直接访问类属性

 

对数

class Dog(object):
    def __init__(self,name):
        self.name = name
    def game(self):
        print '%s 跑步'     %self.name


mao = Dog('nn')
mao.game()

 

类的属性.py

class Tool(object):
    count =0
    def __init__(self,name):
        self.name = name
        # 让类属性的值+1
        Tool.count +=1

# 建造工具对象（对象在创建的时候，会自动调用初始化方法
tool1 = Tool('斧头')
tool2 = Tool('手套')
tool3 = Tool('阶梯')

# 输出工具对象的总数
# 是由类名，属性名 来获取
print Tool.count

 

类的属性03.py

#语法：


class Cat(object):
    @staticmethod
    #静态方法不需要传递第一个参数:self
    def call():
        print '小猫渺渺叫'
Cat.call()

 

继承

class Bird():
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print 'Aaaaaaa....'
            self.hungry = False
        else:
            print 'no Thanks!'

class SongBird(Bird):
    def __init__(self):
        self.sound = 'Squawk!'
        Bird.__init__(self)
    def sing(self):
        print self.sound

#bird = Bird()
#bird.eat()

littlebird = SongBird()
littlebird.eat()
littlebird.sing()

 

继承-01.py

class Humen():
    def game(self):
        print '打游戏'

    def drink(self):
        print '喝水'

    def sleep(self):
        print '睡觉'

    def run(self):
        print '跑步'

class Singer(Humen):
    def sing(self):
        print 'rib唱歌'
    def sleep(self):
        print '不睡觉'


class Rin(Singer):
    def sing(self):
        print 'rin唱歌'

rib = Singer()
rib.sleep()


ji = Rin()
ji.sing()

继承-03.py

class A():
    def demo (self):
        print 'A-----demo方法'
    def test (self):
        print 'A-----test方法'

class B():
    def demo(self):
        print 'B-------demo方法'
    def test(self):
        print 'B-------demo方法'

class C(A,B):
    pass

c=C()
c.test()

 

面向对型4.py

class Dog():
    def __int__(self,new_name):
        self.name = new_name
    def eat(self):
        print '%/s 爱睡觉' % self.name

tom = Dog('tom')
print tom.name
tom.eat()

 

面向对象1.py

#小猫爱吃鱼，小猫要喝水

class Cat():
    def run(self):
        print '小猫走路'

    def drink(self):
        print '小猫喝水'

 

面向对象3.py

 

class Cat():
    def run(self):
        print '% love fish' %self.name


    def drink(self):
        print '% love drink' %self.name



#建造狗对象




#lazy_cat = Cat()

#lazy_cat.eat()

#lazy_cat.drik()

#print lazy_cat


#lazy_cat2 = lazy_cat
#print lazy_cat2



tom = Cat()
tom.run()
tom.name = 'tom'
tom.drink()
print tom

 

 

设计模式

class student(object):
    count = 0

    def __init__(self):
        student.count += 1

    @staticmethod
    def count_num():
        print '现在%s名学生' % student.count


j = student()
d = student()
f = student()
student.count_num()

 

 

class Student(object):
    count = 0
    def __init__(self,name):
        self.name = name
        Student.count += 1

Studnet1 = Student ('学生1')
Studnet1 = Student ('学生2')
Studnet1 = Student ('学生3')

print Student.count

 

class Parent(object):
   x = 1

class Child1(Parent):
   pass

class Child2(Parent):
   pass

print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)

 

class People(object):
    __name = "luffy"
    __age = 18


p1 = People()
print(p1.__name, p1.__age)

 

class MusicPlayer(object):
    isinstance = None
    def __new__(cls, *args, **kwargs):
        # 第一个参数 cls:哪一个类调用，就传递哪一个类
        # 第二个参数 *args:多值参数
        # 第三个参数 **kwargs： 多值的字典参数
        # 创建对象的时候，new 方法会自动调用
        # 重写了父类的方法
            if cls.isinstance is None:
                cls.isinstance = object.__new__(cls)
            return cls.isinstance

player1 = MusicPlayer()
print player1

player2 = MusicPlayer()
print player2