bridge bridge mode

Feb 10 posted in Java (RSS), comments.

Hypothetical demand

Are black or white English-speaking whites are Chinese-speaking whites are Chinese-speaking black English-speaking black

As a general method of subclass the parent class could be produced four sub-classes to this is a combination of 2 * 2 If the branch is more of the N * N

Solution

Bridge mode

Separation of the type in which a stable branch with the inheritance system to distinguish between acts of the other branches of interface package behavior (strategy pattern?)

Next, look at the code

Abstract people

public abstract class People {
    protected Language language;
    
    abstract void speak();
}

Black

public class BlackPeople extends People {

    /**
     * 
     */
    public BlackPeople() {
    }
    
    public BlackPeople(Language language){
        this.language=language;
    }    
    
    @Override
    void speak() {
        System.out.println("I'm black");
        language.speak();
    }

}

White

public class WhitePeople extends People {

    /**
     * 
     */
    public WhitePeople() {
    }
    
    public WhitePeople(Language language){
        this.language=language;
    }    
    
    @Override
    void speak() {
        System.out.println("I'm white");
        language.speak();
    }

}

Abstract class act

public interface Language {
    void speak();
}

Chinese

public class Chinese implements Language {

    public void speak() {
        System.out.println(" Hello World  ");
    }

}

English

public class English implements Language {

    public void speak() {
        System.out.println("hello world");
    }

}

Test class

public class Client extends TestCase {
    public void test1() {
        People black=new BlackPeople(new Chinese());
        black.speak();
        People black2=new BlackPeople(new English());
        black2.speak();
        
        System.out.println("=============");
        
        People white=new WhitePeople(new Chinese());
        white.speak();
        People white2=new WhitePeople(new English());
        white2.speak();
    }
}

Output

I'm black
 Hello World  
I'm black
hello world
=============
I'm white
 Hello World  
I'm white
hello world

This greatly reduced the use pattern code Although there are now six categories but it is 1 +1 +2 +2

If the law is in accordance with the original N * N sub-branch will be using the mode 1 +1 + N + N rather than N * N a class

Less chance of error code is less when a change needs to change in places where less is more important is that there is no duplicate code fragments