本文实例讲述了Python面向对象类的继承。分享给大家供大家参考，具体如下：
一、概述
面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”，继承的过程，就是从一般到特殊的过程。在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
继承概念的实现方式主要有2类：实现继承、接口继承。
实现继承是指使用基类的属性和方法而无需额外编码的能力。
接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)。
在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。
OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。
二、类的继承
2.1 继承的定义
class Person(object): # 定义一个父类
def talk(self): # 父类中的方法
print("person is talking....")
class Chinese(Person): # 定义一个子类， 继承Person类
def walk(self): # 在子类中定义其自身的方法
print('is walking...')
c = Chinese()
c.talk() # 调用继承的Person类的方法
c.walk() # 调用本身的方法
输出：
person is talking....
is walking...
2.2 构造函数的继承
如果我们要给实例 c 传参，我们就要使用到构造函数，那么构造函数该如何继承，同时子类中又如何定义自己的属性？
继承类的构造方法：
1.经典类的写法： 父类名称.__init__(self,参数1，参数2，...)
2. 新式类的写法：super(子类，self).__init__(参数1，参数2，....)
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
self.weight = 'weight'
def talk(self):
print("person is talking....")
class Chinese(Person):
def __init__(self, name, age, language): # 先继承，在重构
Person.__init__(self, name, age) #继承父类的构造方法，也可以写成：super(Chinese,self).__init__(name,age)
self.language = language # 定义类的本身属性
def walk(self):
print('is walking...')
class American(Person):
pass
c = Chinese('bigberg', 22, 'Chinese')
如果我们只是简单的在子类Chinese中定义一个构造函数，其实就是在重构。这样子类就不能继承父类的属性了。所以我们在定义子类的构造函数时，要先继承再构造，这样我们也能获取父类的属性了。
子类构造函数基础父类构造函数过程如下：
实例化对象c ----> c 调用子类__init__() ---- > 子类__init__()继承父类__init__() ----- > 调用父类 __init__()
2.3 子类对父类方法的重写
如果我们对基类/父类的方法需要修改，可以在子类中重构该方法。如下的talk()方法
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
self.weight = 'weight'
def talk(self):
print("person is talking....")
class Chinese(Person):
def __init__(self, name, age, language):
Person.__init__(self, name, age)
self.language = language
print(self.name, self.age, self.weight, self.language)
def talk(self): # 子类 重构方法
print('%s is speaking chinese' % self.name)
def walk(self):
print('is walking...')
c = Chinese('bigberg', 22, 'Chinese')
c.talk()
输出：
bigberg 22 weight Chinese
bigberg is speaking chinese
三、类继承的事例
class SchoolMember(object):
'''学习成员基类'''
member = 0
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
self.enroll()
def enroll(self):
'注册'
print('just enrolled a new school member [%s].' % self.name)
SchoolMember.member += 1
def tell(self):
print('----%s----' % self.name)
for k, v in self.__dict__.items():
print(k, v)
print('----end-----')
def __del__(self):
print('开除了[%s]' % self.name)
SchoolMember.member -= 1
class Teacher(SchoolMember):
'教师'
def __init__(self, name, age, sex, salary, course):
SchoolMember.__init__(self, name, age, sex)
self.salary = salary
self.course = course
def teaching(self):
print('Teacher [%s] is teaching [%s]' % (self.name, self.course))
class Student(SchoolMember):
'学生'
def __init__(self, name, age, sex, course, tuition):
SchoolMember.__init__(self, name, age, sex)
self.course = course
self.tuition = tuition
self.amount = 0
def pay_tuition(self, amount):
print('student [%s] has just paied [%s]' % (self.name, amount))
self.amount += amount
t1 = Teacher('Wusir', 28, 'M', 3000, 'python')
t1.tell()
s1 = Student('haitao', 38, 'M', 'python', 30000)
s1.tell()
s2 = Student('lichuang', 12, 'M', 'python', 11000)
print(SchoolMember.member)
del s2
print(SchoolMember.member)
输出：
----end-----
just enrolled a new school member [haitao].
----haitao----
age 38
sex M
name haitao
amount 0
course python
tuition 30000
----end-----
just enrolled a new school member [lichuang].
3
开除了[lichuang]
2
开除了[Wusir]
开除了[haitao]
希望本文所述对大家Python程序设计有所帮助。

