java 抽象方法默认是public java抽象的原则是什么

转载

mob64ca141275de 2024-01-10 21:30:43

文章标签 java 抽象方法默认是public java 设计模式开发语言 ide 文章分类 Java 后端开发

文章目录

1. 违反依赖倒转原则
2. 遵守依赖倒转原则
3. 依赖关系传递的3种方式

3.1 接口传递
3.2 构造方法传递
3.3 setter方法传递

4. 依赖倒转原则的注意事项和细节

Dependence Inversion Principle 依赖倒转原则是指：

高层模块不应该依赖低层模块，二者都应该依赖其抽象。
抽象不应该依赖细节，细节应该依赖抽象。
依赖倒转(倒置)的中心思想是面向接口编程。
依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类。
使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。

请编程完成Person 接收消息的功能。

1. 违反依赖倒转原则

class Email {
   public String getInfo() {
      return "电子邮件信息: hello,world";
   }
}

class Person {
   public void receive(Email email ) {
      System.out.println(email.getInfo());
   }
}

存在的问题：

如果我们获取的对象是微信，短信等等，则新增类，同时Perons也要增加相应的接收方法。

解决方法：

引入一个抽象的接口IReceiver, 表示接收者, 这样Person类与接口IReceiver发生依赖。
因为Email, WeiXin 等等属于接收的范围，他们各自实现IReceiver 接口就可以, 这样就符合依赖倒转原则。

2. 遵守依赖倒转原则

interface IReceiver {
   public String getInfo();
}

class Email implements IReceiver {
   @Override
   public String getInfo() {
      return "电子邮件信息: hello,world";
   }
}

class WeiXin implements IReceiver {
   @Override
   public String getInfo() {
      return "微信信息: hello,ok";
   }
}

class Person {
   //这里我们是对接口的依赖
   public void receive(IReceiver receiver ) {
      System.out.println(receiver.getInfo());
   }
}

public class DependecyInversion {
   public static void main(String[] args) {
      Person person = new Person();
      person.receive(new Email());
      person.receive(new WeiXin());
   }
}

3. 依赖关系传递的3种方式

3.1 接口传递

interface ITV {  
   public void play();
}

class ChangHong implements ITV {
   @Override
   public void play() {
      System.out.println("长虹电视机，打开");
   }
}

interface IOpenAndClose {
   public void open(ITV tv);
}

class OpenAndClose implements IOpenAndClose{
    @Override
    public void open(ITV tv){
        tv.play();
    }
}

public class DependencyPass {
   public static void main(String[] args) {
      OpenAndClose openAndClose = new OpenAndClose();
      openAndClose.open(new ChangHong());
   }
}

3.2 构造方法传递

interface ITV {  
   public void play();
}

class ChangHong implements ITV {
   @Override
   public void play() {
      System.out.println("长虹电视机，打开");
   }
}

interface IOpenAndClose {
   public void open();
}

class OpenAndClose implements IOpenAndClose{
    public ITV tv;  
    public OpenAndClose(ITV tv){  
         = tv;
    }

    @Override
    public void open(){
        .play();
    }
}

public class DependencyPass {
   public static void main(String[] args) {
      //通过构造器进行依赖传递
      OpenAndClose openAndClose = new OpenAndClose(new ChangHong());
      openAndClose.open();
   }
}

3.3 setter方法传递

interface ITV {  
   public void play();
}

class ChangHong implements ITV {
   @Override
   public void play() {
      System.out.println("长虹电视机，打开");
   }
}

interface IOpenAndClose {
   public void open();

   public void setTv(ITV tv);
}

class OpenAndClose implements IOpenAndClose {
   private ITV tv;

   @Override
   public void setTv(ITV tv) {
       = tv;
   }

   @Override
   public void open() {
      .play();
   }
}

public class DependencyPass {
   public static void main(String[] args) {
      //通过setter方法进行依赖传递
      OpenAndClose openAndClose = new OpenAndClose();
      openAndClose.setTv(new ChangHong());
      openAndClose.open();
   }
}