文章目录
1.假设的定义
2.如何寻找假设
3.价值观假设
4.描述性假设

1.假设的定义
本书所指的假设：没有明说出来的想法，具有以下特征：

隐藏或没有明说；
作者认为理所当然；
对判断结论有较大影响；
可能具有一定的欺骗性。

2.如何寻找假设
有两种地方可以寻找假设：

理由需要假设才能证明结论；
理由需要假设才能成立。

3.价值观假设
在特定情况下， 人们没有明说的喜欢一种价值观超过另外一种价值观的倾向。

典型的价值观冲突


4.描述性假设
指的是人对于世界的过去、现在和未来是什么样的想法。

排序启蒙：简单的找规律
什么是排序启蒙
幼儿时期的排序启蒙非常重要，不仅仅有助于幼儿巩固对抽象的数概念进行练习巩固，同时也是发展数学思维中归纳推理的有效方法。
排序是指根据一组物体的某种特征的差异或规则，按序进行排序。对幼儿来说，排序要比分类难，因为分类只需要判断一个物体是否具有某一特征，以便将其划入某一类别当中。而排序需要幼儿能够联系地比较和区分物体之间的差异，同时还需要调整物体之间的关系。所以排序对孩子的要求更高。
3-6岁幼儿有关排序问题的发展水平
小班阶段：能感知越来越多，越来越少。
能按物体的外部特征或量的差异进行4个以内的物体排序。
能进行2个元素的找规律
中班：能发现数字的规律，能按物体的外部特征或量的差异，进行7个以内的正逆排序，会按一定的规律排序物体。
大班：能发现图形的规律，能按物体的外部特征或量的差异，进行10个以内的正逆排序，能按一定的规律排列物体，初步感知序列之间的传递性、双重性和可逆性关系。
小班阶段的排序教学内容
1、多维度地感知数量的递变，感知“越来越多”“越来越少”
在数字当中能够知道缺了什么数，能够知道怎么按从多到少、从少到多排序。
注意点：首先引导孩子观察物体哪里不一样，然后让孩子从前往后读一遍不同的地方，感知缺了什么。
2、初步感知规律，能够感知2个元素进行规律排序
注意点：首先理解重复的意义，然后通过观察找出表达的规律是什么。先从AB模式，再到ABB模式，再到ABA模式，再到孩子自己创造模式。但是小班只需要两个元素的规律就可以了。
3、引导孩子用语言描述规律
孩子能够把自己看到的现象进行总结描述，按什么规律排序的。
排序和找规律的小游戏
1、串糖葫芦
孩子很喜欢动手操作，这样的找规律孩子会很感兴趣。
2、铺小路
小朋友们通过抛硬币的方式选择一组模式，并按照模式在小路底板上进行摆放花朵。每完成一条小路之后通过手口一致点数、两两点数和闭合点数的方式来数一数路上有多少朵花朵并完成记录。
 3、拼贴找规律
排序找规律的启蒙绘本
《糖果店的有奖竞猜》
为了庆祝自己的糖果店开业，棕熊大叔举办了有奖竞猜的活动。小朋友们好奇地围在店门口的桌子旁，发现各种各样的美味糖果被摆放成三排，仔细一看，好像是有规律的。聪明的小朋友们能猜出来吗？
《让谁先吃好呢》
以“让谁先吃”的故事情境为切入口，利用情境推动幼儿对于高矮、大小和轻重排序经验的不断建构，活动目标在过程中自然展现、层层铺展、一一达成。让幼儿在活动中表达、探索、操作，潜移默化地学习到数学知识，体验排序带来的的乐趣。

   按照单片机的组成结构，其最基本的能够完成算术运算和逻辑运算，即完成数值计算和逻辑判断。

（1）工业控制领域：用来实现对信号的检测、数据的采集以及应用对象的控制，如温、湿度的自动监测与控制，电机的转速与位置控制，工件生产流水线的控制等。

（2）机电一体化产品：机电一体化产品是装备制造行业的发展方向。机电一体化产品是指集机械技术、微电子技术和计算机技术于一体，具有智能化特征的机电产品。

以单片机作为机电产品的控制器，使传统的产品控制智能化、结构简单化，出现了新一代的机电一体化产品。

（3）智能化仪器仪表：使仪器仪表数字化、多功能化（包括通信功能）、微型化，并使长期以来的误差修正和线性化处理等难题迎刃而解。

（4）信息通信技术领域：单片机的通信接口，为单片机在计算机网络与通信系统、

设备的应用提供了硬件支持。

（5）智能交通系统：交通领域中的交通灯控制、监控设备的控制、智能传感器等。

（6）家用电器领域：单片机体积小、价格低廉、具有定时器/计数器且控制功能强，广泛应用于家电设备中，如全自动洗衣机、电饭煲、微波炉、空调和视频音像设备等，从而使人们的生活更舒适方便。

工厂模式有三种：简单工厂模式、工厂方法模式、抽象工厂模式



简单工厂

定义：类创建模式，用来创建其他类的实例，通过不同的特征返回不同类的实例，被返回类具有相同的父类

角色： 产品的父类

产品的具体类

工厂类
  

优点：  

（1）工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。  

（2）客户端无需知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。  （3）通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。
  

缺点：  

（1）由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。  

（2）使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。  

（3）系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。  

（4）简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。  

  

简单工厂模式的适用环境 ： 

（1）工厂类负责创建的对象比较少：由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂；  

（2）客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。 



代码示例：




[java] view
 plaincopy






/** 

 * 产品的父类 

 * @author sky 

 * 

 */  

public interface Job {  

      

    public void work();  

  

}  

  

  

/** 

 * 产品的具体子类 

 * @author sky 

 */  

public class Teacher implements Job {  

    @Override  

    public void work() {  

        System.out.println("I'm teaching...");  

    }  

}  

  

/** 

 * 产品的具体子类2 

 * @author sky 

 */  

public class Programer implements Job {  

  

    @Override  

    public void work() {  

        System.out.println("I'm Programing...");  

    }  

  

}  

  

/** 

 * 工厂类 

 * @author sky 

 */  

public class JobFactory {  

      

    public static final int PROGRAMER = 1;  

      

    public static final int TEACHER = 2;  

      

    public static Job create(int identity){  

        if(identity==PROGRAMER){  

            return new Programer();  

        }else if(identity==TEACHER){  

            return new Teacher();  

        }else{  

            return null;  

        }  

    }  

  

}  

  

/** 

 * 测试类 

 * @author sky 

 */  

public class Test {  

  

    /** 

     * @param args 

     */  

    public static void main(String[] args) {  

        System.out.println("创建程序员：");  

        Job job = JobFactory.create(JobFactory.PROGRAMER);  

        job.work();  

        System.out.println("创建老师：");  

        job =JobFactory.create(JobFactory.TEACHER);  

        job.work();  

    }  

  

}  

  

输出：  

    创建程序员：  

    I'm Programing...  

    创建老师：  

    I'm teaching...  





工厂方法

定义：定义一个用于创建对象的接口，使类得实例化延迟到之类，由子类来决定实例化哪一个类。

在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做。这个核心工厂则变为抽象工厂角色，仅负责给出具工厂子类必须实现的接口，而不接触哪一产品创建的细节。

这种抽象的结果，使这种工厂方法模式可以用来允许系统不修改具体工厂角色的情况下引进新产品，这一特点无疑使得工厂模式具有超过简单工厂模式的优越性。

角色： 工厂接口

工厂具体子类

产品接口

产品具体子类

使用心得：如果一个对象有许多的子类，但是子类可以划为几类，这时，如果使用简单工厂模式，则会使代码过多，逻辑混乱，此时使用工厂方法则能让代码更有层次感，条例分明。例如，工作可以分为程序员，教师等，程序员又可分为java程序员，C++程序员，教师又可分为语文老师，数学老师，此种情况下使用工厂方法模式比较合适

优点：  

（1）在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无需关心创建细节，甚至无需知道具体产品类的类名。  

（2）基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，正是因为所有的具体工厂类都具有同一抽象父类。  

（3）使用工厂方法模式的另一个优点是在系统中加入新产品时，无需修改抽象工厂和抽象产品提供的接口，无需修改客户端，也无需修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了，这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。  

缺点：  

（1）在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。  

（2）由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。  

  

工厂方法模式的适用环境 ：  

（1）一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。  

（2）一个类通过其子类来指定创建哪个对象：在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。  

（3）将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无需关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。 



代码示例：




[java] view
 plaincopy






/** 

 * 产品的父类 

 * @author sky 

 * 

 */  

public interface Job {  

      

    public void work();  

  

}  

  

/** 

 * 产品的具体子类1 

 * @author sky 

 */  

public class ChineseTeacher implements Job {  

  

    @Override  

    public void work() {  

        System.out.println("I'm a chinese teacher");  

    }  

  

}  

  

/** 

 * 产品的具体子类2 

 * @author sky 

 */  

public class MathTeacher implements Job {  

  

    @Override  

    public void work() {  

        System.out.println("I'm a math teacher");  

    }  

  

}  

  

/** 

 * 产品的具体子类3 

 * @author sky 

 */  

public class CProgramer implements Job {  

  

    @Override  

    public void work() {  

        System.out.println("I'm a C programer");  

    }  

  

}  

  

/** 

 * 产品的具体子类4 

 * @author sky 

 */  

public class JavaProgramer implements Job {  

  

    @Override  

    public void work() {  

        System.out.println("I'm a java programer");  

    }  

  

}  

  

/** 

 * 工厂接口 

 * @author sky 

 * 

 */  

public interface JobFactory {  

      

    public Job create(int type);  

  

}  

  

/** 

 * 工厂具体子类1 程序员工厂 

 * @author sky 

 */  

public class ProgramerFactory implements JobFactory {  

  

    public static final int JAVA = 1;  

      

    public static final int C = 2;  

  

    @Override  

    public Job create(int type) {  

  

        if(type == JAVA){  

            return new JavaProgramer();  

        }else if(type == C){  

            return new CProgramer();  

        }  

        return null;  

    }  

  

}  

  

/** 

 * 工厂具体子类2 教师工厂 

 * @author sky 

 */  

public class TeacherFactory implements JobFactory {  

  

    public static final int MATH = 1;  

      

    public static final int CHINESE = 2;  

  

    @Override  

    public Job create(int type) {  

  

        if(type == MATH){  

            return new MathTeacher();  

        }else if(type == CHINESE){  

            return new ChineseTeacher();  

        }  

        return null;  

    }  

  

}  

  

/** 

 * 测试代码 

 * @author sky 

 */  

public class Test {  

  

    public static void main(String[] args) {  

        System.out.println("请创建一个java程序员");  

        JobFactory jf = new ProgramerFactory();  

        Job job = jf.create(ProgramerFactory.JAVA);  

        job.work();  

        System.out.println("请创建一个C程序员");  

        job = jf.create(ProgramerFactory.C);  

        job.work();  

        jf = new TeacherFactory();  

        System.out.println("请创建一个语文老师");  

        job = jf.create(TeacherFactory.CHINESE);  

        job.work();  

        System.out.println("请创建一个数学老师");  

        job = jf.create(TeacherFactory.MATH);  

        job.work();  

    }  

  

}  

  

输出：  

    请创建一个java程序员  

    I'm a java programer  

    请创建一个C程序员  

    I'm a C programer  

    请创建一个语文老师  

    I'm a chinese teacher  

    请创建一个数学老师  

    I'm a math teacher  

抽象工厂

定义：提供一个接口，创建一系列相关连的产品（产品族），而不必指定具体的类。通常，产品族是某个产品的组成部分，比如一个电脑的CPU,内测，硬盘等，一个开发团队的前端、后端、美工等





角色： 工厂接口

    工厂具体子类

    产品接口

  产品具体子类

 抽象工厂模式的优缺点  

优点：  

（1） 隔离了具体类的生成，使得用户不需要知道什么被创建了。  

（2） 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。  

缺点：  

（1）添加新的产品对像时，难以扩展抽象工厂以便生产新种类的产品。  

  

 抽象工厂模式的适用环境 ： 

（1）一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节。这对于所有形态的工厂模式都是重要的；  

（2）一个系统的产品有多于一个的产品族，而系统只消费其中某一族的产品；  

（3）同属于同一个产品族的产品是在一起使用的，这一约束必须要在系统的设计中体现出来；  

（4）系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。



代码示例：




[java] view
 plaincopy






/** 

 * 前端接口 

 * @author sky 

 */  

public interface Client {  

  

    public void doClient();  

}  

  

/** 

 * 前端具体子类 

 * @author sky 

 */  

public class JuniorClient implements Client {  

  

    @Override  

    public void doClient() {  

        System.out.println("I'm a junior client");  

    }  

  

}  

  

/** 

 * 后端接口 

 * @author sky 

 */  

public interface Server {  

  

    public void doServer();  

}  

  

/** 

 *后端具体子类 

 * @author sky 

 */  

public class JuniorServer implements Server {  

  

    @Override  

    public void doServer() {  

        System.out.println("I'm a junior server");  

    }  

  

}  

  

/** 

 * 团队工厂接口 

 * @author sky 

 */  

public interface TeamFactory {  

  

    /** 

     * 创建客户端，如果有多个对象选择，这里可以添加参数，子类中根据具体的参数返回对应的对象 

     * @return 

     */  

    public Client createClient();  

      

    /** 

     * 创建服务端，如果有多个对象选择，这里可以添加参数，子类中根据具体的参数返回对应的对象 

     * @return 

     */  

    public Server createServer();  

}  

  

/** 

 * 团队工厂具体子类 

 * @author sky 

 */  

public class JuniorTeamFactory implements TeamFactory {  

  

    @Override  

    public Client createClient() {  

        return new JuniorClient();  

    }  

  

    @Override  

    public Server createServer() {  

        return new JuniorServer();  

    }  

  

}  

  

/** 

 * 测试类 

 * @author sky 

 */  

public class Test {  

  

    public static void main(String[] args) {  

        System.out.println("我要创建一个初级团队，包括一个初级前端，一个初级服务端");  

        TeamFactory tf = new JuniorTeamFactory();  

        Client client = tf.createClient();  

        Server server = tf.createServer();  

        client.doClient();  

        server.doServer();  

    }  

  

}  

  

输出：  

    我要创建一个初级团队，包括一个初级前端，一个初级服务端  

    I'm a junior client  

    I'm a junior server