分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 

Definition

Specify the kind of objects to create using a prototypical instance, and create new objects by copying this prototype.

Participants

    The classes and/or objects participating in this pattern are:

Prototype (ColorPrototype)

	
Declares an interface for cloning itself
	
	
ConcretePrototype (Color)
	
Implements an operation for cloning itself
	
	
Client (ColorManager)
	
Creates a new object by asking a prototype to clone itself
	
Sample Code in C#

This structural code demonstrates the Prototype pattern in which new objects are created by copying pre-existing objects (prototypes) of the same class.

/*
 * Structural Prototype Design Pattern.
 */

namespace Prototype.Sample
{
    using System;

    /// <summary>
    /// Startup class for Structural Prototype Design Pattern.
    /// </summary>
    internal static class Program
    {
        #region Methods

        /// <summary>
        /// Entry point into console application.
        /// </summary>
        private static void Main()
        {
            // Create two instances and clone each.
            var p1 = new ConcretePrototype1("I");
            var c1 = (ConcretePrototype1) p1.Clone();
            Console.WriteLine("Cloned: {0}", c1.Id);
            var p2 = new ConcretePrototype2("II");
            var c2 = (ConcretePrototype2) p2.Clone();
            Console.WriteLine("Cloned: {0}", c2.Id);
        }

        #endregion
    }

    /// <summary>
    /// The 'Prototype' abstract class.
    /// </summary>
    internal abstract class Prototype
    {
        #region Constructors and Destructors

        /// <summary>
        /// Initializes a new instance of the <see cref="Prototype"/> class.
        /// </summary>
        /// <param name="id">
        /// The id.
        /// </param>
        protected Prototype(string id)
        {
            Id = id;
        }

        #endregion

        #region Public Properties

        /// <summary>
        /// Gets the id.
        /// </summary>
        public string Id { get; }

        #endregion

        #region Public Methods and Operators

        /// <summary>
        /// Clone.
        /// </summary>
        /// <returns>
        /// The <see cref="Prototype"/>.
        /// </returns>
        public abstract Prototype Clone();

        #endregion
    }

    /// <summary>
    /// A 'ConcretePrototype' class.
    /// </summary>
    internal class ConcretePrototype1 : Prototype
    {
        #region Constructors and Destructors

        /// <summary>
        /// Initializes a new instance of the <see cref="ConcretePrototype1"/> class.
        /// </summary>
        /// <param name="id">
        /// The id.
        /// </param>
        public ConcretePrototype1(string id)
            : base(id)
        {
        }

        #endregion

        #region Public Methods and Operators

        /// <summary>
        /// Clone.
        /// Returns a shallow copy.
        /// </summary>
        /// <returns>
        /// The <see cref="Prototype"/>.
        /// </returns>
        public override Prototype Clone()
        {
            return (Prototype) MemberwiseClone();
        }

        #endregion
    }

    /// <summary>
    /// A 'ConcretePrototype' class.
    /// </summary>
    internal class ConcretePrototype2 : Prototype
    {
        #region Constructors and Destructors

        /// <summary>
        /// Initializes a new instance of the <see cref="ConcretePrototype2"/> class.
        /// </summary>
        /// <param name="id">
        /// The id.
        /// </param>
        public ConcretePrototype2(string id)
            : base(id)
        {
        }

        #endregion

        #region Public Methods and Operators

        /// <summary>
        /// Clone.
        /// Returns a shallow copy.
        /// </summary>
        /// <returns>
        /// The <see cref="Prototype"/>.
        /// </returns>
        public override Prototype Clone()
        {
            return (Prototype) MemberwiseClone();
        }

        #endregion
    }
}

// Output:
/*
Cloned: I
Cloned: II

*/

This real-world code demonstrates the Prototype pattern in which new Color objects are created by copying pre-existing, user-defined Colors of the same type.

/*
 * Real-World Prototype Design Pattern.
 */

namespace Prototype.RealWorld
{
    using System;
    using System.Collections.Generic;

    /// <summary>
    /// Startup class for Real-World Prototype Design Pattern.
    /// </summary>
    internal static class Program
    {
        #region Methods

