一、简单例子：
1. 直接new一个实例，这样肯定知道用的哪个实例
2. 定义接口类型的变量，用某个实例去初始化。。。这样也是肯定知道用的哪个实例
一般我们用第二种方式有一个好处，如果以后要改动，那么只需要修改其引用的实例,改动较少!
举个例子：A接口，A1，A2，A3实现A接口，有一个eat方法，A1：吃饭,A2：吃鱼，A3：吃肉
需要得到"吃肉"，那么 A a = new A3();
需要得到"吃饭"，那么 A a = new A1();
二、看代码发现的例子：
接口：
public interface CsBaseService {
//获得总记录条数
public int getTotalCount(JDBCBean jdbcBean);
}
实现类1：
@Service
public class CsLastUpdateService implements CsBaseService {
@Override
public int getTotalCount(JDBCBean jdbcBean) {
return 0;
}
}
实现类2：
public class CsRelateModelService implements CsBaseService {
@Override
public int getTotalCount(JDBCBean jdbcBean) {
return 2；
}
调用的时候：
public class RelateModelController extends BaseController{
@Autowired
private CsRelateModelService relateModelService;
//自动装配实现类2
initParamProcess(relateModelService,new RelateModel(),new Page())
;//初始化实现类2，关键在这步，指定relateModelService为beaseService，具体见BaseController类
int totalCount = beaseService.getTotalCount(jdbcBean);
//然后直接调用实现类2的方法，输出为2
RelateModelController 的父类BaseController
public
abstract
class BaseController {
void initParamProcess(CsBaseService beaseService, JDBCBean jdbcBean,
Page page) {
this.beaseService = beaseService;
//指定哪个实现类为beaseService
this.jdbcBean = jdbcBean;
this.page = page;
}
一、简单例子：1. 直接new一个实例，这样肯定知道用的哪个实例2. 定义接口类型的变量，用某个实例去初始化。。。这样也是肯定知道用的哪个实例一般我们用第二种方式有一个好处，如果以后要改动，那么只需要修改其引用的实例,改动较少!举个例子：A接口，A1，A2，A3实现A接口，有一个eat方法，A1：吃饭,A2：吃鱼，A3：吃肉需要得到"吃肉"，那么 A a = n
看前同事的代码
中
，两个不同的线程走的是同一个
方法
实现
，但是两个线程除了查询的数据库表不一致，其他逻辑完全一致。所以用到了一个
接口
多个
实现
类，每个
实现
类查询不同数据库。记录一下
接口
是怎么
调用
不同的
实现
类的。
定
时
任务一：
定
时
任务二：
同
时
继承了一个
实现
类AbstractSendDataTask
1.JAVA里没有多继承，一个类之能有一个父类。
而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的
方法
（例如
方法
print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在
调用
这个相同的
方法
print()的
时
候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是
调用
相同的
方法
）会有不同的结果。举例说明：
public class Father{
//父类有一个打孩子
方法
public void hitChild(){}
//子类1
public clas
最近在做某“马店”项目
中
的报表，定
时
任务（更新报表数据）
实现
类
中
使用 @Autowired 注入每张报表的逻辑类。随着报表的增多，@Autowired 越来越多。记录一次使用 ApplicationContextAware 优化的过程。
学习总结：
链接：【Java基础、springboot、springcloud、docker 等，学习目录】
前期代码：
@Slf4j
@Component
public class ScheduleBox {
@Autowired
privat
一个
接口
多个
实现
类，如何指定特定
实现
类进行
调用
示例解决
方法
在写程序的
时
候经常会遇到 写一个
接口
有多个
实现
类，那么在
调用
的
时
候是如何去确定
调用
的是哪个
实现
类呢？接下来将为你介绍几种方式：
public interface Animal {
//动物的叫声
public void call();
//动物吃的东西
public void eat();
实现
类1
@Service("dogImpl")
public class Dog implements An
背景：学习security的
时
候查看源码，有个地方采用了
接口
.
方法
的方式，通过ctrl+alt+b快捷键发现
接口
有多个
实现
类
这种情况恰可以使用debug，来查看具体
调用
的是哪个
实现
类的
方法
，操作如下：
1.打断点
2.以debug模式运行项目
3.在断点处，复制想要查看的代码，并在debugger控制台打印出来（回车键）
4.查看其真实类型
到此我知道了，其真实类型是Provider...
1、 直接new一个实例，这样肯定知道用的哪个实例
2、 定义
接口
类型的变量，用某个实例去初始化。。。这样也是肯定知道用的哪个实例
3、用反射创建
实现
类或者
实现
类的子类对象，强转成
接口
类型
ICar iCar = (ICar) ServiceAnnotationSupport.serviceInjection(Class.forName("com.test.AodiCarPlus"));
iCar.run();
今天上厕所的
时
候刷到别人说到面向
接口
编程和面向业务编程，然后就想到了
接口
的特性，随后想到一个
接口
可以有多个
实现
类，有多个
实现
类的话，控制层是怎么
调用
其
中
的
实现
类的呢？因为以前没遇到过这个问题，自己的实际开发
中
一个
接口
只有一个
实现
类，然后就想到万一一个
接口
有两个以上的
实现
类的话，控制层自动注入的
实现
类到底是哪一个的问题。
（然后还想到，自己写的每一个项目，都是一个
接口
一个
实现
类，根本没有利用到
接口
设计的优点，当然这不是本题所讨论的重点，但是可以做个小标记供以后进阶学习。）
下面开始介绍我网上搜集到的三种方式。
1.JAVA里没有多继承，一个类之能有一个父类。
而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的
方法
（例如
方法
print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在
调用
这个相同的
方法
print()的
时
候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是
调用
相同的
方法
）会有不同的结果。举例说明：
public class Father{
//父类有一个打孩子
方法
public void hitChild(){}
//子类1
public clas
对于一个声明了多个
方法
的
接口
，我们使用的
时
候有
时
仅仅关注于几个关键
方法
，并不需要
实现
所有的。可是由于
接口
调用
的语法限制，使得我们不得不在代码
中
也显示声明
实现
了那些我们不关心的
方法
。在Java
中
也有简化
接口
调用
的方式，比如安卓
中
ViewPager监听页面切换
时
的
接口
PageChangeListener，官方提供了简单类: ViewPager.SimpleOnPageChangeListener来简化
调用
。
对于Kotlin来说，可以类似使用java的方式，来
实现
多函数
接口
的简化
调用
，只是要用到object关键字且代码仍会较多。这里，由于Kotlin的语法更为灵活，去
实现
这种
调用
应该有其特色的方式
集合有Collection与Map两种
接口
，其
中
Collection有两种子
接口
(list、set)
一、Collection
接口
的两个子
接口
(list、set)：
1) List
中
的元素有序，不唯一。常用的
实现
类有ArrayList、LinkedList和 vector。
·ArrayList：
底层数据结构是(Object)数组；
ArrayList的Object数组初始...
public void convert(UpFile upFile) throws Exception;
public boolean support(UpFile upFile);
实现
类一
@Service
public class PictureServiceIm
