关于java 开发时，遇到过一种设计结构的疑惑：
如果一个子类继承了一个类的同时实现了一个接口，超类和接口中都有同一个方法，哪一个会传给子类？？
首先贴代码：
1.PermissionDomain.java （domain类，无需关心）
package com.fredia
import java.io.Serializable;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;
/**
* 系统模块信息表的domain
* @author : wangyong
* @version : v0.0.1
*/
@Table(name = "permission")
public class PermissionDomain implements Serializable {
private static final long serialVersionUID = 1L;
/*权限id*/
@Id
private Long id;
/*权限名称*/
private String name;
/*权限类型*/
private String type;
/*资源路径*/
private String url;
/*资源父ID*/
private Long parentId;
/*资源父编号列表*/
private String parentIds;
/*权限字符串*/
private String permission;
/*是否可用 0:true 1:false*/
private Integer available;
/*模块ID*/
private Long moduleId;
/*创建时间*/
private Date createTime;
/*修改时间*/
private Date updateTime;
public Long getId(){
return id;
}
public void setId(Long id){
this.id = id;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public String getType(){
return type;
}
public void setType(String type){
this.type = type;
}
public String getUrl(){
return url;
}
public void setUrl(String url){
this.url = url;
}
public Long getParentId(){
return parentId;
}
public void setParentId(Long parentId){
this.parentId = parentId;
}
public String getParentIds(){
return parentIds;
}
public void setParentIds(String parentIds){
this.parentIds = parentIds;
}
public String getPermission(){
return permission;
}
public void setPermission(String permission){
this.permission = permission;
}
public Integer getAvailable(){
return available;
}
public void setAvailable(Integer available){
this.available = available;
}
public Long getModuleId(){
return moduleId;
}
public void setModuleId(Long moduleId){
this.moduleId = moduleId;
}
public Date getCreateTime(){
return createTime;
}
public void setCreateTime(Date createTime){
this.createTime = createTime;
}
public Date getUpdateTime(){
return updateTime;
}
public void setUpdateTime(Date updateTime){
this.updateTime = updateTime;
}
}
2.IPermissionService.java 简称为B
package com.fredia.service;
import java.util.List;
import java.util.Set;
import comfredia.service.IBaseService;
import com.fredia.PermissionDomain;
/**
* 权限模块业务层接口
* @author : wangyong
* @version : v0.0.1
*/
public interface IPermissionService extends IBaseService<PermissionDomain> {
/**
* 根据权限ID获取权限标识
* @param permissionsId 权限ID列表
* @return
*/
Set<PermissionDomain> getPermissionsId(Set<Long> permissionsId);
/**
* 根据当前类型获取所有父节点类型
* @param type
* @return
* @author : wangyong
* @since : 2017年5月23日
*/
List<PermissionDomain> getParentPermission(String type);
/**
* 创建权限
* @param permissionDomain
* @author : wangyong
* @since : 2017年5月22日
*/
void createPermission(PermissionDomain permissionDomain);
/**
* 修改权限
* @param permissionDomain
* @param ids
* @author : wangyong
* @since : 2017年5月24日
*/
void updatePermission(PermissionDomain permissionDomain,List<Long> ids);
/**
* 获取所有相关子权限
* @param ids
* @return
* @author : wangyong
* @since : 2017年5月24日
*/
List<PermissionDomain> getChildId(List<Long> ids);
}
3.IBaseService.java 简称为A
package com.fredia.service;
import java.util.List;
import com.fredia.Query;
import com.fredia.PageList;
/**
* 业务接口基类
* @author : wangyong
* @version : v0.0.1
*/
public interface IBaseService<T> {
/**
* 根据主键获得一个领域对象
* @param id 对象id
* @return 返回一个领域对象
*/
T get(Long id);
/**
* 根据查询对象获得一个领域对象
* @param query 查询对象
* @return 返回一个领域对象
*/
T getOne(Query query);
/**
* 根据查询对象获得匹配第一个领域对象
* @param query 查询对象
* @return 返回一个领域对象
*/
T getFirst(Query query);
/**
* 根据查询对象获得领域对象列表
* @param query 查询对象
* @return 返回领域对象列表
*/
List<T> getList(Query query);
/**
* 根据查询对象获得领域对象列表
* @param query 查询对象
* @return 返回领域对象列表
*/
List<T> getListNoDesc(Query query);
/**
* 根据查询对象获得领域对象分页列表
* @param query 查询对象
* @return 返回领域对象分页列表
*/
PageList<T> getPageList(Query query);
/**
* 根据查询对象获得领域对象分页列表
* @param query 查询对象
* @return 返回领域对象分页列表
*/
PageList<T> getPageListNoDesc(Query query);
/**
* 根据查询对象获得指定行范围的领域对象列表
* @param query
* @return
*/
List<T> getSliceList(Query query);
/**
* 根据查询对象获得指定行范围的领域对象列表
* @param query
* @return
*/
List<T> getSliceListNoDesc(Query query);
/**
* 通过查询对象获得领域对象统计数
* @param query 查询对象
* @return 返回统计数
*/
int count(Query query);
/**
* 创建一个领域对象
* @param domain 领域对象
* @return 返回一个领域对象`
*/
T create(T domain);
/**
* 根据id删除
* @param id 对象id
*/
void delete(Long id);
/**
* 根据主键更新领域对象
* 更新机制：根据主键更新属性不为null的值
* @param domain 领域对象
*/
void update(T domain);
/**
* 根据主键更新领域对象
* 更新机制：根据主键更新实体全部字段，null值会被更新
* @param domain 领域对象
*/
void updateAll(T domain);
}
4.BaseServiceImpl.java 简称为C
package com.fredia;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.fredia.BaseException;
import com.fredia.Mapper;
import com.fredia.Query;
import com.fredia.QueryCriteria;
import com.frediar.PageList;
import com.fredia.service.IBaseService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 通用业务接口实现类
*
* @author : wangyong
* @version : v0.0.1
*/
@Service
public abstract class BaseServiceImpl<T> implements IBaseService<T> {
@SuppressWarnings("SpringJavaAutowiringInspection")
@Autowired
private Mapper<T> mapper;
@Override
public T get(Long id) {
return mapper.selectByPrimaryKey(id);
}
@Override
public T getOne(Query query) {
List<T> list = this.getList(query);
if (list == null || list.size() == 0) {
return null;
}
if (list.size() == 1) {
return list.get(0);
} else {
throw new BaseException(201, "期望查询一条记录，结果返回多条记录");
}
}
@Override
public T getFirst(Query query) {
query.setOffset(0);
query.setLimit(1);
List<T> list = this.getSliceList(query);
if (list.size() >= 1) {
return list.get(0);
} else {
return null;
}
}
@Override
public List<T> getList(Query query) {
QueryCriteria queryCriteria = query.toCriteria();
processOrder(query, queryCriteria);
return mapper.selectByCondition(queryCriteria);
}
@Override
public List<T> getListNoDesc(Query query) {
QueryCriteria queryCriteria = query.toCriteria();
return mapper.selectByCondition(queryCriteria);
}
private void processOrder(Query query, QueryCriteria queryCriteria) {
String orderBy = query.getOrderBy();
if (StringUtils.isNotBlank(orderBy)) {
if (query.getDesc()) {
queryCriteria.orderBy(orderBy).desc();
} else {
queryCriteria.orderBy(orderBy).asc();
}
} else {
queryCriteria.orderBy("id").desc();
}
query.setOrderBy(orderBy);
}
@SuppressWarnings("rawtypes")
@Override
public PageList<T> getPageList(Query query) {
if (query.getPageIndex() == null) {
throw new BaseException(300, "分页查询必须设置PageIndex");
}
if (query.getPageSize() == null) {
throw new BaseException(300, "分页查询必须设置PageSize");
}
PageHelper.startPage(query.getPageIndex(), query.getPageSize());
List<T> resultList = this.getList(query);
return new PageList<T>(resultList, query.getPageIndex(), query.getPageSize(), ((Page) resultList).getTotal()+query.getOffset());
}
@SuppressWarnings("rawtypes")
@Override
public PageList<T> getPageListNoDesc(Query query) {
if (query.getPageIndex() == null) {
throw new BaseException(300, "分页查询必须设置PageIndex");
}
if (query.getPageSize() == null) {
throw new BaseException(300, "分页查询必须设置PageSize");
}
PageHelper.startPage(query.getPageIndex(), query.getPageSize());
List<T> resultList = this.getListNoDesc(query);
return new PageList<T>(resultList, query.getPageIndex(), query.getPageSize(), ((Page) resultList).getTotal()+query.getOffset());
}
@Override
public List<T> getSliceList(Query query) {
if (query.getLimit() == null) {
throw new BaseException(300, "Limit未设置");
}
if (query.getOffset() == null) {
throw new BaseException(300, "Offset未设置");
}
QueryCriteria queryCriteria = query.toCriteria();
queryCriteria.setLimit(query.getLimit());
queryCriteria.setOffset(query.getOffset());
processOrder(query, queryCriteria);
return mapper.selectSliceByCriteria(queryCriteria);
}
@Override
public List<T> getSliceListNoDesc(Query query) {
if (query.getLimit() == null) {
throw new BaseException(300, "Limit未设置");
}
if (query.getOffset() == null) {
throw new BaseException(300, "Offset未设置");
}
QueryCriteria queryCriteria = query.toCriteria();
queryCriteria.setLimit(query.getLimit());
queryCriteria.setOffset(query.getOffset());
return mapper.selectSliceByCriteria(queryCriteria);
}
@Override
public int count(Query query) {
return mapper.selectCountByCondition(query.toCriteria());
}
@Override
public T create(T domain) {
int insertCount = mapper.insert(domain);
if (insertCount != 1) {
throw new BaseException(300, "数据新增失败");
}
return domain;
}
@Override
public void delete(Long id) {
int deleteCount = mapper.deleteByPrimaryKey(id);
if (deleteCount != 1) {
throw new BaseException(300, "数据删除失败");
}
}
@Override
public void update(T domain) {
int updateCount = mapper.updateByPrimaryKeySelective(domain);
if (updateCount != 1) {
throw new BaseException(300, "数据更新失败");
}
}
@Override
public void updateAll(T domain) {
int updateCount = mapper.updateByPrimaryKey(domain);
if (updateCount != 1) {
throw new BaseException(300, "数据更新失败");
}
}
}
5.PermissionServiceImpl.java 简称为D
package com.fredia.impl;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.fredia.ExceptionUtils;
import com.fredia.BaseServiceImpl;
import com.fredia.PermissionDomain;
import com.fredia.PermissionMapper;
import com.fredia.PermissionQuery;
import com.fredia.IPermissionService;
/**
* 权限模块的业务实现类
* @author : wangyong
* @version : v0.0.1
*/
@SuppressWarnings("SpringJavaAutowiringInspection")
@Service("permissionService")
public class PermissionServiceImpl extends BaseServiceImpl<PermissionDomain> implements IPermissionService {
@Autowired
private PermissionMapper permissionMapper;
@Override
public Set<PermissionDomain> getPermissionsId(Set<Long> permissionsId) {
........//省略业务代码
return permissions;
}
@Override
public void createPermission(PermissionDomain permissionDomain) {
........//省略业务代码
super.update(permissionDomain);
}
@Override
public List<PermissionDomain> getParentPermission(String type) {
........//省略业务代码
return list;
}
@Override
public List<PermissionDomain> getChildId(List<Long> ids) {
........//省略业务代码
return list;
}
}
整理所有上面的逻辑关系就是
D extends C implements B
C implements A
B implements A
多重好处：
1.C已经具体实现A中的接口，子类无需再次实现，提高复用性
2.如需重写超类（superclass）A 里面方法，直接在B方法重写，或者根据自己的业务代码新增方法，而不用修改A类的基层方法，方便domain参数变更，以及接口变动
3.这样做D类可以向上塑形为B
比如说
B b=new D();
这样通过B就可以调用D类中B拥有的方法
本地测试
俩个都是父类，但是为了结构清晰，使用第一种结构更清晰。
