上一节讲到了类，这次讲对象。一个类可以创建对象，对象可以操作类里面的方法，也可以操作类从父类继承的合法方法，还可以操作其他类的共用方法。
在程序设计（这里都以C#语言为准）中的对象和人类世界中的是类似的，人类世界中每一个人都是一个对象，一个人有自己的姓名、身高等属性，一个人可以做很多事情，也受到很多约束；而程序设计里的对象就是模拟了人类世界的对象，一个对象必须要创建，这个对象在创建之时就确定了它的属性，这个对象可以有很多方法，这个对象受到访问权限的约束。
人类生活在人类社会这个时间里，而对象生存在.NET中的CLR环境；人类在社会里受到法律、风俗等约束，对象在CLR里也同样有着自己的一套约定，比如类型、语法等。
对象最为重要的是：有自己的属性（有如一个人的属性）、有自己可以访问的方法（有如一个人可以做的事情）、访问权限（有如一个人做什么事情受到的权限限制）。

人以类聚”，这个成语说明了类的概念，在面向对象设计中的类也是如此，一个类是一组东西的抽象，类可以有抽象出来的类（抽象类），也可以是具体的类，抽象类往往都有具体类，具体类负责实现抽象类定义的方法。一个类，里面定义了属于这个类别的东西共同拥有的属性和方法，比如Duck鸭子类，里面有叫声，羽毛等鸭子都有的属性，有游泳，叫等鸭子都有的方法。
在C#里类还分静态类和非静态类，最大的区别是静态类里必须都是静态方法，静态类必须用类名去访问里面的方法，静态类是编译时就确定的；非静态类必须先创建一个实例对象，然后才能去访问类里的成员和方法，非静态类是动态绑定的，也就是在执行的时候才确定要执行什么方法。
类有修饰它的关键字：Public、Protected，Private。这几个关键字代表的意思是：
1、Public：公共的类，这个类可以在外面的类被访问到；
2、Protected：私有的类，这个类可以在继承它的类被访问到；
3、Private：私有的类，这个类不能在任何其他外面的被类访问到。