子类继承父类遇到和父类同名不同类型的属性可以用json注解转化@JsonProperty，继承主要为了抽象公用方法，
 有时子类的有字段拓展，A1 extend A,  c1 extend c  a1包含c a包含 c1 此时c1,c不可同名
 在实体转化成json的时候，同名的子类覆盖父类属性值
 
 
 
package com.mcd.cn.rdc.pcm.product.business.vo.product;

import com.alibaba.fastjson.annotation.JSONField;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.mcd.cn.rdc.pcm.product.business.vo.menu.MenuComboCompositionlForNewVo;
import com.mcd.cn.rdc.pcm.product.business.vo.menu.MenuForNewVO;
import com.mcd.cn.rdc.pcm.product.business.vo.menu.ProductGroupForNewVO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;

import java.util.List;

/**
 * @author: yuhui
 */
@Data
@ApiModel(description = "缓存商品信息")
@Accessors(chain = true)
public class ProductDetailVO extends MenuForNewVO {

    @ApiModelProperty(value = "商品中文长名称", required = true, notes = "如：麦麦脆汁鸡2块(含：1块鸡胸 + 1块鸡腿)", position = 13,allowableValues = "1,2")
    private String productLongNameCn;
    @ApiModelProperty(value = "商品英文长名称", required = true, notes = "如：麦麦脆汁鸡2块(含：1块鸡胸 + 1块鸡腿)", position = 13,allowableValues = "1,2")
    private String productLongNameEn;
    @ApiModelProperty(value = "商品中文描述", required = true, position = 13,allowableValues = "1,2")
    private String descCn;
    @ApiModelProperty(value = "商品英文描述", required = true, position = 13,allowableValues = "1,2")
    private String descEn;
    @ApiModelProperty(value = "套餐组对象", required = true, notes = "如果单品中存在特制属性，也需要在产品组对象中有值", example = "", position = 14)
    @JsonProperty("comboComprisesList")
    private List<ProductDetailComboCompositionlVo> comboComprisesDetailList;
    private List<ProductGrillVO> grillList;
    @ApiModelProperty(value = "商品组对象", required = true, notes = "存商品组子项", example = "", position = 14)
    private List<ProductSpecsListVO> specsList;
    @ApiModelProperty(value = "商品组对象", required = true, notes = "存商品组子项", example = "", position = 14)
    @JsonProperty("productGroupList")
    private List<ProductDetailGroupVO> productGroupDetailList;
    /**
     *是否存在特制，example：1：有特制 0：无特制
     */
    private Integer hasGrill;


    @JsonIgnore
    private String daypart;
//    @JsonIgnore
//    private String salesPeriod;
//    @JsonIgnore
//    private String salesTime;
}
 
 
 
 
 
 
 
package com.mcd.cn.rdc.pcm.product.business.vo.menu;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.mcd.cn.rdc.pcm.product.business.vo.product.ProductSalesDaypartVO;
import com.mcd.cn.rdc.pcm.product.business.vo.product.ProductSalesPeriodVO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;

import java.util.List;

/**
 * @author: yuhui
 */
@Data
@ApiModel(description = "菜单信息根据类别")
@Accessors(chain = true)
public class MenuForNewVO {

