程杰Prefacesrc code菜鸟教程 C#关于本书学习的疑问解答
作者谈了自己对design patterns学习理解，可供参考
Ref GoFJava与模式，阎宏第1章 代码无错就是优？——简单工厂模式C# solution(方案)可包括多个project(项目)1.8 业务的封装业务逻辑与界面逻辑相分离1.10 简单工厂模式为了简化程序，计算器程序采用 c# 多个button 对应同一消息处理方法//各个button共用同一个事件处理函数
button1.click = new System.EventHandler(button_Click);
button2.click = new System.EventHandler(button_Click);
button3.click = new System.EventHandler(button_Click);
...
private void button_Click(objet sender ,EventArgs e)
{
Button btn =(Button)sender ; //实例化按钮，从而获取当前单击按钮的值
this.txtvalue.Text = btn.Text; //窗体中有txtvalue控件并给它赋值
}简单工厂模式 factory类:abstract product: concrete product1.11 UML类图类图: class接口: interfaceinterface IFly
{
void Fly();
}继承 类继承接口继承//类继承
class Bird : Animal
{}//接口继承
class WideGoose : IFly
{}组合 关联 association聚合 aggregation合成 composition//关联
class Penguin : Bird
{
private Climate climate;``
}`//聚合
class WideGooseAggregate
{
private WideGoose[] arrayWideGoose;
}//合成
class Bird
{
private Wing wing;
public Bird(){
wing = new Wing();
}
}依赖//依赖
abstract class Animal
{
public Metabolism(Oxygen oxygen, Water water){}
}
对比UML图，理解代码；或反之
工厂模式: 实例化具有共同父类的不同对象 应用: EJB,RMI,CORBA可根据不同条件产生不同实例 switch-case 或 反射要素 工厂: 虚拟构造器分类 简单工厂模式工厂方法模式抽象工厂模式简单工厂模式的结构工厂方法模式深入浅出UML类图: 有价值，理解UML作用第2章 商场促销——策略模式2.1 商场收银软件//初始化 Combox
cbxType.Items.AddRange(new object[] {"正常收费","打八折","打七折","打五折"});2.2 增加打折2.3 简单工厂实现2.4 策略模式strategy pattern: 定义算法族 封装变化点vs. 简单工厂 策略选择权在客户端工厂模式相当于黑盒子，策略模式相当于白盒子工厂模式：有一天你决定去吃披萨，一看菜单，哦，种类很多呀，就点了个培根披萨，过了二十分钟，你的披萨就来了就可以吃到了。但这个披萨是怎么做的，到底面粉放了多少，培根放了多少，佐料放了多少，有多少到工序，你是不需要管的，你需要的是一个美味培根披萨。策略模式：同样还是在披萨店，你要一个培根披萨，老板说想吃自己去做吧。原料有培根、面粉、佐料。工序有1、2、3工序，你自己去做吧。然后你就需要自己去做，到底放多少培根，放多少面粉，放多少佐料，这都你自己来决定，工序1、2、3，你是怎么实现的，都你自己决定。最后你得到了披萨。Strategy 类和Context类为aggregate关系，即Strategy将作为构造函数的参数传递给`Context类//抽象算法类
abstract class Strategy
{
//算法方法
public abstract void algorithmInterface();
}
//上下文
class Context
{
Strategy strategy;
public Context(Strategy strategyIn) {}
}2.5 策略模式实现2.6 策略与简单工厂结合public CashContext(CashSuper csuper)
{
this.cs = csuper;
}策略+简单工厂class CashContext
{
CashSuper cs = null;
//根据条件返回相应的对象
public CashContext(string type)
{
switch (type)
{
case "正常收费":
CashNormal cs0 = new CashNormal();
cs = cs0;
break;
...
}
}反射 依赖注入（Dependency Injection）不管工厂模式，还是策略模式，switch-case依然去不掉。原因在哪里?Assembly.Load("程序集名称").CreateInstance("名称空间.类名称")?2.7 策略模式解析反射(reflect)第3章 拍摄UFO–单一职责原则3.1 新手机3.2 拍摄3.3 没用的东西3.4 单一职责原则单一职责原则（SRP：Single responsibility principle）案例六大原则之SRP笔记3.5 方块游戏的设计3.6 手机职责过多吗？第4章 考研求职两不误–开放-封闭原则4.1 考研失败4.2 开放-封闭原则4.3 何时应对变化抽象 -> 隔离 -> 变化4.4 两手准备，并全力以赴第5章 会修电脑不会修收音机？–依赖倒转原则5.1 MM请求修电脑5.2 电话遥控修电脑5.3 依赖倒转原则error: 高层模块 依赖于 低层模块 solution: 抽象 -> 接口5.4 里氏代换原则子类型可替换性依赖倒转 IOC5.5 修收音机第6章 穿什么有这么重要？–装饰模式6.1 穿什么有这么重要？6.2 小菜扮靓第一版6.3 小菜扮靓第二版aim: 所需功能按照正确顺序串联执行，
有点像pipeline?
GOF: 动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。6.4 装饰模式Component classabstract class Component{
public abstract void Operation();
}ConcreteComponentclassclass ConcreteComponent : Component{
public override void Operation(){
Console.WriteLine("具体对象操作");
}
}Decorator classabstract class Decorator : Component{
protected Component component;
public void setComponent(Component component) {
this.component = component; //设置Component
}
//
public override void Operation(){
if(component != NULL){ component.Operation();}
}
}ConcreteDecoratorA classclass ConcreteDecoratorA : Decorator {
private string addState;
public override void Operation(){
base.Operation();
...
}
}static void Main(stringp[] args){
ConcreteComponent c = new ConcreteComponent();
ConcreteDecoratorA d1 = new ConcreteDecoratorA();
ConcreteDecoratorB d2 = new ConcreteDecoratorB();
//Pipeline?
d1.setComponent(c);
d2.setComponent(d1);
d2.Operation();
}
我认为客户端代码就是 pipeline
6.5 小菜扮靓第三版6.6 装饰模式总结装饰模式的装饰顺序重要！Example: 加密数据和过滤词汇是数据处理模块的装饰功能，若先加密再过滤，则不妥！装饰模式 vs. 桥接模式 ??vs. 责任链模式 责任链: 表示上下级审批权限装饰: pipeline实际应用: Java IO 流是典型的装饰模式第7章 为别人做嫁衣–代理模式7.1 为别人做嫁衣！7.2 没有代理的代码结构图 //追求者类
class Pursuit
{
SchoolGirl mm;
public Pursuit(SchoolGirl mm) {this.mm = mm; }
public void GiveDolls() {}
public void GiveFlows() {}
public void GiveChocolate() {}
}
//被追求者类
class SchoolGirl
{
private string name;
public string Name
{
get {return name; }
set {name = value; }
}
}
//客户端调用代码
static void Main(string[] args)
{
SchoolGirl mm = new SchoolGirl();
mm.name = "妹妹";
Pursuit zhuojiayi = new Pursuit(mm);
zhuojiayi.GiveDolls();
...
}
7.3 只有代理的代码结构图 7.4 符合实际的代码//代理接口
interface IGiveGift {
public void GiveDolls();
public void GiveFlows();
public void GiveChocolate();
}
//追求者类
class Pursuit : IGiveGift
{
SchoolGirl mm;
public Pursuit(SchoolGirl mm) {this.mm = mm; }
public void GiveDolls() {}
public void GiveFlows() {}
public void GiveChocolate() {}
}
//代理类
class Proxy : IGiveGift
{
private Pursuit gg;
//被代理者
public Proxy(SchoolGirl mm) {gg = new Pursuit(mm); }
public void GiveDolls() { gg.GiveDolls(); }
public void GiveFlows() { gg.GiveFlows(); }
public void GiveChocolate() { gg.GiveChocolate(); }
}
//客户端
static void Main(String[] args)
{
SchoolGirl jiaojiao = new SchoolGirl();
//代理
Proxy daili = new Proxy(jiaojiao);
daili.GiveDolls();
...
}
7.5 代理模式代理模式原理及实例讲解代理模式角色分为 4 种：主题接口：定义代理类和真实主题的公共对外方法，也是代理类代理真实主题的方法；真实主题：真正实现业务逻辑的类；代理类：用来代理和封装真实主题；Main：客户端，使用代理类和主题接口完成一些工作。Subject类: 定义RealSubject和Proxy的公用接口abstract class Subject
{
public abstract void Request();
}RealSubject类: 定义Proxy所代表的真正实体class RealSubject : Subject
{
public override void Request(){}
}Proxy类:class Proxy : Subject
{
RealSubject real;
public override void Request(){
if(real == NULL) real = new RealSubject();
}
}客户端代码static void Main(string[] args)
{
Proxy proxy = new Proxy(); //代理
proxy.Request();
}7.6 代理模式应用远程代理虚拟代理安全代理7.7 秀才让小六代其求婚第8章 雷锋依然在人间–工厂方法模式8.1 再现活雷锋8.2 简单工厂模式实现class OperationFactory{
public static Operation createOperate(String operate){
Operation oper = NULL;
switch(operate){
case "+":
oper = new OperationAdd();
break;
case "-":
oper = new OperationSub();
break;
case "*":
oper = new OperationMul();
break;
case "/":
oper = new OperationDiv();
break;
}
return oper;
}
}客户端Operation oper;
oper = OperarionFactory.createOperate("+");
oper.NumberA=1;
oper.NumberB=2;
double result = oper.GetResult();8.3 工厂方法模式实现工厂接口interface IFactory{
Operator CreateOperation();
}具体工厂类//加法工厂
Class AddFactory : IFactory{
public Operation CreateOperation{
return new OperationAdd();
}
}
...
//除法工厂
Class DivFactory : IFactory{
public Operation CreateOperation{
return new OperationDiv();
}
}客户端IFactory operFactory = new AddFactory();
Operation oper = operFactory.CreateOperation();
Operation oper;
oper = OperarionFactory.createOperate("+");
oper.NumberA=1;
oper.NumberB=2;
double result = oper.GetResult();8.4 简单工厂vs.工厂方法工厂方法模式: 创建对象的接口，让子类去决定具体实例化的对象，把简单的内部逻辑判断移到了客户端代码。(延迟实例化)只需修改客户端即可: Open-Close Principle8.5 雷锋工厂反射第9章 简历复印–原型模式9.1 夸张的简历9.2 简历代码初步实现传值 vs 传引用clone9.3 原型模式原型类abstract class Prototype{
private string id;
public Prototype(string id) {this.id = id;}
public string Id {
get {return id;}
}
//抽象类的关键
public abstract Prototype Clone();
}`具体原型类class ConcretePrototype : Prototype{
pulic ConcretePrototype(string id) : base(id) {}
public override Prototype Clone(){
//创建当前对象的浅表副本
return (Prototype) this.MemberwiseClone();
}
}客户端MemberWiseClone: 浅clone方法，通过创建一个新对象，并把所有当前对象中非静态域复制到新对象中，从而创建一个浅拷贝。对于值类型的域，进行的是按位拷贝。对于引用类型的域，引用会被赋值而引用的对象则不会。因此，原始对象及其克隆都会引用同一个对象。注意，这种方法对派生类都是有效的，也就是说，你只需在基类中定义一次Clone方法。static void Main(string[] args){
ConcretePrototype p1 = new ConcretePrototype("I");
ConcretePrototype c1.p1.Clone();
...
}Clone 分浅拷贝和深拷贝
两者区别：当有引用类型成员时，浅拷贝复制的是成员的引用，深拷贝复制的是成员对象。ICloneable接口9.4 简历的原型实现简历类class Resume : ICloneable{
public Object Clone(){
return (Object) this.MemberwiseClone();
}
}9.5 浅复制与深复制- MemberwiseClone: 复制时，对于类中的值类型会创建新的变量，而对于引用变量来说，会指向原来的引用并不创建新的引用变量9.6 简历的深复制实现//也实现ICloneable接口
class WorkExperience : ICloneable {
public Object Clone(){
return (Object) this.MemberwiseClone();
}
}简历类class Resume : IClonealbe{
...
private Resume(WorkExprience work){
this.work = (WorkExprience) work.Clone();
}
...
public Object Clone(){
Resume obj = new Resume(this.work);
}
}9.7 复制简历vs.手写求职信第10章 考题抄错会做也白搭–模板方法模式10.1 选择题不会做，蒙呗！10.2 重复=易错+难改继承 -> template 虚方法 virtual10.3 提炼代码10.4 模板方法模式抽象类AbstractClassabstract class AbstractClass{
public abstract void PrimitiveOperation1();
public abstract void PrimitiveOperation2();
public void templateMethod(){
PrimitiveOperation1();
PrimitiveOperation1();
Console.WriteLine("");
}
}ConcreteClassclass ConcreteClassA : AbstractClass{
public override void PrimitiveOperation1(){
Console.WriteLine("具体A类方法 1 实现");
}
public abstract void PrimitiveOperation2(){
Console.WriteLine("具体A类方法 2 实现");
}
}10.5 模板方法模式特点10.6 主观题，看你怎么蒙对比C#模板C#设计模式总结第11章 无熟人难办事？–迪米特法则11.1 第一天上班11.2 无熟人难办事方法: 通过引入一个合理的第三者来降低现有对象之间的耦合度11.3 迪米特法则
迪米特法则（Law of Demeter）: 又叫作最少知识原则（Least Knowledge Principle, LKP），就是说一个对象应当对其他对象有尽可能少的了解,不和陌生人说话。英文简写为: LoD. talk only to your immediate friends
设计模式的门面模式（Facade）和中介模式（Mediator），都是迪米特法则应用的例子第12章 牛市股票还会亏钱？–外观模式12.1 牛市股票还会亏钱？12.2 股民炒股代码12.3 投资基金代码12.4 外观模式12.5 何时使用外观模式分层设计 业务层与数据访问层解耦合增加 Facade 以提供一个简单接口
Facade相当于增加一个接口层，向client提供简洁API接口，同时屏蔽低层复杂的遗留代码
第13章 好菜每回味不同–建造者模式13.1 炒面没放盐essence 抽象流程不变流程中各组件的具体实现细节则是经常变化example建筑流程是确定，往往建筑一座楼房包括下面步骤：（1）打桩，建立基础（2）建立框架等。建造者模式的本质和建造楼房是一致的：即流程不变，但每个流程实现的具体细节则是经常变化。建造者模式的好处就是保证流程不会变化，流程即不会增加、也不会遗漏或者产生流程次序错误，这是非常重要的。 check list 实现么？13.2 建造小人一复杂对象的组装与创建——建造者模式13.3 建造小人二13.4 建造者模式13.5 建造者模式解析Director: 控制流程Builder: 抽象服务ConcreteBuilder: 具体服务Product: 产品13.6 建造者模式基本代码Product: 产品类，由多个部件组成class Product {
IList<string> parts = new IList<string>();
//添加产品部件
public void Add(string part) {
parts.Add(part);
}
}Builder: 抽象建造者类，确定产品组成： PartA与PartB，并返回结果。abstract class Builder{
public abstract void BuilderPartA();
public abstract void BuilderPartB();
public abstract Product GetResult();
}注意: Builder只生产，不规定流程次序；而Dirctor强调规定流程次序ConcreteBuilder: 注意: ConcreteBuilder与Product为关联关系class ConcreteBuilder1 : Builder {
private Product product = new Product();
public override void BuildPartA() {}
...
}Director: 指挥者类，规定流程次序！class Director{
public void Construct(Builder builder) {
//生产次序，important
builder.BuildPartA();
builder.BuildPartB();
}
}客户端static void Main(string[] args){
Director director = new Director();
Builder b1 = new ConcreteBuilder1();
director.Constructor(b1);
Product p1 = b1.GetResult();
...
}第14章 老板回来，我不知道–观察者模式14.1 老板回来？我不知道！14.2 双向耦合的代码观察者模式前台秘书类class Secretary
{
//同事列表
private IList<Investor> investors = new List<Investor>;
//添加成员
public void Attach(Investor invest) { investors.Add(invest); }
//发送通知
public void Notify()
{ foreach( Investor i in investors ) i.Update(); }
//前台状态
public string SecretaryAction {
get { return action; }
set { action = value; }
}
}看股票同事类class Investor {
private string name;
private Secretary sub;
public Investor(string name, Secretary sub){...}
public Update() {}
}客户端代码static void Main(string[] args){
Secretary mm = new Secretary(); //前台小姐mm
//看股票的同事
Investor one = new Investor("One",mm);
Investor two = new Investor("Two",mm);
//前台记录下两个待通知的同事
mm.Attach(one);
mm.Attach(two);
mm.Notify(); //通知同事
}14.3 解耦实践一增加抽象的观察者abstract class Observer {
protected string name;
protected Secretary sub;
public Observer(string name, Secretary sub) {}
}增加两个具体观察者//看股票
class StockObserver : Observer {
public StockObserver(string name, Secretary sub) : base(name,sub) {}
public override void Update() {}
}
//看NBA
class NBAObserver : Observer {
public NBAObserver(string name, Secretary sub) : base(name,sub) {}
public override void Update() {}
}前台秘书类class Secretary {
//同事列表
private IList<Observer> observers = new List<Observer>();
private string action;
//增加 -> 针对抽象接口编程
public void Attach(Observer observer) { observer.Add(observer); }
//减少
public void Detach(Observer observer) { observer.Remove(observer); }
//通知
public void Notify() {
foreach(Observer o in observers)
o.Update();
}
//前台状态
public string SecretaryAction {
get { return action; }
set { action = value; }
}
}14.4 解耦实践二增加抽象通知者接口interface Subject {
void Attach(Observer observer);
void Detach(Observer observer);
void Notify();
string SubjectState {
get;
set;
}
}具体通知者: 老板(boss) 或秘书class Boss : Subject {
//同事列表
private IList<Observer> observers = new List<Observer>();
private string action;
...
}抽象观察者abstract class Observer {
protected string name;
protected Subject sub;
//原来“前台” -> 现改为"抽象通知者"
public Observer(string name, Subject sub) {...}
}客户端代码//老板
Boss dog = new Boss();
//看股票的同事
StockObserver one = new StockObserver("one",dog);
//看NBA的同事
StockObserver two = new StockObserver("two",dog);
dog.Attach(one);
dog.Attach(two);
dog.Detach(one);
dog.SubjectState = "Boss来了";
dog.Notify();
//发送通知结构图 14.5 观察者模式abstract class Subject {
private IList<Observer> observers = new List<Observer>();
//增加观察者
public void Attach(Observer observer) { observers.Add(observer); }
//移除观察者
public void Detach(Observer observer) { observers.Remove(observer); }
//通知
public void Notify(){
foreach(Observer o in observers) { o.Update(); }
}
}Observer类: 抽象观察者abstract class Observer{
public abstract void Update();
}ConcreteSubject类: 具体通知者class ConcreteSubject : Subject {
private string subjectState; //状态
public string SubjectState {
get { return subjectState; }
set { subjectState = value; }
}
}ConcreteObserver类: 具体观察者客户端代码14.6 观察者模式特点维护对象之间的一致性观察者模式：在对象之间定义一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象都会收到通知，并自动更新。 java回调机制 vs. 观察者模式: I thinkL java回调机制近似于观察者模式一个特例(一对一)14.7 观察者模式的不足14.8 事件委托实现14.9 事件委托说明14.10 石守吉失手机后的委托第15章 就不能不换DB吗？–抽象工厂模式15.1 就不能不换DB吗？数据库选型 e.g., SQL Server, Acess15.2 最基本的数据访问程序class User{
private int _id;
public int ID {
get {return _id; }
set { _id = value; }
}
private string _name;
public string Name{
get { return _name; }
set { _name = value; }
}
}SQL class SqlserverUser{
public void insert(User user) {
Console.WriteLine("SQL Server insert a record");
}
}15.3 用了工厂方法模式的数据访问程序IUser 接口interface IUser{
void Insert(User user);
User GetUser(int id);
}SqlserverUser类：访问SQL Server的Userclass SqlserverUser : IUser{
public void Insert(User user){
Console.WriteLine("insert a record into SQL Server Database");
}
public User GetUser(int id){
Console.WriteLine("get User's a record from SQL Server according to ID");
return null;
}
}AccessUser类: 用于访问Acess的Userclass AccessUser : IUser{
public void Insert(User user){
Console.WriteLine("insert a record into Access Database");
}
public User GetUser(int id){
Console.WriteLine("get User's a record from Access according to ID");
return null;
}
}IFactory接口: 定义访问User的抽象工厂接口interface IFactory{
IUser CreateUser();
}SqlServerFactory类: 实现IFactory接口class SqlServerFactory{
public IUser CreateUser(){
return new SqlserverUser();
}
}AccessFactory类: 实现IFactory接口class AccessFactory{
public IUser CreateUser(){
return new AccessUser();
}
}客户端static void Main(string args){
User user = new User();
IFactory factory = new SqlServerFactory();
IUser iu = factory.CreateUser();
iu.Insert(user);
iu.GetUser(1);
Console.Read();
}15.4 用了抽象工厂模式的数据访问程序增加了部门表Department的处理interface IDepaerment{
void insert(Department department);
Department GetDepartment(int i);
}SqlserverDepartment类: 用于访问SQL Server的Departmentclass SqlserverDepartment : IDepartment{
...
}修改IFactory类，增加了访问Department表的抽象工厂接口interface IFactory{
IUser CreateUser();
IDepartment CreateDepartment(); //增加新接口
}
SqlServerFactory类: 实现IFactory接口class SqlServerFactory : IFactory{
public IUser CreateUser(){
return new SqlserverUser();
}
public IDepartment CreateDepartment() {
return new SqlserverDepartment();
}
}客户端static void Main(string[] args)
{
User user = new User();
Department dept = new Department();
//AbstractFactory factory = new SqlServerFactory();
IFactory factory = new AccessFactory();
IUser iu = factory.CreateUser();
iu.Insert(user);
iu.GetUser(1);
IDepartment id = factory.CreateDepartment();
id.Insert(dept);
id.GetDepartment(1);
Console.Read();
}15.5 抽象工厂模式抽象工厂: 可理解为 抽象工厂生产抽象产品 具体工厂生产具体产品15.6 抽象工厂模式的优点与缺点15.7 用简单工厂来改进抽象工厂class DataAccess
{
private static readonly string db = "Sqlserver";
//private static readonly string db = "Access";
public static IUser CreateUser()
{
IUser result = null;
switch (db)
{
case "Sqlserver":
result = new SqlserverUser();
break;
case "Access":
result = new AccessUser();
break;
}
return result;
}
public static IDepartment CreateDepartment()
{
IDepartment result = null;
switch (db)
{
case "Sqlserver":
result = new SqlserverDepartment();
break;
case "Access":
result = new AccessDepartment();
break;
}
return result;
}
}客户端static void Main(string[] args)
{
User user = new User();
Department dept = new Department();
IUser iu = DataAccess.CreateUser();
iu.Insert(user);
iu.GetUser(1);
IDepartment id = DataAccess.CreateDepartment();
id.Insert(dept);
id.GetDepartment(1);
Console.Read();
}15.8 用反射+抽象工厂的数据访问程序依赖注入(Dependency Injection) IoCC# 反射技术: Assembly.Load(AssemblyName).CreateInstance(className);using System.Reflection;
class DataAccess
{
private static readonly string AssemblyName = "抽象工厂模式";
private static readonly string db = "Sqlserver";
//private static readonly string db = "Access";
public static IUser CreateUser()
{
string className = AssemblyName + "." + db + "User";
return (IUser)Assembly.Load(AssemblyName).CreateInstance(className);
}
public static IDepartment CreateDepartment()
{
string className = AssemblyName + "." + db + "Department";
return (IDepartment)Assembly.Load(AssemblyName).CreateInstance(className);
}
}new issue: 更换数据库访问时，还需改变db15.9 用反射+配置文件实现数据访问程序solution: 添加app.config 通过配置文件来解决<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="DB" value="Sqlserver"/>
</appSettings>
</configuration>C#读取配置文件private static readonly string db = ConfigurationManager.AppSettings["DB"];15.10 无痴迷，不成功Application: 反射 应用于 WCF，比如 app.config第16章 无尽加班何时休–状态模式16.1 加班，又是加班！16.2 工作状态-函数版面向对象 程序 -> 类 + 方法 面向过程16.3 工作状态-分类版16.4 方法过长是坏味道Martin Flow: Long Method -> 坏味道过多判断，过多分支 -> 责任分解不到位16.5 状态模式State类: 抽象状态类abstract class State {
public abstract void Handle(Context context);
}ConcreteState类: 具体状态，每一子类实现与一个Context的状态相关行为class ConcreteStateA : State {
public override void Handle(Context context) {
//下一状态为ConcretexStateB
//自动机状态 -> 变迁
context.State = new ConcretexStateB();
}
}
class ConcreteStateB : State {
public override void Handle(Context context) {
//下一状态为ConcretexStateA
//自动机状态 -> 变迁
context.State = new ConcretexStateA();
}
}Context类: 维护一个ConcreteState子类的实例，该实例定义当前状态class Context {
private State state;
public Context(State state) {this.state = state;}
public State State {
get {return state;}
set {
state = value;
...
}
}
public void Request() {state.Handle(this);}
}16.6 状态模式好处与用处16.7 工作状态-状态模式版注意 uml图中虚线箭头的含义，对照代码//工作
public class Work {
private State state;
...
public void WriteProgram() {current.WriteProgram(this);}
}第17章 在NBA我需要翻译–适配器模式17.1 在NBA我需要翻译！Adapter17.2 适配器模式类适配器 通过多重继承，实现接口间匹配C#,Java不支持多重继承，仅C++支持对象适配器Target: 客户端适配接口class Target {
public virtual void Request() {}
}Adaptee: 待适配类class Adaptee {
public virtual void SpecificRequest() {}
}Adapter: 实际适配类，内部包装一个Adaptee对象，实现接口转换class Adapter : Target {
//包装
private Adaptee adaptee = new Adaptee();
public virtual void Request() {
adaptee.SpecificRequest(); //转换
}
}客户端代码static void Main(string[] args){
Target target = new Adapter();
target.Request();
}17.3 何时使用适配器模式17.4 篮球翻译适配器
我认为本节示例有不合理成分，比如外籍中锋为中锋的子类，又比如有外籍后卫呢？
我认为应该改为下图所示: 即 + 组合模式(第19章) 17.5 适配器模式的.NET应用.NET: DataAdapter17.6 扁鹊的医术第18章 如果再回到从前–备忘录模式18.1 如果再给我一次机会……18.2 游戏存进度18.3 备忘录模式Originator: 负责创建备忘录，以记录其内部当前时刻状态Memento: 备忘录，负责存储Originator对象内部状态Caretaker: 负责保存好备忘录18.4 备忘录模式基本代码发起者(Originator)class Originator {
private string state;
public string State {
get {return state;}
set {state = value;}
}
public Memento CreateMemeto() {
return Memetor(state);
}
public void SetMemento(Memento memento){
state = memento.State;
}
public void Show(){
Console.WriteLine("State=" + state);
}
}备忘录(Memento)类class Memento {
private string state;
public Memento(string state) {this.state = state;}
public string State {
get {return state;}
}
}管理者(Caretaker): class Caretaker {
private Memento memento;
public Memento Memento {
get {return memento;}
set {memento = value;}
}
}18.5 游戏进度备忘JAVA与模式 博文
博文写得很好，还有时序图，比书上介绍的更清楚！ 本书作者 程杰 示意图 没有引入 Client行为时序图，很难表现 Design pattern使用方式！
第19章 分公司=一部门–组合模式19.1 分公司不就是一部门吗？树结构 -> 层次化整体 vs 部分19.2 组合模式Component: 组合中对象声明接口abstract class Component {
protected string name;
public Component(string name) {this.name = name;}
public abstract void Add(Component c);
public abstract void Remove(Component c);
public abstract void Display(Component c);
}Leaf: 表示组合中叶节点 -> 无子节点class Leaf : Component {
pulic Leaf(string name) : base(name) {}
...
}Composite: 表示枝节点，有子节点class Composite : Component {
//保存下属的枝/叶节点
private List<Component> children = new List<Component>();
}19.3 透明方式与安全方式19.4 何时使用组合模式ASP.net: TreeView控件19.5 公司管理系统19.6 组合模式好处第20章 想走？可以！先买票–迭代器模式20.1 乘车买票，不管你是谁！20.2 迭代器模式Iterator -> 遍历20.3 迭代器实现Iterator迭代器抽象类abstract class Iterator {
public abstract object First();
public abstract object Next();
public abstract bool IsDone();
public abstract object CurrentItem();
}Aggregate聚焦抽象类abstract class aggregate {
public abstract Iterator createIterator(); //创建迭代器
}ConcreteIterator: 具体迭代器类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(){
return current >= aggregate.Count? true : false;
}
public override object CurrentItem(){
return aggregate[current];
}
}ConcreteAggregate: 具体聚集类class Concreteaggregate : Aggregate {
private IList<object> items = new List<Object>();
public override Iterator(this){
return Concreteaggregate(this);
}
public int Count { //聚焦总数
get {return items.Count;}
}
public object this[int index] {
get {return items[index];}
set {items.Insert(index,value);}
}
}客户端代码20.4 .NET的迭代器实现实现foreach必须要实现IEnumerable和IEnumerator接口IEumerator: 支持对非泛型集合的简单迭代public interface IEumerator {
object Current {get;}
bool MoveNext();
void Reset();
}IEnumerable: 该枚举数支持在非泛型集合上进行简单的迭代IEnumerable的用法public interface IEnumerable{
IEumerator GetEnumerator();
}foreach in实际通过IEnumerable和IEumerator接口实现的20.5 迭代高手第21章 有些类也需计划生育–单例模式21.1 类也需要计划生育21.2 判断对象是否是null实例化21.3 生还是不生是自己的责任GetInstance()public partial class FormToolBox : Form
{
private static FormToolBox ftb = null;//Static var
//构造函数私有化，外部代码不能直接new来实例化
private FormToolBox(){
InitializeComponent();
}
public static FormToolBox GetInstance(){
if(ftb == null
ftb.IsDisposed){
ftb = new FormToolBox();
ftb.MdiParent = Form.
}
}
}form==null: 是把该窗体对象设置为空，但该form仍存在内存里21.4 单例模式Singleton类class Singleton
{
private static Singleton inst;
private Singleton(){}
public static Singleton GetInstance()
{
if(inst == null)
inst = new Singleton();
return inst;
}
}客户端代码static Main(string[] args)
{
Singleton s1 = Singleton.GetInstance();
Singleton s2 = Singleton.GetInstance();
if(s1 == s2)
Console.WriteLine("s1's address is as same as s2");
Console.Read();
}21.5 多线程时的单例多线程并发 -> lock()21.6 双重锁定if(instance == null){
　　lock(obj){
　　　　if(instance == null){instance = new Object();}
　　}
}第一个判断null: 为了尽量减少进入锁的线程数；第二个判断null: 防止重复实例化21.7 静态初始化public sealed class Singleton
{
private static readonly Singleton inst = new Singleton();
private Singleton(){}
public static Singleton GetInstance()
{ return inst; }
}sealed ?readonly ?第22章 手机软件何时统一–桥接模式22.1 凭什么你的游戏我不能玩22.2 紧耦合的程序演化22.3 合成/聚合复用原则
DP: 尽量用合成/聚合，尽量不用类继承
CompositionAggregation手机软件抽象类abstract class HandSoft {
public abstract void Run();
}游戏、通讯录具体类class HandsetGame : HandsetSoft {}
class HandsetAddrList : HandsetSoft {}手机品牌类abstract class HandsetBrand {
protected HandsetSoft soft;
//设置手机软件
public void SetHandsetSoft(HandsetSoft soft) {this.soft = soft;}
}手机品牌具体类22.4 松耦合的程序22.5 桥接模式按照品牌分类实现结构图- 按照软件分类实现结构图 - 桥接22.6 桥接模式基本代码Implementor类abstract class Implementor {
public abstract void Operation();`
}派生类class ConcreteImplementorA : Implementor { ... }Abstraction类class Abstraction {
protected Implementor imp;
}RefinedAbstract类客户端对比组合模式(第19章)22.7 我要开发”好”游戏第23章 烤羊肉串引来的思考–命令模式23.1 吃烤羊肉串！23.2 烧烤摊vs.烧烤店行为请求者与行为实现者 -> 紧耦合23.3 紧耦合设计关联23.4 松耦合设计抽象命令类public abstract class Command{
protected Barbecuer receiver;
public Command(Barbecuer recv){
receiver = recv;
}
//执行命令
abstract public void ExecuteCom();
}具体命令类//烤羊肉串
public class BakeMuttonCom : Command{
public BakeMuttonCom(Barbecuer recv) : base(recv)
{
receiver = recv;
}
public override void ExecuteCom()
{
receiver.BakeMutton(); //具体执行行为
}
}
//烤鸡翅命令
public class BakeChickenCom : Command{
public BakeChickenCom(Barbecuer recv) : base(recv)
{
receiver = recv;
}
public override void ExecuteCom()
{
receiver.BakeChicken(); //具体执行行为
}
}
服务员类public class Waiter{
private Command com;
//设置订单
public void SetOrder(Command com) {this.com = com;}
//通知执行
public void Notify(){
com.ExecuteCom();
}
}客户端23.5 松耦合后23.6 命令模式Command: 执行操作的接口abstract class Command{
protected Receiver receiver;
public Command(Receiver recv) {receiver = recv;}
abstract public void Execute();
}ConcreteCommand: class ConcreteCommand : Command{
public ConcreteCommand(Receiver recv) : base(recv){}
public void Execute() {receiver.Action();}
}Invoker:class Invoker{
private Command command;
public void SetCommand(Command com) {command = com;}
public void ExecuteCommand(){
command.Execute();
}
}Receiver:class Receiver{
public void Action() {}
}客户端static void Main(string[] args){
Receiver r = new Receiver();
Command c = new Command(r);
//r为关联类
Invoker i = new Invoker();
i.SetCommand();
i.ExecuteCommand();
}23.7 命令模式作用第24章 加薪非要老总批？–职责链模式24.1 老板，我要加薪！24.2 加薪代码初步24.3 职责链模式Chain of ResponsibilityHandler类：定义一个处理请求的接口abstract class Handler {
protected Handler successor;
//设定继任者
public void SetSuccessor(Handler suc) {this.successor = suc;}
}ConcreteHandler1: 当请求数在0-10之间有权处理，否则转到下一层级处理class ConcreteHandler1 : Handler{
public override void HandleRequest(int req) {
if(req >= 0 && req < 10) {
...
}else if(successor != NULL) {
successor.HandleRequest(req);
}
}
}ConcreteHandler2: 当请求数在10-20之间有权处理，否则转到下一层级处理class ConcreteHandler2 : Handler{
public override void HandleRequest(int req) {
if(req >= 10 && req < 20) {
...
}else if(successor != NULL) {
successor.HandleRequest(req);
}
}
}ConcreteHandler3: 当请求数在20-30之间有权处理，否则转到下一层级处理class ConcreteHandler3 : Handler{
public override void HandleRequest(int req) {
if(req >= 20 && req < 30) {
...
}else if(successor != NULL) {
successor.HandleRequest(req);
}
}
}客户端static void Main(string[] args){
Handler h1 = new ConcreteHandler1();
Handler h2 = new ConcreteHandler2();
Handler h3 = new ConcreteHandler3();
//设置责任链上/下家
h1.SetSuccessor(h2);
h2.SetSuccessor(h3);
int[] reqs = [2,5,14,22];
foreach(int req in reqs) {h1.HandleRequest(req);}
}24.4 职责链的好处对比数据流24.5 加薪代码重构注意: 管理者自包含关系24.6 加薪成功第25章 世界需要和平–中介者模式25.1 世界需要和平！25.2 中介者模式Mediator:abstract class Mediator {
public abstract void Send(string msg, Colleague colleague);
}Colleague:abstract class Colleague {
protected Mediator mediator;
//获取中介者对象
public Colleague(Mediator mediator) {this.mediator = mediator;}
}ConcreteMediator:class ConcreteMediator : Mediator {
private ConcreteColleague1 c1;
private ConcreteColleague2 c2;
}?25.3 安理会做中介25.4 中介者模式优缺点第26章 项目多也别傻做–享元模式26.1 项目多也别傻做！26.2 享元模式享元模式 vs 工厂模式?Flyweight: 享元类的接口和抽象类abstract class Flyweight{
public abstract void Operate(int extraState);
}ConcreteFlyweight:abstract class ConcreteFlyweight : Flyweight{
public override void Operate(int extraState) {}
}UnsharedConcreteFlyweight: abstract class UnsharedConcreteFlyweight : Flyweight{
public override void Operate(int extraState) {}
}FlyweightFactory: 享元工厂class FlyweightFactory{
private Hashtable flyweights = new Hashtable();
public FlyweightFactory(){
flyweights.Add("X", new ConcreteFlyweight());
flyweights.Add("Y", new ConcreteFlyweight());
flyweights.Add("Z", new ConcreteFlyweight());
}
public Flyweight GetFlyweight(string key){
//根据客户要求，返回已生成的实例
return ((Flyweight) flyweights[key]);
}
}客户端static void Main(string[] args){
int etraState = 22;
FlyweightFactory f = new FlyweightFactory();
Flyweight fx = f.GetFlyweight("X");
...
}26.3 网站共享代码
个人觉得: 作者没有指出享元模式的核心设计思想？
26.4 内部状态与外部状态26.5 享元模式应用第27章 其实你不懂老板的心–解释器模式27.1 其实你不懂老板的心27.2 解释器模式正则表达式AbstractExpression: 抽象表达式，该接口为抽象语法树中所有节点共享abstract class AbstractExpression {
public abstract void Interpret(Context context);
}TerminalExpression: 终结符表达式class TerminalExpression : AbstractExpression {
public override void Interpret(Context context) {...}
}NoterminalExpression: 非终结符表达式class NonterminalExpression : AbstractExpression {
public override void Interpret(Context context) {...}
}Context: 上下文class Context{
private string input;
public string Input {
get {return input;}
set {input = value;}
}
...
}客户端:static void Main(string[] args){
Context context = new Context();
IList<AbstractExpression> list = new List<AbstractExpression>();
list.Add(new TerminalExpression());
...
foreach(AbstractExpression exp in list) {exp.Interpret(context);}
}27.3 解释器模式好处解释器模式 -> 抽象语法树DSL (domain Specific Language)解释器模式缺点编译器生成器27.4 音乐解释器27.5 音乐解释器实现演奏内容类 context:class PlayContent{
//演奏文本
private string text;
public string PlayText {
get {return text;}
set {text=value;}
}
}表达式类 AbstractExpression:abstract class Expression{
//解释器
public void Interpret(PlayContent content) {
...
}
//执行
public abstract void Excute(string key, double value);
}音符类 TerminalExpression:class Note : Expression {
public override void Excute(string key, double value) {...}
}音阶类 TerminalExpression:class Scale : Expression {
public override void Excute(string key, double value) {...}
}客户端switch -> 简单工厂 + 反射？27.6 料事如神Programming for Musicians and Digital Artists: Creating music with ChucK: 王戈第28章 男人和女人–访问者模式28.1 男人和女人！28.2 最简单的编程实现28.3 简单的面向对象实现28.4 用了模式的实现抽象类abstract class Action{
//得到男人结论或反应
public abstract void GetManConclusion(Man concreteElementA);
//得到女人结论或反应
public abstract void GetWomanConclusion(Man concreteElementB);
}
//人
abstract class Person
{
}具体类//男人
class Man : Person
{
public override void Accept(Action visitor)
{
visitor.GetManConclusion(this);
}
}
//女人
class Woman : Person
{
public override void Accept(Action visitor)
{
visitor.GetWomanConclusion(this);
}
}双分派//对象结构
class ObjectStructure
{
private IList<Person> elements = new List<Person>();
//增加
public void Attach(Person element)
{
elements.Add(element);
}
//移除
public void Detach(Person element)
{
elements.Remove(element);
}
//遍历查看显示
public void Display(Action visitor)
{
foreach (Person e in elements){
e.Accept(visitor);
}
}
}客户端static void Main(string[] args)
{
ObjectStructure o = new ObjectStructure();
o.Attach(new Man());
o.Attach(new Woman());
Success v1 = new Success();
o.Display(v1); //遍历Man和Woman的不同反应
Failing v2 = new Failing();
o.Display(v2);
Amativeness v3 = new Amativeness();
o.Display(v3);
Marriage v4 = new Marriage();
o.Display(v4);
Console.Read();
}28.5 访问者模式28.6 访问者模式基本代码visitor类abstract class Visitor
{
public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);
public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
}具体访问类class ConcreteVisitor1 : Visitor
{
public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
{
Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
}
public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
{
Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
}
}Element类: 定义一个accept操作，以访问者为参数abstract class Element
{
public abstract void Accept(Visitor visitor);
}ConcreteElementAclass ConcreteElementA : Element
{
public override void Accept(Visitor visitor)
{
visitor.VisitConcreteElementA(this);
}
public void OperationA()
{ }
}objectStructure类: 遍历class ObjectStructure
{
private IList<Element> elements = new List<Element>();
public void Attach(Element element)
{
elements.Add(element);
}
public void Detach(Element element)
{
elements.Remove(element);
}
public void Accept(Visitor visitor)
{
foreach (Element e in elements)
{
e.Accept(visitor);
}
}
}28.7 比上不足，比下有余Application: 编译器中AST生成？第29章 OOTV杯超级模式大赛–模式总结29.1 演讲任务29.2 报名参赛29.3 超模大赛开幕式29.4 创建型模式比赛29.5 结构型模式比赛29.6 行为型模式一组比赛29.7 行为型模式二组比赛29.8 决赛29.9 梦醒时分29.10 没有结束的结尾附 录 A 培训实习生–面向对象基础A.1 培训实习生A.2 类与实例object = attributes + operationsA.3 构造方法initializeA.4 方法重载A.5 属性与修饰符attribute getsetA.6 封装A.7 继承is-a关键字baseA.8 多态overridevirtualA.9 重构A.10 抽象类abstractA.11 接口A.12 集合A.13 泛型A.14 委托与事件? - delegate - eventA.15 客套附 录 B 参考文献

