Python 继承和组合 接口

#解决代码重用的问题,减少代码冗余
#继承是一种什么‘是’什么的关系
class People:
    def __init__(self, name, age):
        # print(‘People.__init__‘)
        self.name = name
        self.age = age
    def walk(self):
        print(‘%s is walking‘ %self.name)

class Teacher(People):
    pass

class Student(People):
    pass

# t=Teacher(‘egon‘,18)
# print(t.name,t.age)
# print(t.__dict__)
# t.walk()

# s=Student(‘alex‘,13)
# print(s.name,s.age)
# s.walk()

#====================
class People:
    def __init__(self, name, age,sex):
        self.name = name
        self.age = age
        self.sex=sex

    def walk(self):
        print(‘%s is walking‘ % self.name)

    def foo(self):
        print(‘from father %s‘ %self.name)

class Teacher(People):
    school = ‘偶的博爱‘
    #__init__(t,‘egon‘,18,‘male‘,10,3000)
    def __init__(self, name, age,sex,level,salary):
        People.__init__(self,name,age,sex)
        #People.__init__(t,‘egon‘,18,‘male‘)
        #t.name=‘egon‘
        #t.age=18
        #t.sex=‘male‘

        self.level=level
        self.salary=salary

    def teach(self):
        print(‘%s is teaching‘ %self.name)

    def foo(self):
        People.foo(self)
        print(‘from teacher‘)

class Student(People):
    def __init__(self, name, age,sex,group):
        People.__init__(self, name, age, sex)
        self.group=group
    def study(self):
            print(‘%s is studying‘ %self.name)

t=Teacher(‘egon‘,18,‘male‘,10,3000) #__init__(t,‘egon‘,18,‘male‘,10,3000)
t.foo()

#
# class Teacher:
#     school = ‘偶的博爱‘
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
#     def teach(self):
#         print(‘%s is teaching‘ %self.name)
#     def walk(self):
#         print(‘%s is walking‘ %self.name)
#
#
# class Student:
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
#
#     def study(self):
#         print(‘%s is studying‘ %self.name)
#     def walk(self):
#         print(‘%s is walking‘ %self.name)

继承

#继承是用来创建新的类的一种方式,好处是可以减少重复代码
#继承是类与类之间的关系,是一种什么是什么的关系

#组合:是一种什么有什么的关系,也是为了减少重复代码
class People:
    def __init__(self, name, age, year, mon, day):
        self.name = name
        self.age = age
        self.birth = Date(year, mon, day)

    def walk(self):
        print(‘%s is walking‘ % self.name)

class Date:
    def __init__(self,year,mon,day):
        self.year=year
        self.mon=mon
        self.day=day

    def tell_birth(self):
        print(‘出生于<%s>年 <%s>月 <%s>日‘ % (self.year,self.mon,self.day))

class Teacher(People):
    def __init__(self, name, age, year, mon, day,level,salary):
        People.__init__(self,name,age,year,mon,day)
        self.level=level
        self.salary=salary

    def teach(self):
        print(‘%s is teaching‘ %self.name)

class Student(People):
    def __init__(self, name, age, year, mon, day,group):
        People.__init__(self,name,age,year,mon,day)
        self.group=group
    def study(self):
        print(‘%s is studying‘ %self.name)
# t=Teacher(‘egon‘,18,1990,2,33)
# print(t.name,t.age)
# print(t.birth)
# t.birth.tell_birth()
# print(t.birth.year)
# print(t.birth.mon)
# print(t.birth.day)

class Course:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

    def tell_info(self):
        print(‘课程名<%s> 价钱<%s> 周期<%s>‘ %(self.name,self.price,self.period))

#=====================================
# class Date:
#     def __init__(self,year,mon,day):
#         self.year=year
#         self.mon=mon
#         self.day=day
#
#     def tell_birth(self):
#         print(‘出生于<%s>年 <%s>月 <%s>日‘ % (self.year,self.mon,self.day))
#
# class Teacher:
#     def __init__(self,name,age,birth):
#         self.name=name
#         self.age=age
#         self.birth=birth
#
#     def teach(self):
#         print(‘%s is teaching‘ %self.name)
#
# t_birth=Date(1990,2,33)
# t=Teacher(‘egon‘,18,t_birth)

组合

接口

时间: 2024-12-11 13:02:57

Python 继承和组合 接口的相关文章

python 继承与组合

