前提：

1.只有在python2中才分新式类和经典类，python3中统一都是新式类

2.新式类和经典类声明的最大不同在于,所有新式类必须继承至少一个父类

3.所有类不管是否显式声明父类，都有一个默认继承object父类

在python2中的区分

经典类：

class 类名:

    pass

新式类：

class 类名(父类):

    pass

在python3中，上述两种定义方式全都是新式类

# 实例化

class Chinese:

    country = 'China'       # 类变量

    def __init__(self, name, age, sex):  # Chinese.__init__(p1,'shuke','18','male')

        self.Name = name                 # p1.Name=name; p1.Age=age; p1.Sex=sex

        self.Age = age

        self.Sex = sex

    def talk(self):

        print('%s is talking' % self.Name)

# 实例化

p1 = Chinese('shuke', '', 'male')  # Chinese.__init__(p1,'shuke','18','male')

p2 = Chinese('jack', '', 'female')  # Chinese.__init__(p2,'jack','25','female')

class Riven:

    camp='Noxus'

    def __init__(self,nickname,

                 aggressivity=54,

                 life_value=414,

                 money=1001,

                 armor=3):

        self.nickname=nickname

        self.aggressivity=aggressivity

        self.life_value=life_value

        self.money=money

        self.armor=armor

    def attack(self,enemy):

        damage_value=self.aggressivity-enemy.armor

        enemy.life_value-=damage_value

class Garen:

    camp='Demacia'

    def __init__(self,nickname,

                 aggressivity=58,

                 life_value=455,

                 money=100,

                 armor=10):

        self.nickname=nickname

        self.aggressivity=aggressivity

        self.life_value=life_value

        self.money=money

        self.armor=armor

    def attack(self,enemy):

        damage_value=self.aggressivity-enemy.armor

        enemy.life_value-=damage_value

class BlackCleaver:

    def __init__(self,price=475,aggrev=9,life_value=100):

        self.price=price

        self.aggrev=aggrev

        self.life_value=life_value

    def update(self,obj):

        obj.money-=self.price #减钱

        obj.aggressivity+=self.aggrev #加攻击

        obj.life_value+=self.life_value #加生命值

    def fire(self,obj): #这是该装备的主动技能,喷火,烧死对方

        obj.life_value-=1000 #假设火烧的攻击力是1000

r1=Riven('草丛伦')

g1=Garen('盖文')

b1=BlackCleaver()

print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲

if r1.money > b1.price:

    r1.b1=b1

    b1.update(r1)

print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲

print(g1.life_value)

r1.attack(g1) #普通攻击

print(g1.life_value)

r1.b1.fire(g1) #用装备攻击

print(g1.life_value) #g1的生命值小于0就死了

==========================第一部分

例如

　　猫可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：

#猫和狗有大量相同的内容

class 猫：

    def 喵喵叫(self):

        print '喵喵叫'

    def 吃(self):

        # do something

    def 喝(self):

        # do something

    def 拉(self):

        # do something

    def 撒(self):

        # do something

class 狗：

    def 汪汪叫(self):

        print '喵喵叫'

    def 吃(self):

        # do something

    def 喝(self):

        # do something

    def 拉(self):

        # do something

    def 撒(self):

        # do something

==========================第二部分

上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：

　　动物：吃、喝、拉、撒

　　   猫：喵喵叫（猫继承动物的功能）

　　   狗：汪汪叫（狗继承动物的功能）

伪代码如下：

class 动物:

    def 吃(self):

        # do something

    def 喝(self):

        # do something

    def 拉(self):

        # do something

    def 撒(self):

        # do something

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类

class 猫(动物)：

    def 喵喵叫(self):

        print '喵喵叫'

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类

class 狗(动物)：

    def 汪汪叫(self):

        print '喵喵叫'

==========================第三部分

#继承的代码实现

class Animal:

    def eat(self):

        print("%s 吃 " %self.name)

    def drink(self):

        print ("%s 喝 " %self.name)

    def shit(self):

        print ("%s 拉 " %self.name)

    def pee(self):

        print ("%s 撒 " %self.name)

