java中的一些总结

1.面向接口编程就是面向抽象编程吗？
    面向接口编程就是面向抽象编程，
    例子：
    A是接口（接口就是抽象的），B是类（生成后类对象是具体的）。
        A s = new B()；
    s 这个具有A接口规定的一切方法（B类里强制必须实现的）。
    这样C,D,E,F类也可以实现A接口
    如果想替换成C,D,E,F就很简单了，调用的时候还是用A接口规定的那些方法。
    (面向接口编程的意思是指在面向对象的系统中所有的类或者模块之间的交互是由接口完成的
    解释如下：
    A s = new B();
    在内存堆中创建一个B对象，在内存栈中创建一个A的引用s指向了B，用A中的方s.print()方法去调用
    B中的同名方法（B中实现A中的方法），
    所谓的面向接口编程可以降低程序之间的耦合度，是指在具体的调用处都是接口进行的，并不依赖某个具体的类，在
    A s = new B();中，B可以被任意实现了A接口的其他类替换掉。
    在Sping的IOC中面向接口编程降低了类之间的耦合度得到了很好的体现，
    )
2.Spring是如何进行事务管理的?
    是通过AOP对配置的方法进行拦截，然后在调用事物管理器中的预设代码对事物进行管理，再委托被拦截的方法完成原有的任务。
Spring的底层是如何控制事物的？
    spring控制事物的底层 一种是反射机制，spring底层实现的就是利用反射机制，通过他来实现注入，事物控制，通过声明的方式进行，也就是spring里的AOP，进行处理
    而AOP的最底层实现就是JAVA设计模式中的动态代理。
Spring是如何实现依赖注入的？
    平常java开发中,程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这中开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不有程序员实例化，而是通过spring容器帮我们
    new指定的实例并且将实例而注入到需要该对象的类中。依赖注入的另一种说法就是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我们程序员，而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做。
   
    set注入：

    这是最简单的注入方式，假设有一个SpringAction,类中需要实例化一个SpringDao对象，那么就可以定义一个private的SpringDao成员变量，然后创建 SpringDao的set方法（这是ioc的注入入口）；
   
    public class SpringAction { 
        //注入对象springDao 
    private SpringDao springDao; 
        //一定要写被注入对象的set方法 
        public void setSpringDao(SpringDao springDao) { 
        this.springDao = springDao; 
     } 
 
        public void ok(){ 
        springDao.ok(); 
     } 
    } 
    随后编写spring的xml文件，<benan>z中的name属性的一个别名，class属性指类的全名，因为在SpringAction中有一个公共属性Springdao,所以要在<bean>标签中创建一个<property>标签指定SpringDao.
    <property>标签中的name 就是SpringAction类中的SpringDao属性名，ref指下面<bean name = "SpringDao"...>z这样其实是spring将SpringDaoImpl对象实例化并且调用SpringAction的SetSpringDao方法将SpringDao注入；
   
    <!--配置bean,配置后该类由spring管理--> 
     <bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
        <!--(1)依赖注入,配置当前类中相应的属性--> 
        <property name="springDao" ref="springDao"></property> 
     </bean> 
    <bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>

    构造器注入：
   
    这种方式的注入是指带有参数的构造函数注入，看下面的列子，我创建了两个成员变量SpringDao和User，但是并未设置对象的set方法，所以不能支持第一种注入方式，这里的注入方式是SpringAction的构造函数中注入，也就是说在创建
    SpringAction对象时要将SpringDao和User两个参数值传进来：

    public class SpringAction {
    //注入对象springDao
    private SpringDao springDao;
    private User user;

    public SpringAction(SpringDao springDao,User user){
    this.springDao = springDao;
    this.user = user;
    System.out.println("构造方法调用springDao和user");
    }

    public void save(){
    user.setName("卡卡");
    springDao.save(user);
    }
    }
    在xml文件中同样不用<property>的形式，而是使用<constructor-arg>标签，ref属性同样指想其它<bean>标签name属性：
     
         <!--配置bean,配置后该类由spring管理--> 
        <bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
            <!--(2)创建构造器注入,如果主类有带参的构造方法则需添加此配置--> 
            <constructor-arg ref="springDao"></constructor-arg> 
            <constructor-arg ref="user"></constructor-arg> 
        </bean> 
            <bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean> 
             <bean name="user" class="com.bless.springdemo.vo.User"></bean> 
   
    解决构造方法参数的不确定性，你可能会遇到构造方法传入的两参数都是同类型的，为了分清哪个该赋对应值，则需要进行一些小处理：
    下面是设置index，就是参数位置：

        <bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
            <constructor-arg index="0" ref="springDao"></constructor-arg> 
            <constructor-arg index="1" ref="user"></constructor-arg> 
        </bean> 
   
    另一种是设置参数类型：
    <constructor-arg type="java.lang.String" ref=""/>

    接口注入：
   
    在接口中定义要注入的信息，并通过接口来完成注入。（Spring不支持这种注入方式--不支持的原因是--Spring声称其是非入侵式的《离开这个框架也能活》，如果使用接口注入的话，就违背了这一原则）
   

    另外注意：通过Spring创建的对象默认是单例的，如果需要创建多实例对象可以在<bean>标签后面添加一个属性：
        <bean name="..." class="..." scope="prototype"> 

AOP和OOP的区别？

    AOP面向切面编程，Aop偏重业务处理过程的某个步骤或阶段，强调降低模块之间的耦合度，是代码拥有更好的移植性。
    面向对象编程则是对业务分析中抽取的实体进行方法和属性的封装。
    Aop的一个很重要的特点就是源代码无关性，也就是说如果我们的系统中引入了AOP组件，即使我们把该组件去掉，系统代码也应该能够编译通过，要实现这一点，可以使用动态proxy模式，这个在
    spring中已经有良好的实现，spring中的事物管理大量了AOP。