设计模式—创建型模式

最新推荐文章于 2024-03-25 22:00:55 发布
最新推荐文章于 2024-03-25 22:00:55 发布
阅读量332 收藏 3
点赞数
分类专栏： 设计模式 C++ 文章标签： C++ 设计模式 创建型模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011370855/article/details/103223146
版权

文章目录

创建型模式

创建型模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。
优点：程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

1、工厂模式

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。工厂模式作为一种创建模式，一般在创建复杂对象时，考虑使用；在创建简单对象时，建议直接new完成一个实例对象的创建。

1.1、简单工厂模式

主要特点是需要在工厂类中做判断，从而创造相应的产品，当增加新产品时，需要修改工厂类。使用简单工厂模式，我们只需要知道具体的产品型号就可以创建一个产品。

缺点：工厂类集中了所有产品类的创建逻辑，如果产品量较大，会使得工厂类变的非常臃肿。
在这里插入图片描述

/*
1、创建一个 Shape 接口和实现 Shape 接口的实体类。
2、定义工厂类 ShapeFactory。
3、使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。
*/
 /*
 关键代码：创建过程在工厂类中完成。
 */
 #include <iostream>
 ​ ​
 //定义产品类型信息
 enum SHAPE_TYPE
 {
     CIRCLE,
     RECTANGLE,
     SQUARE
};

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

//具体的产品类
class Circle : public Shape
{
public:
    Circle ():Shape(){}
    const void draw() override
    {
        cout <<"Circle "<< endl;
    }
};
 ​
 //具体的产品类
class Square: public Shape
{
public:
    Square():Shape(){}
    const void draw() override
    {
        cout <<"Square"<< endl;
    }
};

class Rectangle: public Shape
{
public:
    Rectangle():Shape(){}
    const void draw() override
    {
        cout <<"Rectangle"<< endl;
    }
};
 
 //工厂类
 class ShapeFactory
 {
 public:
     //根据产品信息创建具体的产品类实例，返回一个抽象产品类
     Shape* getShape(SHAPE_TYPE type)
     {
         switch(type)
         {
         case CIRCLE:
             return new Circle();
         case RECTANGLE:
             return new Rectangle();
         case SQUARE:
             return new Square();
         default:
             return nullptr;
         }
     }
 };
 ​
 int main()
 {
     ShapeFactory* factory = new ShapeFactory();
     Shape* pcircle= factory->getShape(CIRCLE);
     pcircle->draw();
     Shape* prectangle = factory->getShape(RECTANGLE);
     prectangle->draw();
     delete pcircle;
     pcircle= nullptr;
     delete prectangle ;
     prectangle  = nullptr;
     delete factory;
     factory = nullptr;
     return 0;
 }

1.2、工厂方法模式

定义一个创建对象的接口，其子类去具体现实这个接口以完成具体的创建工作。如果需要增加新的产品类，只需要扩展一个相应的工厂类即可。

缺点：产品类数据较多时，需要实现大量的工厂类，这无疑增加了代码量。


/*
1、创建一个 Shape 接口和实现 Shape 接口的实体类。
2、创建一个 ShapeFactory接口和实现 ShapeFactory接口的实体类。
3、根据不同的ShapeFactory实体类获取所需对象的类型。
*/

 /*
 关键代码：创建过程在其子类执行。
 */ ​
 #include <iostream>
//抽象产品类
class Shape
{
public:
    virtual void draw() = 0;
};
//抽象工厂类
class ShapeFactory
{
public:
    virtual Shape* getShape() = 0;
};

//具体的产品类
class Circle : public Shape
{
public:
    Circle ():Shape(){}
    const void draw() override
    {
        cout <<"Circle "<< endl;
    }
};
 ​
 //具体的产品类
class Square: public Shape
{
public:
    Square():Shape(){}
    const void draw() override
    {
        cout <<"Square"<< endl;
    }
};