class Cat(Animal):

    def __init__(self, name):

        self.name = name

        self.breed = '猫'

    def cry(self):

        print('喵喵叫')

class Dog(Animal):

    def __init__(self, name):

        self.name = name

        self.breed='狗'

    def cry(self):

        print('汪汪叫')

# ######### 执行 #########

c1 = Cat('小白家的小黑猫')

c1.eat()

c2 = Cat('小黑的小白猫')

c2.drink()

d1 = Dog('胖子家的小瘦狗')

d1.eat()

使用继承来重用代码比较好的例子

class BirthDate:

    def __init__(self,year,month,day):

        self.year=year

        self.month=month

        self.day=day

class Couse:

    def __init__(self,name,price,period):

        self.name=name

        self.price=price

        self.period=period

class Teacher:

    def __init__(self,name,gender):

        self.name=name

        self.gender=gender

    def teach(self):

        print('teaching')

class Professor(Teacher):

    def __init__(self,name,gender,birth,course):

        Teacher.__init__(self,name,gender)

        self.birth=birth

        self.course=course

p1=Professor('shuke','male',

             BirthDate('','',''),　　　　　　 # 组合类的使用

             Couse('python','','4 months'))　　# 组合类的使用

print(p1.birth.year,p1.birth.month,p1.birth.day)

print(p1.course.name,p1.course.price,p1.course.period)

'''

运行结果:

1 27

python 28000 4 months

'''

class People:

    def __init__(self,name,age,sex):

        self.name=name

        self.age=age

        self.sex=sex

class Date:

    def __init__(self,year,mon,day):

        self.year=year

        self.mon=mon

        self.day=day

    def tell(self):

        print('%s-%s-%s' %(self.year,self.mon,self.day))

class Teacher(People):

    def __init__(self,name,age,sex,salary,year,mon,day):

        self.name=name

        self.age=age

        self.sex=sex

        self.salary=salary

        self.birth=Date(year,mon,day)

class Student(People):

    def __init__(self,name,age,sex,year,mon,day):

        self.name=name

        self.age=age

        self.sex=sex

        self.birth=Date(year,mon,day)

t=Teacher('shuke',18,'male',3000,1995,12,31)

t.birth.tell()

'''

执行结果:

1995-12-31

'''

=================第一部分：Java 语言中的接口很好的展现了接口的含义: IAnimal.java

/*

* Java的Interface很好的体现了我们前面分析的接口的特征:

* 1)是一组功能的集合,而不是一个功能

* 2)接口的功能用于交互,所有的功能都是public,即别的对象可操作

* 3)接口只定义函数,但不涉及函数实现

* 4)这些功能是相关的,都是动物相关的功能,但光合作用就不适宜放到IAnimal里面了 */

package com.oo.demo;

public interface IAnimal {

    public void eat();

    public void run();

    public void sleep();

    public void speak();

}

=================第二部分：Pig.java：猪”的类设计,实现了IAnnimal接口

package com.oo.demo;

public class Pig implements IAnimal{ //如下每个函数都需要详细实现

    public void eat(){

        System.out.println("Pig like to eat grass");

    }

    public void run(){

        System.out.println("Pig run: front legs, back legs");

    }

    public void sleep(){

        System.out.println("Pig sleep 16 hours every day");

    }

    public void speak(){

        System.out.println("Pig can not speak"); }

}

=================第三部分：Person2.java

/*

*实现了IAnimal的“人”,有几点说明一下:

* 1)同样都实现了IAnimal的接口,但“人”和“猪”的实现不一样,为了避免太多代码导致影响阅读,这里的代码简化成一行,但输出的内容不一样,实际项目中同一接口的同一功能点,不同的类实现完全不一样

* 2)这里同样是“人”这个类,但和前面介绍类时给的类“Person”完全不一样,这是因为同样的逻辑概念,在不同的应用场景下,具备的属性和功能是完全不一样的 */

package com.oo.demo;

public class Person2 implements IAnimal {

    public void eat(){

        System.out.println("Person like to eat meat");

    }

    public void run(){

        System.out.println("Person run: left leg, right leg");

    }

    public void sleep(){

        System.out.println("Person sleep 8 hours every dat");

    }