考研英语二大作文和小作文看这一篇就够啦~（小作文方法已更新）先一句话回答问题：作文千万不要全靠背诵范文备考，还是要总结自己的模板框架！个人介绍学姐大学本科就读于一个普通二本学校，学历史专业。英语算中游水平，四六级成绩虽然都是一次通过，但都是卡线通过。考研跨考新闻传播，比较坎坷，二战才上岸。一战时候，因为在英语作文上栽了大跟头，所以二战调整了方法，打了个翻身仗，最后英语拿到了85分，对了一下答案，客观题完型错两个，扣1分，阅读理解错一个，扣2分，新题型错两个，扣4分，一共扣7分。剩下主观题翻译加写作一共得32分。 因为在作文复习上“积累”了比较多的经验，所以来回答一下这个问题。文章的目录如下：一战：走入误区，惨败收场 学姐一战备考作文时候，现在回头想想真的是付出的精力时间太少了。我一直以为，作文这个东西需要有足够的输入，才能写出高分作文，所谓滴水石穿非一日之功。
以前上中学时候，语文最头疼的就是写作文，常常是思考了很久，搜肠刮肚，大脑还是一片空白，还是迟迟下不了笔，没有思路，不知道怎么构思、怎么表达。所以，作文全靠东拼西凑。中文作文烂，英文又怎么写得好，毕竟我们写英语作文都是先用中文来构思打草稿，然后翻译成英文写下来。于是，英语理所当然地成了我另一个老大难。
考研英语，作文是一个绕不过去的坎儿。而我十分清楚大学这几年是怎么虚度过来的，英语几乎已经武功全废，基本上退化到高中水平，甚至连高中都不如。起码高中那几年英语每天都在学习都在刷题，有不会的地方还可以问老师。大学之后，认真学习英语的天数两只手可以数过来，就是考前突击的那些天。所以，我认定作文短期内不可能有大的提升，就把大部分时间精力花在了研究客观题上，我的策略是通过客观题争取拿高分，作文全靠一个字：背。
所以，当时作文备考走上了一条背诵范文的不归路。加上当时班里请了一个上一届考研通过的学姐来给我们做考研经验分享，她自己就是靠背诵范文、拿历年真题作文练笔的方法拿到83分高分的。于是，更加坚定了我一背到底的决心。现在回头想想，只想送给自己俩字：愚蠢至极。我没有考虑到的是，学姐拿到高分是因为人家本来就是学霸，英语基础高出人均一大截儿，所以，人家背背范文完全可行，甚至不背范文也能凭自身写出漂亮的作文来。而我并没有认清自己底子薄的现实，就敢照搬照抄学姐的经验，无异于自我毁灭。
于是我开始了背背背的疯狂模式。黄皮书上的历年范文背了十篇，觉得用词用句都好高大上。还认真抄录了一遍，就当练字了。然后，买了一本王江涛的写作范文100篇，背了20篇范文。当时非常认可道长的理念：多读多写多背。觉得这是一个很朴实的方法，毕竟十几年英语就是一路背过来的，成了背诵派的忠实信徒。
结果真的非常惨痛，英语一战考了60分。对了对答案，最有信心的客观题也没高到哪儿去。最后算了算，作文差不多13分左右。
失利之后，抑郁了一段时间。后来，认真分析了一下自己的备考方法，我想知道到底问题出在什么地方。最有信心的客观题并没有拿到一个理想的成绩，作文更是不堪。我意识到我的备考策略是有很大漏洞的，我走的是“以客观题保命”的路线，轻视了作文这个主观题。
期间，我也在网上看到一个学长的经验分享贴，也是点醒了我。他说，作文的提分性价比是最高的，很多人认为作文是主观题，短期努力难以见效，误以为它的提分空间不大，其实不然，应试类的考试，英语写作都是有套路的。真是一语点醒梦中人。完全说的就是我。还好我是那种愈挫愈勇的人，海明威说，“一个人可以被消灭，但不能被打败。”（《老人与海》）引用个名人名言添添文采，捂脸遁。
二战：在哪里跌倒，就从哪里爬起来 二战备考，我彻底纠正了自己的备考方法，从之前“重客观，轻主观”这种错误的理念，转变成“主客观并重”这种两手抓两手都要硬的理念。事实证明，这个决定是无比英明的。
这次复习我从九月底就开始准备作文，留出充裕的时间备战。首先，我吸取了一战时一意孤行一背到底的教训，全面地搜集、了解当下最主流的作文备考方法。我发现市面上的作文主流备考方法主要可以分成两大派：背诵派和模板派。
背诵派主张：顾名思义，背诵教就是主张作文背背背，典型做法是背诵范文。信仰“熟读唐诗三百首，不会作诗也会吟”。
优点：长期来看，背诵的确能提升英语写作能力。因为背诵可以培养语感，又可以熟悉单词和语法。范文背得熟练了，朗朗上口了，慢慢会写并不在话下。
缺点：拼命强调输入的重要性，对如何输出却含含糊糊，只告诉你“下笔如有神、无招胜有招”，到底背多少范文才能自己写出高分作文，没有人知道。完全不考虑时间对考研学生的重要性，根本不在意我们的痛苦。如果再遇见谁跟你推荐背范文，我建议你使用反弹大法。
2. 模板派主张：写作文套模板就行，考前背几个模板，到了考场再根据不同题目临场发挥。
优点：现在的确，网上各种现成模板真是随处可见、遍地开花，搜集也比较容易。看上去可以节省不少时间。缺点：网上但凡是能搜到的模板都是公开的资料，根本无法估计有多少人用过，拿来就用总觉得心里七上八下，担心被被阅卷老师判成雷同模板。再者，这些模板适不适合考题心里也没底，万一栽了真是欲哭无泪。所以拣现成模板用非常不靠谱。
小结 这两个派别其实是走了两个极端，一个非常复杂，复杂到完全靠能力，一个非常简单，简单到完全赌运气。所以最好的方法是融合两者的优点，又同时避开它们的缺点——打磨自己的模板+背诵模板用得上的表达。
资料测评 初步定下方法，我在网上搜了一下学长学姐们推荐的考研作文书，把推荐指数比较高的基本都买了回来。买回来发现，这些书有一个共同点，都是先理论后范文的成书模式，范文质量的水平我认为难分伯仲。所以，剩下的主要就是学习提炼这些老师的方法精髓，然后采众家之长，形成自己的写作方法。私以为，任何一个成功背后都是从模仿到创新的过程，既然从零开始，就要先去模仿学习大佬大神们的成功方法，移植到自己身上后，如果有排异反应，再去不断调整适应，最后变成血液里自己的东西。
我主要买了五本作文书。下面一一分析一下它们的优劣之处。
五本合影王江涛《王江涛考研英语二满分写作》道长的这本书理论部分和英语一那本《考研英语高分写作》几乎一脉相承，毕竟是同一个道长，同一种思想，还是那个熟悉的配方：万文皆可背！
核心观点： 道长认为，考研写作不外乎六字真经：背诵、默写、仿写。 一背：想提高英文就是要多读、多背、多写。背诵标准要做到：滚瓜烂熟、脱口而出、多多益善。只要把20篇范文背到烂熟于心，上了考场就可以灵活运用。 二默：不仅要背，背完要默写，默写完了再比对范文发现拼写、语法等错误。 三仿：用刚背过的范文中的好词好句去套另一篇主题相近的作文题目。
利弊分析： 不可否认，背诵确实有利于提高英语水平，谁的英语学习不是一路背过来的呢。我无比坚信，只要坚持背诵，长此以往，英语肯定会有提升。 问题在于考研的备考时间实在有限，大部分人的作文都在最后冲刺阶段才开始准备，最多两个月时间，而背诵是极其需要时间精力的一件事情，效率太低了。投入产出不成正比。 我个人的惨痛经历也证明，背得再熟，考场一下打回原形，背得过但是真的用不上。不要妄想考场上文思泉涌、妙笔生花了，能用对高中的就不错了，现实很残酷的。
2. 黄培辰《考研英语二写作高分攻略》黄老师也是新东方的，但是以前没有听说过。因为英语二作文书的选择实在不多，也是抱着试试看的态度买回来。
核心观点： 黄老师和道长不谋而合，也提出背诵和默写是最有效的提分途径。认为作文分不高，一是因为背得多练得少，二是因为无效背诵多。提倡背诵时要学会归纳总结，而不是死记硬背。
利弊分析： 背诵的优劣我上面分析过了。主要总结一下黄老师关于图表作文方法论的核心：用三种思维破解三个段落。认为图表作文按传统三段式展开：图表描述段、图表看法段和可有可无的一段。 图表描述段：根据历年考题，图表可分为两类，可计算的图表（线状图和柱形图）和不可计算的图表（饼状图和表格）。在描述图表时必须具备三个要素：主题词、数据推算、趋势对比和结论。并用这三元素作描述段的框架展开。 图表看法段：图表和图画只是考查形式不一样，但是题材上有共通之处，黄老师分成了8类话题，每一类给出破解思路。这些话题本质上都和人的行为、思想和对世界的认知有关，所以可以坚持“以人为本”的角度来写看法的延伸句。每个话题总结一些论述词汇和角度，形成话题思维。 可有可无的一段：第三段可以不写，如果要写，可以从三点展开：1. 对第二段进行归纳总结。2. 评估图表的走向趋势。3. 给出建议或措施。
但是问题是，虽然提出了8个话题的中文破解思路，但需要自己梳理总结8种话题的词汇表达，这对基础薄弱的同学真的不怎么友好，操作复杂，也是需要花大时间整理。
3.
朱伟《恋练有辞 考研英语写作宝典》核心观点：他认为图表作文和图画作文一样，都要采取经典三段式展开：一描述，二分析，三评论。
利弊分析： 这本书涉及图表作文的篇幅较小，不像图画作文每一段都给出了写作思路。 图表只是给出了三段的大纲：第一段描述图表，第二段分析原因，第三段表达看法，提出建议或预测。其中，描述图表分两步，一是总体介绍，总体上介绍图表描述了什么，二是数据支撑，引用图表数据对介绍进行说明。 这个大纲算是给出了图表作文框架搭建的一个雏形，但是各段每句怎么展开没有交代，感觉又回到了来时路。
4. 何凯文《考研英语写作高分攻略》核心观点：从重要程度看，考研大作文最重要的是语言，其次是结构，最后才是内容。
利弊分析： 这本书的图表作文同样是凄凄惨惨戚戚，没有给具体的解决方案。但是，图画作文中有可以偷师的地方。比如第三段，图表作文和图画作文完全可以通用。 但是，书中只是给出零散的相关句型，比如结论句怎么写，建议句怎么写，操作性上来看还是不太高。
5. 刘洪波《雅思写作真经总纲》刘洪波老师被称为“雅思教父”，但恕我孤陋寡闻。不要被这本书的配图迷惑了，虽然各种插图真的欣赏不来，但是重要的是领会思想，让它服务于提高作文分数。当初为什么要入这本雅思写作的书呢？因为英二作文的资料实在太少了，即使个别书中出现也永远是绿叶的角色，零零星星介绍一点不算方法的方法。当时正好看到一篇帖子，说雅思作文也考图表作文，所以搜了一本买来看看，因为下定决心是要彻底拿下作文的。 真是无心插柳柳成荫，这本书本来没当回事，看完之后却给我收获最大，守得云开见月明，最晚看到它却给我写作上最大的帮助，让我对写作有了一个前所未有的认识，最终帮助我形成了图表作文的写作框架。
核心观点： 刘老师研发了雅思作文15句逻辑模板，量化了写作思维。固化了每句话的写作目的和任务，让行文的逻辑形成一个固定的模板，一个清晰的逻辑链条。
利弊分析： 这五个段落完全遵循总分总的模式，第一段提出论点，第二三四段论证，第五段结论。运用到考研图表中，就是第一段描述图表，第二段进行分析，第三段得出结论提出建议。在涉及论证分析的中间段落，刘老师提出三种思想武器，我只提取对考研有帮助的两种：一是以人为本法，不论什么话题都离不开人，从人的四种需求（身体上、心理上、物质上、精神上）出发进行论证分析。二是核心词汇法（我改为主题词法），从图表提取出主题词，思考主题词的本质特点，获得更多论据。 弊端在于，老师只是给出每一句的常用句型和供参考的万能角度，具体写法需要学生自己通过仿写满分范文和搜集相关素材来搭建自己的语料库。还是在时间和可操作性上不太适合短期应试的备考学生。
小结 这五本书各有利弊，为了尽快搭建自己的写作框架，我的方法是采众家之长，一搭骨架二填血肉。骨架部分（逻辑）我中和了朱伟和刘洪波老师的思路，最终确定三段9句的逻辑框架：描述、分析+评论，然后第二段角度主要选用了黄培辰老师和刘洪波老师的以人为本法和主题词法。血肉部分（语料素材）从真题范文和这些作文书中找完全够用。
打造个人模板框架一级框架的逻辑确定 经过总结，我决定采用传统三段式，虽然保守，但是是最稳妥保险的打法，也是阅卷人最青睐的一种段落安排方式。毕竟，作文要想拿高分，最应该研究的两种人，除了命题人就是阅卷人了，能让阅卷人在短时间的浏览过程中快速抓到主要信息是最明智的做法。
另外，为什么用三段式，题目要求已经给我们暗示了。 每一年图表作文的题目要求都是这样的: Directions: Write an essay on the following chart. Inyour essay, you should
1) interpret the chart, and
2) give your comments.
You should write about 150 words on the ANSWER SHEET.
其中，题目要求必须包含两条内容。第一条，interpret the chart 解释图表，也就是解释图表背后的形成原因。而在解释原因前，首先需要描述图表，不描述怎么解释原因呢。也就是描述图表中的主要项目及数据。所以，第一段描述图表，第二段分析原因。 第二条，give your comments 给出个人评论，也就是图表反映的趋势变化再提炼一遍，给个预测，提个建议。所以，第三段给出评论。 这是一级大框架的初步确定：第一段描述图表，第二段分析原因，第三段给出评论。
二级框架的角度确立 第一段：怎么描述图表？ 在对图表进行描述之前，首先得了解都有什么样的图表。不同的图表有不同的“面相”，面相不同，描述的方法也就不同。 我把英二考过的真题汇总在一起（下图），很明显真题一共考了四种图表：柱形图（考5次）、线形图（考1次）、饼状图（考3次）和表格（考1次）。
这四种图表其实可以划分成两类：变化类和占比类。变化类图表包括柱形图和线形图，这两个重在趋势变化，特点是分横坐标和纵坐标，其中有一个坐标为时间，另一个坐标为数值，显示的是项目随着时间的变化而增长或减少，也有人称为动态图表。占比类图表包括饼状图和表格，这两个重在比例大小，往往没有时间，显示的是当前阶段各个要素的比例，不体现变化，也被叫做静态图表。
确定了图表的分类，怎么对这两类图表进行描述呢？ 我是个对数字极其不敏感的人，看到数字就头疼，所以图表描述这块真的很让我头大，根本不知道从何开始描述。一战时候也看过关于描述图表的一些方法，学了各种图表描述的句子，但是费了很大劲儿还是记不住，感觉没描述到点儿上。但是，还是要硬着头皮去找规律，我是希望能有一个图表描述的固定句型，到了考场只套不同的数据就可以。经过对历年真题的研究，加上参考不同资料，这个规律还真被我找到了，套用起来还算比较简单。其实考研大作文就是我们小学语文课学过的“看图说话”。图表作文和漫画作文一样，一个是看图说话，一个是看表说话。我们经常说，对一个人的第一印象怎么怎么样。第一印象不就是整体印象嘛，描述图表也是，先总体描述一下，再说细节，这是符合从整体到局部的观察顺序的。 所以，第一段的图表描述就包括两部分，首先是整体描述，再是具体的细节描述。而整体描述其实就是描述标题，一句话概括即可，比如图表描述了关于什么什么的信息。具体的细节描述就是描述图表中具体的项目数据，选取两点细节描述就可以，不宜写得过长，以免喧宾夺主。
关于图表怎么描述，我专门写了一篇文章，详细介绍了每一句该如何展开，该用什么表达。链接在这：（欢迎关注我的专栏：考研英语写作秘笈 ）第二段：怎么分析原因？ 在确定第一段思路的时候，我遵循的是从整体到局部的一个描述顺序，说白了就是总分顺序。描述原因还是按照总分的逻辑来，总分思路主要得益于之前看过一个关于英语写作的帖子，里面介绍了美国的一个语言学家卡普兰曾经做过的一个调查：美国学生、亚洲学生在英文写作中体现出的思维方式和背后的文化影响。调查发现，美国学生的英文写作模式是直线型的，即开篇提出论点，接下来就用具体的论据支撑论点。无论一篇文章还是一个段落，都有一个主题句（topic sentence）来概括中心思想。因此整篇文章结构严谨，脉络清晰。 相反，亚洲学生的写作模式是螺旋型的，重在思路的自由流畅，思想的含蓄表达，通常是绕了好几圈到了文章末尾才点明主题；或者通篇都不说明中心思想，由读者自己去领悟和联想。西方人在不了解东方文化背景和思维模式的时候，常对这种螺旋型的感到无从理解。 而我们既然写的是英语文章，就应该遵循英文的写作模式，尤其要重视主题句的作用。
所以，第二段可以先总的说一下有两点原因，接着分写两条具体的原因。
我个人觉得这是最难写的一段。首先，在切入角度上，刘洪波老师的以人为本法和主题词法对我非常有启发，美中不足的是，刘老师提供的角度有点多。我理想的原因分析是能找到两个万能角度，这样在考场上的操作效率才会高。但是，怎么能让这两个原因通用万能，适合更多的考题我犯了难。何凯文老师说，“在英文写作过程中，我们无非会遇到两个问题：1）无话可说，对于写作本身就有障碍。2）有话可说，却不知如何用正确的英语表达。”无话可说的问题我在一战时候已经经历过，其实就算是用中文写一篇图表作文，我可能都写不好，这也是大多数人共同存在的问题，这是没有提前准备出应对考题的写作角度导致的。在总结问题后，看了这么多资料，我已经梳理出中文的逻辑框架，写作角度已经确定固化，剩下最大的问题就是怎么用英语表达出来。 空想是没用的，都说最有价值的复习资料就是真题本身。所以，我觉得研究真题才是王道。于是，我试着从话题上找线索。
我发现，这些真题作文题目，确实像刘洪波老师说的，不管是社会生活还是校园生活，每种话题都离不开人，都和人这个群体息息相关。怎么才能把现象背后的原因和人结合到一起呢？我思考了很久，想破了脑袋也无果，就卡住了。
后来，我在专业课复习时候，发现历史主观题回答都是有套路的，需要从时代背景、政治经济文化这些点去分析原因影响。我一下子就想到了图表作文的原因分析了，两个简直有异曲同工之妙，只是历史时代不一样，但是在性质上都是分析特定时代特定问题的原因，所以分析的角度上应该是通用的。不管图表作文中要反映什么现象，现象发生的原因除了敏感的政治角度，都可以从社会经济这个角度切入。
第一条原因可以说，社会经济的发展提升了人们生活水平，推动了这一现象的发生。比如，2018年，消费者选择餐厅会考虑不同因素这个现象，就可以说First, owing to an economic boom that is durable and lasting, the living standards of ordinary people have been rising consistently, which turns out to be an essential prerequisite for this phenomenon's happening.经济发展了，人民生活水平提高，成了这个现象发生的重要前提。完全说得通。 如果第一条原因算作外因的话，第二条原因就需要从人这个主体的内部需求内因出发，进行分析，毕竟内因才是根本的第一位的原因。所以，第二条原因可以说，个人需求（心理精神上的需求）推动了这个现象的发生。还是消费者选择餐馆这个例子，就可以说 Second, with basic needs of people significantly satisfied, they drive and force higher-level needs to emerge, thus facilitating the observable occurrence of this phenomenon.人们的基本需求满足之后，就会有更高的需求，也是现象发生的原因。
要想切合更多的考题就需要从这两个角度积累更多的语料，我除了从黄皮书历年真题的范文里摘抄相关的表达外，还从以上几本作文书里面找了更多地道的说法。关于这些语料内容，很多老师也持相同的观点，语言第一，结构第二，内容第三。所以，内容上只要做到相关就可以，能自圆其说就行。考研作文题目其实就是想培养学生在纷繁复杂的社会中保持正确的三观，世界观人生观价值观。所以，我们写的每一句话每一个字在内容上能符合主旋律，不跑偏就可以，不必追求创新、特立独行。 第三段：怎么给出评论？以前语文老师让我们写作文的时候，经常说最后一段就是一个总结和升华。放在考研作文上，第三段主要涉及一些场面话，说的宏观漂亮一点就可以。既然题目要求明确说明要给出个人评论了，第一句肯定是先评论，给个结论句，比如：以上这些因素都预示这种现象会继续发展。接着就是老套路的提建议和给预测，都是非常简单的两句，比如：我们应该树立正确的心态，采取什么样的行动；只有这样才有一个更好的未来等等。
这样，图表作文的9句框架就完全清晰了。
这个9句框架对我的作文复习非常重要，形成了这种框架意识后，我又把它应用到小作文的复习中，也打磨出了一套小作文的写作框架。小作文框架在下文。
把写作框架固定下来以后，我发现9句话就像地图一样，每一句话就是一个路标，拿到一个作文题，都不需要花时间构思，直接按照这个地图走完，一句一句地写，非常快。我在最后一个月的复习中，主要是练习套用历年真题，在保证思路准确的前提下，不断润色雕琢各句话的语言。这样就不再需要像一战那样，漫无目的地背范文，最后在考场上抓瞎。 我个人认为，基础薄弱的同学可以按照我的框架，整理总结一套自己的模板。因为到考场上现想现写真的不是我们的强项，提前准备好写作思路才是对付考研这种应试考试最正确最有效率的方法。
基础好的同学，本身能写出言之有物的东西，可以采用摘录法，总结某一类题材的通用表达。只用我的这套逻辑框架就可以，最后可以打造出有自己语言特色的模板。其实，任何写作的本质都是思维的体现。所以只有想得清楚，才能写的明白。写的明白，阅卷老师才看得明白，这才是我们的最终目的。
我用我的血泪史告诉大家，在作文的复习上，走正确的路，才是最快的路。其实跳出应试，从培养能力角度来说，大多数人真正的短板是思维能力，养成一个有逻辑的思维方式和表达习惯，也会让我们终身受益。
小作文框架来啦！！小作文的复习难点一是考查的类型多（9种），二是考查的话题多（每年话题不同）。多数英语老师都要求学生准备所有类型，确保万无一失，而掌握这么多小作文类型，至少要一个月时间。问题是即使准备了所有类型，面对当年新考的话题，仍然需要你自己重新创作内容。云鲸考研团队的中外老师花了5年时间，拆解了几百篇小作文的高分范文，再加上对考研作文阅卷批改经验，终于摸索出小作文在语言和思路的深处有一些共性，从中提炼出了小作文万能模板。我们的模板是考研圈背诵内容最少、填写最少、切题最好的小作文模板，没有之一。小作文模板由两部分组成：一个是通用部分，一个是核心部分。什么是通用内容？什么是核心内容呢？我给大家举个例子就明白了。比方说，写建议信。下面表格中，标红处即是核心内容，其他则为通用内容。我们通过研究所有高分范文的通用部分，提炼出了3种万能框架；然后通过研究核心内容，总结出了9种万能核心句。你只需要3个框架+9组核心句就能够应对所有类型+所有话题。其中“框架”相当于“通用内容”，解决小作文类型多的问题，背会这3个框架就搞定了所有小作文类型；“核心句”相当于“核心内容”，解决小作文话题多的问题，背会这9种核心句，就能覆盖所有已考话题和未考话题。这种方法使用起来也超级简单，只需要三步：Step 1：判断题目考查小作文类型，根据类型选用“通用内容”；Step 2：判断题目考查话题，根据话题选用“核心内容”；Step 3：“通用内容”+“核心内容”选好后，默写下来，一篇小作文就完成。详细的框架是什么，核心句有哪些，在体验营的第一天课程里，老师会分别讲这两部分的具体内容。常见问题汇总 1. 考试的时候是先写作文还是最后写作文？作文留多长时间？ 考试的时候具体是先写作文还是最后写作文，要根据每个人自己的情况。有的同学习惯按照试卷的顺序来做，这样做下来按部就班比较稳妥；有的同学担心前边的题目花时间太多，作文时间仓促或者没有时间写，这样的同学可以先写作文。 我当时做题的顺序是小作文—大作文—阅读理解—完型—新题型—翻译。作文是我比较有把握的，模板也练习很多遍了，先写完作文可以预留出很多时间来给阅读答题。仅供参考，还是按照自己的习惯来。
2. 作文书写重要吗？需要拿出时间来练字吗？ 书写非常重要。大纲里面明确规定，书写不好分数降一档，小作文一个分数档是2分，大作文一个分数档是3分，写的太潦草，可能五分就没了。所以，一定要重视书写。 其实练习书写也可以当成一个复习累了放松的方式。不管你练习什么体，衡水体还是其他体，重要的是工整清楚，花体就不建议了，让阅卷老师辨认起来费劲的都不建议。具体练字时间，我觉得每天15到20分钟足够了。
3. 需要练习预测作文吗？ 关于预测作文，能做就做，如果时间紧张，还是以真题为主，多练习真题，毕竟真题是最贴合考试标准的。
4. 阅卷老师会不会觉得模板内容太空？ 不会。首先，考研作文的考查重点不是看你的观点有多新颖，因为考研话题都是没有争议的话题；第二，考研作文的考查重点是语言，就是根据语言的多样性、准确性来评分，在逻辑无懈可击的情况下，打磨出高级的句型和语言就不会空。
如果我的回答对你有帮助，可以帮我点个赞+收藏么？蟹蟹蟹蟹~~~记得关注 @苏苏学姐 我呀