IOC 反转控制
- 控制反转 是一种思想，通俗的来讲就是，把自己控制创建对象的权力转交出去给一个特定的容器，自己不用直接管理对象的创建，只是间接的通过这个容器的拿到自己想要的对象
耦合
- 在理解IOC之前我们要去理解另一个概念，就是 耦合 ，
什么是耦合呢 ，通常我们需要通过很多类之间合作来完成一个业务逻辑 ，通常的引用方式是 通过在一个类的内部组合另一个类的引用才能调用其内部的功能，这样子做确实能实现业务，但是他们之间的必然联系会很密切，耦合度非常的高，导致维护的难度很高，所以我们才会用 IOC 这种思想来降低 这种维护的难度，降低耦合度；
试着用代码来理解：
比如一个老板去给一个工作者指派工作
public class DomeNoe {
public void gongzuo(){
System.out.println("Noe工作了");
}
}
/*老板 指派工作*/
public class Boss{
DomeNoe noe=new DomeNoe();
//
public void domeGongzuo(){
noe.gongzuo();
}
}
直接在 Boss 中 new 了 DomeNoe
有一天DomeNoe 累了 休息一下 老板就必须重新找一个来顶替工作者 所以会在内部 又new了一个新的工作者 DomeTow，
public class DomeTow {
public void gongzuo(){
System.out.println("tow工作了");
}
}
/*老板指派任务给了 tow*/
public class Boss {
DomeTow tow=new DomeTow();
public void domeGongzuo(){
tow.gongzuo();
}
}
这样子做的话，每次换一个人都要老板都要自己new一个新的工作者出来 没有老板会愿意这样子做的 那会累死。
所以他会找一个人事来帮他管理这个事情，所以他会把控制权 反转给了人事
所以我们来做一个简单的控制反转 当然在这里之前你得了解多态
/*指定工作 和 判断休息 的规范*/
public interface Gongzuo {
void gongzuo();
boolean isXiuxi();
}
public class DomeNoe implements Gongzuo{
@Override
public void gongzuo() {
System.out.println("noe在工作");
}
//判断是否休息
@Override
public boolean isXiuxi() {
return true;
}
}
/*tow*/
public class DomeTow implements Gongzuo{
@Override
public void gongzuo() {
System.out.println("tow在工作");
}
/*false代表没有休息 */
@Override
public boolean isXiuxi() {
return false;
}
}
/*人事管理者*/
public class Personnel {
private Gongzuo gongzuozhe;
public void getDome(){
gongzuozhe =new DomeNoe();
/*判断是否休息 */
if (!gongzuozhe.isXiuxi()){
gongzuozhe.gongzuo();
return;
}
gongzuozhe=new DomeTow();
if(!gongzuozhe.isXiuxi()){
gongzuozhe.gongzuo();
return;
}
System.out.println("工作者都休息了！");
}
}
/*老板*/
public class Boss {
private Personnel personnel;
public void gongZuoBa(){
personnel=new Personnel();
personnel.getDome();
}
public static void main(String[] args) {
new Boss().gongZuoBa();//打印时 tow在工作
}
}
*这样子做的话 老板只需要创建人事管理者并调用它的一个方法 就不用管了 而控制创建工作者的权力就交给了人事者 ，当now 休息的时候只需要人事去创建tow来工作 老板就可以轻松的下指令就行了，这就是控制反转 把控制的权力反转给一个容器 是一种编程的思想 可以使代码降低耦合，实现代码的复用
DI 依赖注入
控制反转是一种思想 而依赖注入是一种技术 依赖注入和反转控制是相辅相成的 是实现反转控制的一种方式 那么依赖到底是什么呢？ 依赖就是 当我们 Boos 的类中就要依赖 Personnel 类 而我们的Personnel 类就要依赖 我们两个 工作者类 ；而注入就是我们要在给他们注入他们想要的类 符合规范的类；实现真正意义上的解耦 实现代码的可复用性；
其实依赖注入非常的简单 就是把要依赖的类的类型当作被依赖类中的成员属性 ，用构造函数或者set方法去给他注入就行了！
来看看代码
在之前的代码 都是在类中直接new 依赖的类 我们直接用set方法给他注入
在这里我们暂时把 一个测试类 来当作一个容器 去给他们注入想要的类 所以控制权到了容器中
package com.company.IOC;
/*老板*/
public class Boss {
private Personnel personnel;
public Boss(){}
public Boss(Personnel personnel) {
this.personnel = personnel;
}
public Personnel getPersonnel() {
return personnel;
}
public void setPersonnel(Personnel personnel) {
this.personnel = personnel;
}
public void gongZuoBa(){
personnel.getDome();
}
}
package com.company.IOC;
/*人事管理者*/
public class Personnel {
private Gongzuo gongzuozhe;
public Personnel(){
}
public Personnel(Gongzuo gongzuozhe){
this.gongzuozhe=gongzuozhe;
}
public Gongzuo getGongzuozhe() {
return gongzuozhe;
}
public void setGongzuozhe(Gongzuo gongzuozhe) {
this.gongzuozhe = gongzuozhe;
}
public void getDome(){
/*判断是否休息 */
if (!gongzuozhe.isXiuxi()){
gongzuozhe.gongzuo();
return;
}
System.out.println("该工作者都去休息了");
}
}
package com.company.IOC;
public class DomeTest {
public static void main(String[] args) {
DomeNoe noe=new DomeNoe();
DomeTow tow=new DomeTow();
Personnel personnel=new Personnel();
personnel.setGongzuozhe(tow);
Boss boss =new Boss(personnel);
boss.gongZuoBa();
}
}
这样所以的控制权都交给了测试类
