设计模式 (工厂类=父类;实现类=子类)

设计模式

是在特定环境下人们解决某类重复出现额问题的一套成功的有效的方案
四人组(gang of four) 将"模式"的概念引入软件工程
“在一定的环境下,用固定套路解决问题”

设计模式的概念

设计模式的基础是: 多态
设计模式的原则是: 高内聚 ,低耦合(各个类之间少参与,保持模块性)
单一职责原则: 类的职责单一,对外只提供一种功能,引起变化的原因也只有一个.
开闭原则: 类的改动是通过增加代码而进行的,而不是修改源码.
迪米特法则: 一个对象应当对其他对象尽可能的少了解,从而降低各个对象之间的耦合,提高系统的可维护性.符合设计模式的基本原则(多组合,少继承).
里氏代换原则: 任何抽象类出现的地方都可以用他的实现类代替,实际就是虚拟机制,语言级别实现面向对象功能.
依赖倒转原则: 依赖于抽象接口,不要依赖于具体的实现类,也就是针对接口编程.

简单工厂和工厂方法

简单工厂的优点

1.实现了对象创建和使用的分离
2.不用记住类名,只需记住参数,减少了记忆量

简单工厂的缺点

1.对工厂类负担过重
2.复杂度增加
3.违反了工厂的原则
简单工厂步骤
1.先建立一个抽象工厂类
2.在抽象工厂类里面写一个抽象方法
3.建立一个普通类
4.在普通类中重写抽象方法

 public abstract class AbsFruit
        {
            public abstract void showName();

        }
        class Apple : AbsFruit
        {
            public override void showName()
            {
                Console.WriteLine("苹果");
            }
        }
        class Banana : AbsFruit
        {
            public override void showName()
            {
                Console.WriteLine("香蕉");
            }
        }

工厂方法:
是一个产品一个厂
优点是
1.不需要记住具体类名,甚至连具体参数都不用记忆
2.实现了对象创建和使用的分离
3.系统的可拓展性也就变得风场好,无需修改接口和原类
缺点是
1.增加系统中类的个数,复杂度和理解度增加
2.增加了系统的抽象性和理解难度

第一步建立一个抽象工厂类

namespace 工厂方法
{
    public abstract class AbsFac
    {
        public abstract AbsPhone CreatePhone();
    }
}

第二步建立一个抽象手机类

namespace 工厂方法
{
    public abstract class AbsPhone
    {
        public abstract void show();
    }
}

第三步建立一个实现手机类

namespace 工厂方法
{
    public class Apple : AbsPhone
    {
        public override void show()
        {
            Console.WriteLine("apple");
        }
    }
}

第四步建立一个实现手机工厂类

namespace 工厂方法
{
    public class AppleFac : AbsFac

    {
        public override AbsPhone CreatePhone()
        {

            return new Apple();
        }


    }
}

第五步建立一个主类

namespace 工厂方法
{
    class Program
    {
        static void Main(string[] args)
        {
            AppleFac apple = new AppleFac();
            apple.CreatePhone().show();
            Console.WriteLine();
        }
    }
}

单例模式

分为懒汉模式和饿汉模式

懒汉模式指的是需要用了的时候在创建 (if == null)就创建
懒汉模式适用于线程比较少的场景，因为线程一旦多，加锁的开销就会体现出来（当然最后对懒汉优化的那种方案已经差不多解决这个问题了），总之它是一种时间换空间的模式。

饿汉模式指的是不论之前有没有直接创建
饿汉模式适用于线程比较多的场景，它会占用全局静态区一定的空间，但是能够确保只有一个实例。但是当线程很少，甚至是没有用到这个单例类的时候，就显得得不偿失了，它占用的空间问题就体现出来了，这是一种空间换时间的模式。