    @ApiModelProperty(value = "商品id", required = true, example = "", position = 0)
    private Long id;
    @ApiModelProperty(value = "商品编码", required = true, example = "", position = 0)
    private String productCode;
    @ApiModelProperty(value = "菜单商品显示名称中文", required = true, notes = "如：麦麦脆汁鸡2块", position = 1)
    private String productNameCn;
    @ApiModelProperty(value = "菜单商品显示名称英文", notes = "如：McCrispy Chicken-2pcs", position = 2)
    private String productNameEn;
    @ApiModelProperty(value = "价格组redis存储key", required = true, notes = "redis存储key", example = "", position = 3)
    private String priceGroupInfo;
    @ApiModelProperty(value = "商品图片相对路径redis存储key", required = true, notes = "只有图片名称，图片路径需要前台配置redis存储key", example = "", position = 4)
    private String productImage;
    @ApiModelProperty(value = "每周售卖日", required = true, notes = "7位数字表示一周中每天的售卖情况, 1:可售; 0:不可售. 例: 1111100, 表示周一到周五可售", example = "", position = 4)
    private String  dayOfWeek;
    @ApiModelProperty(value = "菜品类别", required = true, notes = "1：单品 2：套餐 3：产品组", position = 11,allowableValues = "1,2,3")
    private String productType;
    @ApiModelProperty(value = "售卖标识", required = true, notes = "1:可卖,0:不可买,2:隐藏", position = 12,allowableValues = "0,1,2")
    private String saleFlag;
    @ApiModelProperty(value = "商品组的前端交互方式", required = true, notes = "1：单品到详情页；2：产品组到详情页", position = 13,allowableValues = "1,2")
    private String  uiType;
    @ApiModelProperty(value = "商品组对象", required = true, notes = "存商品组子项", example = "", position = 14)
    private List<ProductGroupForNewVO> productGroupList;
    @ApiModelProperty(value = "bu", required = true, notes = "商品bu", position = 13,allowableValues = "1,2")
    private String  bu;
    @ApiModelProperty(value = "套餐组对象", required = true, notes = "如果单品中存在特制属性，也需要在产品组对象中有值", example = "", position = 14)
    private List<MenuComboCompositionlForNewVo> comboComprisesList;
    private List<TagVO> productTagList;
    @ApiModelProperty(value = "商品售卖期间", required = true, notes = "商品售卖期间", example = "", position = 14)
    private List<ProductSalesPeriodVO> salesPeriod;
    @ApiModelProperty(value = "售卖时间段", required = true, notes = "商品每天的售卖时间段，与指定的餐段时间取交集为实际有效售卖时间", example = "", position = 14)
    private List<ProductSalesDaypartVO> salesTime;

    @JsonIgnore
    private String daypart;
//    @JsonIgnore
//    private String salesPeriod;
//    @JsonIgnore
//    private String salesTime;
}

对于访问父类的变量我们到底应该如何做？？
 
1. 直接访问通过方法访问父类的变量：
 
 
 
 
  

   第一种情况代码 
     
    
  
 
 
 
 
package com.huawei.test 
public class ProtectedVariable extends Parent{ 
public static void main(String[] args) { 
Parent v1 = new ProtectedVariable(); 
v1.setName("keke8614"); 
System.out.println(v1.getName()); 
Parent v2 = new ProtectedVariable(); 
v2.setName("keke8615"); 
System.out.println(v2.getName()); 
System.out.println(v1.getName()); 
} 
} 
class Parent{ 
private String name; 
public String getName() { 
return name; 
} 
public void setName(String name) { 
this.name = name; 
} 
} 
 
 
package com.huawei.test
public class ProtectedVariable extends Parent{	
	public static void main(String[] args) {
		Parent v1 = new ProtectedVariable();
		v1.setName("keke8614");
		System.out.println(v1.getName());
		Parent v2 = new ProtectedVariable();
		v2.setName("keke8615");
		System.out.println(v2.getName());
		System.out.println(v1.getName());
	}
}
class Parent{
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
 
2. 第二种方法通过继承访问父类的变量：
 
 
 
 
  

   第二种方法代码 
     
    
  
 
 
 
 
package com.huawei.test; 
public class ProtectedVariable extends Parent{ 
public static void main(String[] args) { 
Parent v1 = new ProtectedVariable(); 
v1.name = "keke8614"; 
System.out.println(v1.name); 
Parent v2 = new ProtectedVariable(); 
v2.name = "keke8615"; 
System.out.println(v1.name); 
System.out.println(v2.name); 
} 
} 
class Parent{ 
protected String name; 
} 
 
 
package com.huawei.test;
public class ProtectedVariable extends Parent{
	public static void main(String[] args) {
		Parent v1 = new ProtectedVariable();
		v1.name = "keke8614";
		System.out.println(v1.name);
		Parent v2 = new ProtectedVariable();
		v2.name = "keke8615";
		System.out.println(v1.name);
		System.out.println(v2.name);
	}
}
class Parent{
	protected String name;
}
 
 
通过上面的方法我们都可以访问到变量，那么到底哪种访问符合便准的编程规范呢，我很是疑惑？
 
这是我在看一些源码中时发现的。而源码中更多的是以下的编码格式
 
 
 
 
 
  