前一篇文章介绍了简单工厂和工厂方法模式,这次讨论抽象工厂模式。
1、抽象工厂模式定义
抽象工厂模式也叫Abstract Factory模式，是由GoF提出的23种设计模式中的一种，也是对象创建型模式之一。它提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它提供一个接口，以创建多个相关联的对象，而无需具体指定其具体的类。形象地说，它是一个工厂，能够生产众多产品。当用户需要某种产品的时候，不需要去关心这个产品的具体实现，而只需要指定产品的名称，抽象工厂就能够按你的要求进行生产。这里所指的产品，在C#中我们代表的是一个实例的类。
2、在什么情况下使用抽象工厂模式
在面向对象的程序设计中，我们经常会定义许多类，并通过new对其进行实例化。一旦类对象较多，且在实例化的时候，要做的初始化工作比较复杂的时候，我们就可以通过抽象工厂来管理。根据对象的性质和内容分别抽象成类，同时定义接口和接口方法。一旦定义了抽象工厂，实例类的工作就交给工厂，使用者只需要告诉工厂，你实例化的对象是什么就行了。
3、抽象工厂模式实现原理
抽象工厂模式（Abstract Factory）强调的是对象组合机制，由在父工厂内定义不同的“子工厂”对象来负责不同的目标对象的创建。请注意下面要点：
（1）、 抽象工厂模式中，产品（目标对象）的使用者可能需要使用具体的子工厂来生成该产品；
（2）、抽象工厂模式采用传参数的形式直接在父工厂内决定该产品对象应该由哪一个子工厂生产。即Abstract Factory模式中，跟客户打交道的只有抽象工厂与抽象产品，客户不需要知道产品由哪个工厂生产，也不需要知道被生产的是哪一种具体的产品；
（3）、Factory Method模式中，省城的对象产品只限定于某一类产品；Abstract Factory模式则可以提供多个生产接口生成多类产品；
（4） 、Abstract Factory模式Factory Method模式的更高层次的抽象，也更最具一般性。可以把Factory Method模式看作是Abstract Factory模式的一种特殊情况。
4、C#实现代码
using System;
using System.Collections.Generic;
using System.Text;
namespace AbstractFactory.Design.Pattern
{
class Program
{
static void Main(string[] args)
{
IAbstratFactory factory1 = new ConcreteFactory1();
IAbstratFactory factory2 = new ConcreteFactory2();
Evironment e1 = new Evironment(factory1);
Evironment e2 = new Evironment(factory2);
e1.Show();
e2.Show();
e1.Run();
e2.Run();
Console.ReadKey();
}
}
//抽象产品
public interface IAbstractProduceA
{
void MakeProduce();
}
public interface IAbstractProduceB
{
void InterTract(IAbstractProduceA a);
}
//具体产品
public class ProduceA1:IAbstractProduceA
{
public void MakeProduce()
{
Console.WriteLine("ProduceA1 is Created now!");
}
}
public class ProduceB1 : IAbstractProduceB
{
public void InterTract(IAbstractProduceA a)
{
Console.WriteLine(this + " contact with " + a);
}
}
public class ProduceA2 : IAbstractProduceA
{
public void MakeProduce()
{
Console.WriteLine("ProduceA2 is Created now!");
}
}
public class ProduceB2 : IAbstractProduceB
{
public void InterTract(IAbstractProduceA a)
{
Console.WriteLine(this+" contact with "+a);
}
}
//抽象工厂
public interface IAbstratFactory
{
IAbstractProduceA CreateProduceA();
IAbstractProduceB CreateProduceB();
}
//具体工厂
public class ConcreteFactory1 : IAbstratFactory
{
public IAbstractProduceA CreateProduceA()
{
return new ProduceA1();
}
public IAbstractProduceB CreateProduceB()
{
return new ProduceB1();
}
}
public class ConcreteFactory2 : IAbstratFactory
{
public IAbstractProduceA CreateProduceA()
{
return new ProduceA2();
}
public IAbstractProduceB CreateProduceB()
{
return new ProduceB2();
}
}
//客户端
public class Evironment
{
private IAbstractProduceA abstractProdueA;
private IAbstractProduceB abstractProdueB;
public Evironment(IAbstratFactory factory)
{
abstractProdueA = factory.CreateProduceA();
abstractProdueB = factory.CreateProduceB();
}
public void Show()
{
abstractProdueA.MakeProduce();
}
public void Run()
{
abstractProdueB.InterTract(abstractProdueA);
}
}

单件模式属于创建型模式，创造性模式主要是关注于如何以及何时创建对象。Singleton 模式可以保证一个类有且只有一个实例，并提供一个访问它的全局访问点。在程序设计过程中，有很多情况需要确保一个类只能有一个实例。

namespace Singleton.Design.Pattern
{
class Program
{
static void Main(string[] args)
{
//Singleton e = new Singleton(); 这是错误的，因为已经设定为保护类型了
Singleton instance = Singleton.Instance();
instance.Show();
Console.ReadKey();
}
}
public class Singleton
{
private static Singleton instance;
protected Singleton()
{
}
public static Singleton Instance()
{
if (instance == null)
{
instance = new Singleton();
}
return instance;
}
public void Show()
{
Console.WriteLine("Singleton is Show now!");
}
}
}

设计模式中工厂方法包括了：简单工厂，工厂方法和抽象工厂，下面给出简单工厂和工厂方法的C#实现，你可以直接拷贝运行。

namespace Factory.Design.Pattern
{
class Program
{
static void Main(string[] args)
{
//设计模式之简单工厂
//LightSimpleFactory lsf = new LightSimpleFactory();
//Light lsb= lsf.Create("Blue");
//Light lsr = lsf.Create("Red");
//lsb.TurnOn();
//lsr.TurnOn();

//设计模式之工厂方法
CreatorMethod cb = new BlueCreator();
CreatorMethod cr = new RedCreator();
Light lb = cb.factory();
Light lr = cr.factory();
lb.TurnOn();
lr.TurnOn();
Console.ReadKey();
}
}
public abstract class Light
{
public abstract void TurnOn();
}
public class BlueLight : Light
{
public override void TurnOn()
{
Console.WriteLine("Blue Light is turn on!");
}
}
public class RedLight : Light
{
public override void TurnOn()
{
Console.WriteLine("Red Light is turn on!");
}
}
#region 简单工厂
public class LightSimpleFactory
{
public Light Create(string LightType)
{
switch (LightType)
{
case "Blue":
{
return new BlueLight();
}
case "Red":
{
return new RedLight();
}
default:
{
return null;
}
}
}
}
#endregion
#region 工厂方法
public abstract class CreatorMethod
{
public abstract Light factory();
}
public class BlueCreator : CreatorMethod
{
public override Light factory()
{
return new BlueLight();
}
}
public class RedCreator : CreatorMethod
{
public override Light factory()
{
return new RedLight();
}
}
#endregion
}

现在网上有大量的文章写设计模式，无论是Gof的23种设计模式，还是其他自己创造处理的模式，但是在做这些工作之前应该深入理解什么叫设计模式。
总的来说，设计模式是一各个编程套路，类似于建筑设计，网上也有关于什么叫设计模式的经典分析，下面仅仅作为摘要简述：
1、来自豆瓣网的声音：
设计模式并不是什么新的东西。有些模式，你或许已经在实际项目中应用了很多年了，只是不知道人家原来是这么称呼它的！
2、来自博客园的分析：
设计模式就是解决问题的一种方式，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样你就可以一次又一次的使用该解决方案而不做重复性的劳动。设计模式有四个基本要素：模式名称、问题、解决方案、效果。
按照模式的目的性准则，模式可以分为创建型模式、结构型模式和行为型模式。创建型模式与对象的创建有关；结构型模式处理类和对象的组合；行为型模式对类和对象怎样交互和怎样分配职责进行描述。
按照模式的范围准则，模式可以分为类模式和对象模式。类模式处理类和子类的关系，这些关系通过继承建立，是静态的，在编译时就确定下来。对象模式是处理对象之间的关系，这些关系在运行时刻是可以变化的，更具动态性。
创建型类模式将对象的创建工作部分延迟到子类。创建型对象模式则是将它延迟到另一个对象中。
结构型类模式使用继承机制来组合类。结构型对象模式则描述了对象的组装方式。
行为型类模式使用继承描述算法和控制流。行为型对象模式描述使用一组对象怎样协作完成单个对象无法完成的任务。

1、网站被黑的原因
此次我们网站遭到的是sql注入攻击，具体攻击目标是数据库中存放2009年1月份数据表，黑客修改了这张表的一个字段的信息，导致了我们网站被嵌入带有威胁的js代码。
2、解决办法
到目前为止，我们已经把整个数据库的所有记录信息都进行了排查、消除了所有带有危害的数据，我们也已经把所有容易受到攻击的端口关闭（ftp的21端口）、并重新设置数据库的用户名和密码；另外，开发人员和系统人员都在努力寻找和修补在Web服务器上可能存在的sql注入漏洞。
3、未来防范策略
（1）、严格限制对sql server数据库的访问权限；
（2）、对网站的sql语句进行全面排查，确保所有对数据库请求操作都进行字符串过滤；
（3）、关闭除了80和443以外的其他所有端口；
（4）、定期对数据库最可能受攻击的数据进行安全检查。

对于网站的理解，不同层次的人有不同的理解。一个网站可以简单地只有几个静态页面，花上一两个小时的时间就可以做好；但是也可能设计地非常精巧，能够承受亿万级的访问量，这样的网站设计起来就很复杂，而且会耗掉大量的人力物力。简单的网站提供的功能是有限的，作用也很小；但是对于大型的网站，就非常地有用，可以提供丰富多彩的功能，比如Google、百度、淘宝、新浪、搜狐等这些网站。
所有的网站开发人员都希望能够设计出性能稳定、负载能力大的网站，而一个对于web系统：最大的瓶颈是数据库；展现效率的决定性因素是前端调用和架构；系统健壮性的决定性因素是总体架构。
1、Web系统最大瓶颈是数据库
无论是使用哪类数据库管理软件（DB2、SQL Server、Oracle），数据库瓶颈是让网站开发者最为头痛的，每一次数据库连接操作都会消耗极大的系统资源（CPU资源、磁盘IO资源等），如果并发达到百万级，没有合理的数据库访问策略，那么网站肯定马上就瘫痪。解决这一问题，主要靠缓存机制，而在数据库缓存里最好用的莫过于Memcached（非常高效的分布式数据库缓存工具），有了Memcached，那么就可以大量地减少数据库链接数，而且可以进行分布式，极大了减小了数据库的压力，而且可以随时增加服务器扩充数据库负载能力。当然Memcached并非绝对灵丹妙药，必须在网站架构和程序代码上下功夫，比如数据库读写分离、缓存更新机制等。Memcached是针对Linux操作系统的，在Windows下也可以用，但并不一定能够达到很好的效果，幸运的是微软现在也自己开发了一套类似的东西：Velocity。
2、展现效率的决定性因素是前端调用和架构
如果你认真去分析淘宝网的页面代码，你就会发现这句话一点都没有错，当服务器响应快速了之后，如何能够展现地更快，就是前端优化，淘宝的前端开发工程师曾说过：页面响应80%时间来自js、css和html代码，由此可见前端的重要性。对于css和div，在兼容浏览器的前提下，最好能够尽量向web标准靠拢，对于js，我建议是使用稳定的js框架，个人喜欢JQuery。
3、系统健壮性的决定性因素是总体架构
网站的总体架构相当于一个人的骨架，没有好的架构不用提稳定性了。一个好的网站架构应该满足：三层（表现、逻辑、数据访问）分离、代码规范、可扩充，如果是大型网站，还要是分布式的、数据库读写分离。