七大原则三-->依赖倒转原则-->依赖关系的三种实现

依赖关系传递的三种方式
1) 接口传递
2) 构造方法传递
3) setter方式传递

公共的接口 和 实现类

/**
 * 公共的电视接口
 */
 interface ITV { 
     public void play();
 }
/**
 * 公共的电视实现类
 */
 class ChangHong implements ITV {
    @Override
    public void play() {
        System.out.println("长虹电视机，打开");
    } 
 }

第一种实现

/**
 * 方式1： 通过接口传递实现依赖
 * 定义 开关接口
 */
 interface IOpenAndClose {
     public void open(ITV tv); //抽象方法,接收接口
 }
 
/**
 * 开关实现类
 */
 class OpenAndClose implements IOpenAndClose{
    @Override
     public void open(ITV tv){
         tv.play();
      }
  }

第二种实现

// 方式2: 通过构造方法依赖传递
 interface IOpenAndClose {
     public void open(); //抽象方法
 }

 class OpenAndClose implements IOpenAndClose{
     public ITV tv; //成员
     public OpenAndClose(ITV tv){ //构造器
         this.tv = tv;
     }
     public void open(){
         this.tv.play();
     }
 }

第三种实现

// 方式3 , 通过setter方法传递
interface IOpenAndClose {
    public void open(); // 抽象方法

    public void setTv(ITV tv);
}

class OpenAndClose implements IOpenAndClose {
    private ITV tv;

    public void setTv(ITV tv) {
        this.tv = tv;
    }

    public void open() {
        this.tv.play();
    }
}

package com.wf.zhang.inversion.improve2;
public class DependencyPass {
    public static void main(String[] args) {
        
//        System.out.println("------>第一种接口实现");
//        ChangHong changHong = new ChangHong();
//        OpenAndClose first = new OpenAndClose();
//        first.open(changHong);
        
    
//        System.out.println("------>通过构造器进行依赖传递");
//        ChangHong changHong = new ChangHong();
//        OpenAndClose two = new OpenAndClose(changHong);
//        two.open();
        
    
        System.out.println("------>通过setter方法进行依赖传递");
        OpenAndClose three = new OpenAndClose();
        ChangHong changHong = new ChangHong();
        three.setTv(changHong);
        three.open();

    }

}

/**
 * 公共的电视接口
 */
 interface ITV { 
     public void play();
 }
/**
 * 公共的电视实现类
 */
 class ChangHong implements ITV {
    @Override
    public void play() {
        System.out.println("长虹电视机，打开");
    } 
 }

/**
 * 方式1： 通过接口传递实现依赖
 * 定义 开关接口
 */
// interface IOpenAndClose {
//     public void open(ITV tv); //抽象方法,接收接口
// }
 
/**
 * 开关实现类
 */
// class OpenAndClose implements IOpenAndClose{
//    @Override
//     public void open(ITV tv){
//         tv.play();
//      }
//  }



// 方式2: 通过构造方法依赖传递
/* interface IOpenAndClose {
     public void open(); //抽象方法
 }

 class OpenAndClose implements IOpenAndClose{
     public ITV tv; //成员
     public OpenAndClose(ITV tv){ //构造器
         this.tv = tv;
     }
     public void open(){
         this.tv.play();
     }
 }
*/

// 方式3 , 通过setter方法传递
interface IOpenAndClose {
    public void open(); // 抽象方法

    public void setTv(ITV tv);
}

class OpenAndClose implements IOpenAndClose {
    private ITV tv;

    public void setTv(ITV tv) {
        this.tv = tv;
    }

    public void open() {
        this.tv.play();
    }
}

依赖倒转原则的注意事项和细节
1) 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好.
2) 变量的声明类型尽量是抽象类或接口, 这样我们的变量引用和实际对象间，就存在
一个缓冲层，利于程序扩展和优化
3) 继承时遵循里氏替换原则