        /// <summary>
        /// Entry point into console application.
        /// </summary>
        private static void Main()
        {
            var colorManager = new ColorManager
            {
                ["red"] = new Color(255, 0, 0),
                ["green"] = new Color(0, 255, 0),
                ["blue"] = new Color(0, 0, 255),
                ["angry"] = new Color(255, 54, 0),
                ["peace"] = new Color(128, 211, 128),
                ["flame"] = new Color(211, 34, 20)
            };

            // User clones selected colors.
            var color1 = colorManager["red"].Clone() as Color;
            var color2 = colorManager["peace"].Clone() as Color;
            var color3 = colorManager["flame"].Clone() as Color;
        }

        #endregion
    }

    /// <summary>
    /// The 'Prototype' abstract class.
    /// </summary>
    internal abstract class Prototype
    {
        #region Public Methods and Operators

        /// <summary>
        /// Clone.
        /// </summary>
        /// <returns>
        /// The <see cref="Prototype"/>.
        /// </returns>
        public abstract Prototype Clone();

        #endregion
    }

    /// <summary>
    /// The 'ConcretePrototype' class.
    /// </summary>
    internal class Color : Prototype
    {
        #region Fields

        /// <summary>
        /// The blue.
        /// </summary>
        private readonly int _blue;

        /// <summary>
        /// The green.
        /// </summary>
        private readonly int _green;

        /// <summary>
        /// The red.
        /// </summary>
        private readonly int _red;

        #endregion

        #region Constructors and Destructors

        /// <summary>
        /// Initializes a new instance of the <see cref="Color"/> class.
        /// </summary>
        /// <param name="red">
        /// The red.
        /// </param>
        /// <param name="green">
        /// The green.
        /// </param>
        /// <param name="blue">
        /// The blue.
        /// </param>
        public Color(int red, int green, int blue)
        {
            _red = red;
            _green = green;
            _blue = blue;
        }

        #endregion

        #region Public Methods and Operators

        /// <summary>
        /// Clone.
        /// </summary>
        /// <returns>
        /// The <see cref="Prototype"/>.
        /// </returns>
        public override Prototype Clone()
        {
            Console.WriteLine("Cloning color RGB: {0,3},{1,3},{2,3}", _red, _green, _blue);
            return MemberwiseClone() as Prototype;
        }

        #endregion
    }

    /// <summary>
    /// Prototype manager.
    /// </summary>
    internal class ColorManager
    {
        #region Fields

        /// <summary>
        /// The colors.
        /// </summary>
        private readonly Dictionary<string, Prototype> _colors = new Dictionary<string, Prototype>();

        #endregion

        #region Public Indexers

        /// <summary>
        /// This.
        /// </summary>
        /// <param name="key">
        /// The key.
        /// </param>
        /// <returns>
        /// The <see cref="Prototype"/>.
        /// </returns>
        public Prototype this[string key]
        {
            get { return _colors[key]; }

            set { _colors.Add(key, value); }
        }

        #endregion
    }
}

// Output:
/*
Cloning color RGB: 255,  0,  0
Cloning color RGB: 128,211,128
Cloning color RGB: 211, 34, 20

*/

 

分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 

Definition

Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.

Participants

The classes and/or objects participating in this pattern are:

AbstractClass (DataObject)

	
Defines abstract primitive operations that concrete subclasses define to implement steps of an algorithm
		
Implements a template method defining the skeleton of an algorithm. The template method calls primitive operations as well as operations defined in AbstractClass or those of other objects
	
	
ConcreteClass (CustomerDataObject)
	
Implements the primitive operations or carry out subclass-specific steps of the algorithm
	
Sample Code in C#

This  structural code demonstrates the Template method which provides a skeleton calling sequence of methods. One or more steps can be deferred to subclasses which implement these steps without changing the overall calling sequence.

/*
 * Structural Template Method Pattern.
 */

using System;

