精华内容
下载资源
问答
  • 抽象和具体的经典例子
    千次阅读
    2021-02-12 11:07:34

    在这之前有给大家详细的介绍过java抽象类,相信很多人应该都比较了解了,那么下面就要继续来给大家分享一个java抽象类的实例。

    题目:

    不同几何图形的面积计算公式是不一样的,可是,它们具有的特性是一样的,都具有长和宽这两个属性,也都具有面积计算的方法。

    那么可以定义一个抽象类,在这个抽象类当中含有两个属性(width 和 height)和一个抽象方法area( )。

    具体实现步骤:

    1、创建一个表示图形的抽象类Shape:public abstract class Shape

    {

    public int width; // 几何图形的长

    public int height; // 几何图形的宽

    public Shape(int width, int height)

    {

    this.width = width;

    this.height = height;

    }

    public abstract double area(); // 定义抽象方法,计算面积

    }

    2、定义一个正方形类,这个类继承自形状类Shape,并重写了area( )

    抽象方法。

    正方形类的代码:public class Square extends Shape

    {

    public Square(int width, int height)

    {

    super(width, height);

    }

    // 重写父类中的抽象方法,实现计算正方形面积的功能

    @Override

    public double area()

    {

    return width * height;

    }

    }

    3、定义一个三角形类,这个类和正方形类相同,需要继承形状类Shape,并重写父类中的抽象方法area()。

    三角形类的代码:public class Triangle extends Shape

    {

    public Triangle(int width, int height)

    {

    super(width, height);

    }

    // 重写父类中的抽象方法,实现计算三角形面积的功能

    @Override

    public double area()

    {

    return 0.5 * width * height;

    }

    }

    4、最后,创建一个测试类,分别创建正方形类和三角形类的对象,并调用各类中的area()方法,打印出不同形状的几何图形的面积。

    测试类的代码:public class ShapeTest

    {

    public static void main(String[] args)

    {

    Square square = new Square(5, 4); // 创建正方形类对象

    System.out.println("正方形的面积为:" + square.area());

    Triangle triangle = new Triangle(2, 5); // 创建三角形类对象

    System.out.println("三角形的面积为:" + triangle.area());

    }

    }

    分析:

    在这个程序当中,创建了四个类,分别是图形类Shape、正方形类Square、三角形类Triangle 以及测试类ShapeTest。

    在这当中,图形类Shape是一个抽象类,创建了两个属性,分别为图形的长度和宽度,并通过构造方法Shape( )给这两个属性赋值。

    在Shape类的最后定义了一个抽象方法area( ),用来计算图形的面积。

    这里的话Shape类只是定义了计算图形面积的方法,而对于如何计算并没有任何限制。

    我们也能够这样去理解,抽象类Shape仅定义了子类的一般形式。

    正方形类Square继承抽象类Shape,并实现了抽象方法area( )。

    三角形类Triangle的实现和正方形类相同。

    在测试类ShapeTest的main( )方法当中,首先创建了正方形类和三角形类的实例化对象square和triangle,之后,分别调用area(

    )方法实现了面积的计算功能。

    5、结果:正方形的面积为:20.0

    三角形的面积为:5.0

    你还想了解更多的java程序代码例子,那么就请多多的关注奇Q工具网来进行了解吧。

    推荐阅读:

    更多相关内容
  • 父类子类, 组合都能实现 抽象,层级. 2.要达到最好的泛化.最好是无参数,无返回值.所有都是变成 field. 如无必要,勿增实体,延迟具体化.卡姆剃刀法则 ftp 下载基本配置: host ,userName ftp 下载器: 1.下载地址...

    如何梳理和重构_含复杂性度量

    两个例子:

    例子1: 一个 ftp 下载器

    例子2: 支付参数

    总结:

       1. 接口和实现. 父类和子类, 组合都能实现 抽象,层级.

       2.要达到最好的泛化.最好是无参数,无返回值.所有都是变成 field.

       3.组合的赋值是立体的.(一个嵌套一个的赋值,不可能是 abstract class), 继承的new 实例的赋值是拉平的.( 每一层都赋值,不过容易搞不清楚每一层需要赋值哪些参数.)

    方法论:

       1.思考每个层级需要哪些字段

         1.1 这些字段是否可枚举化. (可枚举化的放 field,不可枚举化的放到接口里)

            这样的好处是最下层的bean 都可以通过 spring 容器来管理. 父类的 bean 该 autowired 的也可以 autowired.

           父类不能autowired

       1.2 最终的 spring bean.

    如无必要,勿增实体,延迟具体化.卡姆剃刀法则

    成功的设计

    配合 spring 的动态配置获取. 因为要根据可变参数具体化(实例),所以无法利用 spring 的配置了.

    无法固定的东西通过参数传递. 但是一旦有了形参,通用性就降低了.

    如果要更好的使用 spring 的容器,那么设计的时候就要明确可固化和不可固化参数.

    例如:ftp 下载.前缀可固化. 文件名依赖 Date 可变.

    概念线(继承)实例线(继承概念先,实例线垂直上是依赖)

    ftp 下载基本配置: host ,userName

    ftp 下载器: 1.下载地址,2.本地文件保存地址. 3.ftp 下载基本配置

    渠道下载器 1.remotePrePath 2.localPrePath

    phoenix 渠道下载器 继承 <渠道下载器>: 无自有属性. 把 userName 和远程remotePrePath初始化.

    业务下载器: 1.midPath (远程和本地保持一致) 2. 文件名(远程和本地保持一致)

    phoenixPay 渠道下载器 ?

    设计的时候可以用字段, 如果该层级的具体化类能赋值的用 field.

    如果具体化类不能赋值的最好用abstract getField()方法. 这样能避免继承者忘记掉赋值相关属性.

    不过如果想用组合的方式,那么就无法用 abstract 了.

    好的犯案. 通过初始化方法来初始化.通不好的方案,过类来初始化

    不算成功的设计1:

    ftp 下载基本配置: host ,userName

    ftp 下载器: 1.下载地址,2.本地文件保存地址. 3.ftp 下载基本配置

    渠道下载器 1.remotePrePath 2.localPrePath

    业务下载器: 1.midPath (远程和本地保持一致) 2. 文件名(远程和本地保持一致)

    具体化:

    phoenix 渠道下载器 继承 <渠道下载器>: 无自有属性. 把 userName 和远程remotePrePath初始化.

    phoenixPay 渠道下载器 ?

    问题来了:

        phoenixPay 渠道下载器 到底是继承 <phoenix 渠道下载器> 还是 <业务下载器>?

    答: 如果具体化没有新增的字段,那么暂时先别具体化.把渠道和业务具体化放到一起.少一个类.

     

    解决方案(解决双继承问题):

       phoenix 渠道下载器 继承 业务下载器:

       phoenixPay 渠道下载器 继承 phoenix 渠道下载器

     

    支付参数的具体化却不同.

      支付宝参数和微信参数不同.

       都是渠道的具体化,各自支付宝和微信的biz 子类,都要各自演化. 无法有一个通用的 biz子 类.

    展开全文
  • 抽象工厂模式适用的环境,抽象工厂模式vs工厂方法模式,产品等级结构产品族的概念,模式结构的4个角色,抽象工厂模式案例及代码:计算机包含内存(RAM),CPU等硬件设备,根据如图所示的“产品等级结构-产品族示意...

    抽象工厂模式vs工厂方法模式

    1. 工厂方法模式中具体工厂只需要生产一种具体产品
    2. 抽象工厂模式中具体工厂可以生产相关的一组具体产品,这样的一组产品称为产品族

    引入两个概念

    产品等级结构

    产品等级结构:产品的继承结构。

    比如:抽象电视机和具体品牌电视之间构成了一个产品等级结构
    在这里插入图片描述

    产品族

    产品族:是指由同一个工厂生产的,位于不同产品等级结构一组产品

    比如:
    ① 海尔工厂生成的海尔电视机、海尔电冰箱。
    海尔电视机、海尔电冰箱就属于同一个产品族
    ③ 在这里海尔电视机属于电视机产品等级结构,海尔电冰箱属于电冰箱等级结构 ,它们位于不同产品等级结构
    在这里插入图片描述

    模式结构的角色

    1. 抽象工厂

    ① 定义了返回具体产品对象的方法
    产品有几种就定义几个方法

    1. 具体工厂

    ① 实现父类中 返回具体产品对象的方法
    具体工厂的个数 = 产品族的个数 --> 品牌的个数

    1. 抽象产品

    ① 将业务方法抽象出来
    抽象产品的个数 = 产品等级结构的个数 -->电视机、电冰箱 (产品类别的个数)

    1. 具体产品

    ① 只要指明一个产品所处的产品族,以及所属的产品等级结构,就可以唯一确定这个产品
    ② 实现该产品的业务方法
    具体产品的个数 = 产品族个数(品牌) * 产品等级结构的个数(产品类别)
    比如品牌(产品族)有两个:海尔和海信
    抽象产品(产品等级结构)有两个:电视机、电冰箱
    则具体产品就是2 * 2

    抽象工厂模式案例

    案例背景

    计算机包含内存(RAM),CPU等硬件设备,根据如图所示的“产品等级结构-产品族示意图”,使用抽象工厂模式实现计算机设备创建过程并绘制类图
    在这里插入图片描述

    案例分析

    1. 产品族(即具体工厂 --> 品牌)的个数有两个:PC 和 MAC
    2. 产品等级结构(即抽象产品 --> 产品类别)的个数有两个:CPU 和 RAM

    实现步骤

    1. 编写一个抽象工厂类:AbstractFactory,
      两个具体工厂:PcFactory和MacFactory ,
      两个抽象产品类:CPU,RAM,
      四个具体产品类:PcCPU,MacCPU,PcRAM,MacRAM
    2. 编写一个用户类Client和辅助类XMLUtil以实现通过XML文件来制造不同的产品
    3. 更改XML中的属性,观察用户类是否能使用不同的产品

    代码实现(按顺序)

    文件结构/类图

    在这里插入图片描述

    在这里插入图片描述

    1. 抽象产品类(2个)

    /**
     * @author 王胖子
     * @version 1.0
     */
    public interface CPU {
        public void play();
    }
    
    
    /**
     * @author 王胖子
     * @version 1.0
     */
    public interface RAM {
        public void play();
    }
    

    2. 具体产品类(4个)

    一个具体工厂生产一个产品族,一个产品族里有两种产品:CPU和RAM
    ② 有两个具体工厂:PC工厂 和 MAC工厂
    PC工厂生产 PcCPU 和 PcRAM

    /**
     * @author 王胖子
     * @version 1.0
     */
    public class PcCPU implements CPU {
        @Override
        public void play() {
            System.out.println("PC的CPU工作中...");
        }
    }
    
    /**
     * @author 王胖子
     * @version 1.0
     */
    public class PcRAM implements RAM {
        @Override
        public void play() {
            System.out.println("PC的RAM工作中...");
        }
    }
    
    
    /**
     * @author 王胖子
     * @version 1.0
     */
    public class MacCPU implements CPU {
        @Override
        public void play() {
            System.out.println("MAC的CPU工作中...");
        }
    }
    
    
    /**
     * @author 王胖子
     * @version 1.0
     */
    public class MacRAM implements RAM {
        @Override
        public void play() {
            System.out.println("MAC的RAM工作中...");
        }
    }
    
    

    3. 抽象工厂(1个)

    /**
     * @author 王胖子
     * @version 1.0
     */
    public interface AbstractFactory {
        public CPU produceCPU();
        public RAM produceRAM();
    }
    
    

    4. 具体工厂(2个)

    /**
     * @author 王胖子
     * @version 1.0
     */
    public class PcFactory implements AbstractFactory {
        @Override
        public CPU produceCPU() {
            return new PcCPU();
        }
    
        @Override
        public RAM produceRAM() {
            return new PcRAM();
        }
    }
    
    
    /**
     * @author 王胖子
     * @version 1.0
     */
    public class MacFactory implements AbstractFactory {
        @Override
        public CPU produceCPU() {
            return new MacCPU();
        }
    
        @Override
        public RAM produceRAM() {
            return new MacRAM();
        }
    }
    
    

    5. 配置类(config.xml)

    <?xml version="1.0"?>
    <config>
        <className>PcFactory</className>
    </config>
    

    6. 读取配置类(XMLUtil.java)

    import org.w3c.dom.Document;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    import java.io.File;
    
    /**
     * @author 王胖子
     * @version 1.0
     */
    public class XMLUtil {
        //该方法用于从xml配置文件中提取具体类类名,并返回一个实例对象
        public static Object getBean() {
            try {
                //创建DOM对象
                DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
                DocumentBuilder builder = dFactory.newDocumentBuilder();
                Document doc;
                //这个地址从项目根目录开始读取
                doc = builder.parse(new File("src//config.xml"));
    
                //获取包含类名的文本节点
                NodeList nl = doc.getElementsByTagName("className");
                Node classNode = nl.item(0).getFirstChild();
                String cName = classNode.getNodeValue();
    
                //通过类名生成实例对象并返回
                Class c = Class.forName(cName);
                Object obj = c.newInstance();
                return obj;
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    }
    
    

    7. 客户类

    /**
     * @author 王胖子
     * @version 1.0
     */
    public class Client {
        public static void main(String[] args) {
            CPU cpu;
            RAM ram;
            AbstractFactory factory;
            factory = (AbstractFactory) XMLUtil.getBean();
            cpu = factory.produceCPU();
            ram = factory.produceRAM();
            cpu.play();
            ram.play();
        }
    }
    
    

    输出结果

    在这里插入图片描述

    模式适用环境

    抽象工厂模式主要适用于:

    1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节
    2. 系统中有多于一个的产品族,但每次只使用其中某一产品族
    3. 属于同一个产品族的产品将在一起使用,这一约束必须在系统的设计中体现出来
    4. 产品等级结构稳定,在设计完成之后不会向系统中增加新的产品等级结构或者删除已有的产品等级结构
    展开全文
  • 主要介绍了Java接口和抽象类用法,结合实例形式总结分析了Java接口与抽象类的具体定义、使用技巧与相关注意事项,需要的朋友可以参考下
  • 简单工厂模式、工厂模式、抽象工厂模式案例详解及C++实现。

    目录

    一、简单工厂模式

    1. 什么是简单工厂模式

    2. 简单工厂模式实例

    3. 简单工厂模式的优缺点

     二、工厂模式

    1. 什么是工厂模式

    2. 工厂模式实例

    3. 简单工厂与工厂模式对比

     三、抽象工厂模式

    1. 什么是抽象工厂模式

    2. 抽象工厂模式实例

    3. 抽象工厂类总结


    一、简单工厂模式

    1. 什么是简单工厂模式

    Simple Factory Pattern,简单工厂模式,也叫做静态工厂方法模式(Static Factory Method Pattern)。属于类的创建型设计模式的一种,通过一个专门的类(工厂)来负责创建其他类的实例(具体产品),这些类都有一个共同的抽象类作为基类(抽象产品)。

    简单工厂模式中的三个角色

    1. 工厂角色:Creator,用于创建所有的具体产品实例,是简单工厂模式的核心。工厂类直接被外部调用,并提供一个静态方法,根据传入的参数不同来创建不同产品类的实例。
    2. 抽象产品角色:Product,它是工厂类所创建的所有实例的类的共同基类,用于描述产品的公共接口。它和工厂类是依赖的关系(作为工厂类静态方法的返回值)。
    3. 具体产品角色:Concrete Product,它是抽象产品类的子类,也是工厂类要创建的目标类。

    2. 简单工厂模式实例

     假设我们要生产一个手机,由苹果手机,小米手机,首先我们应该定义一个抽象产品类PhoneInterface

    //抽象产品类
    class PhoneInterface
    {
    public:
    	virtual void print_brand() = 0;
    };

    然后根据抽象产品类来实现具体的产品类,假设我们有苹果手机和小米手机

    //具体产品类
    class apple : public PhoneInterface
    {
    public:
    	virtual void print_brand()
    	{
    		cout << "苹果手机" << endl;
    	}
    };
    
    
    class XiaoMi : public PhoneInterface
    {
    public:
    	virtual void print_brand()
    	{
    		cout << "小米手机" << endl;
    	}
    };

    接下来就应该创建一个工厂类,在工厂类中定义了创建所有产品类实例的逻辑,以及选择创建哪个产品类实例的判断。

    //工厂类
    class Factory
    {
    public:
    	PhoneInterface* production_phone(int flag)
    	{
    		PhoneInterface* pTemp = NULL;
    		switch (flag) //所有的生产都集中在一个工厂中,每次修改都要在类中修改,不符合开闭原则
    		{
    		case 1:
    			pTemp = new apple;
    			break;
    		case 2:
    			pTemp = new XiaoMi;
    			break;
    		default:
    			pTemp = NULL;
    			break;
    		}
    		return pTemp;
    	}
    };

    这样,客户就可以通过工厂类来生产客户所需要的手机,并可以成功完成手机型号的生产。

    int main()
    {
    	Factory* pF = NULL;
    	PhoneInterface* pPhone = NULL;
    
    	pF = new Factory;
    	pPhone = pF->production_phone(1);
    	pPhone->print_brand();
    	delete pPhone;
    	
    	pPhone = pF->production_phone(2);
    	pPhone->print_brand();
    	delete pF;
    	delete pPhone;
    
    	system("pause");
    	return 0;
    }

    3. 简单工厂模式的优缺点

     优点:工厂类是整个简单工厂模式的核心,通过工厂类对外隐藏了创建实例的具体细节,用户直接使用工厂类去创建自己需要的实例,而不必关心实例是如何创建出来的,也不必关心内部结构是怎么组织的。

    缺点:正所谓成也萧何,败也萧何,简单工厂模式的优点来源于工厂类,其缺点也来源于工厂类,因为所有实例的创建逻辑都集中在工厂类中,一旦工厂出现问题,所有实例的创建都将无法进行,并且增删产品都要去修改工厂类来实现,不符合开闭原则。因为简单工厂模式不符合开闭原则,所以它不是标准的设计模式。

     二、工厂模式

    1. 什么是工厂模式

    factory pattern,工厂模式同样属于类的创建型模式,也成为多态工厂模式。工厂模式对简单工厂模式不遵守开闭原则这一缺点做了修正,工厂模式多出了一个抽象工厂角色作为接口,实际的生产工作在具体工厂类中实现,这样进一步的抽象化使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。简单来说,就是把简单工厂中的工厂细分为不同产品的工厂,每个工厂生产一种产品。

    1. 抽象工厂角色(Creator),所有具体工厂都要实现这个接口;
    2. 具体工厂(Concrete Creator),负责实例化具体产品对象;
    3. 抽象角色(Product),和简单工厂模式一样,它是工厂类所创建的所有实例的类的共同基类,用于描述产品的公共接口。
    4. 具体产品角色(Concrete Product),具体工厂类所要实例化的对象。

    2. 工厂模式实例

    抽象产品类和具体产品类不变 

    //抽象产品类
    class PhoneInterface
    {
    public:
    	virtual void print_brand() = 0;
    };
    
    //苹果手机产品实现
    class apple : public PhoneInterface
    {
    public:
    	virtual void print_brand()
    	{
    		cout << "苹果手机" << endl;
    	}
    };
    
    //小米手机产品实现
    class XiaoMi : public PhoneInterface
    {
    public:
    	virtual void print_brand()
    	{
    		cout << "小米手机" << endl;
    	}
    };

     首先定义一个抽象的工厂类,来定义具体工厂的统一接口

    //抽象工厂类
    class FactoryInterface
    {
    public:
    	virtual PhoneInterface* production_phone() = 0;
    };

    然后定义一个苹果手机工厂,用于生产苹果手机,再定义一个小米手机工厂,用于生产苹果手机,那么这两个工厂就是具体工厂角色

    //苹果手机工厂
    class AppleFactory : public FactoryInterface
    {
    public:
    	virtual PhoneInterface* production_phone()
    	{
    		return new apple;
    	}
    };
    
    //小米手机工厂
    class XiaomiFactory : public FactoryInterface
    {
    public:
    	virtual PhoneInterface* production_phone()
    	{
    		return new XiaoMi;
    	}
    };

    当我们需要生产手机产品的时候,直接使用苹果手机工厂去创建苹果手机对象,用小米手机工厂去创建小米手机对象即可。假如,我们增加需求,需要华为手机,这时只要增加一个华为工厂和华为手机的实现类即可,工厂的抽象类和手机的抽象类都不用动,符合开闭原则。

    int main()
    {
    	FactoryInterface* pFactory = NULL;
    	PhoneInterface* pPhone = NULL;
    
    	//要生产一台苹果手机
    	//先创建一个苹果手机工厂
    	pFactory = new AppleFactory;
    	pPhone = pFactory->production_phone();
    	pPhone->print_brand();
    	delete pPhone;
    	delete pFactory;
    
    	//生产一个小米手机
    	pFactory = new XiaomiFactory;
    	pPhone = pFactory->production_phone();
    	pPhone->print_brand();
    	delete pPhone;
    	delete pFactory;
    
    	system("pause");
    	return 0;
    }

    3. 简单工厂与工厂模式对比

     简单工厂模式把所有的创建逻辑都放在了一个工厂类中,而工厂模式则是提供了一个抽象的工厂接口,由具体工厂去创建产品实例,极大的方便了增加产品,删除产品等操作,且很好的符合了开闭原则,简单工厂模式每次增删产品都要直接修改工厂类,而工厂模式只需要增加一个具体工厂类和一个具体产品类就可以完成功能的扩充。

    在简单工厂模式中,客户端是面向具体工厂编程,增加产品要在工厂类中修改代码;而工厂模式是面向抽象工厂编程,增加产品只要创建一个新的具体工厂就可以了,这就是面向抽象类编程。

     三、抽象工厂模式

    1. 什么是抽象工厂模式

    Abstract Factory Pattern,抽象工厂模式。假设在前面的工厂模式下,我们对产品线提出了进一步的要求,因为手机既要在国内销售,又要在国外销售,所以同一品牌手机增加了大陆版、美版、港版等产品线。如果使用工厂模式,每一个品牌的手机,每一个版本的手机都要单独一个具体工厂来创建,很不方便‘这时候,就有了抽象工厂模式,抽象工厂模式可以创建一个产品族(包含多条产品线)。抽象工厂模式用官方语言描述就是,一种为访问类提供一个创建一组相关或相互依赖对象的接口,且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。 她也有四种角色,和工厂模式一样。

    1. 抽象工厂角色(Creator),所有具体工厂都要实现这个接口,可以创建多个不同等级的产品(多条产品线);
    2. 具体工厂(Concrete Creator),负责实例化具体产品对象,多条产品线;
    3. 抽象角色(Product),和简单工厂模式一样,它是工厂类所创建的所有实例的类的共同基类,用于描述产品的公共接口。
    4. 具体产品角色(Concrete Product),具体工厂类所要实例化的对象。

    2. 抽象工厂模式实例

    首先创建一个抽象手机类 

    //抽象产品
    class PhoneInterface
    {
    public:
    	virtual void print_brand() = 0;
    };

    根据抽象手机类定义大陆版苹果手机类,美版苹果手机类,大陆版小米手机类,美版小米手机类

    //美版的苹果手机
    class UsApple : public PhoneInterface
    {
    public:
    	virtual void print_brand()
    	{
    		cout << "美版的苹果手机" << endl;
    	}
    };
    
    //大陆版小米手机
    class ChinaXiaomi : public PhoneInterface
    {
    public:
    	virtual void print_brand()
    	{
    		cout << "大陆版本的小米手机" << endl;
    	}
    };
    
    //美版的小米手机
    class UsXiaomi : public PhoneInterface
    {
    public:
    	virtual void print_brand()
    	{
    		cout << "美版的小米手机" << endl;
    	}
    };

    接下来定义一个抽象工厂类,该抽象工厂类中包含两个接口,一个是苹果手机生产线,一个是小米手机生产线

    //抽象工厂
    class FactoryInterface
    {
    public:
    	//产品线1:苹果手机
    	virtual PhoneInterface* production_apple() = 0;
    	//产品线2:小米手机
    	virtual PhoneInterface* production_xiaomi() = 0;
    };

    根据抽象工厂来定义两个具体工厂,一个是大陆版手机工厂,一个是美版手机工厂

    //生产大陆版本手机的工厂
    class ChinaFactory : public FactoryInterface
    {
    public:
    	//产品线1:苹果手机
    	virtual PhoneInterface* production_apple()
    	{
    		return new ChinaApple;
    	}
    	//产品线2:小米手机
    	virtual PhoneInterface* production_xiaomi()
    	{
    		return new ChinaXiaomi;
    	}
    };
    
    //生产美版手机的工厂
    class UsFactory : public FactoryInterface
    {
    public:
    	//产品线1:苹果手机
    	virtual PhoneInterface* production_apple()
    	{
    		return new UsApple;
    	}
    	//产品线2:小米手机
    	virtual PhoneInterface* production_xiaomi()
    	{
    		return new UsXiaomi;
    	}
    };

    客户可以直接使用两个具体工厂去生产大陆版苹果/小米手机或美版苹果/小米手机

    int main()
    {
    	FactoryInterface* pFactory = NULL;
    	PhoneInterface* pPhone = NULL;
    
    	//使用大陆版手机的工厂
    	cout << "======大陆版手机工厂======" << endl;
    	pFactory = new ChinaFactory;
    	//生产大陆版苹果手机
    	pPhone = pFactory->production_apple();
    	pPhone->print_brand();
    	delete pPhone;
    	//生产大陆版小米手机
    	pPhone = pFactory->production_xiaomi();
    	pPhone->print_brand();
    	delete pPhone;
    	delete pFactory;
    
    	//使用美版手机的工厂
    	cout << "======美版手机工厂======" << endl;
    	pFactory = new UsFactory;
    	pPhone = pFactory->production_apple();
    	pPhone->print_brand();
    	delete pPhone;
    	pPhone = pFactory->production_xiaomi();
    	pPhone->print_brand();
    	delete pPhone;
    	delete pFactory;
    
    	system("pause");
    	return 0;
    }

    3. 抽象工厂类总结

    当增加一个新的产品族时,只需要增加一个新的具体工厂即可,如果整个产品族只有一个等级的产品,比如只有一条生产线,抽象工厂就和工厂模式一样了。

    展开全文
  • 这本经典、畅销的数据结构教材详细介绍了数据抽象的基础知识,强调作为面向对象方法基础原理的规范实施之间的区别。书中使用的软件工程原则概念以及UML图便于增强学生的理解。 本书特点 ◆详细介绍了数据抽象...
  • 抽象类:案例:猫

    2021-05-22 18:16:20
    抽象类:案例:猫狗 需求:请采用抽象类的思想实现猫狗的案例,并在测试类中进行测试 1 定义动物类 package com.itheima_02; /* 抽象类 */ public abstract class Animal { private int age = 20; ...
  • http://blog.csdn.net/zhlyyea/article/details/2114654 转载于:https://www.cnblogs.com/wangchuang/archive/2013/03/28/2986992.html
  • Java关于继承的经典案例 点赞!点赞!点赞! 题干:结合继承的思想,分析下列需求并实现 1.定义项目经理类Manager 【属性:姓名 工号 工资 奖金】【行为:工作work】 2.定义程序员类Coder【属性:姓名 工号 工资】...
  • JAVA中的接口和抽象类实例源码介绍。所有的对象都是通过类来描绘的,但是并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。抽象类往往用来表征我们在对...
  • 4 以图中的枫叶动物皮影动物为例,它们是对动物园看到的小动物的形状抽象,在描述时可以引导幼儿表述为:“小老鼠枫叶的形状就像动物园的小老鼠一样,大象皮影的形状像动物园见到的大象一样。”图中小动物形状从...
  • 在Java语言中, abstract class interface是支持抽象类定义的两种机制。正是由于这两种机制的存在,才赋予了Java强大的 面向对象能力。abstract classinterface之间在对于抽象类定义的支持方面具有很大的相似性...
  • 抽象工厂模式 抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在抽象工厂模式...
  • Java抽象类的一个经典例子

    千次阅读 2020-06-11 12:25:38
    设计一个扩展自抽象类GeometriObject的新的Triangle类。绘制Triangle类GeometricObject类的UML图并实现Triangle类。编写一个测试程序,提示用户输入三角形的三条边、一种颜色以及一个表明该三角形是否填充的布尔值...
  • (3) 抽象类可以但不是必须有抽象属性和抽象方法,但是一旦有了抽象方法,就一定要把这个类声明为抽象类 (4) 具体派生类必须覆盖基类的抽象方法 (5) 抽象派生类可以覆盖基类的抽象方法,也可以不覆盖。如果不覆盖,...
  • 通过C++实现了简单工厂模式、工厂模式、抽象工厂模式三大设计模式的经典案例
  • Java接口和抽象类详解

    2021-03-18 11:55:16
    抽象类在继承中, 父类是一个通用类,每一个子类都会使类变得越来越明确和具体。如果从子类追溯到父类,类就会变得通用、更加不明确。类的设计应该确保父类包含它的子类的共同特征行为。有时候,一个父类会设计得...
  • 【引】周末的清晨,少有的好天气冲走不少日常中的忙乱阴霾,石头兄弟给我发来了一篇文章“system abstraction”...软件系统中概念的抽象,是组织思维以加快设计构建...
  • 比如,我们可以使用接口来实现面向对象的抽象特性、多态特性基于接口而非实现的设计原则,使用抽象类来实现面向对象的继承特性模板设计模式等等。 不过,并不是所有的面向对象编程语言都支持这两个语法概念,...
  • 抽象 接口 有什么区别? 含有 abstract 修饰符的 class 即为抽象类,abstract 类不能创建的实例对象。含有 abstract 方法的类必须定义为抽象类,抽象类中的方法不必是抽象的。 抽象类中定义抽象方法必须在具体...
  • 分享给大家供大家参考,具体如下: 星际争霸是战略游戏,所以同样的兵种,敌我显示是不同的。 典型的就是鼠标的颜色,点中自己的物体的时候,鼠标颜色变成绿色,点中敌人的物体的时候,鼠标颜色变成红色。 还有就是...
  • 主要介绍了Java中的接口和抽象类用法,结合实例形式较为详细的分析了Java中关于接口和抽象类的概念、定义、用法与相关注意事项,需要的朋友可以参考下
  • 摘 要:伴随着新课程标准改革的逐渐深化,情境式的教学模式在初中数学的教学实践中应用的也愈来愈广泛。...同时丰富的情景式数学教学也可以通过经典类、生活类、科学类等多种类型的数学问题教学案例的演绎,...
  • 在我之前的一篇post《抽象接口的谁是谁非》中,同事管伟的讨论,得到很多朋友的关注,因为是不成体系的论道,所以给大家了解造成不便,同时关于这个主题的系统性理论,我认为也有必要做以总结,因此才有了本篇...
  • 做项目时,为了做出通用的编程,往往需要面向抽象编程,面向接口编程,那么什么时候使用抽象类,什么时候使用接口呢?接口(interface)可以说成是抽象类的一种特例,接口中的所有方法都必须是抽象的。接口中的方法...
  • 在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是并不是所有的类都能用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就应该被定义为抽象类。抽象类概述比如,我们要...
  • 明白了等级结构产品族的概念,就理解工厂方法模式和抽象工厂模式的区别了,如果工厂的产品全部属于同一 个等级结构,则属于工厂方法模式;如果工厂的产品来自多个等级结构,则属于抽象工厂模式。在本例中,如果 ...
  • java抽象接口经典讲解
  • 接口只能定义属性、索引器、事件、方法声明,不能包含字段。2、抽象类是一个不完整的类,需要进一步细化,而接口是一个行为规范。微软的自定义接口总是后带able字段,证明其是表述一类“我能做。。。”3、接口可以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 175,721
精华内容 70,288
关键字:

抽象和具体的经典例子