class Rectangle: public Shape
{
public:
    Rectangle():Shape(){}
    const void draw() override
    {
        cout <<"Rectangle"<< endl;
    }
};
 
 //工厂类
 class CircleFactory: public ShapeFactory
 {
 public:
     CircleFactory():ShapeFactory(){}
     Shape* getShape()
     {
        return new Circle();
     }
 };
 ​
  //工厂类
 class RectangleFactory: public ShapeFactory
 {
 public:
     RectangleFactory():ShapeFactory(){}
     Shape* getShape()
     {
        return new Rectangle();
     }
 };
 
  //工厂类
 class SquareFactory: public ShapeFactory
 {
 public:
     SquareFactory():ShapeFactory(){}
     Shape* getShape()
     {
        return new Square();
     }
 };
 
 int main()
 {
     ShapeFactory* pcirclefactory = new CircleFactory();
     Shape* pcircle= pcirclefactory->getShape();
     pcircle->draw();
     ShapeFactory* prectanglefactory = new RectangleFactory();
     Shape* prectangle = prectanglefactory->getShape();
     prectangle->draw();
     
     delete pcircle;
     pcircle= nullptr;
     delete prectangle ;
     prectangle  = nullptr;
     delete pcirclefactory;
     pcirclefactory = nullptr;
     delete prectanglefactory;
     prectanglefactory = nullptr;
     return 0;
 }

1.3、抽象工厂模式

抽象工厂模式提供创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

当存在多个产品系列，而客户端只使用一个系列的产品时，可以考虑使用抽象工厂模式。

缺点：当增加一个新系列的产品时，不仅需要现实具体的产品类，还需要增加一个新的创建接口，
扩展相对困难。

 /*
 * 关键代码：在一个工厂里聚合多个同类产品。
 * 以下代码以白色衣服和黑色衣服为例，白色衣服为一个产品系列，黑色衣服为一个产品系列。白色上衣搭配白色裤子，黑色上衣搭配黑色裤字。每个系列的衣服由一个对应的工厂创建，这样一个工厂创建的衣服能保证衣服为同一个系列。
 */
 ​
 //抽象上衣类
 class Coat
 {
 public:
     virtual const string& color() = 0;
 };
 ​
 //黑色上衣类
 class BlackCoat : public Coat
 {
 public:
     BlackCoat():Coat(),m_strColor("Black Coat")
     {
     }
 ​
     const string& color() override
     {
         cout << m_strColor.data() << endl;
         return m_strColor;
     }
 private:
     string m_strColor;
 };
 ​
 //白色上衣类
 class WhiteCoat : public Coat
 {
 public:
     WhiteCoat():Coat(),m_strColor("White Coat")
     {
     }
     const string& color() override
     {
         cout << m_strColor.data() << endl;
         return m_strColor;
     }
 ​
 private:
     string m_strColor;
 }; 
 ​
 //抽象裤子类
 class Pants
 {
 public:
     virtual const string& color() = 0;
 };
 ​
 //黑色裤子类
 class BlackPants : public Pants
 {
 public:
     BlackPants():Pants(),m_strColor("Black Pants")
     {
     }
     const string& color() override
     {
         cout << m_strColor.data() << endl;
         return m_strColor;
     }
 ​
 private:
     string m_strColor;
 };
 ​
 //白色裤子类
 class WhitePants : public Pants
 {
 public:
     WhitePants():Pants(),m_strColor("White Pants")
     {
     }
     const string& color() override
     {
         cout << m_strColor.data() << endl;
         return m_strColor;
     }
 ​
 private:
     string m_strColor;
 };
 ​
 //抽象工厂类，提供衣服创建接口
 class Factory
 {
 public:
     //上衣创建接口，返回抽象上衣类
     virtual Coat* createCoat() = 0;
     //裤子创建接口，返回抽象裤子类
     virtual Pants* createPants() = 0;
 };
 ​
 //创建白色衣服的工厂类，具体实现创建白色上衣和白色裤子的接口
 class WhiteFactory : public Factory
 {
 public:
     Coat* createCoat() override
     {
         return new WhiteCoat();
     }
 ​
     Pants* createPants() override
     {
         return new WhitePants();
     }
 };
 ​
 //创建黑色衣服的工厂类，具体实现创建黑色上衣和白色裤子的接口
 class BlackFactory : public Factory
 {
     Coat* createCoat() override
     {
         return new BlackCoat();
     }
 ​
     Pants* createPants() override
     {
         return new BlackPants();
     }
 };

