extends和implements

简单说： 1.extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承

public abstract class test extends SearchEntity{
	public void run(){
		test test=new test(); //报错
		test.getEntityName();
	}
}

抽象的對象都不能new对象，所以更没法调用父类得方法，所以不能继承

public class test extends SearchEntity{
	public void run(){
		test test=new test(); //报错
		test.getEntityName();
	}
	@Override
	public Class getEntityClass() {
		// TODO Auto-generated method stub
		return null;
	}
}
如果继承得父类里面有抽象得方法 那么就必须要实现父类得抽象方法

2.JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements


3.继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了 

4.extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法; 

5.可以通过父类获取子类信息，用map集合得形式注入，key就是对象得类名，value就是对象得信息

    @Autowired(required = false)
	private Map<String, SearchDocInfo> docInfos;

	public Collection<SearchDocInfo> getAllSearchDocInfos() {

		List<SearchDocInfo> list = new ArrayList<SearchDocInfo>();
		for (Entry<String, SearchDocInfo> vo : docInfos.entrySet()) {
			vo.getValue();
			vo.getValue().setDocCode(vo.getValue().getEntityClass().toString()
					.substring(vo.getValue().getEntityClass().toString().lastIndexOf(".") + 1).toLowerCase());
			list.add(vo.getValue());
		}
		return list;
	}

术语话来说： 
extends 继承类；implements 实现接口。 




类和接口是不同的：类里是有程序实现的；而接口无程序实现，只可以预定义方法

Java也提供继承机制﹐但还另外提供一个叫interface的概念。由于Java的继承机制只能提供单一继承（就是只能继承一种父类别）﹐所以就以Java的interface来代替C++的多重继承。interface就是一种介面﹐规定欲沟通的两物件﹐其通讯该有的规范有哪些。

如以Java程式语言的角度来看﹐Java的interface则表示一些函数或资料成员为另一些属于不同类别的物件所需共同拥有,则将这些函数与资料成员定义在一个interface中,然后让所有不同类别的Java物件可以共同操作使用之。 

Java的class只能继承一个父类别（用extends关键字）,但可以拥有（或称实作）许多interface（用implements关键字）。


接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口与类相似点：
一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

接口特性
接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别
1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
注：JDK 1.8 以后，接口里可以有静态方法和方法体了。

利用接口实现得功能：
1.利用接口 ，获取实现该接口得所有得实现类里面指定得方法：

首先定义好接口
public interface IptyPortletTaskService {
	
	public Integer getTaskCount(Map map);

}

然后定义实现该接口得实现类
@Service
public class BudRemindTaskCountService implements IptyPortletTaskService{
	
	@Autowired
	private BudBillDao billDao;
	
	@Override
	public Integer getTaskCount(Map map) {
		Integer BudTaskCount=billDao.getTaskCount(map);
		return BudTaskCount;
	}

}

@Service
public class PctBillTaskCountRemindService implements IptyPortletTaskService{
	
	@Autowired
	private IPctBillService billService;
	
	@Autowired
	private IPctChangeBillService pctChangeBillService;
	
	@Override
	public Integer getTaskCount(Map map) {
		Integer PctTaskCount = billService.getPctTaskCount(map);
		Integer PctChangeTaskCount = pctChangeBillService.getPctChangeTaskCount(map);
	    return PctTaskCount+PctChangeTaskCount;
	}

}

然后要注入map key就是实现类得类名 value就是实现类

@Autowired(required=false)
private Map<String, IptyPortletTaskService> portletTaskService;

if(portletTaskService!=null&&portletTaskService.size()>0){
			for (Entry<String, IptyPortletTaskService> vo : portletTaskService.entrySet()) {
				Integer count = vo.getValue().getTaskCount(map);
				taskCount=taskCount+count;
			}
		}

同时还有第二种方式去利用结构

首先定义好接口 像这种 在接口中定义接口得形式和定义二个接口没有什么区别
因为接口永远都是public的，只能说这样的写法风格不好。更好的写法是将两个接口单独使用两个类文件进行定义。
public interface IGlobalInfoService {
	public Map<String, List<Map>> getGlobalInfo(Map params);

	/**
	 * 前端获取全局基础资料服务接口， 提供全局数据的需要实现此接口
	 * 
	 * @author liubo
	 *
	 */
	public interface IGlobalEleInfo {
		public Object globalInfo(Map params);
	}

}

然后定义好实现类：
@Service
public class AceCacheInfo implements IGlobalEleInfo {

	@Autowired
	MadAceDao aceDao;

	@Override
	@Desc("aceList")
	public List<Map> globalInfo(Map params) {
		return aceDao.selectGlobalCacheInfo(params);
	}

}

@Service
public class ValsetCacheInfo implements IGlobalEleInfo {

    @Autowired
    private PaValsetDao paValsetDao;


    @Override
    @Desc("valsetList")
    public List<Map> globalInfo(Map params) {
        return paValsetDao.selectGlobalCacheInfo(params);
    }

}

然后直接注入list  list里面就是开始定义得接口
这样也可以 其实上面得查询数量也可以这样去写，不过是list和map得区别

@Autowired
private List<IGlobalEleInfo> globalEleInfos;



if (globalEleInfos != null) {
			globalEleInfos.parallelStream().forEach(info -> {
				Desc desc = null;
				try {
					Map params = new HashMap();
					params.putAll(cond);
					Method method = info.getClass().getDeclaredMethod("globalInfo", Map.class);
					desc = method.getAnnotation(Desc.class);
					StopWatch stopWatch=new StopWatch("globalInfo");
					stopWatch.start(desc.toString());
					infos.put(desc.value(), info.globalInfo(params));
					stopWatch.stop();
					//System.out.println(stopWatch.prettyPrint());
				} catch (Exception ex) {
					LOG.error("get globalcache " + desc.value() + " error:", ex);
					throw new MadException(ex.getMessage());
				}
			});
		}