    public void speak(){

        System.out.println("Hellow world, I am a person");

    }

}

=================第四部分：Tester03.java

package com.oo.demo;

public class Tester03 {

    public static void main(String[] args) {

        System.out.println("===This is a person===");

        IAnimal person = new Person2();

        person.eat();

        person.run();

        person.sleep();

        person.speak();

        System.out.println("\n===This is a pig===");

        IAnimal pig = new Pig();

        pig.eat();

        pig.run();

        pig.sleep();

        pig.speak();

    }

}

java中的interface

class Interface:#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。

    def read(self): #定接口函数read,未实现

        pass

    def write(self): #定义接口函数write，未实现

        pass

class Txt(Interface): #文本，具体实现read和write

    def read(self):

        print('文本数据的读取方法')

    def write(self):

        print('文本数据的读取方法')

class Sata(Interface): #磁盘，具体实现read和write

    def read(self):

        print('硬盘数据的读取方法')

    def write(self):

        print('硬盘数据的读取方法')

class Process(Interface):

    def read(self):

        print('进程数据的读取方法')

    def write(self):

        print('进程数据的读取方法')

class A(object):

    def test(self):

        print('from A')

class B(A):

    def test(self):

        print('from B')

class C(A):

    def test(self):

        print('from C')

class D(B):

    def test(self):

        print('from D')

class E(C):

    def test(self):

        print('from E')

class F(D,E):

    # def test(self):

    #     print('from F')

    pass

f1=F()

f1.test()

print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性

#新式类继承顺序:F->D->B->E->C->A

#经典类继承顺序:F->D->B->A->E->C

#python3中统一都是新式类

#pyhon2中才分新式类与经典类

#_*_coding:utf-8_*_

__author__ = 'Linhaifeng'

class Vehicle: #定义交通工具类

     Country='China'

     def __init__(self,name,speed,load,power):

         self.name=name

         self.speed=speed

         self.load=load

         self.power=power

     def run(self):

         print('开动啦...')

class Subway(Vehicle): #地铁

    def __init__(self,name,speed,load,power,line):

        Vehicle.__init__(self,name,speed,load,power)   # 调用:父类名.父类方法()

        self.line=line

    def run(self):

        print('地铁%s号线欢迎您' %self.line)

        Vehicle.run(self)

line13=Subway('中国地铁','180m/s','1000人/箱','电',13)

line13.run()

class Vehicle: #定义交通工具类

     Country='China'

     def __init__(self,name,speed,load,power):

         self.name=name

         self.speed=speed

         self.load=load

         self.power=power

     def run(self):

         print('开动啦...')

class Subway(Vehicle): #地铁

    def __init__(self,name,speed,load,power,line):

        #super(Subway,self) 就相当于实例本身 在python3中super()等同于super(Subway,self)

        super().__init__(name,speed,load,power)

        self.line=line

    def run(self):

        print('地铁%s号线欢迎您' %self.line)

        super(Subway,self).run()

class Mobike(Vehicle):#摩拜单车

    pass

line13=Subway('中国地铁','180m/s','1000人/箱','电',13)

line13.run()

#!/usr/bin/env python

#-*- coding:utf-8 -*-

#每个类中都继承了且重写了父类的方法

class A:

    def __init__(self):

        print('A的构造方法')

class B(A):

    def __init__(self):

        print('B的构造方法')

        A.__init__(self)

class C(A):

    def __init__(self):

        print('C的构造方法')

        A.__init__(self)

class D(B,C):

    def __init__(self):

        print('D的构造方法')

        B.__init__(self)

        C.__init__(self)

    pass

f1=D()

print(D.__mro__) #python2中没有这个属性

'''

执行结果:

D的构造方法

B的构造方法

A的构造方法

C的构造方法

A的构造方法

(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

'''

#!/usr/bin/env python

#-*- coding:utf-8 -*-

#每个类中都继承了且重写了父类的方法

class A:

    def __init__(self):

        print('A的构造方法')

class B(A):

    def __init__(self):

        print('B的构造方法')

        super(B,self).__init__()