2、单例模式

单例模式顾名思义，保证一个类仅可以有一个实例化对象，并且提供一个可以访问它的全局接口。实现单例模式必须注意一下几点：

  • 单例类只能由一个实例化对象。

  • 单例类必须自己提供一个实例化对象。

  • 单例类必须提供一个可以访问唯一实例化对象的接口。

  • 单例模式分为懒汉和饿汉两种实现方式。
    在这里插入图片描述

2.1、懒汉单例模式

懒汉单利模式：用的时候才会实例化类。实例过程中存在线程安全的问题。在访问量较小，甚至可能不会去访问的情况下，采用懒汉实现，这是以时间换空间。

2.1.1、非线程安全的懒汉单例模式
/*
* 关键代码：构造函数是私有的，不能通过赋值运算，拷贝构造等方式实例化对象。
*/
​
//懒汉式一般实现：非线程安全，getInstance返回的实例指针需要delete
class Singleton
{
public:
    static Singleton* getInstance();
    ~Singleton(){}
​
private:
    Singleton(){}                                        //构造函数私有
    Singleton(const Singleton& obj) = delete;            //明确拒绝
    Singleton& operator=(const Singleton& obj) = delete; //明确拒绝
    
    static Singleton* m_pSingleton;
};
​
Singleton* Singleton::m_pSingleton = NULL;
​
Singleton* Singleton::getInstance()
{
    if(m_pSingleton == NULL)
    {
        m_pSingleton = new Singleton; 	//没有加锁，多线程访问时出现问题
    }
    return m_pSingleton;
}
2.1.2、线程安全的懒汉单例模式
 std::mutex mt;
 
 class Singleton
 {
 public:
     static Singleton* getInstance();
 private:
     Singleton(){}                                    //构造函数私有
     Singleton(const Singleton&) = delete;            //明确拒绝
     Singleton& operator=(const Singleton&) = delete; //明确拒绝
     static Singleton* m_pSingleton; 
 };
 Singleton* Singleton::m_pSingleton = NULL;
 
 Singleton* Singleton::getInstance()
 {
     if(m_pSingleton == NULL)
     {
         mt.lock();
         if(m_pSingleton == NULL)
         {
             m_pSingleton = new Singleton();
         }
         mt.unlock();
     }
     return m_pSingleton;
 }
2.1.3、返回一个reference指向local static对象（非线程安全）

这种单例模式实现方式多线程可能存在不确定性：任何一种non-const static对象，不论它是local或non-local,在多线程环境下“等待某事发生”都会有麻烦。解决的方法：在程序的单线程启动阶段手工调用所有reference-returning函数。这种实现方式的好处是不需要去delete它。

class Singleton
{
public:
    static Singleton& getInstance();
private:
    Singleton(){}
    Singleton(const Singleton&) = delete;  //明确拒绝
    Singleton& operator=(const Singleton&) = delete; //明确拒绝
};
​​
Singleton& Singleton::getInstance()
{
    static Singleton singleton;
    return singleton;
}

2.2、饿汉单例模式

饿汉：在单例类定义的时候就进行实例化。在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。

 //饿汉式：线程安全，注意一定要在合适的地方去delete它
 class Singleton
 {
 public:
     static Singleton* getInstance();
 private:
     Singleton(){}                                    //构造函数私有
     Singleton(const Singleton&) = delete;            //明确拒绝
     Singleton& operator=(const Singleton&) = delete; //明确拒绝
 ​
     static Singleton* m_pSingleton;
 };
 ​
 Singleton* Singleton::m_pSingleton = new Singleton(); //单例类定义的时候就进行实例化
 ​
 Singleton* Singleton::getInstance()
 {
     return m_pSingleton;
 }