namespace TemplateMethod.Sample
{
    /// <summary>
    /// Startup class for sample Template Method design pattern.
    /// </summary>
    public class Program
    {
        /// <summary>
        /// Entry point into console application.
        /// </summary>
        public static void Main()
        {
            AbstractClass aA = new ConcreteClassA();
            aA.TemplateMethod();

            AbstractClass aB = new ConcreteClassB();
            aB.TemplateMethod();
        }
    }

    /// <summary>
    /// The 'AbstractClass' abstract class.
    /// </summary>
    public abstract class AbstractClass
    {
        /// <summary>
        /// The primitive operation 1.
        /// </summary>
        public abstract void PrimitiveOperation1();

        /// <summary>
        /// The primitive operation 2.
        /// </summary>
        public abstract void PrimitiveOperation2();

        /// <summary>
        /// The template method.
        /// </summary>
        public void TemplateMethod()
        {
            PrimitiveOperation1();
            PrimitiveOperation2();
            Console.WriteLine(string.Empty);
        }
    }

    /// <summary>
    /// A 'ConcreteClass' class.
    /// </summary>
    public class ConcreteClassA : AbstractClass
    {
        /// <summary>
        /// The primitive operation 1.
        /// </summary>
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("ConcreteClassA.PrimitiveOperation1()");
        }

        /// <summary>
        /// The primitive operation 2.
        /// </summary>
        public override void PrimitiveOperation2()
        {
            Console.WriteLine("ConcreteClassA.PrimitiveOperation2()");
        }
    }

    /// <summary>
    /// A 'ConcreteClass' class.
    /// </summary>
    public class ConcreteClassB : AbstractClass
    {
        /// <summary>
        /// The primitive operation 1.
        /// </summary>
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("ConcreteClassB.PrimitiveOperation1()");
        }

        /// <summary>
        /// The primitive operation 2.
        /// </summary>
        public override void PrimitiveOperation2()
        {
            Console.WriteLine("ConcreteClassB.PrimitiveOperation2()");
        }
    }
}

// Output:
/*
ConcreteClassA.PrimitiveOperation1()
ConcreteClassA.PrimitiveOperation2()

ConcreteClassB.PrimitiveOperation1()
ConcreteClassB.PrimitiveOperation2()


*/

This  real-world code demonstrates a Template method named Run() which provides a skeleton calling sequence of methods. Implementation of these steps are deferred to the CustomerDataObject subclass which implements the Connect, Select, Process, and Disconnect methods.

/*
 * Real-World Template Method Pattern.
 */

using System;
using System.Data;
using System.Data.OleDb;

namespace TemplateMethod.RealWorld
{
    /// <summary>
    /// Startup class for Real-World Template Method design pattern.
    /// </summary>
    public class Program
    {
        /// <summary>
        /// Entry point into console application.
        /// </summary>
        public static void Main()
        {
            DataAccessObject daoCategories = new Categories();
            daoCategories.Run();

            DataAccessObject daoProducts = new Products();
            daoProducts.Run();
        }
    }

    /// <summary>
    /// The 'AbstractClass' abstract class.
    /// </summary>
    public abstract class DataAccessObject
    {
        /// <summary>
        /// The connection string.
        /// </summary>
        protected string ConnectionString;

        /// <summary>
        /// The data set.
        /// </summary>
        protected DataSet DataSet;

        /// <summary>
        /// Connect.
        /// </summary>
        public virtual void Connect()
        {
            // Make sure mdb is available to program.
            ConnectionString = "provider=Microsoft.JET.OLEDB.4.0; data source=..\\..\\db1.mdb";
        }

        /// <summary>
        /// Select.
        /// </summary>
        public abstract void Select();

        /// <summary>
        /// Process.
        /// </summary>
        public abstract void Process();

        /// <summary>
        /// Disconnect.
        /// </summary>
        public virtual void Disconnect()
        {
            ConnectionString = string.Empty;
        }

        /// <summary>
        /// The 'Template Method'.
        /// </summary>
        public void Run()
        {
            Connect();
            Select();
            Process();
            Disconnect();
        }
    }

