关于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拥有的方法

本地测试

俩个都是父类，但是为了结构清晰，使用第一种结构更清晰。