   源码常用方式代码 
     
    
  
 
 
 
 
package com.huawei.test; 
public class ProtectedVariable extends Parent{ 
public static void main(String[] args) { 
Parent v1 = new ProtectedVariable(); 
v1.setName("keke8614"); 
System.out.println(v1.getName()); 
Parent v2 = new ProtectedVariable(); 
v2.setName("keke8615"); 
System.out.println(v2.getName()); 
System.out.println(v1.getName()); 
} 
} 
class Parent{ 
protected String name; 
public String getName() { 
//可能对name进行操作 
return name; 
} 
public void setName(String name) { 
//可能对name进行操作 
this.name = name; 
} 
} 
 
 
package com.huawei.test;
public class ProtectedVariable extends Parent{	
	public static void main(String[] args) {
		Parent v1 = new ProtectedVariable();
		v1.setName("keke8614");
		System.out.println(v1.getName());
		Parent v2 = new ProtectedVariable();
		v2.setName("keke8615");
		System.out.println(v2.getName());
		System.out.println(v1.getName());
	}
}
class Parent{
	protected String name;
	public String getName() {
		//可能对name进行操作
		return name;
	}
	public void setName(String name) {
		//可能对name进行操作
		this.name = name;
	}
}
 
 
这样设计到底起到了什么好处啊？？希望给予正解......

我有个需求是：继承自同一个父类的多个子类要继承父类的一个静态属性。（就比如说父类为人，有静态属性名字，子类男人，女人都要继承名字这个静态属性）
 在实际编码中，我发现有趣的现象，多个子类其实是共享父类的静态属性的。具体是什么意思，请看下面我举的一个例子。
 
 
首先是类图，父类是AbstractClass,他有两个子类分别是ConcreteClass1,ConcreteClass2。
 父类有一个静态属性是Form类型的变量。
 

 两个子类分别对这个继承自父类的静态属性赋值。
 ConcreteClass1赋值如下：10 小祝
 
 
public class ConcreteClass1 extends AbstractClass{
		
	
	public ConcreteClass1() {
		this.form = new Form(10, "小祝");
	}
}
 
ConcreteClass2 赋值如下： 2 小王
 
 
public class ConcreteClass2 extends AbstractClass{
		
	
	public ConcreteClass2() {
		this.form = new Form(2, "小王");
	}
	
}
 
然后为了验证这两个子类是不是共享父类的这个属性，我们做如下的测试
 
 
public class Client {
	public static void main(String[] args) {
		//创建一个ConcreteClass1子类对象   "小祝"，10元
		AbstractClass ac1 = new ConcreteClass1();
		System.out.println(ac1.getFormName()+":"+ac1.getFormMoney());
		//创建一个ConcreteClass2子类对象     "小王"，2元
		AbstractClass ac2 = new ConcreteClass2();
		System.out.println(ac2.getFormName()+":"+ac2.getFormMoney());
		System.out.println();
		
		//此时如果他们不共享的话，应该是 "小祝"，10元
		System.out.println(ac1.getFormName()+":"+ac1.getFormMoney());
		
	}
	
	
}
 
可以看出，如果两个子类不是共享同一个父类的属性，那么输出将会是：
 
 
但是实际输出是：
 
 这说明其实两个子类共有一个静态属性，当一个子类对这个属性进行更改后，另一个子类的该属性也随之更改。
 
 
那么如果我的需求是两个子类要有独自不受别的子类影响的继承自父类的属性怎么办？
 那就要把父类中的这个属性不能作为静态属性（即去掉static）
 
 之后再一次测试
 
 发现两个子类互不影响。