    /// <summary>
    /// A 'ConcreteClass' class.
    /// </summary>
    public class Categories : DataAccessObject
    {
        /// <summary>
        /// Select.
        /// </summary>
        public override void Select()
        {
            const string sql = "select CategoryName from Categories";
            OleDbDataAdapter dataAdapter = new OleDbDataAdapter(sql, ConnectionString);
            DataSet = new DataSet();
            dataAdapter.Fill(DataSet, "Categories");
        }

        /// <summary>
        /// Process.
        /// </summary>
        public override void Process()
        {
            Console.WriteLine("Categories ------ ");
            DataTable dataTable = DataSet.Tables["Categories"];
            foreach (DataRow row in dataTable.Rows)
            {
                Console.WriteLine(row["CategoryName"]);
            }

            Console.WriteLine();
        }
    }

    /// <summary>
    /// A 'ConcreteClass' class.
    /// </summary>
    public class Products : DataAccessObject
    {
        /// <summary>
        /// Select.
        /// </summary>
        public override void Select()
        {
            const string sql = "select ProductName from Products";
            OleDbDataAdapter dataAdapter = new OleDbDataAdapter(sql, ConnectionString);
            DataSet = new DataSet();
            dataAdapter.Fill(DataSet, "Products");
        }

        /// <summary>
        /// Process.
        /// </summary>
        public override void Process()
        {
            Console.WriteLine("Products ------ ");
            DataTable dataTable = DataSet.Tables["Products"];
            foreach (DataRow row in dataTable.Rows)
            {
                Console.WriteLine(row["ProductName"]);
            }

            Console.WriteLine();
        }
    }
}

// Output:
/*

Categories ------
Beverages
Condiments
Confections
Dairy Products
Grains/Cereals
Meat/Poultry
Produce
Seafood

Products ------
Chai
Chang
Aniseed Syrup
Chef Anton's Cajun Seasoning
Chef Anton's Gumbo Mix
Grandma's Boysenberry Spread
Uncle Bob's Organic Dried Pears
Northwoods Cranberry Sauce
Mishi Kobe Niku


*/

 

Ant Design

服务于企业级产品的设计体系，基于确定和自然的设计价值观上的模块化解决方案，让设计者和开发者专注于更好的用户体验。







Ant Design Mobile of React

Ant Design Mobile of Angular



Ant Design of React 

Ant Design of Angular 

Ant Design of Vue 





相关资源

Ant Design Pro

Ant Design Mobile

NG-ZORRO - Ant Design of Angular

NG-ZORRO-MOBILE

Ant Design Vue

Kitchen - Sketch 工具集

Ant Design Landing - 首页模板集

Scaffolds - 脚手架市场

Umi - React 应用开发框架

dva - 数据流前端框架

Ant Motion - 设计动效

设计资源下载

国内镜像站点 ??

社区

 Awesome Ant Design

 Medium

 Twitter

 Ant Design 专栏

 体验科技专栏

SEE Conf - 蚂蚁体验科技大会

加入我们

帮助

GitHub

更新日志

Ant Design 实战教程

常见问题

在线讨论 (中文)

在线讨论 (English)

报告 Bug

讨论列表

StackOverflow

SegmentFault

更多产品

 语雀 - 知识创作与分享工具

云凤蝶 - 移动建站平台

AntV - 数据可视化

Egg - 企业级 Node 开发框架

蚂蚁体验科技

Made with ❤ byAFX



 Not using Hotjar yet?

Select an element on the page.

1.应用场景


			
前端组件库

			
antd 是基于 Ant Design 设计体系的 React/vue/Angular UI 组件库，主要用于研发企业级中后台产品。

			
帮助快速开发前端企业级工程项目.
			
		
2.学习/操作


			
TBD
			
		
3.问题/补充


			
TBD
			
		
4.参考


			
https://ant.design/index-cn //官网

			
https://www.antdv.com/docs/vue/introduce-cn/  //Ant Design of Vue

			
https://ant.design/docs/react/introduce-cn  //Ant Design of React

			
https://ng.ant.design/docs/introduce/zh  //Ant Design of Angular
			
		
后续补充

...