简单工厂、工厂方法、抽象工厂的比较与分析

//Phone抽象类
public abstract class Phone {
    abstract void produce();
}
//ApplePhone类
public class ApplePhone extends Phone {
    @Override
    void produce() {
        System.out.println("生产苹果手机");
    }
}
//HuaweiPhone类
public class HuaweiPhone extends Phone {
    @Override
    void produce() {
        System.out.println("生产华为手机");
    }
}
//简单工厂类
public class PhoneFactory {
    Phone getPhone(String type){
        switch (type.toLowerCase()){
            case "apple":
                return new ApplePhone();
            case "huawei":
                return new HuaweiPhone();
            default:
                return null;
        }
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        PhoneFactory phoneFactory = new PhoneFactory();
        Phone phone=phoneFactory.getPhone("apple");
        phone.produce();

        PhoneFactory phoneFactory1 = new PhoneFactory();
        Phone phone1=phoneFactory.getPhone("huawei");
        phone1.produce();
    }
}

//Phone抽象类
public abstract class Phone {
    abstract  void produce();
}
//PhoneFactory接口
public interface PhoneFactory {
    Phone getPhone();
}
//通过继承抽象类定义ApplePhone
public class ApplePhone extends  Phone {
    @Override
    void produce() {
        System.out.println("生产苹果手机");
    }
}
//通过实现接口定义ApplePhoneFactory
public class ApplePhoneFactory implements PhoneFactory {
    @Override
    public Phone getPhone() {
        return new ApplePhone();
    }
}
//通过继承抽象类定义HuaweiPhone
public class HuaweiPhone extends Phone {
    @Override
    void produce() {
        System.out.println("生产华为手机");
    }
}
//通过实现接口定义HuaweiPhoneFactory
public class HuaweiPhoneFactory implements PhoneFactory {
    @Override
    public Phone getPhone() {
        return new HuaweiPhone();
    }
}
//Test测试类
public class Test {
    public static void main(String[] args) {
        PhoneFactory phoneFactory= new ApplePhoneFactory();
        phoneFactory.getPhone().produce();

        PhoneFactory phoneFactory1 = new HuaweiPhoneFactory();
        phoneFactory1.getPhone().produce();
    }
}

//Phone抽象类,可以用接口方式代替
public abstract class Phone {
    abstract  void producePhone();
}
//NoteBook抽象类，可以用接口方式代替
public abstract class NoteBook {
    abstract void produceNoteBook();
}
//抽象工厂
public interface Factory {
    Phone getPhone();
    NoteBook getNoteBook();
}
//Apple Phone类
public class ApplePhone extends Phone {
    @Override
    void producePhone() {
        System.out.println("生产苹果手机");
    }
}
//Apple MacBook类
public class AppleMacBook extends NoteBook {
    @Override
    void produceNoteBook() {
        System.out.println("生产苹果MacBook");

    }
}
//Apple工厂类
public class AppleFactory implements Factory {
    @Override
    public Phone getPhone() {
        return new ApplePhone();
    }

    @Override
    public NoteBook getNoteBook() {
        return new AppleMacBook();
    }
}
//Huawei Phone类
public class HuaweiPhone extends Phone {
    @Override
    void producePhone() {
        System.out.println("生产华为手机");
    }
}
//Huawei NoteBook类
public class HuaweiNoteBook extends NoteBook {
    @Override
    void produceNoteBook() {
        System.out.println("生产华为笔记本电脑");
    }
}
//Huawei工厂类
public class HuaweiFactory implements Factory {
    @Override
    public Phone getPhone() {
        return new HuaweiPhone();
    }

    @Override
    public NoteBook getNoteBook() {
        return new HuaweiNoteBook();
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Factory appleFactory = new AppleFactory();
        appleFactory.getPhone().producePhone();
        appleFactory.getNoteBook().produceNoteBook();
        
        Factory huaweiFactory = new HuaweiFactory();
        huaweiFactory.getPhone().producePhone();
        huaweiFactory.getNoteBook().produceNoteBook();
    }
}