~李疆
~李疆

23种设计模式个人总结之C#版

 

目录

 

1.单例模式

2.抽象工厂模式

3.工厂方法模式

4.建造者模式

5.原型模式

6.适配器模式

7.装饰器模式

8.代理模式

9.外观模式

10.桥接模式

11.组合模式

12.享元模式

13.策略模式

14.模板方法模式

15.观察者模式

16.迭代器模式

17.责任链模式

18.命令模式

19.备忘录模式

20.状态模式

21.访问者模式

22.中介者模式

23.解释器模式

1.单例模式

untiy中单例模式有3种表达方式

第一种：（这种比较简单，但是需要新建一个空物体，并将脚本挂载上去。推荐使用此方式）

public class GameObjectPool : MonoBehaviour
{
    public static GameObjectPool _instance;
    private void Awake()
    {
        _instance = this;
    }
}

23种设计模式个人总结之C#版_第1张图片

第二种：（这种方式不用挂载脚本，不过代码量较大）

public class GameObjectPool : MonoBehaviour
{
    private GameObjectPool() { }
    private static GameObjectPool _instance;
    public static GameObjectPool GetInstance()
    {
        if (_instance == null)
        {
            //动态的生成一个名为“GameObjectPool”的对象并将单例脚本附加上去
            _instance = new GameObject("GameObjectPool").AddComponent();

        }
        return _instance;
    }
}

第三种：（这种方式需要挂载脚本，而且代码量还较大）

public class GameObjectPool : MonoBehaviour
{
    private GameObjectPool() { }
    private static GameObjectPool _instance;
    public static GameObjectPool GetInstance()
    {
        if (_instance == null)
        {
            _instance = new GameObjectPool ();

        }
        return _instance;
    }
}

第四种：（通过先Find再Get,需要将此代码挂载到名为“GameManager”的空物体上）

public class GameObjectPool : MonoBehaviour
{
    private static GameObjectPool _instance;
    public static GameObjectPool Instance
    {
        if (_instance == null)
        {
            _instance =GameObject.Find("GameManager").GetComponent();

        }
        return _instance;
    }
}

2.抽象工厂模式

23种设计模式个人总结之C#版_第2张图片


    class Client
    {
        static void Main(string[] args)
        {
            // 南昌工厂制作南昌的鸭脖和鸭架
            AbstractFactory nanChangFactory = new NanChangFactory();
            YaBo nanChangYabo = nanChangFactory.CreateYaBo();
            nanChangYabo.Print();
            YaJia nanChangYajia= nanChangFactory.CreateYaJia();
            nanChangYajia.Print();

            // 上海工厂制作上海的鸭脖和鸭架
            AbstractFactory shangHaiFactory = new ShangHaiFactory();
            shangHaiFactory.CreateYaBo().Print();
            shangHaiFactory.CreateYaJia().Print();

            Console.Read();
        }
    }

    public abstract class AbstractFactory// 抽象工厂类
    {
        public abstract YaBo CreateYaBo();
        public abstract YaJia CreateYaJia();
    }

    public class NanChangFactory : AbstractFactory// 南昌绝味工厂
    {
        
        public override YaBo CreateYaBo()// 制作南昌鸭脖
        {
            return new NanChangYaBo();
        }
        public override YaJia CreateYaJia()// 制作南昌鸭架
        {
            return new NanChangYaJia();
        }
    }

    public class ShangHaiFactory : AbstractFactory// 上海绝味工厂
    {
        public override YaBo CreateYaBo()
        {
            return new ShangHaiYaBo();
        }
        public override YaJia CreateYaJia()
        {
            return new ShangHaiYaJia();
        }
    }

    public abstract class YaBo
    {
        public abstract void Print();
    }
    public abstract class YaJia
    {
        public abstract void Print();
    }

    public class NanChangYaBo : YaBo
    {
        public override void Print()
        {
            Console.WriteLine("南昌的鸭脖");
        }
    }
    public class ShangHaiYaBo : YaBo
    {
        public override void Print()
        {
            Console.WriteLine("上海的鸭脖");
        }
    }

    public class NanChangYaJia : YaJia
    {
        public override void Print()
        {
            Console.WriteLine("南昌的鸭架子");
        }
    }
    public class ShangHaiYaJia : YaJia
    {
        public override void Print()
        {
            Console.WriteLine("上海的鸭架子");
        }
    }

3.工厂方法模式

23种设计模式个人总结之C#版_第3张图片


     public static void Main(string[] args)
        {

            LiveFactory liveFactory = new MusicFactory();
            Live musicLive = liveFactory.Create();
            musicLive.Action();
            Console.ReadLine();
          }

 public abstract class Live
    {
        public abstract void Action();
    }
    public class Music : Live
    {
        public override void Action()
        {
            Console.WriteLine("哼哼哈嘿，快使用刷结棍！");
        }
    }
    public class Bread : Live
    {
        public override void Action()
        {
            Console.WriteLine("努力，面包会有的，鸡蛋也会有的。");
        }
    }
    public abstract class LiveFactory
    {
        public abstract Live Create();
    }
    public class MusicFactory : LiveFactory
    {
        public override Live Create()
        {
            return new Music();
        }
    }
    public class BreadFactory : LiveFactory
    {
        public override Live Create()
        {
            return new Bread();
        }
    }

=》哼哼哈嘿，快使用双结棍！ 

4.建造者模式

23种设计模式个人总结之C#版_第4张图片


    class Customer
    {
        static void Main(string[] args)
        {
            Director director = new Director();
            Builder b1 = new ConcreteBuilder1();
            Builder b2 = new ConcreteBuilder2();

            director.Construct(b1);// 老板叫员工去组装第一台电脑
   
            Computer computer1 = b1.GetComputer();// 组装完，组装人员搬来组装好的电脑
            computer1.Show();
           
            director.Construct(b2);// 老板叫员工去组装第二台电脑
            Computer computer2 = b2.GetComputer();
            computer2.Show();

            Console.Read();
        }
    }
    public class Director
    { 
        public void Construct(Builder builder)// 组装电脑
        {
            builder.BuildPartCPU();
            builder.BuildPartMainBoard();
        }
    }

    public class Computer// 电脑类
    {
        private IList parts = new List();
        public void Add(string part)
        {
            parts.Add(part);
        }
        public void Show()
        {
            Console.WriteLine("电脑开始在组装.......");
            foreach (string part in parts)
            {
                Console.WriteLine("组件"+part+"已装好");
            }

            Console.WriteLine("电脑组装好了");
        }
    }

    public abstract class Builder// 抽象建造者
    {
        public abstract void BuildPartCPU();// 装CPU
        public abstract void BuildPartMainBoard();// 装主板       
        public abstract Computer GetComputer();// 获得组装好的电脑
    }
    public class ConcreteBuilder1 : Builder
    {
        Computer computer = new Computer();
        public override void BuildPartCPU()
        {
            computer.Add("CPU1");
        }
        public override void BuildPartMainBoard()
        {
            computer.Add("Main board1");
        }
        public override Computer GetComputer()
        {
            return computer;
        }
    }
    public class ConcreteBuilder2 : Builder
    {
        Computer computer = new Computer();
        public override void BuildPartCPU()
        {
            computer.Add("CPU2");
        }
        public override void BuildPartMainBoard()
        {
            computer.Add("Main board2");
        }
        public override Computer GetComputer()
        {
            return computer;
        }
    }

 23种设计模式个人总结之C#版_第5张图片

5.原型模式

23种设计模式个人总结之C#版_第6张图片

class Program
    {
        static void Main(string[] args)
        {
            MonkeyPrototype prototypeMonkey=new ConcretePrototype ("Monkey");
            MonkeyPrototype clone1 = prototypeMonkey.Clone() as ConcretePrototype;
            Console.WriteLine("克隆1：" + clone1.name);
            MonkeyPrototype clone2 = prototypeMonkey.Clone() as ConcretePrototype;
            Console.WriteLine("克隆2：" + clone2.name);
            Console.ReadLine();
        }
    }
    public abstract class MonkeyPrototype //孙悟空原型
    {
        public string name { get; set; }
        public MonkeyPrototype(string Name)
        {
            name = Name;
        }
        public abstract MonkeyPrototype Clone();
    }
    public class ConcretePrototype:MonkeyPrototype
    {
        public ConcretePrototype(string id) : base(id) { }
        public override MonkeyPrototype Clone()//浅拷贝
        {
            return (MonkeyPrototype)MemberwiseClone();//调用MemberwiseClone()的是浅拷贝
        }
    }

6.适配器模式

23种设计模式个人总结之C#版_第7张图片