class C(A):

    def __init__(self):

        print('C的构造方法')

        super(C,self).__init__()

class D(B,C):

    def __init__(self):

        print('D的构造方法')

        super(D,self).__init__()

f1=D()

print(D.__mro__) # python2中没有这个属性

'''

执行结果:

D的构造方法

B的构造方法

C的构造方法

A的构造方法

(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

'''

>>> def func(obj):

...     print(obj.__len__())

...

>>> func('Hello')

5

>>> func([0,1,2,3])

4

>>> func((7,8,9))

3

#!/usr/bin/python

# -*- coding:utf-8 -*-

class Animal:

    def talk(self):

        print('Is talking')

class People(Animal):

    def talk(self):

        print('say hello...')

class Pig(Animal):

    def talk(self):

        print('say hengheng...')

class Dog(Animal):

    def talk(self):

        print('say wangwang...')

class Cat(Animal):

    def talk(self):

        print('say miaomiao...')

def func(obj):      # 参数obj就是对态性的体现

    obj.talk()      # 执行同一个方法

peo1=People()       # 产生一个人的对象

pig1=Pig()          # 产生一个猪的对象

dog1=Dog()          # 产生一个狗的对象

cat1=Cat()          # 产生一个猫的对象

func(peo1)

func(pig1)

func(dog1)

func(cat1)

'''

执行结果:

say hello...

say hengheng...

say wangwang...

say miaomiao...

'''

#!/usr/bin/env python

#-*- coding:utf-8 -*-

import abc

class File(metaclass=abc.ABCMeta):

    @abc.abstractmethod

    def click(self):

        pass

class Text(File):

    def click(self):

        print('open file')

class ExeFile(File):

    def click(self):

        print('execute file')

def func(file):         # 参数file就是对态性的体现

   file.click()

t1=Text()               # 实例化一个文本文件的对象

e1=ExeFile()            # 实例化一个可执行文件的对象

func(t1)

func(e1)

'''

执行结果:

open file

execute file

'''

>>> class A:

...     def fa(self):

...         print('from A')

...     def test(self):

...         self.fa()

...

>>> class B(A):

...     def fa(self):

...         print('from B')

...

>>> b=B()

>>> b.test()

from B

#把fa定义成私有的，即__fa

>>> class A:

...     def __fa(self): #在定义时就变形为_A__fa

...         print('from A')

...     def test(self):

...         self.__fa() #只会与自己所在的类为准,即调用_A__fa

...

>>> class B(A):

...     def __fa(self):

...         print('from B')

...

>>> b=B()

>>> b.test()

from A

class Foo:

    def __init__(self,val):

        self.__NAME=val #将所有的数据属性都隐藏起来

    def getname(self):

        return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)

    def setname(self,value):

        if not isinstance(value,str):  #在设定值之前进行类型检查

            raise TypeError('%s must be str' %value)

        self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME

    def delname(self):

        raise TypeError('Can not delete')

    name=property(getname,setname,delname) #不如装饰器的方式清晰

import time

class Date:

    def __init__(self,year,month,day):

        self.year=year

        self.month=month

        self.day=day

    @staticmethod

    def now():

        t=time.localtime()

        return Date(t.tm_year,t.tm_mon,t.tm_mday)

class EuroDate(Date):

    def __str__(self):

        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)

e=EuroDate.now()

print(e) #我们的意图是想触发EuroDate.__str__,但是结果为

'''

输出结果:

<__main__.Date object at 0x1013f9d68>

'''

import time

class Date:

    def __init__(self,year,month,day):

        self.year=year

        self.month=month

        self.day=day

    # @staticmethod

    # def now():

    #     t=time.localtime()

    #     return Date(t.tm_year,t.tm_mon,t.tm_mday)

    @classmethod #改成类方法

    def now(cls):

        t=time.localtime()

        return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪个类来调用,即用哪个类cls来实例化

class EuroDate(Date):

    def __str__(self):

        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)

e=EuroDate.now()

print(e) #我们的意图是想触发EuroDate.__str__,此时e就是由EuroDate产生的,所以会如我们所愿

'''

输出结果:

year:2017 month:3 day:3

'''