一.组合 #老师 课程 生日 class Course: def __init__(self,name,period,price): self.name = name self.period = period self.price = price class Birth: def __init__(self,year,month,day): self.year = year self.month = month self.day = day class Teacher: def __init__

[Think In Java]基础拾遗1 - 对象初始化、垃圾回收器、继承、组合、代理、接口、抽象类

目录 第一章 对象导论第二章 一切都是对象第三章 操作符第四章 控制执行流程第五章 初始化与清理第六章 访问权限控制第七章 复用类第九章 接口 第一章 对象导论 1. 对象的数据位于何处? 有两种方式在内存中存放对象: (1)为了追求最大的执行速度,对象的存储空间和生命周期可以在编写程序时确定,这可以通过将对象置于堆栈或者静态存储区域内来实现.这种方式牺牲了灵活性. (2)在被称为堆的内存池中动态地创建对象.在这种方式,知道运行时才知道对象需要多少对象,它们的生命周期如何,以及它们的具体类型.

继承和组合、抽象类和接口

继承和组合的使用原则: 1.很多资料中提到的一点,如果两个类之间是is-a的关系,那么就使用继承,而如果是has-a的关系就使用组合. 但是这也不是代表is-a是使用继承的绝对理由,有时候为了消除继承关系带来的耦合,使用组合可以更好的实现封装细节. 如果在一个系统中大量应用继承,继承层次深了,那么会给系统的开发和维护带来困难. 2.无论何时,如果你使用继承,但是又不想向上转型,那么这个时候就应该慎重选择,只要有可能,就应该考虑使用组合来达 到自己的目的.因为组合在类的运行期间通过类的属性来改变类

python类继承和组合

在python3中所有类默认继承object,凡是继承了object的类都成为新式类,以及该子类的子类Python3中所有的类都是新式类,没有集成object类的子类成为经典类(在Python2中没有集成object的类以及它的子类都是经典类 继承式用来创建新的类的一种方式,好处是减少重复代码 class People: def __init__(self,name,age): self.name=name self.age=age def walking(self): print('%s is

组合接口时名字冲突问题

之前从没注意到实现多个接口可能会存在方法冲突的问题,在<Thinking in Java>中看到一个有趣的例子,其本质是重载和重写的问题,关于重载和重写的概念和区别可参看另一篇文章Java基础一:面向对象的特征.首先看例子: 1 interface I1 { 2 void f(); 3 } 4 5 interface I2 { 6 int f(int i); 7 } 8 9 interface I3 { 10 int f(); 11 } 12 13 class C { 14 public in

java的继承和组合

继承和组合是java中非常常用的两种创建新类型的方法,两者都能提高代码的复用率. 继承主要是想让子类继承父类的基本特性:组合技术通常用于想在新类中使用现有类的功能,而非它的接口.两者的分别是"IS A"和"HAS A"的关系 继承: class Shape { public void draw() { System.out.println("draw a shape"); } public void erase() { System.out.pr

Java中的继承与组合

本文主要说明Java中继承与组合的概念,以及它们之间的联系与区别.首先文章会给出一小段代码示例,用于展示到底什么是继承.然后演示如何通过“组合”来改进这种继承的设计机制.最后总结这两者的应用场景,即到底应该选择继承还是组合. 1.继承 假设我们有一个名为Insect(昆虫)的类,这个类包含两个方法:1)移动move(): 2)攻击attack(). 代码如下: class Insect { private int size; private String color; public Insect

菜鸟译文(一)——Java中的继承和组合

阅读英文的能力对于程序员来说,是很重要的.这几年也一直在学习英文,今天心血来潮,就在网上找了一篇简短的博文翻译一下.水平一般,能力有限,还请各位看官多多指点. 译文: 本文将会举例说明Java中继承和组合的概念.首先举一个继承的例子,然后展示一下如何用组合来改善继承的设计.最后概括一下如何在它们之间做出选择. 1. 继承 假设我们有一个Insect类.这个类包含两个方法:一个是move(),一个是attack(). class Insect { private int size; private

Java中的继承与组合(转载)

本文主要说明Java中继承与组合的概念,以及它们之间的联系与区别.首先文章会给出一小段代码示例,用于展示到底什么是继承.然后演示如何通过“组合”来改进这种继承的设计机制.最后总结这两者的应用场景,即到底应该选择继承还是组合. 1.继承 假设我们有一个名为Insect(昆虫)的类,这个类包含两个方法:1)移动move(): 2)攻击attack().代码如下: class Insect { private int size; private String color; public Insect(