class Target
    {
        public virtual void Request()
        {
            Console.WriteLine("普通请求");
        }
    }
    class Adapter:Target
    {
         Adaptee adaptee = new Adaptee();
        public override void Request()
        {
            adaptee.SpecificRequest();
        }
    }
    class Adaptee
    {
        public void SpecificRequest()
        {
            Console.WriteLine("我是需要适配的类");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Target target = new Adapter();
            target.Request();
            Console.Read();
        }
    }

 =》我是需要适配的类

7.装饰器模式

23种设计模式个人总结之C#版_第8张图片

23种设计模式个人总结之C#版_第9张图片

    class Program
    {
        static void Main(string[] args)
        {
            Phone ap = new ApplePhone(); //新买了个苹果手机
            Decorator aps = new Sticker(ap); //准备贴膜组件
            aps.Print();
 
            Decorator apa = new Accessories(ap); //过了几天新增了挂件组件
            apa.Print();
 
            Sticker s = new Sticker(ap);       //准备贴膜组件
            Accessories a = new Accessories(s);//同时准备挂件
            a.Print(); 
        }
    }
    public abstract class Phone
    {
        public abstract void Print();
    }
    public class ApplePhone:Phone
    {
        public override void Print()
        {
            Console.WriteLine("我有一部苹果手机");
        }
    }
    public abstract class Decorator:Phone
    {
        private Phone p ;    //该装饰对象装饰到的Phone组件实体对象 
        public Decorator(Phone p)
        {
            this.p = p;
        }
        public override void Print()
        {
            if (this.p != null)
            {
                p.Print();
            }
        }
    }
    public class Sticker:Decorator// 贴膜
    {
        public Sticker(Phone p) : base(p) { }
        public override void Print()
        {
            base.Print();
            AddSticker();
        }
        public void AddSticker()
        {
            Console.WriteLine("现在苹果手机有贴膜了");
        }
    }
    public class Accessories:Decorator// 手机挂件，即具体装饰者
    {
        public Accessories(Phone p) : base(p) { }
        public override void Print()
        {
            base.Print();
            AddAccessories();
        }
        public void AddAccessories()
        {
            Console.WriteLine("现在苹果手机有漂亮的挂件了");
        }
    }

 23种设计模式个人总结之C#版_第10张图片

8.代理模式

23种设计模式个人总结之C#版_第11张图片


    class Client
    {
        static void Main(string[] args)
        {
            Person proxy = new Friend();
            proxy.BuyProduct();
            Console.Read();
        }
    }
    public abstract class Person
    {
        public abstract void BuyProduct();
    }
    public class RealBuyPerson : Person
    {
        public override void BuyProduct()
        {
            Console.WriteLine("帮我买一个IPhone和一台苹果电脑");
        }
    }
    public class Friend:Person
    {
        RealBuyPerson realSubject;
        public override void BuyProduct()
        {
            Console.WriteLine("通过代理类访问真实实体对象的方法");
            if (realSubject == null)
            {
                realSubject = new RealBuyPerson();
            }
            PreBuyProduct();
            realSubject.BuyProduct();
            this.PostBuyProduct();
        }
        public void PreBuyProduct()
        {
            // 可能不知一个朋友叫这位朋友带东西，首先这位出国的朋友要对每一位朋友要带的东西列一个清单等
            Console.WriteLine("我怕弄糊涂了，需要列一张清单，张三：要带相机，李四：要带Iphone...........");
        }
        public void PostBuyProduct()
        {
            Console.WriteLine("终于买完了，现在要对东西分一下，相机是张三的；Iphone是李四的..........");
        }
    }

 

9.外观模式

23种设计模式个人总结之C#版_第12张图片23种设计模式个人总结之C#版_第13张图片

    class Client
    {
        static void Main(string[] args)
        {
            Facade facade = new Facade();
            facade.MethodA();
            facade.MethodB();
            Console.Read();
        }
    }
    class SubSystemOne
    {
        public void MethodOne()
        {
            Console.WriteLine("子系统方法一");
        }
    }
    class SubSystemTwo
    {
        public void MethodTwo()
        {
            Console.WriteLine("子系统方法二");
        }
    }
    class SubSystemThree
    {
        public void MethodThree()
        {
            Console.WriteLine("子系统方法三");
        }
    }
    class SubSystemFour
    {
        public void MethodFour()
        {
            Console.WriteLine("子系统犯法四");
        }
    }
    class Facade
    {
        SubSystemOne one;
        SubSystemTwo two;
        SubSystemThree three;
        SubSystemFour four;
        public Facade()
        {
            one = new SubSystemOne();
            two = new SubSystemTwo();
            three = new SubSystemThree();
            four = new SubSystemFour();
        }
        public void MethodA()
        {
            Console.WriteLine("\n方法组合A()---");
            one.MethodOne();
            two.MethodTwo();
            four.MethodFour();
        }
        public void MethodB()
        {
            Console.WriteLine("\n方法组B()---");
            two.MethodTwo();
            three.MethodThree();
        }
    }

 23种设计模式个人总结之C#版_第14张图片

10.桥接模式

23种设计模式个人总结之C#版_第15张图片

    class Client
    {
        static void Main(string[] args)
        {
            ISoftware wechat = new WeChat();
            ISoftware qq = new QQ();

            Console.WriteLine("ios系统运行软件：");
            System ios = new IOS();
            ios.Run(wechat);
            ios.Run(qq);

            Console.WriteLine("");

            Console.WriteLine("Android系统运行软件：");
            System android = new Android();
            ios.Run(wechat);
            ios.Run(qq);

            Console.Read();
        }
    }
    public interface ISoftware
    {
        void Running();
    }
    public class WeChat:ISoftware
    {
        public void Running()
        {
            Console.WriteLine("微信已经运行");
        }
    }
    public class QQ : ISoftware
    {
        public void Running()
        {
            Console.WriteLine("QQ已经运行");
        }
    }
    public abstract class System
    {
        public abstract void Run(ISoftware software);
    }
    public class IOS:System 
    {
        public override void Run(ISoftware software)
        {
            Console.WriteLine("欢迎来到IOS系统");
            software.Running();
        }
    }
    public class Android: System 
    {
        public override void Run(ISoftware software)
        {
            Console.WriteLine("欢迎来到Android系统");
            software.Running();
        }
    }

 23种设计模式个人总结之C#版_第16张图片

11.组合模式

23种设计模式个人总结之C#版_第17张图片

    //抽象构件，它是叶子和容器共同的父类，并且声明了叶子和容器的所有方法
    abstract class AbstractFile
    {
        public abstract void Add(AbstractFile file);//新增文件
        public abstract void Delete(AbstractFile file);//删除文件
        public abstract AbstractFile GetChildFile(int i);//获取子构件（可以使文件，也可以是文件夹）
        public abstract void KillVirue();//对文件进行杀毒
    }
    class Folder:AbstractFile//文件夹
    {
        private List fileList = new List();
        private string name;
        public Folder(string name)
        {
            this.name = name;
        }
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public override void Add(AbstractFile file)
        {
            fileList.Add(file);
        }
 
        public override void Delete(AbstractFile file)
        {
            fileList.Remove(file);
        }
 
        public override AbstractFile GetChildFile(int i)
        {
            return fileList[i] as AbstractFile;
        }
 
        public override void KillVirue()
        {
            Console.WriteLine("对文件夹{0}进行杀毒",name);
            foreach (AbstractFile obj in fileList)
            {
                obj.KillVirue();
            }
        }
    }
class ImageFile:AbstractFile//图片文件
    {
        private string name;
 
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public ImageFile(string name)
        {
            this.name = name;
        }
        public override void Add(AbstractFile file)
        {
            Console.WriteLine("对不起，不支持该方法");
        }
        public override void Delete(AbstractFile file)
        {
            Console.WriteLine("对不起，不支持该方法");
        }
        public override AbstractFile GetChildFile(int i)
        {
            Console.WriteLine("对不起，不支持该方法");
            return null;
        }
        public override void KillVirue()
        {
            //模拟杀毒
            Console.WriteLine("已经对{0}进行了杀毒", name);
        }
    }
class TextFile:AbstractFile//文本文件
    {
        private string name;
 
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public TextFile(string name)
        {
            this.name = name;
        }
        public override void Add(AbstractFile file)
        {
            Console.WriteLine("对不起，不支持该方法");
        }
        public override void Delete(AbstractFile file)
        {
            Console.WriteLine("对不起，不支持该方法");
        }
        public override AbstractFile GetChildFile(int i)
        {
            Console.WriteLine("对不起，不支持该方法");
            return null;
        }
        public override void KillVirue()
        {
            //模拟杀毒
            Console.WriteLine("已经对{0}进行了杀毒", name);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            AbstractFile file1, file2, folder1,file3, folder2, folder3;
            folder1 = new Folder("我的视频");
            folder2 = new Folder("我的图片");
            folder3 = new Folder("我的资料");
 
            file1 = new TextFile("文本1");
 
            file2 = new ImageFile("图像2");
            file3 = new TextFile("文本2");
            folder1.Add(file1);
            folder2.Add(file2);
            folder2.Add(file3);
            folder2.KillVirue();
            Console.ReadLine();
        }
    }

 

12.享元模式

       我们可以共用一个 Hello world 对象，其中字符串 “Hello world” 为内部状态，可共享；字体颜色为外部状态，不可共享，由客户端设定。

23种设计模式个人总结之C#版_第18张图片

    class Program
    {
        static void Main(string[] args)
        {
            School school = new School();
            Student student = school.GetStudent(1);
            Console.WriteLine(student.ToString());
            student = school.GetStudent(2);
            Console.WriteLine(student.ToString());
            Console.ReadKey();
        }
    }
    public abstract class abStudent
    {
        public string Name;
        public string schName;
        public string Sex;
        public abStudent()
        {
            schName = "西南科技大学";
            Sex = "男";
        }

        public override string ToString()
        {
            return string.Format("我叫{0},性别{1},在读学校{2}", Name, Sex, schName);
        }
    }
    public class Student : abStudent
    {
        public Student(string name)
        {
            Name = name;
        }
    }
    public class School
    {
        private Dictionary StudentList;
        public School()
        {
            StudentList = new Dictionary();
            StudentList.Add(1, new Student("张三"));
            StudentList.Add(2, new Student("李四"));
        }
        public Student GetStudent(int num)
        {
            return StudentList[num] as Student;
        }
    }

 

13.策略模式

class Program
    {
        static void Main(string[] args)
        {
            Context PShow = new Context(new PersonStragety());
            Console.WriteLine("单人票单价为：{0}", PShow.GetTax(100.00));
            Context GShow = new Context(new Group());
            Console.WriteLine("团体票单价为：{0}", GShow.GetTax(100.00));

            Console.Read();
        }
    }
    public interface Stragety
    {
        double CalculateTax(double income);
    }   
    public class PersonStragety:Stragety//单人票
    {
        public double CalculateTax(double income)
        {
            return income;
        }
    }
    public class Group:Stragety//团体票
    {
        public double CalculateTax(double income)
        {
            return income*0.9f;
        }
    }
    public class Context
    {
        private Stragety m_stragety;
        public Context (Stragety stragety)
        {
            m_stragety = stragety;
        }
        public double GetTax(double income)
        {
            return m_stragety.CalculateTax(income);
        }
    }

 

14.模板方法模式

23种设计模式个人总结之C#版_第19张图片

 class Client
    {
        static void Main(string[] args)
        {
            Spinach spinach = new Spinach();
            spinach.CookVegetabel();
            Console.Read();
        }
    }
    public abstract class Vegetabel
    {
        // 模板方法，不要把模版方法定义为Virtual或abstract方法，避免被子类重写，防止更改流程的执行顺序
        public void CookVegetabel()
        {
            Console.WriteLine("抄蔬菜的一般做法");
            pourOil();
            HeatOil();
            pourVegetable();
            stir_fry();
        }
        public void pourOil()
        {
            Console.WriteLine("倒油");
        }
        public void HeatOil()
        {
            Console.WriteLine("把油烧热");
        }
        public abstract void pourVegetable();// 油热了之后倒蔬菜下去，具体哪种蔬菜由子类决定
        public void stir_fry()
        {
            Console.WriteLine("翻炒");
        }
    }
    public class Spinach : Vegetabel// 菠菜
    {

        public override void pourVegetable()
        {
            Console.WriteLine("倒菠菜进锅中");
        }
    }
    public class ChineseCabbage : Vegetabel// 大白菜
    {
        public override void pourVegetable()
        {
            Console.WriteLine("倒大白菜进锅中");
        }
    }

 23种设计模式个人总结之C#版_第20张图片

15.观察者模式

23种设计模式个人总结之C#版_第21张图片

public abstract class Blog// 订阅号抽象类
    {
        private List observers = new List();
        public string Symbol { get; set; }//描写订阅号的相关信息
        public string Info { get; set; }//描写此次update的信息
        public Blog(string symbol, string info)
        {
            Symbol = symbol;
            Info = info;
        }
        // 对同一个订阅号，新增和删除订阅者的操作
        public void AddObserver(IObserver ob)
        {
            observers.Add(ob);
        }
        public void RemoveObserver(IObserver ob)
        {
            observers.Remove(ob);
        }
        public void Update()
        {
            foreach (IObserver ob in observers)// 遍历订阅者列表进行通知
            {
                if (ob != null)
                {
                    ob.Receive(this);
                }
            }
        }
    }
    public class MyBlog : Blog// 具体订阅号类
    {
        public MyBlog(string symbol, string info)
            : base(symbol, info) { }
    }
    public interface IObserver// 订阅者接口
    {
        void Receive(Blog tenxun);
    }
    public class Subscriber : IObserver// 具体的订阅者类
    {
        public string Name { get; set; }
        public Subscriber(string name)
        {
            Name = name;
        }
        public void Receive(Blog xmfdsh)
        {
            Console.WriteLine("订阅者 {0} 观察到了{1}{2}", Name, xmfdsh.Symbol, xmfdsh.Info);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Blog xmfdsh = new MyBlog("xmfdsh", "发布了一篇新博客");

            xmfdsh.AddObserver(new Subscriber("张三"));
            xmfdsh.AddObserver(new Subscriber("李四"));
            xmfdsh.AddObserver(new Subscriber("王五"));
            xmfdsh.AddObserver(new Subscriber("赵六"));
 
            xmfdsh.Update();//更新信息
            Console.ReadLine();//输出结果，此时所有的订阅者都已经得到博客的新消息
        }
    }

 

16.迭代器模式

23种设计模式个人总结之C#版_第22张图片

    class Program
    {
        static void Main(string[] args)
        {
            ConcreteAggregate monkey = new ConcreteAggregate();
            monkey[0] = "猴子";
            monkey[1] = "刘木同";
            monkey[2] = "笨蛋";
            monkey[3] = "小弟";
            monkey[4] = "领导";
            monkey[5] = "内部人员";
            monkey[6] = "小偷";

            Iterator i = new ConcreteIterator(monkey);
            object item = i.First();//从第一个乘客开始
            while (!i.IsDone())
            {
                Console.WriteLine("{0}请买火车票", i.CurrentItem());//若没买票，请补票
                i.Next();//遍历下一个
            }
            Console.Read();
        }
    }
    abstract class Iterator
    {
        public abstract object First();//1开始对象
        public abstract object Next();//2得到下一个对象
        public abstract bool IsDone();//3判断是否到结尾
        public abstract object CurrentItem();//4当前对象
    }
    abstract class Aggregate//聚集抽象类
    {
        public abstract Iterator CreateIterator();//创建迭代器
    }
    class ConcreteIterator : Iterator//具体迭代器类
    {
        private ConcreteAggregate aggregate;//定义一个具体聚集对象
        private int current = 0;
        public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;//初始化时将具体的聚集对象传入
        }
        public override object First()//得到聚集的第一个对象
        {
            return aggregate[0];
        }
        public override object Next()//得到聚集的下一个对象
        {
            object ret = null;
            current++;
            if (current < aggregate.Count)
            {
                ret = aggregate[current];
            }
            return ret;
        }
        public override bool IsDone()//判断当前是否遍历到结尾，到结尾返回true
        {
            return current >= aggregate.Count ? true : false;
        }
        public override object CurrentItem()
        {
            return aggregate[current];//返回当前的聚集对象
        }
    }  
    class ConcreteAggregate : Aggregate//具体聚集类
    {
        private IList items = new List();
        public override Iterator CreateIterator()
        {
            return new ConcreteIterator(this);
        }
        public int Count
        {
            get { return items.Count; }
        }
        public object this[int index]
        {
            get { return items[index]; }
            set { items.Insert(index, value); }
        }
    }

 23种设计模式个人总结之C#版_第23张图片


17.责任链模式


23种设计模式个人总结之C#版_第24张图片


    public class PurchaseRequest// 采购请求
    {
        
        public double Amount { get; set; }// 金额
        public string ProductName { get; set; }
        public PurchaseRequest(double amount, string productName)
        {
            Amount = amount;
            ProductName = productName;
        }
    }
    public abstract class Approver// 审批人,Handler
    {
        public Approver NextApprover { get; set; }
        public string Name { get; set; }
        public Approver(string name)
        {
            Name = name;
        }
        public abstract void ProcessRequest(PurchaseRequest request);
    }
    public class Manager : Approver
    {
        public Manager(string name): base(name) { }
        public override void ProcessRequest(PurchaseRequest request)
        {
            if (request.Amount < 10000.0)
            {
                Console.WriteLine("{0}-{1}  想买  {2}", this, Name, request.ProductName);
            }
            else if (NextApprover != null)
            {
                NextApprover.ProcessRequest(request);
            }
        }
    }
    public class VicePresident : Approver// ConcreteHandler,副总
    {
        public VicePresident(string name): base(name) { }
        public override void ProcessRequest(PurchaseRequest request)
        {
            if (request.Amount < 25000.0)
            {
                Console.WriteLine("{0}-{1}  想买  {2}", this, Name, request.ProductName);
            }
            else if (NextApprover != null)
            {
                NextApprover.ProcessRequest(request);
            }
        }
    }
    public class President : Approver// ConcreteHandler，总经理
    {
        public President(string name): base(name) { }
        public override void ProcessRequest(PurchaseRequest request)
        {
            if (request.Amount < 100000.0)
            {
                Console.WriteLine("{0}-{1}  想买  {2}", this, Name, request.ProductName);
            }
            else
            {
                Console.WriteLine("Request需要组织一个会议讨论");
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            PurchaseRequest requestTelphone = new PurchaseRequest(4000.0, "手机");
            PurchaseRequest requestSoftware = new PurchaseRequest(10000.0, "软件");
            PurchaseRequest requestComputers = new PurchaseRequest(40000.0, "电脑");

            Approver manager = new Manager("张三");
            Approver Vp = new VicePresident("李四");
            Approver Pre = new President("王五");
        
            manager.NextApprover = Vp;// 设置责任链
            Vp.NextApprover = Pre;

            manager.ProcessRequest(requestTelphone); // 处理请求
            manager.ProcessRequest(requestSoftware);
            manager.ProcessRequest(requestComputers);
            Console.ReadLine();
        }
    }


 


18.命令模式


23种设计模式个人总结之C#版_第25张图片


 class Program
    {
        static void Main(string[] args)
        {
            OrderReceiver o = new OrderReceiver(); //命令的响应者      >响应传达者传达的命令
            Command ecmd = new examcmd(o);       //命令的传达和监视者>传达发出这的命令给响应者
            Invoke ka = new Invoke(ecmd);        //命令的发出者      
            ka.Init();                           //>传达给传递者扩散命令

            Console.WriteLine("考试结束后");
            Command pcmd = new papercmd(o); //命令的传达和监视者
            Invoke kb = new Invoke(pcmd);   //命令的发出者
            kb.Init();

            Console.ReadLine();
        }
    }
    public class OrderReceiver// 命令最后的执行者
    {
        public void GetExam()
        {
            Console.WriteLine("进行期中考试！");
        }
        public void GetPaper()
        {
            Console.WriteLine("交卷！");
        }
    }
    public abstract class Command// 传递命令者的抽象类
    {
        protected OrderReceiver recediver;// 命令执行者
        public Command(OrderReceiver recediver)
        {
            this.recediver = recediver;
        }
        public abstract void Action();// 执行命令的方法
    }
    public class examcmd : Command// 执行考试命令传递者
    {
        public examcmd(OrderReceiver recetive) : base(recetive) { }
        public override void Action()
        {
            recediver.GetExam();
        }
    }
    public class papercmd : Command// 执行交卷命令传递者
    {
        public papercmd(OrderReceiver request) : base(request) { }
        public override void Action()// 执行命令
        {
            
            recediver.GetPaper();//开始考试
        }
    }
    public class Invoke// 命令的发出者
    {
        protected Command cmd;
        public Invoke(Command cmd)
        {
            this.cmd = cmd;
        }
        public void Init()
        {
            cmd.Action();
        }
    }


 


19.备忘录模式


23种设计模式个人总结之C#版_第26张图片


class Program
{
    static void Main(string[] args)
    {
        var persons = new List
        {
                new ContactPerson { Name= "Learning Hard", MobileNum = "123445"},
                new ContactPerson { Name = "Tony", MobileNum = "234565"},
                new ContactPerson { Name = "Jock", MobileNum = "231455"}
            };
        var mobileOwner = new MobileOwner(persons);
        mobileOwner.Show();

        // 创建备忘录并保存备忘录对象
        var caretaker = new Caretaker { ContactM = mobileOwner.CreateMemento() };

        Console.WriteLine("----移除最后一个联系人--------");// 更改发起人联系人列表
        mobileOwner.ContactPersons.RemoveAt(2);
        mobileOwner.Show();

        Console.WriteLine("-------恢复联系人列表------");// 恢复到原始状态
        mobileOwner.RestoreMemento(caretaker.ContactM);
        mobileOwner.Show();

        Console.Read();
    }
}
public class ContactPerson
{
    public string Name { get; set; }
    public string MobileNum { get; set; }
}
public class MobileOwner// 发起人
{
    public List ContactPersons { get; set; }// 发起人需要保存的内部状态
    public MobileOwner(List persons)
    {
        ContactPersons = persons;
    }
    public ContactMemento CreateMemento()// 创建备忘录，将当期要保存的联系人列表导入到备忘录中
    {
        // 这里也应该传递深拷贝，new List方式传递的是浅拷贝，
        // 因为ContactPerson类中都是string类型,所以这里new list方式对ContactPerson对象执行了深拷贝
        // 如果ContactPerson包括非string的引用类型就会有问题，所以这里也应该用序列化传递深拷贝
        return new ContactMemento(new List(this.ContactPersons));
    }
    public void RestoreMemento(ContactMemento memento)// 将备忘录中的数据备份导入到联系人列表中
    {
       //应该传递contactPersonBack的深拷贝，深拷贝可以使用序列化来完成
        ContactPersons = memento.ContactPersonBack;
    }
    public void Show()
    {
        Console.WriteLine("联系人列表中有{0}个人，他们是:", ContactPersons.Count);
        foreach (ContactPerson p in ContactPersons)
        {
            Console.WriteLine("姓名: {0} 号码为: {1}", p.Name, p.MobileNum);
        }
    }
}
public class ContactMemento// 备忘录
{
    public List ContactPersonBack; // 保存发起人的内部状态
    public ContactMemento(List persons)
    {
        ContactPersonBack = persons;
    }
}
public class Caretaker// 管理角色
{
    public ContactMemento ContactM { get; set; }
}


 23种设计模式个人总结之C#版_第27张图片


20.状态模式


        核心思想就是：当对象的状态改变时，同时改变其行为，很好理解！就拿QQ来说，有几种状态，在线、隐身、忙碌等，每个状态对应不同的操作，而且你的好友也能看到你的状态，所以，状态模式就两点：1、可以通过改变状态来获得不同的行为。2、你的好友能同时看到你的变化。


 class Program
    {
        static void Main(string[] args)
        {
            State s = new State();
            s.Say();
            s.Say();
            s.Say();
            Console.Read();
        }
       
    }
    public interface People
    {
        void Say(State s);
    }
    public class Chinese : People
    {
        public void Say(State s)
        {
            Console.Write("现在是中文...");
            s.people = new English();
            Console.WriteLine("现在切换到了英文");
        }
    }
    public class English : People
    {
        public void Say(State s)
        {
            Console.Write("现在是英文...");
            s.people = new Chinese();
            Console.WriteLine("现在切换到了中文");
        }
    }
    public class State
    {
        public People people { get; set; }
        public State()
        {
            people = new Chinese();
            Console.WriteLine("现在默认状态是中文");
        }
        public void Say()
        {
            people.Say(this);
        }
    }


 


21.访问者模式


23种设计模式个人总结之C#版_第28张图片


    public abstract class Element
    {
        public abstract void Accept(IVistor vistor);
        public abstract void Print();
    }

    public class ElementA : Element
    {
        public override void Accept(IVistor vistor)
        {
            vistor.Visit(this);
        }
        public override void Print()
        {
            Console.WriteLine("我是元素A");
        }
    }
    public class ElementB : Element
    {
        public override void Accept(IVistor vistor)
        {
            vistor.Visit(this);
        }
        public override void Print()
        {
            Console.WriteLine("我是元素B");
        }
    }
    public interface IVistor// 抽象访问者
    {
        void Visit(ElementA a);
        void Visit(ElementB b);
    }
    public class ConcreteVistor : IVistor// 具体访问者
    {
        public void Visit(ElementA a)
        {
            a.Print();
        }
        public void Visit(ElementB b)
        {
            b.Print();
        }
    }
    public class ObjectStructure// 对象结构
    {
        private ArrayList elements = new ArrayList();
        public ArrayList Elements
        {
            get { return elements; }
        }
        public ObjectStructure()
        {
            Random ran = new Random();
            for (int i = 0; i < 6; i++)
            {
                int ranNum = ran.Next(10);
                if (ranNum > 5)
                {
                    elements.Add(new ElementA());
                }
                else
                {
                    elements.Add(new ElementB());
                }
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            ObjectStructure objectStructure = new ObjectStructure();
            foreach (Element e in objectStructure.Elements)
            {
                e.Accept(new ConcreteVistor());// 每个元素接受访问者访问
            }
            Console.Read();
        }
    }


 


 


22.中介者模式


    public abstract class AbstractCardPartner// 抽象牌友类
    {
        public int MoneyCount { get; set; }
        protected AbstractCardPartner()
        {
            MoneyCount = 0;
        }
        public abstract void ChangeCount(int count, AbstractMediator mediator);
    }
    public class ParterA : AbstractCardPartner// 牌友A类
    {
        public override void ChangeCount(int count, AbstractMediator mediator)// 依赖与抽象中介者对象
        {
            mediator.AWin(count);
        }
    }
    
    public class ParterB : AbstractCardPartner// 牌友B类
    {
        public override void ChangeCount(int count, AbstractMediator mediator)// 依赖与抽象中介者对象
        {
            mediator.BWin(count);
        }
    }
    public abstract class AbstractMediator// 抽象中介者类
    {
        protected AbstractCardPartner A;
        protected AbstractCardPartner B;
        protected AbstractMediator(AbstractCardPartner a, AbstractCardPartner b)
        {
            A = a;
            B = b;
        }
        public abstract void AWin(int count);
        public abstract void BWin(int count);
    }
    public class MediatorPater : AbstractMediator// 具体中介者类
    {
        public MediatorPater(AbstractCardPartner a, AbstractCardPartner b): base(a, b) { }
        public override void AWin(int count)
        {
            A.MoneyCount += count;
            B.MoneyCount -= count;
        }
        public override void BWin(int count)
        {
            B.MoneyCount += count;
            A.MoneyCount -= count;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            AbstractCardPartner A = new ParterA();
            AbstractCardPartner B = new ParterB(); 
            
            A.MoneyCount = 20;// 初始钱
            B.MoneyCount = 20;

            AbstractMediator mediator = new MediatorPater(A, B);
  
            A.ChangeCount(5, mediator);// A赢了
            Console.WriteLine("A 现在的钱是：{0}", A.MoneyCount);// 应该是25
            Console.WriteLine("B 现在的钱是：{0}", B.MoneyCount); // 应该是15

            B.ChangeCount(10, mediator);// B 赢了
            Console.WriteLine("A 现在的钱是：{0}", A.MoneyCount);// 应该是15
            Console.WriteLine("B 现在的钱是：{0}", B.MoneyCount); // 应该是25
            Console.Read();
        }
    }




23.解释器模式


23种设计模式个人总结之C#版_第29张图片


    class Program
    {
        static void Main(string[] args)
        {
            BooleanExp booleanExp1 = new BooleanExp("true");
            BooleanExp booleanExp2 = new BooleanExp("false");

            OrExp orExp = new OrExp(booleanExp1, booleanExp2);//或表达式
            Console.WriteLine(orExp.Interpret());

            AndExp andExp = new AndExp(booleanExp1, booleanExp2);//与表达式
            Console.WriteLine(andExp.Interpret());

            Console.Read();
        }
    }
    abstract class ExpressionClass
    {
        public abstract bool Interpret();
    }
    class BooleanExp : ExpressionClass//布尔表达式
    {
        string Context;
        public BooleanExp(string context)
        {
            Context = context;
        }
        public override bool Interpret()
        {
            return Context.ToLower() == "true";
        }
    }
    class OrExp : ExpressionClass//或表达式
    {
        BooleanExp Exp1;
        BooleanExp Exp2;

        public OrExp(BooleanExp exp1, BooleanExp exp2)
        {
            Exp1 = exp1;
            Exp2 = exp2;
        }
        public override bool Interpret()
        {
            return Exp1.Interpret() || Exp2.Interpret();
        }
    }
    class AndExp : ExpressionClass// 与表达式
    {
        BooleanExp Exp1;
        BooleanExp Exp2;
        public AndExp(BooleanExp exp1, BooleanExp exp2)
        {
            Exp1 = exp1;
            Exp2 = exp2;
        }
        public override bool Interpret()
        {
            return Exp1.Interpret() && Exp2.Interpret();
        }
    }




 

























你可能感兴趣的:(23种设计模式个人总结之C#版)






    

  • 《昼颜》里的日本女人：相遇要万种风情，分手要残忍绝情
迷影咖啡

    作者：迷之菌子神奇菇迷影咖啡：一本正经做烘焙，胡说八道聊电影漫天萤火虫消散之时良宵就将过去，人们也说含苞待放的花蕾总会开了又谢，因紧紧相拥而面红耳赤的躯体，便是我们经历过这热爱的证明。夫妻关系介绍《昼颜》是2014年电视剧《昼颜：工作日下午三点的恋人们》的续集，故事发在电视剧情节结束的三年后，讲述了已经恢复独身的纱和偶然与曾经的出轨对象北野重逢后再次陷入感情漩涡的故事。《昼颜》制作灵感源自利佳子在
    

    • 

  • 迎接2019
唯有杜康1994

    告别2018这一年是机遇与挑战，痛苦与喜悦，失去与收获的一年一月:收获了第一份爱情，开始真正想去了解一个人三月:对工作有了更深入的认识，靠自己的力量完成晋升五月:搬家，住进了自己理想的公寓，一间属于自己的屋子。满地的书六月:外调广州，升经理，有了自己的第一个团队。七月:怀着自我否定，第一次完成了部门任务八月:第一个员工流失，痛哭不已明白无不散之筵席九月:员工陆续离开，经济是一切的根本。十月:陪员工
    

    • 

  • 亲子日记之祝姑姥姥生日快乐（282）
冰心雨露_d504

    2021年7月18日，周日，晴周日上班的不上班，上学的不上学，全家都属于休息状态，洗衣做饭是上午的主要任务，中午休息一会儿，下午比较晚了出去给梦怡买了二年级上册的口算题卡，然后去参加姑姑的生日聚餐，本来姑姑应该是周一生日，因为周一都要上班，就提前到周日过了，说是过生日其实就是想借此机会一家人聚聚，毕竟平常都忙，没有时间聚在一起，梦怡还给姑姥姥做了生日贺卡，虽然长相一般，重在心意。生日快乐
    

    • 

  • android 自定义曲线图,Android自定义View——贝赛尔曲线
weixin_39767513
android自定义曲线图

    个人博客：haichenyi.com。感谢关注本文针对有一定自定义View的童鞋，最好对贝赛尔曲线有辣么一丢丢了解，不了解也没关系。花5分钟看一下GcsSloop的安卓自定义View进阶-Path之贝塞尔曲线。本文的最终效果图：最终效果图.gif思路首先他是一个只有上半部分的正弦形状的水波纹，很规则。其次，他这个正弦图左右在移动。然后，就是它这个自定义View，上下也在移动，是慢慢增加的最后，优化
    

    • 

  • 信任
饮冰伊乔

    随着社会的发展，微信和支付宝交易给人们带来了极大的方便，越来越多的人出门都只选择拿一部手机即可，方便安全，可昨天我就遇到了一件比较尴尬的事。昨天傍晚，我从公司出来，感觉有点饿，决定索性吃了饭再回去，来到去过几次的一个店里，如往常一样叫了餐，当时店里吃饭的不多，老板麻利的先去做了，正要扫微信付账的时候发现手机没电了，迷之尴尬，我只好跟老板说不用做了，手机没电了，我身上又没现金，付不了帐了。老板娘很热
    

    • 

  • Django之Debug篇
菜鸟之编程
Djangodjangopython后端

    一、DebugToolBar基本使用1.1、概述Django框架的调试工具栏使用django-debug-toolbar库，是一组可配置的面板，显示有关当前请求/响应的各种调试信息，点击时，显示有关面板内容的更多详细信息。官方文档：DjangoDebugToolbar—DjangoDebugToolbar4.3.0documentation1.2、安装pipinstalldjango-debug-
    

    • 

  • C#中的PLINQ和LINQ的效率对比
搬砖的诗人Z
C#c#linq开发语言

    PLINQ（ParallelLINQ）和LINQ（LanguageIntegratedQuery）都是.NET框架中的功能，用于对集合进行查询和操作。它们之间的主要区别在于并行处理能力。LINQ:LINQ是一种用于在.NET应用程序中进行数据查询和操作的语言集成功能。它提供了一种统一的方式来查询各种数据源，如集合、数组、XML、数据库等。LINQ是在单线程环境中执行查询操作的，因此对于大型数据集或
    

    • 

  • 以高质量调查研究助力组织工作提质增效
木同木同

    近日，中共中央办公厅印发了《关于在全党大兴调查研究的工作方案》(后简称《方案》），要求各地区各部门结合实际认真贯彻落实。调查研究是我们党的传家宝，是谋事之基、成事之道。组织部门作为党管干部的核心部门，肩负着管党员、管干部、管人才的重要职责，调查研究更是把握组织工作规律、破解组织工作难题的重要办法。要用好调查研究这一法宝，把准政治方向，贯穿问题导向，坚持实事求是，以高质量调查研究助力组织工作提质增效
    

    • 

  • 地低为海人低为王
缘梦草

    地低为海，人低为王。低，高之基，高，低之顶。谦虚才能收益，咄咄逼人会招损。高粱熟了，头会低下。受益反而会深藏不露。捧人之术，把人捧高，然后控制。受控之人，大都是虚荣心作祟。活成别人想象中的样子，像别人想象中那么有面子的活着是悲哀的。穷不可怕，怕的是虚荣心。当你好面子，你就会被控制。一旦受虚荣心控制，你不得不谨小慎微的维护面子，付出多余的能量，希望得到别人的一句赞。面子就是金子打造的牢笼，让你在赞美
    

    • 

  • 计划比盲目做重要
一祉微笑

    坚持分享第99天。一次次会议提醒着老师们假期余额不足，马上面临停机状态。50多天掐指而过，想想放假时的计划，对照如今的完成情况，感觉差太远。想着好好看书，如今50多天过去了第6本还处在未完待续状态；想着假期好好陪陪孩子，在玩中学一些知识，如今想想，孩子学的真不多；想着暑假坚持跑步，有时还是容易给自己找借口，休息三两天。给这个假期一个综合评价，只能说只完成了计划的百分之五六十。想想为什么临近开学没达
    

    • 

  • 081天 约柜失而复得
宁宁2018

    撒迦利亚书4:6他对我说：“这是耶和华指示所罗巴伯的。万军之耶和华说：‘不是倚靠势力，不是倚靠才能，乃是倚靠我的灵方能成事。’
    

    • 

  • 《金文成〈正蒙〉日记124。2020-11-9》
金吾生

    《金文成〈正蒙〉日记124。2020-11-9》今天是庚子丁亥丙子，九月廿四，2020年11月9日星期一。作者篇7【舜之孝，汤、武之武，虽顺逆不同，其为不幸均矣。】船山讲解说，顺，指的是舜的父亲最终受到感化，转变了态度，结局圆满之事；逆，指的是＂桀放、纣诛＂，即，商汤放桀，周武诛纣，都是采用暴力，不是感化方式，所以是逆。顺与逆，都是为了解决弊政，然其差异之大如此，然而，无论圆满还是遗憾，其实他们都
    

    • 

  • 如何把大象装进冰箱的思考 210624
大丁_初心生活

    央视春晚曾有个小品，宋丹丹问赵本山，如何把大象装进冰箱。赵本山说不知道。宋丹丹得意地说，第一步，把冰箱门打开。第二步，把大象装进去。第三步，把冰箱门关上。我相信很多人看了都是一笑了之，我们也从潜意识上给出了否定的答案。樊登老师给出了不一样的解读，他认为这其实是解决问题的经典方法。“把大象装冰箱”，目标十分明确，宋丹丹给出的执行步骤也十分清晰。可赵本山却不会？难道赵本山不知道这三个步骤吗？肯定知道。
    

    • 

  • 风险管理和采购管理核心考点梳理
WorkLee
PMPPMP风险管理采购管理

    个人总结，仅供参考，欢迎加好友一起讨论PMP-风险管理和采购管理核心考点梳理风险管理风险是一个中性词，包括机会和威胁。风险管理的子过程非常多，但是相对来说子过程之间的逻辑非常清晰，整个风险管理的过程都是在维护一个非常重要的工件-风险登记册。风险管理是项目管理全生命周期都要开展的。1）规划风险管理风险管理计划包含哪些内容？解析：风险管理计划是描述如何安排与实施风险管理活动。（风险管理计划中无风险）包
    

    • 

  • 沟通管理和相关方管理核心考点梳理
WorkLee
PMPPMP沟通管理相关方干系人

    个人总结，仅供参考，欢迎加好友一起讨论PMP-沟通管理和相关方管理核心考点梳理沟通管理和相关方（干系人）管理这两章放在一起进行梳理，这两章很多的考点很容易混淆，经常会纠结于一些题目，究竟选择沟通管理还是干系人管理的知识点。沟通管理1）规划沟通管理沟通在PMP中是指信息流的传递，PM是根据谁的需求来确定这种信息流的传递方式、频率，内容、格式呢？解析：规划沟通管理是基于每个相关方或相关方群体的信息需求
    

    • 

  • 数据管理知识体系指南（第二版）-第五章——数据建模和设计-学习笔记
键盘上的五花肉
数据治理数据库数据仓库数据治理

    目录5.1引言5.1.1业务驱动因素5.1.2目标和原则5.1.3基本概念5.2活动5.2.1规划数据建模5.2.2建立数据模型5.2.3审核数据模型5.2.4维护数据模型5.3工具5.3.1数据建模工具5.3.2数据血缘工具5.3.3数据分析工具5.3.4元数据资料库5.3.5数据模型模式5.3.6行业数据模型5.4方法5.4.1命名约定的最佳实践5.4.2数据库设计中的最佳实践5.5数据建模和
    

    • 

  • 2020-04-09
柠_fc84

    我和清新冥想的相伴之旅我是来自大二的学生，一名性格活泼的女学生。平时没事喜欢看看书，做做运动，同时也是一名英语爱好者。因一次机遇结识了潘多拉口语课，在此获益良多，但这单单是满足不了我的，也是因为随着现在课程的开展，生活烦心事的增加，情绪波动大，使我紧绷。于是我和清新冥想课程英文版相遇啦。它带给我不一样的体验，使我的心情越来越轻松，那些不好的情绪也愈见愈远，我刚开始接触的时候是好奇，本来加上我对英语
    

    • 

  • 道德经第三十四章
套马地汉纸

    道德经第三十四章原文：大道泛兮，其可左右！万物恃之而生，而不辞，功成不名有。爱养万物而不为主，常无欲，可名于小；万物归焉而不为主，可名为大。是以圣人终不为大，故能成其大。译文：大道广泛流行，无所不到。万物依赖它生长而不推辞，有所成就而不自以为有功。养育万物而不自以为主，永远没有私欲，可以说是渺小得很，所以可称它为“小”；物归附于它而它不自以为主宰，可以说极其伟大，所以可称它为“大”。由于它不自以为
    

    • 

  • Linux学习系列之vim编辑器（一）
llibertyll
linux学习

    vi编辑器的操作模式输入模式—aio等—>命令模式<—：键—末行模式从输入/末行模式切换到命令模式都是需要按ESC键注:a光标后输入，i光标前输入，o直接向下加一行输入，O向上加一行输入在vi编辑器中光标的移动（命令行模式下）键组合（命令）光标的移动$光标移动到当前行的结尾0（零）光标移动到当前行的开始GG光标移动到最后一行gg光标移动到第一行在命令行模式下删除与复制的操作键组合（命令）含义dd删
    

    • 

  • 6/21 最后的编织之观后感
ChereAlicia

    今天看了7分钟震撼人心之短篇有种当局者迷旁观者清的感觉在外人眼里看来已经足够但自有人深陷其中无法自拔而那个人很有可能是自己超脱物质寻求自己真正想要的方能得到内心的平息和安宁图片发自App
    

    • 

  • 每天学点成语
余子烨

    1、口诀：功败垂成未成功，不以为然不赞同；火中取栗被利用，罚不当罪处罚重；2、解释：功败垂成：事情接近成功的时候却遭到了失败。出自：《三国志·杨阜传》：“弃垂成之功，陷不义之名，阜以死守之。”不以为然：不认为是对的。表示不同意或否定。出自：宋·苏轼《再乞罢详定役法状》：“右臣先曾奏论前衙一役，只当招募，不当定差，执政不以为然。”火中取栗：一只猴子和一只猫看见炉火中烤着栗子，猴子叫猫去偷，猫用爪子从
    

    • 

  • 2023-11-07
碎碎念念的每一天

    忽然开始自卑了，感觉自己无论各个方面都太平平，读书不多，家务做不好，体重控制的不好，早起也困难，起来又不知道该做什么，没有一个可以为之奋斗的目标，也没有很好的交际圈，感觉自己就像一只在笼子里的鸟，想飞也飞不高……我想改变这样的现状，可该如何呢？其实都是我不够努力，没有争分夺秒，没有自律，这些都是我未来跟人拉开差距的原因，所以，我不应该只是自卑，自卑过头会变成焦虑，我应该努力去改变，哪怕改变一小点，
    

    • 

  • stm32之GPIO寄存器
luofengmacheng
嵌入式stm32嵌入式硬件单片机

    文章目录1背景2GPIO寄存器的类型2.1端口配置寄存器2.2设置/清除寄存器和位清除寄存器3总结1背景C51单片机在进行数据的输入输出时，是直接操作与外部引脚关联的内部寄存器，例如，当设置P2_1为0时，就是将外部引脚的P21引脚设置为低电平，当读取P2_1时，就是读取P21的电平。与之类似，stm32芯片内部也有很多用于输入输出的寄存器，这些寄存器也是用于操作外部引脚，但是比C51单片机复杂很
    

    • 

  • 《老子》笔记19 2018-10-28
海上明月共

    第二十二章[原文]曲则全，枉则直，洼则盈，敝则新，少则得，多则惑。是以圣人抱一为天下式。不自见，故明；不自是，故彰，不自伐，故有功；不自矜，故长。夫唯不争，故天下莫能与之争。古之所谓"曲则全"者，岂虚言哉？诚全而归之。[译文]委曲便会保全，屈枉便会直伸；低洼便会充盈，陈旧便会更新；少取便会获得，贪多便会迷惑。所以有道的人坚守这一原则作为天下事理的范式，不自我表扬，反能显明；不自以为是，反能是非彰明
    

    • 

  • 爱心账户之存钱日记11.20
静_d595

    新沙发终于到了，满心欢喜，可旧沙发的处理又是个头疼的问题，免费送都没有人要。临时想起来公司那个收垃圾的，看看付费能不能拉走。对方说随便给点都行，我又拿不准，于是就想说88把。对方说给两包烟就行了，我说还是给钱吧，也不想欠人情。如果请专门搬东西的估计得200加了，还算是比较顺利，刚好想到他。选了12元存进我的爱心账户！
    

    • 

  • 大话设计模式之工厂模式
码农客栈
设计模式开发语言

    工厂模式（FactoryPattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式，而无需指定将要创建的对象的确切类。通过使用工厂模式，我们可以将对象的创建和使用分离，从而使代码更具灵活性和可维护性。在工厂模式中，通常会有三种角色：工厂接口（FactoryInterface）：声明了一个用于创建对象的接口，这样所有具体工厂类都必须实现该接口。具体工厂（ConcreteFactory）：实
    

    • 

  • macOS安装mongoDB（homebrew）
lx741602698
macosmongodb数据库

    使用HomebrewHomebrew是macOS的一个包管理器，可以非常方便地安装MongoDB和其他软件。如果你还没有安装Homebrew，可以从它的官网上找到安装指令。已安装Homebrew的话，先更新一下homebrewbrewupdate你可以使用下面的命令来安装MongoDB的社区版：brewtapmongodb/brewbrewinstallmongodb-community安装完成后
    

    • 

  • 《外观模式（极简c++）》
Bovinitwo
设计模式（极简c++版）c++开发语言

    本文章属于专栏-概述-《设计模式（极简c++版）》-CSDN博客模式说明方案：外观模式提供了一个统一的接口，简化了一组复杂子系统的访问方式。优点：将客户端与子系统解耦，降低了复杂性。提高了代码的灵活性和可维护性。缺点：可能导致外观类过于庞大，承担了过多的责任。增加了系统的抽象层，有时会影响性能。本质思想：外观模式的本质思想是为一组复杂的子系统提供一个简单的接口，隐藏其复杂性，使得客户端可以更轻松地
    

    • 

  • 程序员开发技术整理
laizhixue
学习前端框架

    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
    

    • 

  • 大话设计模式之代理模式
码农客栈
设计模式代理模式

    代理模式（ProxyPattern）是一种结构型设计模式，它允许通过代理对象控制对另一个对象的访问。代理对象充当客户端和实际对象之间的中介，客户端通过代理对象间接访问实际对象，从而可以在访问控制、缓存、延迟加载等方面提供额外的功能。在代理模式中，通常会有三种角色：Subject（抽象主题）：声明了真实对象和代理对象的共同接口，这样在任何使用真实对象的地方都可以使用代理对象。RealSubject（
    

    • 

  • windows下源码安装golang
616050468
golang安装golang环境windows

             系统： 64位win7， 开发环境：sublime text 2，  go版本： 1.4.1
 
 1.  安装前准备(gcc, gdb, git)
       golang在64位系
    

    • 

  • redis批量删除带空格的key
bylijinnan
redis

    redis批量删除的通常做法：
redis-cli keys "blacklist*" | xargs redis-cli del
上面的命令在key的前后没有空格时是可以的，但有空格就不行了：
$redis-cli keys "blacklist*"
1) "blacklist:12: [email protected]
    

    • 

  • oracle正则表达式的用法
0624chenhong
oracle正则表达式

      方括号表达示
方括号表达式
描述
[[:alnum:]]
字母和数字混合的字符
[[:alpha:]]
字母字符
[[:cntrl:]]
控制字符
[[:digit:]]
数字字符
[[:graph:]]
图像字符
[[:lower:]]
小写字母字符
[[:print:]]
打印字符
[[:punct：]]
标点符号字符
[[:space:]]
    

    • 

  • 2048源码(核心算法有，缺少几个anctionbar，以后补上)
不懂事的小屁孩
2048

    2048游戏基本上有四部分组成，
1：主activity，包含游戏块的16个方格，上面统计分数的模块
2：底下的gridview，监听上下左右的滑动，进行事件处理，
3：每一个卡片，里面的内容很简单，只有一个text，记录显示的数字
4：Actionbar，是游戏用重新开始，设置等功能(这个在底下可以下载的代码里面还没有实现)
写代码的流程
1：设计游戏的布局，基本是两块，上面是分
    

    • 

  • jquery内部链式调用机理
换个号韩国红果果
JavaScriptjquery

    只需要在调用该对象合适(比如下列的setStyles)的方法后让该方法返回该对象（通过this  因为一旦一个函数称为一个对象方法的话那么在这个方法内部this（结合下面的setStyles）指向这个对象）
function create(type){
var element=document.createElement(type);
//this=element; 
    

    • 

  • 你订酒店时的每一次点击 背后都是NoSQL和云计算
蓝儿唯美
NoSQL

    全球最大的在线旅游公司Expedia旗下的酒店预订公司，它运营着89个网站，跨越68个国家，三年前开始实验公有云，以求让客户在预订网站上查询假期酒店时得到更快的信息获取体验。
云端本身是用于驱动网站的部分小功能的，如搜索框的自动推荐功能，还能保证处理Hotels.com服务的季节性需求高峰整体储能。
Hotels.com的首席技术官Thierry Bedos上个月在伦敦参加“2015 Clou
    

    • 

  • java笔记1
a-john
java

    1，面向对象程序设计（Object-oriented Propramming，OOP）：java就是一种面向对象程序设计。
2，对象：我们将问题空间中的元素及其在解空间中的表示称为“对象”。简单来说，对象是某个类型的实例。比如狗是一个类型，哈士奇可以是狗的一个实例，也就是对象。
3，面向对象程序设计方式的特性：
    3.1 万物皆为对象。
   
    

    • 

  • C语言 sizeof和strlen之间的那些事 C/C++软件开发求职面试题 必备考点（一）
aijuans
C/C++求职面试必备考点

            找工作在即，以后决定每天至少写一个知识点，主要是记录，逼迫自己动手、总结加深印象。当然如果能有一言半语让他人收益，后学幸运之至也。如有错误，还希望大家帮忙指出来。感激不尽。
       后学保证每个写出来的结果都是自己在电脑上亲自跑过的，咱人笨，以前学的也半吊子。很多时候只能靠运行出来的结果再反过来
    

    • 

  • 程序员写代码时就不要管需求了吗？
asia007
程序员不能一味跟需求走

          编程也有2年了，刚开始不懂的什么都跟需求走，需求是怎样就用代码实现就行，也不管这个需求是否合理，是否为较好的用户体验。当然刚开始编程都会这样，但是如果有了2年以上的工作经验的程序员只知道一味写代码，而不在写的过程中思考一下这个需求是否合理，那么，我想这个程序员就只能一辈写敲敲代码了。
      我的技术不是很好，但是就不代
    

    • 

  • Activity的四种启动模式
百合不是茶
android栈模式启动Activity的标准模式启动栈顶模式启动单例模式启动

    android界面的操作就是很多个activity之间的切换,启动模式决定启动的activity的生命周期 ;
 
启动模式xml中配置
    <activity android:name=".MainActivity" android:launchMode="standard&quo
    

    • 

  • Spring中@Autowired标签与@Resource标签的区别
bijian1013
javaspring@Resource@Autowired@Qualifier

    Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，如：@Resource、 @PostConstruct及@PreDestroy。
 
1. @Autowired    @Autowired是Spring 提供的，需导入    Package:org.springframewo
    

    • 

  • Changes Between SOAP 1.1 and SOAP 1.2
sunjing
ChangesEnableSOAP 1.1SOAP 1.2

    JAX-WS
SOAP Version 1.2 Part 0: Primer (Second Edition)
SOAP Version 1.2 Part 1: Messaging Framework (Second Edition)
SOAP Version 1.2 Part 2: Adjuncts (Second Edition)
 
Which style of WSDL
    

    • 

  • 【Hadoop二】Hadoop常用命令
bit1129
hadoop

    以Hadoop运行Hadoop自带的wordcount为例，
 
hadoop脚本位于/home/hadoop/hadoop-2.5.2/bin/hadoop，需要说明的是，这些命令的使用必须在Hadoop已经运行的情况下才能执行
  Hadoop HDFS相关命令
 hadoop fs -ls
 列出HDFS文件系统的第一级文件和第一级
    

    • 

  • java异常处理（初级）
白糖_
javaDAOspring虚拟机Ajax

    从学习到现在从事java开发一年多了，个人觉得对java只了解皮毛，很多东西都是用到再去慢慢学习，编程真的是一项艺术，要完成一段好的代码，需要懂得很多。
最近项目经理让我负责一个组件开发，框架都由自己搭建，最让我头疼的是异常处理，我看了一些网上的源码，发现他们对异常的处理不是很重视，研究了很久都没有找到很好的解决方案。后来有幸看到一个200W美元的项目部分源码，通过他们对异常处理的解决方案，我终
    

    • 

  • 记录整理-工作问题
braveCS
工作

    1）那位同学还是CSV文件默认Excel打开看不到全部结果。以为是没写进去。同学甲说文件应该不分大小。后来log一下原来是有写进去。只是Excel有行数限制。那位同学进步好快啊。
2）今天同学说写文件的时候提示jvm的内存溢出。我马上反应说那就改一下jvm的内存大小。同学说改用分批处理了。果然想问题还是有局限性。改jvm内存大小只能暂时地解决问题，以后要是写更大的文件还是得改内存。想问题要长远啊
    

    • 

  • org.apache.tools.zip实现文件的压缩和解压，支持中文
bylijinnan
apache

    刚开始用java.util.Zip，发现不支持中文（网上有修改的方法，但比较麻烦）
后改用org.apache.tools.zip
org.apache.tools.zip的使用网上有更简单的例子
下面的程序根据实际需求，实现了压缩指定目录下指定文件的方法
import java.io.BufferedReader;
import java.io.BufferedWrit
    

    • 

  • 读书笔记-4
chengxuyuancsdn
读书笔记

    1、JSTL 核心标签库标签
2、避免SQL注入
3、字符串逆转方法
4、字符串比较compareTo
5、字符串替换replace
6、分拆字符串
1、JSTL 核心标签库标签共有13个，
学习资料：http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html
功能上分为4类：
(1)表达式控制标签：out
    

    • 

  • [物理与电子]半导体教材的一个小问题
comsci
问题

    
      各种模拟电子和数字电子教材中都有这个词汇-空穴
      书中对这个词汇的解释是; 当电子脱离共价键的束缚成为自由电子之后,共价键中就留下一个空位,这个空位叫做空穴
      我现在回过头翻大学时候的教材,觉得这个
    

    • 

  • Flashback Database --闪回数据库
daizj
oracle闪回数据库

    Flashback 技术是以Undo segment中的内容为基础的， 因此受限于UNDO_RETENTON参数。要使用flashback 的特性，必须启用自动撤销管理表空间。
在Oracle 10g中， Flash back家族分为以下成员： Flashback Database， Flashback Drop，Flashback Query(分Flashback Query,Flashbac
    

    • 

  • 简单排序:插入排序
dieslrae
插入排序

    
public void insertSort(int[] array){
int temp;
for(int i=1;i<array.length;i++){
temp = array[i];
for(int k=i-1;k>=0;k--)
    

    • 

  • C语言学习六指针小示例、一维数组名含义，定义一个函数输出数组的内容
dcj3sjt126com
c

    # include <stdio.h>
int main(void)
{
int * p; //等价于 int *p 也等价于 int* p;
int i = 5;
char ch = 'A';
//p = 5; //error
//p = &ch; //error
//p = ch; //error
p = &i; // 
    

    • 

  • centos下php redis扩展的安装配置3种方法
dcj3sjt126com
redis

    方法一
1.下载php redis扩展包  代码如下 复制代码
#wget http://redis.googlecode.com/files/redis-2.4.4.tar.gz
2 tar -zxvf 解压压缩包，cd /扩展包 （进入扩展包然后 运行phpize 一下是我环境中phpize的目录，/usr/local/php/bin/phpize (一定要
    

    • 

  • 线程池(Executors)
shuizhaosi888
线程池

    在java类库中，任务执行的主要抽象不是Thread，而是Executor，将任务的提交过程和执行过程解耦
public interface Executor {
void execute(Runnable command);
}
 
public class RunMain implements Executor{
@Override
pub
    

    • 

  • openstack 快速安装笔记
haoningabc
openstack

    前提是要配置好yum源
版本icehouse，操作系统redhat6.5
最简化安装，不要cinder和swift
三个节点
172 control节点keystone glance horizon
173 compute节点nova
173 network节点neutron
control
/etc/sysctl.conf
net.ipv4.ip_forward =
    

    • 

  • 从c面向对象的实现理解c++的对象（二）
jimmee
C++面向对象虚函数

    1. 类就可以看作一个struct，类的方法，可以理解为通过函数指针的方式实现的，类对象分配内存时，只分配成员变量的，函数指针并不需要分配额外的内存保存地址。
2. c++中类的构造函数，就是进行内存分配(malloc)，调用构造函数
3. c++中类的析构函数，就时回收内存(free)
4. c++是基于栈和全局数据分配内存的，如果是一个方法内创建的对象，就直接在栈上分配内存了。
专门在
    

    • 

  • 如何让那个一个div可以拖动
lingfeng520240
html

    
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml
    

    • 

  • 第10章 高级事件（中）
onestopweb
事件

    index.html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    

    • 

  • 计算两个经纬度之间的距离
roadrunners
计算纬度LBS经度距离

    要解决这个问题的时候，到网上查了很多方案，最后计算出来的都与百度计算出来的有出入。下面这个公式计算出来的距离和百度计算出来的距离是一致的。
/**
*
* @param longitudeA
* 经度A点
* @param latitudeA
* 纬度A点
* @param longitudeB
* 
    

    • 

  • 最具争议的10个Java话题
tomcat_oracle
java

    1、Java8已经到来。什么！？ Java8 支持lambda。哇哦，RIP Scala！ 　　随着Java8 的发布，出现很多关于新发布的Java8是否有潜力干掉Scala的争论，最终的结论是远远没有那么简单。Java8可能已经在Scala的lambda的包围中突围，但Java并非是函数式编程王位的真正觊觎者。 　
　2、Java 9 即将到来 　　
Oracle早在8月份就发布
    

    • 

  • zoj 3826 Hierarchical Notation(模拟)
阿尔萨斯
rar

     题目链接：zoj 3826 Hierarchical Notation
题目大意：给定一些结构体，结构体有value值和key值，Q次询问，输出每个key值对应的value值。
解题思路：思路很简单，写个类词法的递归函数，每次将key值映射成一个hash值，用map映射每个key的value起始终止位置，预处理完了查询就很简单了。 这题是最后10分钟出的，因为没有考虑value为{}的情
    

    •