3、建造者模式

建造者模式：将复杂对象的构建和其表示分离，使得相同的构建过程可以产生不同的表示。

以下情形可以考虑使用建造者模式：

  • 对象的创建复杂，但是其各个部分的子对象创建算法一定。

  • 需求变化大，构造复杂对象的子对象经常变化，但将其组合在一起的算法相对稳定。

建造者模式的优点：

  • 将对象的创建和表示分离，客户端不需要了解具体的构建细节。

  • 增加新的产品对象时，只需要增加其具体的建造类即可，不需要修改原来的代码，扩展方便。

  • 产品之间差异性大，内部变化较大、较复杂时不建议使用建造者模式。


/*
*关键代码：建造者类：创建和提供实例； Director类：管理建造出来的实例的依赖关系。
*/
​
#include <iostream>
#include <string>
using namespace std;
​
//具体的产品类
class Order
{
public:
    void setFood(const string &food)
    {
        m_strFood = food;
    }
    ​ const string &food()
    {
        cout << m_strFood.data() << endl;
        return m_strFood;
    }

    void setDrink(const string &drink)
    {
        m_strDrink = drink;
    }
    ​ const string &drink()
    {
        cout << m_strDrink << endl;
        return m_strDrink;
    }
    ​ private : string m_strFood;
    string m_strDrink;
};
​
//抽象建造类，提供建造接口。
class OrderBuilder
{
public:
    virtual ~OrderBuilder()
    {
        cout << "~OrderBuilder()" << endl;
    }
    virtual void setOrderFood() = 0;
    virtual void setOrderDrink() = 0;
    virtual Order *getOrder() = 0;
};
​
//具体的建造类
class VegetarianOrderBuilder : public OrderBuilder
{
public:
    VegetarianOrderBuilder()
    {
        m_pOrder = new Order;
    }
    ​ ~VegetarianOrderBuilder()
    {
        cout << "~VegetarianOrderBuilder()" << endl;
        delete m_pOrder;
        m_pOrder = nullptr;
    }
    ​ void setOrderFood() override
    {
        m_pOrder->setFood("vegetable salad");
    }
    ​ void setOrderDrink() override
    {
        m_pOrder->setDrink("water");
    }
    ​
        Order *
        getOrder() override
    {
        return m_pOrder;
    }
    ​ private : Order *m_pOrder;
};
​
//具体的建造类
class MeatOrderBuilder : public OrderBuilder
{
public:
    MeatOrderBuilder()
    {
        m_pOrder = new Order;
    }
    ~MeatOrderBuilder()
    {
        cout << "~MeatOrderBuilder()" << endl;
        delete m_pOrder;
        m_pOrder = nullptr;
    }
    ​ void setOrderFood() override
    {
        m_pOrder->setFood("beef");
    }
    ​ void setOrderDrink() override
    {
        m_pOrder->setDrink("beer");
    }
    ​
        Order *
        getOrder() override
    {
        return m_pOrder;
    }
    ​ private : Order *m_pOrder;
};
​
//Director类，负责管理实例创建的依赖关系，指挥构建者类创建实例
class Director
{
public:
    Director(OrderBuilder *builder) : m_pOrderBuilder(builder)
    {
    }
    void construct()
    {
        m_pOrderBuilder->setOrderFood();
        m_pOrderBuilder->setOrderDrink();
    }
    ​ private : OrderBuilder *m_pOrderBuilder;
};
​
int main()
{
    //  MeatOrderBuilder* mBuilder = new MeatOrderBuilder;
    OrderBuilder *mBuilder = new MeatOrderBuilder; //注意抽象构建类必须有虚析构函数，解析时才会                                                      调用子类的析构函数
    Director *director = new Director(mBuilder);
    director->construct();
    Order *order = mBuilder->getOrder();
    order->food();
    order->drink();
    ​delete director;
    director = nullptr;
    ​delete mBuilder;
    mBuilder = nullptr;
    ​return 0;
}

