夜光序言:
淅淅沥沥的雨,落在池塘,水下的鱼儿飞速游来游去,晴了,一切都安静了。
正文:
以道御术 / 以术识道
package 接口隔离原则;
public class Segregation {
}
//接口1
//按照接口隔离的原则
//夜光:需要将接口Ione拆分为独立的几个接口
//将A类和C类和他们的接口建立依赖关系,也就是接口隔离原则
interface Ione{ //定义五个方法
void operation1();
void operation2();
void operation3();
void operation4();
void operation5();
}
//下面我们分别实现
class B implements Ione{
@Override //重写
public void operation1() {
System.out.println("B 实现了operation1");
}
@Override
public void operation2() {
System.out.println("B 实现了operation2");
}
@Override
public void operation3() {
System.out.println("B 实现了operation3");
}
@Override
public void operation4() {
System.out.println("B 实现了operation4");
}
@Override
public void operation5() {
System.out.println("B 实现了operation5");
}
}
//下面我们分别实现
class D implements Ione{
@Override //重写
public void operation1() {
System.out.println("B 实现了operation1");
}
@Override
public void operation2() {
System.out.println("B 实现了operation2");
}
@Override
public void operation3() {
System.out.println("B 实现了operation3");
}
@Override
public void operation4() {
System.out.println("B 实现了operation4");
}
@Override
public void operation5() {
System.out.println("B 实现了operation5");
}
}
//写一个A类
class A{ //A类通过接口Ione 依赖使用B类,但是只用到了四个方法
public void depend1(Ione li){
li.operation1();
}
public void depend2(Ione li){
li.operation2();
}
public void depend3(Ione li){
li.operation3();
}
public void depend4(Ione li){
li.operation4();
}
}
//写一个A类
class C{ //A类通过接口Ione 依赖使用D类,但是只用到了2个方法
public void depend1(Ione li){
li.operation1();
}
public void depend2(Ione li){
li.operation2();
}
}
package 接口隔离原则;
public class Segregation1 {
public static void main(String[] args) {
//使用一把
A1 a = new A1(); //先new一个a出来
a.depend2(new B1()); //这样就可以了,A类通过接口去依赖B类
}
}
//接口1
//按照接口隔离的原则
//夜光:需要将接口Ione拆分为独立的几个接口
//将A类和C类和他们的接口建立依赖关系,也就是接口隔离原则
interface ITwo{ //定义五个方法
void operation1();
void operation4();
void operation5();
}
interface IThree{
void operation2();
void operation3();
}
interface IFour{
}
//下面我们分别实现
class B1 implements ITwo{
@Override //重写
public void operation1() {
System.out.println("B 实现了operation1");
}
@Override
public void operation4() {
System.out.println("B 实现了operation4");
}
@Override
public void operation5() {
System.out.println("B 实现了operation5");
}
}
//下面我们分别实现
class D1 implements IThree{
@Override
public void operation2() {
System.out.println("B 实现了operation2");
}
@Override
public void operation3() {
System.out.println("B 实现了operation3");
}
}
//写一个A类
class A1{ //A类通过接口Ione 依赖使用B类,但是只用到了四个方法
public void depend1(Ione li){
li.operation1();
}
public void depend2(ITwo li){
li.operation1();
}
public void depend3(Ione li){
li.operation3();
}
public void depend4(Ione li){
li.operation4();
}
}
//写一个A类
class C1{ //A类通过接口Ione 依赖使用D类,但是只用到了2个方法
public void depend1(Ione li){
li.operation1();
}
public void depend2(Ione li){
li.operation2();
}
}
package 依赖倒转原则;
//夜光
//1. 高层模块不应该依赖底层模块,二者都应该依赖其抽象
//2. 抽象不应该依赖细节,细节应该依赖抽象
//3. 依赖倒转(倒置)的中心思想是面向接口编程
// 在java中抽象是指的接口和抽象类,细节指的是实现类
// 接口和抽象类指定规范,具体的细节交给实现类去做
public class DependecyInversion {
public static void main(String[] args) {
Person person = new Person();
person.receive(new Email()); //调用
}
}
class Email{
public String getInfo(){
return "电子邮件信息";
}
}
//完成Person接收消息的功能
//方式1完成
class Person{
public void receive(Email email){
System.out.println(email.getInfo());
}
}
package 依赖倒转原则;
//夜光
//1. 高层模块不应该依赖底层模块,二者都应该依赖其抽象
//2. 抽象不应该依赖细节,细节应该依赖抽象
//3. 依赖倒转(倒置)的中心思想是面向接口编程
// 在java中抽象是指的接口和抽象类,细节指的是实现类
// 接口和抽象类指定规范,具体的细节交给实现类去做
public class DependecyInversion {
public static void main(String[] args) {
//客户端无需改变
Person person = new Person();
person.receive(new Email()); //调用
}
}
//定义接口
interface IReceiver{
public String getInfo(); //就很简短的定义了一个方法,下面是具体实现
}
class Email implements IReceiver{
public String getInfo(){ //夜光:这里是具体的实现
return "电子邮件信息";
}
}
//完成Person接收消息的功能
//方式1完成
//receive(Email email) 问题来了,直接传入一个类,意思就是需要依赖这个类
//简单,比较容易想到
//如果我们获取的是微信,短信信息,则新增类,并且Person也要新增相应的方法
//解决思路,引入一个抽象接口IReceiver,表示接收者,表示Person类与接口发生依赖
//因为微信或者短信等等,属于接收的范围,他们各自实现IReceiver接口就行
//这样就符合依赖倒转原则
class Person{
/*public void receive(Email email){ //这里就不用这么写了
System.out.println(email.getInfo());
}*/
public void receive(IReceiver receiver){ //这里这样写,符合依赖倒转原则
System.out.println(receiver.getInfo());
}
}
package 依赖倒转原则;
//夜光
//1. 高层模块不应该依赖底层模块,二者都应该依赖其抽象
//2. 抽象不应该依赖细节,细节应该依赖抽象
//3. 依赖倒转(倒置)的中心思想是面向接口编程
// 在java中抽象是指的接口和抽象类,细节指的是实现类
// 接口和抽象类指定规范,具体的细节交给实现类去做
public class DependecyInversion {
public static void main(String[] args) {
//客户端无需改变
Person person = new Person();
person.receive(new Email()); //调用第一种方式
person.receive(new weixin()); //调用第二种方式
}
}
//定义接口
interface IReceiver{
public String getInfo(); //就很简短的定义了一个方法,下面是具体实现
}
//第一种接收方式
class Email implements IReceiver{
public String getInfo(){ //夜光:这里是具体的实现
return "电子邮件信息";
}
}
//第二种,微信接收方式
class weixin implements IReceiver{
public String getInfo(){ //夜光:这里是具体的实现
return "微信信息";
}
}
//完成Person接收消息的功能
//方式1完成
//receive(Email email) 问题来了,直接传入一个类,意思就是需要依赖这个类
//简单,比较容易想到
//如果我们获取的是微信,短信信息,则新增类,并且Person也要新增相应的方法
//解决思路,引入一个抽象接口IReceiver,表示接收者,表示Person类与接口发生依赖
//因为微信或者短信等等,属于接收的范围,他们各自实现IReceiver接口就行
//这样就符合依赖倒转原则
class Person{
/*public void receive(Email email){ //这里就不用这么写了
System.out.println(email.getInfo());
}*/
public void receive(IReceiver receiver){ //这里这样写,符合依赖倒转原则
System.out.println(receiver.getInfo());
}
}
package 依赖倒转原则;
public class DependecyPass {
public static void main(String[] args) {
}
}
//方式1:通过接口传递实现依赖
//开关的接口
interface IOpenAndClose{
public void Open(ITV tv); //抽象方法,接收接口
}
//ITV接口
interface ITV{
public void play();
}
//实现接口
class OpenAndClose implements IOpenAndClose{
@Override
public void Open(ITV tv){
tv.play();
}
}
package 依赖倒转原则;
public class DependecyPass {
public static void main(String[] args) {
}
}
class ChangHong implements ITV{
@Override
public void play() {
System.out.println("电视机已经打开");
}
}
/*
//方式1:通过接口传递实现依赖
//开关的接口
interface IOpenAndClose{
public void Open(ITV tv); //抽象方法,接收接口
}
//ITV接口
interface ITV{
public void play();
}
//实现接口
class OpenAndClose1 implements IOpenAndClose{
@Override
public void Open(ITV tv){
tv.play();
}
}
*/
//-------------------------------------------------------------------
/*
//第二种方式,夜光
//方式2:通过构造方法依赖传递
interface IOpenAndClose{
public void Open(); //抽象方法
}
interface ITV{ //ITV接口
public void play();
}
class OpenAndClose implements IOpenAndClose{
public ITV tv;
public OpenAndClose(ITV tv){
this.tv = tv;
}
@Override
public void Open(){
this.tv.play();
}
}*/
//-----------------------------------------------------------------
//方式3: