IOC

阅读量：5955 次

发布时间：2019-06-19

本文共 5036 字，大约阅读时间需要 16 分钟。

IoC

接口及面向接口编程

什么是IoC

Spring的Bean配置

Bean的初始化

Spring的常用注入方式

java接口声明了那些方法是对外公交的

面向接口编程

在结构设计中，分清层次以及调用关系，每层只向上层提供一组功能接口，各层间仅依赖接口而非实现类

接口实现的变动不影响各层间的调用

“面向接口编程”中的“接口”是用于隐藏具体实现和实现多态性的组件

什么是多态？（复习下java基础知识）

父类或接口指向子类对象。

多态的好处：提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端: 前期定义的内容不能调用后期子类的特有内容。

实现多态的前提：

必须有关系（继承或实现）

要有覆盖

多态成员的特点

成员变量：

编译时：参考引用变量所属类中是否有调用的成员变量，有，则编译通过，没有，编译失败。

运行时：参考引用变量所属类中是否有调用的成员变量，并运行该所属类中的成员变量。

一句话概括：（编译和运行都参考等号的左边）

成员函数：

编译时：参考引用变量所属类中是否有调用的函数，有，则编译通过，没有，编译失败。

运行时：参考的是对象所属的类中是否有调用的函数。

一句话概括：（编译看左边运行看右边）

静态函数：

编译时：参考引用变量所属类中是否有调用的静态函数，有，则编译通过，没有，编译失败。

运行时：参考引用变量所属类中是否有调用的静态函数。

一句话概括：（编译和运行都参考等号的左边）

其实调用静态函数（方法）常用的是直接类名调用即可。

Father

/*** @author LJW* @project testjava* @package polymorphic* @file    Father.java* @time 2017-12-14 16:28:28*/public class Father {static  String message="Father";/** *  年龄 */int age;/** * 姓名 */String name;public Father(){    this.age=40;    this.name="小头爸爸";}public Father(int age,String name){    this.age=age;    this.name=name;}public void say(){    System.out.println("Father: age:"+this.getAge()+",name:"+this.getName());}public static void sayTwo(){    System.out.println("Two:Father: "+message);}public int getAge() {    return age;}public void setAge(int age) {    this.age = age;}public String getName() {    return name;}public void setName(String name) {    this.name = name;}}

Son

/*** @author LJW* @project testjava* @package polymorphic* @file    Son.java* @time 2017-12-14 16:44:44*/public class Son extends Father {static String message="Son";/** *  年龄 */int age;/** * 姓名 */String name;public Son(){    this.age=24;    this.name="大头儿子";}public Son(int age,String name){    this.age=age;    this.name=name;}public void say(){    System.out.println("Son:  age:"+this.getAge()+",name: "+this.getName());}public static void sayTwo(){    System.out.println("Two:Son: "+message);}@Overridepublic int getAge() {    return age;}@Overridepublic void setAge(int age) {    this.age = age;}@Overridepublic String getName() {    return name;}@Overridepublic void setName(String name) {    this.name = name;}}

Test

/** * @author LJW * @project testjava * @package polymorphic * @file  Test.java * @time 2017-12-14 16:52:52 */public class Test {public static void main(String[] args) {    Father temp=new Son();    System.out.println("age:"+temp.age+",name:"+temp.name);   //成员变量    temp.say();                     //成员函数    System.out.println(temp.message);//不建议这样写   类.静态变量    temp.sayTwo();                  //不建议这样写   类.静态函数}}

结果：

接口

OneInterface

/** * @author LJW * @project testjava * @package polymorphic * @file  OneInterface.java * @time 2017-12-15 21:17:17 */public interface OneInterface {    String name="OneInterface";    public void say();}

OneInterfaceImpl

/** * @author LJW * @project testjava * @package polymorphic * @file  OneInterfaceImpl.java * @time 2017-12-15 21:19:19 */public class OneInterfaceImpl implements OneInterface {    public static final String name="OneInterfaceImpl";    @Override    public void say() {        System.out.println("Hello World!");    }}

InterfaceTest

/** * @author LJW * @project testjava * @package polymorphic * @file  InterfaceTest.java * @time 2017-12-15 21:20:20 */public class InterfaceTest {    public static void main(String[] args) {        OneInterface oneInterface= new OneInterfaceImpl();        oneInterface.say();        System.out.println(oneInterface.name);  //不建议这样写(类.变量) static    }}

结果：

什么是IoC?

IoC(Inversion of Control):控制反转，控制权的转移，应用程序本身不负责依赖对象的创建和维护，而是由外部容器负责创建和维护。

http://blog.csdn.net/qq_22654611/article/details/52606960

这位大佬解释的比较好。引用解释下感谢：

谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

The Spring Ioc container

当有了IoC/DI的容器后，在客户端类中不再主动去创建这些对象了。

DI(依赖注入)是其一种实现方式，目的是创建对象并且组装对象之间的关系。再引用下那位大佬的话解释下：

IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

引用

总结：控制反转IoC(Inversion of Control)是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权力转移到第三方，比如转移交给了IoC容器，它就是一个专门用来创建对象的工厂，你要什么对象，它就给你什么对象，有了 IoC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IoC容器了，通过IoC容器来建立它们之间的关系。(获取依赖对象的过程被反转了）。