4、原型模式

原型模式：原型模式是通过拷贝一个现有对象生成新对象的。

以下情形可以考虑使用原型模式：

  • 当new一个对象，非常繁琐复杂时，可以使用原型模式来进行复制一个对象。比如创建对象时，构造函数的参数很多，而自己又不完全的知道每个参数的意义，就可以使用原型模式来创建一个新的对象，不必去理会创建的过程。

  • 当需要new一个新的对象，这个对象和现有的对象区别不大，我们就可以直接复制一个已有的对象，然后稍加修改。

  • 当需要一个对象副本时，比如需要提供对象的数据，同时又需要避免外部对数据对象进行修改，那就拷贝一个对象副本供外部使用。

在这里插入图片描述


 /*
 * 关键代码：拷贝，return new className(*this);
 */
 #include <iostream>
 
 /*
 创建一个抽象类 Shape 和扩展了 Shape 类的实体类。下一步是定义类 ShapeCache，该类把 shape 对象存储在一个 Hashtable 中，并在请求的时候返回它们的克隆。
 
 */​
 using namespace std;
 ​
 
 //原型角色：定义用于复制现有实例来生成新实例的方法；
 class Shape
 {
 public:
     virtual Shape* clone()
     {
        return new Shape(*this); //调用Shape(const Shape& obj)函数
     };
     
     
     //关键代码拷贝构造函数
     Shape(const Shape& obj)
     {
         this->id = obj.id;
         this->type = obj.type;
     }
     
     public string getType()
     {
        return type;
     }  
     
     public string getID()
     {
        return id;
     }
     
     public void setID(string sid) 
     {
        id = sid;
     }     
     
     virtual void draw() = 0;
     
 private：
     string id;   
     string type; 
 };
 ​
 //具体原型角色：实现用于复制现有实例来生成新实例的方法
 class Rectangle :public Shape
 {
 public:
     Rectangle():Shape()
      , type("Rectangle")                
     {
     }
     ~Sheep()
     {
     }

    void draw() override
    {
      cout <<"Rectangle"<< endl;
    }
 };
 
  class Circle  :public Shape
 {
 public:
     Circle ():Shape()
      , type("Circle ")                
     {
     }
     ~Sheep()
     {
     }

    void draw() override
    {
      cout <<"Circle "<< endl;
    }
 };
 
  class Square :public Shape
 {
 public:
     Square():Shape()
      , type("Square")                
     {
     }
     ~Sheep()
     {
     }

    void draw() override
    {
      cout <<"Square"<< endl;
    }
 };
//使用者角色：维护一个注册表，并提供一个找出正确实例原型的方法。最后，提供一个获取新实例的方法，用来委托复制实例的方法生成新实例。
#include <hash_map>
class ShaleCache
{
  public:
    ShaleCache(){}
    hash_map<string, Square*> shapmap;
    
    void loadCache()
    {
      shapmap["Square"]= new Square();
      shapmap["Circle"]= new Circle();
      shapmap["Rectangle"]= new Rectangle();
    }
  
  
  Shape* getShape(string shapeId) {
      Shape* cachedShape = shapeMap.at(shapeId);
      return (Shape*) cachedShape.clone();
      
  }
 int main()
 {
     ShaleCache* pShaleCache = new ShaleCache();
     pShaleCache->loadCache();
     
     
     Shape * pSquare = pShaleCache->getShape("Square");
     pSquare->draw();
     

     delete pShaleCache;
     pShaleCache = nullptr;
     delete pSquare;
     pSquare = nullptr;
     return 0;
 }
软件设计模式创建型模式实验代码
01-08
），单例模式（网站计算器是web应用程序的一项基本功能,用于统计使用网站的人数,可反应出网站的受欢迎程序,请设计一个简单的web页面（java，asp.net均可），并为该页面设计一个计算器，用来统计当前访问网址的用户数...
用java中继承和方法重写实现求最大公约数和最小公倍数
孙琨SealSun
10-16 5622
用java中继承和方法重写实现求最大公约数和最小公倍数 编写一个类，该类有一个方法public int f(int a,int b),返回a,b的最大公约数。然后编写一个从该类派生的子类，并重写祖先的 f 方法，且返回a,b 的最小公倍数。要求在子类重写父类方法时，首先
ts讲解(接口interface)
qq_56636514的博客
05-31 1万+
介绍 官网是这样定义的： TypeScript的核心原则之一是对值所具有的结构进行类型检查。 它有时被称做“鸭式辨型法”或“结构性子类型化”。 在TypeScript里，接口的作用就是为这些类型命名和为你的代码或第三方代码定义契约。 我是这样理解的： 给对象里每个属性定义类型（简单又粗暴） 接口初探 下面通过一个简单示例来观察接口是如何工作的： function printLabel(labelledObj: { label: string }) { console.log(labelledObj.la
必备基础01-TypeScript
最新发布
qq_33627452的博客
03-25 984
TypeScript是用于应用程序规模开发的JavaScript。TypeScript是强类型，面向对象的编译语言。它是由微软的Anders Hejlsberg（C＃的设计者）设计的。TypeScript既是一种语言又是一组工具。TypeScript是JavaScript的一个超集。换句话说，TypeScript是JavaScript加上一些额外的功能。TypeScript 扩展了 JavaScript 的语法，所以任何现有的 JavaScript 程序可以不加改变的在 TypeScript 下工作。
定义一个继承层次的例子-Shape类Circle类的定义
bug07250432的专栏
08-16 3529
http://hi.baidu.com/wolfand11/item/03eec320e8a8228a6e2cc3d8 昨天回复了一个Shape类的问题，涉及到了C++中的多态等问题，这里分析一下。 问题的要求是：定义一个Shape基类，然后定义它的派生类 Circle、Rectangle 、 Triangle，要求每个派生类有输出面积的函数，指定在实现中要使用C++的多态。
TypeScript学习笔记(7)-接口
wdk996的博客
01-01 1155
可以使用接口来描述对象、命名和参数化对象的类型，以及将现有的命名对象类型组成新的对象类型。简单说就是 描述变量类型的。// 定义接口//声明 Person类型的变量console.log(wdk.fullName()) // 输出 "w dk"//提示 不能将类型“number”分配给类型“string”。接口在编译时可以验证参数，属性类型 以及返回类型确保可以编译成功，而不用等运行时发现错误。
设计模式之创建型模式
02-26
它又称为静态工厂方法模式，属于类的创建型模式。简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。提供一个类，由它负责根据一定的条件...
创建型设计模式.doc
12-15
原型模式是一种创建型模式，通过复制已有对象来创建新对象，避免了创建新对象的复杂过程。文件中提到克隆图形对象，比如圆形和矩形，这可以通过实现 `Cloneable` 接口并重写 `clone()` 方法来实现。当需要创建多个...
软件设计模式作业 创建型设计模式
05-24
（1）：请使用抽象工厂模式设计系统。 （2）：为系统增加一种新的主题，并实现。 （3）：如果当系统主题发生变化的时候通讯录风格也发生变化，在这种情况之下上面设计的系统将如何变化？ （4）：（2）和（3）的结论...
typescript函数类型接口
aifan2109的博客
07-27 636
1 /* 2 接口的作用：在面向对象的编程中，接口是一种规范的定义，它定义了行为和动作的规范，在程序设计里面，接口起到一种限制和规范的作用。接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部状态数据，也不关心这些类里方法的实现细节，它只规定这批类里必须提供某些方法，提供这些方法的类就可以满足实际需要。 typescrip中的接口类似于java，同时还增加了更灵活的接口类...
TypeScript——TS简介（面试题）、运行环境、变量声明、基础类型、类型断言、初识接口
qq_52301431的博客
09-23 3581
1. TypeScript，简称为TS，是JS的超级；Vue3.0就是使用TS开发出来的，并且推荐开发者使用TS进行开发；2. TS是可以直接运行的（比如使用ts-node），最终编译为纯的JS运行在任意的平台之上，是开源的；3. 始于JavaScript，归于JavaScript！2、TS的特征或理解——面试题。
ts设计模式(工厂模式，单例模式)
qq_52179917的博客
12-06 1813
目录简单工厂工厂方法抽象工厂1. 安装ts: npm install -g typescript2. 安装ts-node:npm install ts-node -g3. 安装插件 code runner 工厂方法 抽象工厂
TypeScript（二）
差不少的博客
07-20 733
类 定义class类 对象中包含两个部分：属性和方法 实例属性： 属性存在实例，只有new了实例，才能看到这些属性 类属性： 通过类访问属性 上图中 如果能访问成功，age就是类属性 在上方代码中应该会报错，因为类指的是Person，而age是实例属性，在Person外部也没有定义过Person.age所以访问不到 怎么定义类属性 类中的属性前添加static关键字 类属性也被称为静态属性 总结： 属性前加readonly 正常情况下实例属性可随意修改值 但属性前添加readonly关键字后，
【TS基础】记录一些不错的综合案例，没事看看复习
庞囧的博客
11-17 282
文章目录断言与类型赋予的区别 断言与类型赋予的区别 interface Shape { color: string; } /** 接口继承 */ interface Square extends Shape { sideLength: number; } let square = <Square>{}; // 断言 let square1 = {} as Square; // 断言 let square2: Square; // 类型赋予 square.color = "blue"
Typescript的Interface的相关使用示例和进阶知识
YunWisdom
07-04 768
接口是Typescript中一种非常强大的特性，它用于定义对象的结构和行为。让我为你解释一下接口的基本概念和用法。接口定义了一个规定，规定了对象应该具有的属性和方法。当一个对象符合接口的规定时，我们称该对象实现了该接口。
学习TypeScript(二)---接口
输入技术、输出想法
01-10 473
学习TypeScript（二）---接口接口接口初探可选属性只读属性readonly vs const函数类型类类型类实现接口一个类可以实现多个接口接口继承接口 接口 TypeScript 的核心原则之一是对值所具有的结构进行类型检查。我们使用接口（Interfaces）来定义对象的类型。接口是对象的状态(属性)和行为(方法)的抽象(描述) 接口初探 需求: 创建人的对象, 需要对人的属性进行一定的约束 id是number类型, 必须有, 只读的 name是string类型, 必须有 age是number类
TS基础操作
m0_74208638的博客
08-31 164
ts简介及基础操作方法
Java基础 接口实现 设计一个形状类(接口)Shape,方法:求周长和求面积
热门推荐
qq_40877709的博客
08-17 2万+
题目： 设计一个形状类(接口)Shape,方法:求周长和求面积形状类(接口)的子类(实现类);:Rect(矩形),Circle(圆形)Rect类的子类:Square(正方形)不同的子类会有不同的计算周长和面积的方法。 创建三个不同的形状对象,放在Shape类型的数组里,分别打印出每个对象的周长和面积。 形状接口 public interface Shape { // 求面积方法 double getArea(); // 求周长方法 double getPerimeter(); } 圆形类 pub
接口作业
weixin_47034879的博客
04-25 502
接口作业： 定义shape接口,包含求面积和求周长的方法； 定义Circle类、Rectangle类、Square类； 要求Circle类和Rectangle类实现shape接口，Square类继承Rectangle类； 运行时，让用户选择输入什么图形，然后输入相应数据，求出该图形的面积和周长。 import java.util.*; //Shape接口 interface Shape{ float getArea(); //求面积 .
软件设计模式：创建型模式解析
软件设计模式-创建型模式概述 在软件设计模式中，创建型模式（Creational Pattern）是一类特殊的设计模式，主要解决对象创建的问题。创建型模式的主要目的是封装对象的创建过程，从而使系统更加灵活、可维护和可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陆不凡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值