泛型(Generic) —泛形的作用
JDK5中的泛形允许程序员在编写集合代码时，就限制集合的处理类型，从而把原来程序运行时可能发生问题，转变为编译时的问题，以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。
注意：泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。
泛形的基本术语，以ArrayList
ArrayList
ArrayList
整个称为ArrayList
整个BaseDao
自定义泛形——泛型类和反射泛形
如果一个类多处都要用到同一个泛型，这时可以把泛形定义在类上（即类级别的泛型），语法格式如下：
public class GenericDao
private T field1;
public void save(T obj){}
public T getId(int id){}
}
泛形的典型应用：BaseDao和反射泛型
Annotation(注解) 概述
从JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是Annotation(注解)。
什么是Annotation，以及注解的作用?三个基本的Annotation:
@Override: 限定重写父类方法, 该注解只能用于方法
@Deprecated: 用于表示某个程序元素(类, 方法等)已过时
@SuppressWarnings: 抑制编译器警告.
Annotation 其实就是代码里的特殊标记, 它用于替代配置文件，也就是说，传统方式通过配置文件告诉类如何运行，有了注解技术后，开发人员可以通过注解告诉类如何运行。在Java 技术里注解的典型应用是：可以通过反射技术去得到类里面的注解，以决定怎么去运行类。掌握注解技术的要点：
如何自定义注解
如何反射注解，并根据反射的注解信息，决定如何去运行类
自定义Annotation
定义新的Annotation 类型使用@interface 关键字
声明注解的属性
注解属性的作用：原来写在配置文件中的信息，可以通过注解的属性进行描述。Annotation 的属性声明方式：String name()或String[] likes();
属性默认值声明方式：String name() default “xxx”;
特殊属性value：如果注解中有一个名称value的属性，那么使用注解时可以省略value=部分，如@MyAnnotation(“xxx")
特殊属性value[];
枚举值之间使用逗号分隔
@MyAnnotation(name="jack",age=30,likes={"唱歌","跳舞"})
JDK 的元Annotation
元Annotation指修饰Annotation的Annotation。JDK中定义了如下元Annotation：
@Retention: 只能用于修饰一个Annotation 定义, 用于指定该Annotation 可以保留的域, @Rentention 包含一个RetentionPolicy 类型的成员变量, 通过这个变量指定域。RetentionPolicy.CLASS: 编译器将把注解记录在class 文件中. 当运行Java 程序时, JVM 不会保留注解. 这是默认值
RetentionPolicy.RUNTIME:编译器将把注释记录在class 文件中. 当运行Java 程序时, JVM 会保留注解. 程序可以通过反射获取该注释
RetentionPolicy.SOURCE: 编译器直接丢弃这种策略的注释
JDK 的元Annotation
@Target：指定注解用于修饰类的哪个成员. @Target 包含了一个名为value，类型为ElementType(JDK6)的成员变量。
@Documented: 用于指定被该元Annotation 修饰的Annotation 类将被javadoc 工具提取成文档。
@Inherited: 被它修饰的Annotation 将具有继承性.如果某个类使用了被@Inherited 修饰的Annotation, 则其子类将自动具有该注解。
提取Annotation 信息
JDK 5.0 在https://www.doczj.com/doc/3f4569581.html,ng.reflect 包下新增了AnnotationElement 接口, 该接口代表程序中可以接受注释的程序元素
当一个Annotation 类型被定义为运行时Annotation 后, 该注释才是运行时可见, 当class 文件被载入时保存在class 文件中的Annotation 才会被虚拟机读取
程序可以调用AnnotationElement 对象的如下方法来访问Annotation 信息
动态代理(代理类产生代理对象)
明确两个概念：
代理对象存在的价值：主要用于拦截对真实业务对象的访问。
代理对象有什么方法？与真实对象相同，只是无业务代码。
现在要生成某一个对象的代理对象，这个代理对象通常也要编写一个类来生成，所以首先要编写用于生成代理对象的类。
如何编写生成代理对象的类，两个要素：
代理谁
如何生成代理对象
代理谁？
设计一个类变量，以及一个构造函数，记住代理类代理哪个对象。
如何生成代理对象？(invoke方法)
设计一个方法生成代理对象（在方法内编写代码生成代理对象是此处编程的难点）
动态代理(JDK提供)
ava提供了一个Proxy类，调用它的newInstance方法可以生成某个对象的代理对象，使用该方法生成代理对象时，需要三个参数：
1.生成代理对象使用哪个类加载器
2.生成哪个对象的代理对象，通过接口指定
3.生成的代理对象的方法里干什么事，由开发人员编写handler接口的实现来指定。
初学者必须记住的2件事情：
Proxy类负责创建代理对象时，如果指定了handler（处理器），那么不管用户调用代理对象的什么方法，该方法都是调用处理器的invoke方法。
由于invoke方法被调用需要三个参数：代理对象、方法、方法的参数，因此不管代理对象哪个方法调用处理器的invoke方法，都必须把自己所在的对象、自己（调用invoke方法的方法）、方法的参数传递进来。
动态代理应用
在动态代理技术里，由于不管用户调用代理对象的什么方法，都是调用开发人员编写的处理器的invoke方法（这相当于invoke方法拦截到了代理对象的方法调用）。
并且，开发人员通过invoke方法的参数，还可以在拦截的同时，知道用户调用的是什么方法，因此利用这两个特性，就可以实现一些特殊需求，例如：拦截用户的访问请求，以检查用户是否有访问权限、动态为某个对象添加额外的功能。
c3p0-config.xml
log4j
1泛型
package cn.itcast.a_generic;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
/**
* 泛型基本用法
* @author Jie.Yuan
*
*/
public class App {
// 运行时期异常
@Test
public void testGeneric() throws Exception {
// 集合的声明
List list = new ArrayList();
list.add("China");
list.add(1);
// 集合的使用
String str = (String) list.get(1);
}
// 使用泛型
@Test
public void testGeneric2() throws Exception {
// 声明泛型集合的时候指定元素的类型
List
list.add("China");
// list.add(1);// 编译时期报错
String str = list.get(1);
}
/*
* 泛型擦除实例
public void save(List
}
public void save(List
*/
// 泛型写法
@Test
public void testGeneric3() throws Exception {
// 声明泛型集合，集合两端类型必须一致
List
List
List list2 = new ArrayList
List
// 错误
//List
// 错误：泛型类型必须是引用类型,不能为基本类型
// List
}
}
2
package cn.itcast.a_generic;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
/**
* 泛型, 涉及到一些关键字
*
* Ctrl + shift + R 查看当前项目中类
* Ctrl + shift + T 查看源码jar包中的类
* @author Jie.Yuan
*
*/
public class App_extends {
/**
* list集合只能处理Double/Float/Integer等类型
* 限定元素范围：元素的类型要继承自Number类(上限) * @param list
*/
public void save(List list) {
}
@Test
public void testGeneric() throws Exception {
List
List
List
List
// 调用
save(list_1);
save(list_2);
save(list_3);
//save(list_4);
}
}
3
package cn.itcast.a_generic;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
/**
* 泛型, 涉及到一些关键字
*
* Ctrl + shift + R 查看当前项目中类
* Ctrl + shift + T 查看源码jar包中的类
* @author Jie.Yuan
*
*/
public class App_super {
/**
* super限定元素范围：必须是String父类【下限】* @param list
*/
public void save(List list) {
}
@Test
public void testGeneric() throws Exception {
// 调用上面方法，必须传入String的父类
List
List
List
//save(list3);
}
}
4
package cn.itcast.a_generic;
/**
* 抽象的类
* @author Jie.Yuan
* @param
*/
public class BaseDao
@Override
public void save(T t) {
// TODO Auto-generated method stub }
@Override
public void update(T t) {
// TODO Auto-generated method stub
}
}
5
package cn.itcast.a_generic;
public class Dept {
}
6
package cn.itcast.a_generic;
import org.junit.Test;
/**
* 泛型方法/泛型类
* @author Jie.Yuan
*
*/
public class GenericDemo
// 定义泛型方法
public
return null;
}
public void update(T t) {
}
// 测试方法
@Test
public void testMethod() throws Exception {
// 泛型类：在创建爱泛型类对象的时候，确定类型
GenericDemo
demo.save("test", 1);
}
}
7
package cn.itcast.a_generic;
/**
* 泛型接口
* @author Jie.Yuan
*
* @param
*/
public interface IBaseDao
void save(T t );
void update(T t );
}
8
package cn.itcast.a_generic;
public class Person {
}
9
package cn.itcast.a_generic;
/**
* 具体业务模块
* @author Jie.Yuan
*
*/
public class PersonDao implements IBaseDao
public void save(Person p){
}
@Override
public void update(Person t) {
}
}
2 反射
1
package cn.itcast.b_reflect;
public class Account {
private int id;
private String accountName;
private double money;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getAccountName() {
return accountName;
}
public void setAccountName(String accountName) { this.accountName = accountName;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
}
2
package cn.itcast.b_reflect;
public class AccountDao extends BaseDao
// 只需要写父类没有实现的方法(个性化需求) }
3
package cn.itcast.b_reflect;
public class Admin {
private int id;
private String userName;
private String pwd;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
https://www.doczj.com/doc/3f4569581.html,erName = userName;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
@Override
public String toString() {
return "Admin [id=" + id + ", pwd=" + pwd + ", userName=" + userName + "]";
}
}
4
package cn.itcast.b_reflect;
public class AdminDao extends BaseDao
// 根据主键查询
}
5
package cn.itcast.b_reflect;
import org.junit.Test;
public class App {
@Test
public void testSave() throws Exception {
AdminDao adminDao = new AdminDao();
Admin admin = adminDao.findById(8);
System.out.println(admin);
System.out.println(adminDao.getAll());
}
}
6
package cn.itcast.b_reflect;
import https://www.doczj.com/doc/3f4569581.html,ng.reflect.ParameterizedType;
import https://www.doczj.com/doc/3f4569581.html,ng.reflect.Type;
import java.sql.SQLException;
import java.util.List;
import https://www.doczj.com/doc/3f4569581.html,mons.dbutils.handlers.BeanHandler;
import https://www.doczj.com/doc/3f4569581.html,mons.dbutils.handlers.BeanListHandler;
/**
* 所有dao的公用的方法，都在这里实现
* @author Jie.Yuan
*
*/
public class BaseDao
// 保存当前运行类的参数化类型中的实际的类型
private Class clazz;
// 表名
private String tableName;
// 构造函数：1. 获取当前运行类的参数化类型；2. 获取参数化类型中实际类型的定义(class)
public BaseDao(){
// this 表示当前运行类(AccountDao/AdminDao)
// this.getClass() 当前运行类的字节码(AccountDao.class/AdminDao.class)
// this.getClass().getGenericSuperclass(); 当前运行类的父类，即为BaseDao
// 其实就是“参数化类型”，ParameterizedType
Type type = this.getClass().getGenericSuperclass();
// 强制转换为“参数化类型”【BaseDao
ParameterizedType pt = (ParameterizedType) type;
// 获取参数化类型中，实际类型的定义【new Type[]{Account.class}】
Type types[] = pt.getActualTypeArguments();
// 获取数据的第一个元素：Accout.class
clazz = (Class) types[0];
// 表名(与类名一样，只要获取类名就可以)
tableName = clazz.getSimpleName();
}
/**
* 主键查询
* @param id 主键值
* @return 返回封装后的对象
*/
public T findById(int id){
/*
* 1. 知道封装的对象的类型
* 2. 表名【表名与对象名称一样，且主键都为id】
*
* 即，
* ---》得到当前运行类继承的父类BaseDao
* ----》得到Account.class
*/
String sql = "select * from " + tableName + " where id=? ";
try {
return JdbcUtils.getQuerrRunner().query(sql, new BeanHandler
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/**
* 查询全部
* @return
*/
public List
String sql = "select * from " + tableName ;
try {
return JdbcUtils.getQuerrRunner().query(sql, new BeanListHandler
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
7
package cn.itcast.b_reflect;
import javax.sql.DataSource;
import https://www.doczj.com/doc/3f4569581.html,mons.dbutils.QueryRunner;
import https://www.doczj.com/doc/3f4569581.html,boPooledDataSource;
/**
* 封装常用的操作
* @author Jie.Yuan
*
*/
public class JdbcUtils {
// 初始化连接池
private static DataSource dataSource;
static {
dataSource = new ComboPooledDataSource();
}
public static DataSource getDataSource() {
return dataSource;
}
/**
* 创建DbUtils常用工具类对象
*/
public static QueryRunner getQuerrRunner() {
return new QueryRunner(dataSource);
}
}
8
package cn.itcast.c_reflect;
public class Admin {
// Field
private int id = 1000;
private String name = "匿名";
// Constructor
public Admin(){
System.out.println("Admin.Admin()");
}
public Admin(String name){
System.out.println("Admin.Admin()" + name);
}
// Method
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
https://www.doczj.com/doc/3f4569581.html, = name;
}
}
9
package cn.itcast.c_reflect;
import https://www.doczj.com/doc/3f4569581.html,ng.reflect.Constructor;
import https://www.doczj.com/doc/3f4569581.html,ng.reflect.Field;
import https://www.doczj.com/doc/3f4569581.html,ng.reflect.Method;
import org.junit.Test;
// 反射技术
public class App {
// 1. 创建对象
@Test
public void testInfo() throws Exception {
// 类全名
String className = "cn.itcast.c_reflect.Admin";
// 得到类字节码
Class clazz = Class.forName(className);
// 创建对象1: 默认构造函数简写
//Admin admin = (Admin) clazz.newInstance();
// 创建对象2：通过带参数构造器创建对象
Constructor constructor = clazz.getDeclaredConstructor(String.class);
Admin admin = (Admin) constructor.newInstance("Jack");
}
@Test
//2. 获取属性名称、值
public void testField() throws Exception {
// 类全名
String className = "cn.itcast.c_reflect.Admin";
// 得到类字节码
Class clazz = Class.forName(className);
// 对象
Admin admin = (Admin) clazz.newInstance();
// 获取所有的属性名称
Field[] fs = clazz.getDeclaredFields();
// 遍历：输出每一个属性名称、值
for (Field f : fs) {
// 设置强制访问
f.setAccessible(true);
// 名称
String name = f.getName();
// 值
Object value = f.get(admin);
System.out.println(name + value);
}
}
@Test
//3. 反射获取方法
public void testMethod() throws Exception {
// 类全名
String className = "cn.itcast.c_reflect.Admin";
// 得到类字节码
Class clazz = Class.forName(className);
// 对象
Admin admin = (Admin) clazz.newInstance();
// 获取方法对象public int getId() {
Method m = clazz.getDeclaredMethod("getId");
// 调用方法
Object r_value = m.invoke(admin);
System.out.println(r_value);
}
}
Anno
1
package cn.itcast.d_anno;
import java.util.List;
import org.junit.Test;
/**
* 常用的注解
* @author Jie.Yuan
*
*/
public class App_1 {
// 重写父类的方法
@Override
public String toString() {
return super.toString();
}
// 抑制编译器警告
@SuppressWarnings(value = {"unused","unchecked"}) private void save() {
List list = null;
}
// 标记方法以及过时
@Deprecated
private void save1() {
}
@Test
public void testMain() throws Exception {
}
}
2
package cn.itcast.d_anno;
import https://www.doczj.com/doc/3f4569581.html,ng.reflect.Field;
import https://www.doczj.com/doc/3f4569581.html,ng.reflect.Method;
import javax.persistence.Table;
import org.junit.Test;
/**
* 测试：自定义注解的语法
* @author Jie.Yuan
*
*/
public class App_2 {
private String test;
@Id
@Author(remark = "保存信息！！！", age = 19)
public void save() throws Exception {
// 获取注解信息：name/age/remark
// 1. 先获取代表方法的Method类型;
Class clazz = App_2.class;
Method m = clazz.getMethod("save");
// 2. 再获取方法上的注解
Author author = m.getAnnotation(Author.class);
// 获取输出注解信息
System.out.println(author.authorName());
System.out.println(author.age());
System.out.println(author.remark());
}
@Test
public void testMain() throws Exception {
save();
}
}
3
package cn.itcast.d_anno;
import static https://www.doczj.com/doc/3f4569581.html,ng.annotation.ElementType.CONSTRUCTOR;
import static https://www.doczj.com/doc/3f4569581.html,ng.annotation.ElementType.FIELD;
import static https://www.doczj.com/doc/3f4569581.html,ng.annotation.ElementType.LOCAL_VARIABLE;
import static https://www.doczj.com/doc/3f4569581.html,ng.annotation.ElementType.METHOD;
import static https://www.doczj.com/doc/3f4569581.html,ng.annotation.ElementType.PARAMETER;
import static https://www.doczj.com/doc/3f4569581.html,ng.annotation.ElementType.TYPE;
import https://www.doczj.com/doc/3f4569581.html,ng.annotation.Retention;
import https://www.doczj.com/doc/3f4569581.html,ng.annotation.RetentionPolicy;
import https://www.doczj.com/doc/3f4569581.html,ng.annotation.Target;
import https://www.doczj.com/doc/3f4569581.html,ng.reflect.Type;
/**
* 自定义注解(描述一个作者)
* @author Jie.Yuan
*
*/
// 元注解- 1. 定义注解的可用范围
@Target({TYPE,FIELD , METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE}) //@Target({METHOD,FIELD,TYPE}) 指定只能在方法、字段、类上用；
// 元注解- 2. 指定注解的声明周期
@Retention(RetentionPolicy.RUNTIME) // 字节码级别有效
动态规划基本原理 动态规划基本原理 近年来，涉及动态规划的各种竞赛题越来越多，每一年的NOI几乎都至少有一道题目 需要用动态规划的方法来解决；而竞赛对选手运用动态规划知识的要求也越来越高，已经 不再停留于简单的递推和建模上了。 要了解动态规划的概念，首先要知道什么是多阶段决策问题。 一、多阶段决策问题 如果一类活动过程可以分为若干个互相联系的阶段，在每一个阶段都需作出决策(采 取措施)，一个阶段的决策确定以后，常常影响到下一个阶段的决策，从而就完全确定了 一个过程的活动路线，则称它为多阶段决策问题。 各个阶段的决策构成一个决策序列，称为一个策略。每一个阶段都有若干个决策可供 选择，因而就有许多策略供我们选取，对应于一个策略可以确定活动的效果，这个效果可 以用数量来确定。策略不同，效果也不同，多阶段决策问题，就是要在可以选择的那些策 略中间，选取一个最优策略，使在预定的标准下达到最好的效果. 让我们先来看下面的例子：如图所示的是一个带权有向的多段图，要求从A到D的最 短 图4-1 带权有向多段图 路径的长度(下面简称最短距离)。 我们可以搜索，枚举图中的每条路径，但当图的规模大起来时，搜索的效率显然不可 能尽人意。让我们来试用动态规划的思路分析这道题：从图中可以看到，A点要到达D点 必然要经过B1和B2中的一个，所以A到D的最短距离必然等于B1到D的最短距离加上5，或是B2到D的最短距离加上2。同样的，B1到D的最短距离必然等于C1到D的最短距离 加上3或是C2到D的最短距离加上2，……。 我们设G[i]为点i到点D的距离，显然G[C1]=4，G[C2]=3，G[C3]=5，根据上面的分析， 有： G[B1]=min{G[C1]+3，G[C2]+2}=5， G[B2]=min{G[C2]+7，G[C3]+4}=9， 再就有G[A]=min{G[B1]+5，G[B2]+2}=10，
动态代理 简单介绍 代理可分为静态代理和动态代理。静态代理在源代码级实现，而动态代理在运行时实现。 代理的几个概念： 抽象角色：声明真实对象和代理对象的共同接口。（就是接口） 代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。（就是实现上述接口的代理，即代理对象）真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。（就是要代理的真正对象，即被代理对象，或称目标对象） 在使用JDK中的动态代理时，要注意目标对象必须实现接口。动态代理的几个概念： 动态代理类：实现了一系列的接口，而这些接口是在动态代理类被创建时指定的。 代理接口：就是由动态代理类所实现的接口。 代理实例：就是动态代理类的实例。 动态代理类和其实例可以由https://www.doczj.com/doc/3f4569581.html,ng.reflect.Proxy来创建。如要创造接口Foo的代理： InvocationHandler handler = new MyInvocationHandler(...); //创建动态代理类 Class proxyClass = Proxy.getProxyClass( Foo.class.getClassLoader(), new Class[] { Foo.class }); //创建动态代理类的实例 Foo f = (Foo) proxyClass. getConstructor(new Class[] { InvocationHandler.class }). newInstance(new Object[] { handler }); 或者使用（更简单，一步完成创建动态代理类的实现）： Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(), new Class[] { Foo.class }, handler); 实例演示 DynamicProxy.java
概率论基础知识 第一章随机事件及其概率 一随机事件 §1几个概念 1、随机实验:1）试验可在相同条件下重复进行；（2）试验的可能结果不止一个，且所有可能结果是已知的；（3）每次试验哪个结果出现是未知的；随机试验以后简称为试验，并常记为E。 例如：E1：掷一骰子，观察出现的总数；E2：上抛硬币两次，观察正反面出现的情况； E3：观察某电话交换台在某段时间内接到的呼唤次数。 2、随机事件：在试验中可能出现也可能不出现的事情称为随机事件常记为A，B，C……例如，在E1中，A表示“掷出2点”，B表示“掷出偶数点”均为随机事件。 3、必然事件与不可能事件：记为Ω。每次试验都不 记为Φ。 例如，在E1中，“掷出不大于6点”的事件便是必然事件，而“掷出大于6点”的事件便是
不可能事件,以后 4、基本事件： 例如，在E1中，“掷出1点”，“掷出2点”，……，“掷出6点”均为此试验的基本事件。 例如，在E1中“掷出偶数点”便是复合事件。 5、样本空间：从集合观点看，常记为e. 例如，在E1中，用数字1，2，……，6表示掷出的点数，而由它们分别构成的单点集{1}，{2}，…{6}便是E1中的基本事件。在E2中，用H表示正面，T表示反面，此试验的样本点有（H，H），（H，T），（T，H），（T，T），其基本事件便是{（H，H）}，{（H，T）}，{（T，H）}，{（T，T）}显然，任何事件均为某些样本点构成的集合。 例如，在E1中“掷出偶数点”的事件便可表为{2，4，6}。试验中所有样本点构成的集合称为样本空间。记为Ω。 例如， 在E1中，Ω={1，2，3，4，5，6} 在E2中，Ω={（H，H），（H，T），（T，H），（T，T）} 在E3中，Ω={0，1，2，……}
动态规划算法原理及其应用研究 系别：x x x 姓名：x x x 指导教员： x x x 2012年5月20日
摘要：动态规划是解决最优化问题的基本方法，本文介绍了动态规划的基本思想和基本步骤，并通过几个实例的分析，研究了利用动态规划设计算法的具体途径。关键词：动态规划多阶段决策 1.引言 规划问题的最终目的就是确定各决策变量的取值，以使目标函数达到极大或极小。在线性规划和非线性规划中，决策变量都是以集合的形式被一次性处理的；然而，有时我们也会面对决策变量需分期、分批处理的多阶段决策问题。所谓多阶段决策问题是指这样一类活动过程：它可以分解为若干个互相联系的阶段，在每一阶段分别对应着一组可供选取的决策集合；即构成过程的每个阶段都需要进行一次决策的决策问题。将各个阶段的决策综合起来构成一个决策序列，称为一个策略。显然，由于各个阶段选取的决策不同，对应整个过程可以有一系列不同的策略。当过程采取某个具体策略时，相应可以得到一个确定的效果，采取不同的策略，就会得到不同的效果。多阶段的决策问题，就是要在所有可能采取的策略中选取一个最优的策略，以便得到最佳的效果。动态规划是一种求解多阶段决策问题的系统技术，可以说它横跨整个规划领域（线性规划和非线性规划）。在多阶段决策问题中，有些问题对阶段的划分具有明显的时序性，动态规划的“动态”二字也由此而得名。动态规划的主要创始人是美国数学家贝尔曼（Bellman）。20世纪40年代末50年代初，当时在兰德公司（Rand Corporation）从事研究工作的贝尔曼首先提出了动态规划的概念。1957年贝尔曼发表了数篇研究论文，并出版了他的第一部著作《动态规划》。该著作成为了当时唯一的进一步研究和应用动态规划的理论源泉。在贝尔曼及其助手们致力于发展和推广这一技术的同时，其他一些学者也对动态规划的发展做出了重大的贡献，其中最值得一提的是爱尔思（Aris）和梅特顿（Mitten）。爱尔思先后于1961年和1964年出版了两部关于动态规划的著作，并于1964年同尼母霍思尔（Nemhauser）、威尔德（Wild）一道创建了处理分枝、循环性多阶段决策系统的一般性理论。梅特顿提出了许多对动态规划后来发展有着重要意义的基础性观点，并且对明晰动态规划路径的数
动态规划基本原理 近年来，涉及动态规划的各种竞赛题越来越多，每一年的NOI几乎都至少有一道题目需要用动态规划的方法来解决；而竞赛对选手运用动态规划知识的要求也越来越高，已经不再停留于简单的递推和建模上了。 要了解动态规划的概念，首先要知道什么是多阶段决策问题。 一、多阶段决策问题 如果一类活动过程可以分为若干个互相联系的阶段，在每一个阶段都需作出决策(采取措施)，一个阶段的决策确定以后，常常影响到下一个阶段的决策，从而就完全确定了一个过程的活动路线，则称它为多阶段决策问题。 各个阶段的决策构成一个决策序列，称为一个策略。每一个阶段都有若干个决策可供选择，因而就有许多策略供我们选取，对应于一个策略可以确定活动的效果，这个效果可以用数量来确定。策略不同，效果也不同，多阶段决策问题，就是要在可以选择的那些策略中间，选取一个最优策略，使在预定的标准下达到最好的效果. 让我们先来看下面的例子：如图所示的是一个带权有向的多段图，要求从A到D的最短 图4-1 带权有向多段图 路径的长度(下面简称最短距离)。 我们可以搜索，枚举图中的每条路径，但当图的规模大起来时，搜索的效率显然不可能尽人意。让我们来试用动态规划的思路分析这道题：从图中可以看到，A点要到达D点必然要经过B1和B2中的一个，所以A到D的最短距离必然等于B1到D的最短距离加上5，或是B2到D的最短距离加上2。同样的，B1到D的最短距离必然等于C1到D的最短距离加上3或是C2到D的最短距离加上2，……。 我们设G[i]为点i到点D的距离，显然G[C1]=4，G[C2]=3，G[C3]=5，根据上面的分析，
有： G[B1]=min{G[C1]+3，G[C2]+2}=5， G[B2]=min{G[C2]+7，G[C3]+4}=9， 再就有G[A]=min{G[B1]+5，G[B2]+2}=10， 所以A到D的最短距离是10，最短路径是A→B1→C2→D。 二、动态规划的术语 1．阶段 把所给求解问题的过程恰当地分成若干个相互联系的阶段，以便于求解，过程不同，阶段数就可能不同．描述阶段的变量称为阶段变量。在多数情况下，阶段变量是离散的，用k 表示。此外，也有阶段变量是连续的情形。如果过程可以在任何时刻作出决策，且在任意两个不同的时刻之间允许有无穷多个决策时，阶段变量就是连续的。 在前面的例子中，第一个阶段就是点A，而第二个阶段就是点A到点B，第三个阶段是点B到点C，而第四个阶段是点C到点D。 2．状态 状态表示每个阶段开始面临的自然状况或客观条件，它不以人们的主观意志为转移，也称为不可控因素。在上面的例子中状态就是某阶段的出发位置，它既是该阶段某路的起点，同时又是前一阶段某支路的终点。 在前面的例子中，第一个阶段有一个状态即A，而第二个阶段有两个状态B1和B2，第三个阶段是三个状态C1，C2和C3，而第四个阶段又是一个状态D。 过程的状态通常可以用一个或”一组数”来描述，称为状态变量。一般，状态是离散的，但有时为了方便也将状态取成连续的。当然，在现实生活中，由于变量形式的限制，所有的状态都是离散的，但从分析的观点，有时将状态作为连续的处理将会有很大的好处。此外，状态可以有多个分量(多维情形)，因而用向量来代表；而且在每个阶段的状态维数可以不同。 当过程按所有可能不同的方式发展时，过程各段的状态变量将在某一确定的范围内取值。状态变量取值的集合称为状态集合。 3．无后效性 我们要求状态具有下面的性质：如果给定某一阶段的状态，则在这一阶段以后过程的发
JA V A的反射机制与动态代理 李海峰（QQ:61673110）-Andrew830314@https://www.doczj.com/doc/3f4569581.html, 运行时类型信息（RunTime Type Information，RTTI）使得你在程序运行时发现和使用类型信息。RTTI主要用来运行时获取向上转型之后的对象到底是什么具体的类型。 1.Class对象： JAVA使用Class对象来执行RTTI。每个类都有一个Class对象，它用来创建这个类的所有对象，反过来说，每个类的所有对象都会关联同一个Class对象（对于数组来说，维数、类型一致的数组的Class对象才是相同的），每个对象的创建都依赖于Class对象的是否创建，Class对象的创建发生在类加载（https://www.doczj.com/doc/3f4569581.html,ng.ClassLoader）的时候。 https://www.doczj.com/doc/3f4569581.html,ng.Class类实现了Serializable、GenericDeclaration、Type、AnnotatedElement四个接口，分别实现了可序列化、泛型定义、类型、元数据（注解）的功能。 你可以把Class对象理解为一个类在内存中的接口代理（它代理了这个类的类型信息、方法签名、属性），JVM加载一个类的时候首先创建Class对象，然后创建这个类的每个实例的时候都使用这个Class对象。 Class只有一个私有的无参构造方法，也就是说Class的对象创建只有JVM可以完成。 如何验证同一个类的多个对象的Class对象是一个呢？ Cf1 cf1 = new Cf1(); Class clazz = Cf1.class; System.out.println(cf1.getClass() == clazz); 我们知道==用来比较引用是否相等（也就是同一个引用），上面的输出语句结果是true。那么Class对象是否相等是JAVA对象中唯一可以使用==判断的。 如何获取Class对象： 1.所有的引用数据类型（类-类型）的类名、基本数据类型都可以通过.class方式获取其Class 对象（对于基本数据类型的封装类还可以通过.TYPE的方式获取其Class对象，但要注意.TYPE实际上获取的封装类对应的基本类型的Class对象的引用，那么你可以判断出int.class==Integer.TYPE返回true，int.class==Integer.class返回false！），通过这种方式不会初始化静态域，使用.class、.TYPE的方式获取Class对象叫做类的字面常量； 2.Class的forName(String name)传入一个类的完整类路径也可以获得Class对象，但由于使用的是字符串，必须强制转换才可以获取泛型的Class
高考总复习：古典概型与几何概型 【考点梳理】 知识点一、古典概型 1. 定义 具有如下两个特点的概率模型称为古典概型： （1）试验中所有可能出现的基本事件只有有限个； （2）每个基本事件出现的可能性相等。 2. 古典概型的基本特征 （1）有限性：即在一次试验中，可能出现的结果，只有有限个，也就是说，只有有限个不同的基本事件。 （2）等可能性：每个基本事件发生的可能性是均等的。 3.古典概型的概率计算公式 由于古典概型中基本事件发生是等可能的，如果一次试验中共有n 种等可能的结果，那么每一个基本事件的概率都是 1n 。如果某个事件A 包含m 个基本事件，由于基本事件是互斥的，则事件A 发生的概率为其所含m 个基本事件的概率之和，即n m A P =)(。 所以古典概型计算事件A 的概率计算公式为： 试验的基本事件总数 包含的基本事件数事件A A P =)( 4.求古典概型的概率的一般步骤： （1）算出基本事件的总个数n ； （2）计算事件A 包含的基本事件的个数m ； （3）应用公式()m P A n =求值。 5．古典概型中求基本事件数的方法： （1）穷举法； （2）树形图； （3）排列组合法。利用排列组合知识中的分类计数原理和分步计数原理，必须做到不重复不遗漏。 知识点二、几何概型
1. 定义： 事件A 理解为区域Ω的某一子区域A ，A 的概率只与子区域A 的几何度量（长度、面积或体积）成正比，而与A 的位置和形状无关。满足以上条件的试验称为几何概型。 2.几何概型的两个特点： （1）无限性，即在一次试验中基本事件的个数是无限的； （2）等可能性，即每一个基本事件发生的可能性是均等的。 3.几何概型的概率计算公式： 随机事件A 的概率可以用“事件A 包含的基本事件所占的图形面积（体积、长度）”与“试验的基本事件所占总面积（体积、长度）”之比来表示。 所以几何概型计算事件A 的概率计算公式为：Ω=μμA A P )( 其中μΩ表示试验的全部结果构成的区域Ω的几何度量，A μ表示构成事件A 的区域的几何度量。 要点诠释：用几何概型的概率公式计算概率时，关键是构造出随机事件所对应的几何图形，并对几何图形进行相应的几何度量. 对于一些简单的几何概型问题，可以快捷的找到解决办法. 【典型例题】 类型一、古典概型 例1(2014 四川高考)一个盒子里装有三张卡片，分别标记有数字 错误!未找到引用源。，错误!未找到引用源。，错误!未找到引用源。，这三张卡片除标记的数字外完全相同．随机有放回地抽取 错误!未找到引用源。 次，每次抽取 错误!未找到引用源。 张，将抽取的卡片上的数字依次记为 错误!未找到引用源。，错误!未找到引用源。，错误!未找到引用源。． (1) 求“抽取的卡片上的数字满足 错误!未找到引用源。 ”的概率； (2) 求“抽取的卡片上的数字 错误!未找到引用源。，错误!未找到引用源。，错误!未找到引用源。 不完全相同”的概率． 【解析】 (1) 由题意，错误!未找到引用源。 的所有可能为 共 错误!未找到引用源。 种．
课题：古典概型与几何概率 考纲要求： ① 理解古典概型及其概率计算公式；② 会计算一些随机事件所含的基本事件数及事件 发生的概率；③了解随机数的意义，能运用模拟方法估计概率；④了解几何概型的意义. 教材复习 1.古典概型：把同时具有： “()1每一次试验中所有可能出现的结果都是有限的，每次试验只出现其中一个结果；()2每一个结果出现的可能性相同”的两个特征的随机试验的数 学模型称为古典概型： 基本步骤：①计算一次试验中基本事件的总数n ；②事件A 包含的基本事件的个数m ； ③由公式n m A P = )(计算. 注：必须在解题过程中指出等可能的.. 2.几何概型：如果每个事件发生的概率只与构成事件的长度（面积或体积）成比例，则称这样的概率模型为几何概率模型，简称几何概型. 特性：每一次试验中所有可能出现的结果都是无限的，每一个结果出现的可能性都是相等的. 基本步骤：（1）构设变量（2）集合表示（3）作出区域（4）计算求解. 几何概型的计算：()P A = 积）的区域长度（面积或体试验的全部结果所构成积） 的区域长度（面积或体构成事件A 3.随机数：是在一定范围内随机产生的数，并且在这个范围内得到每一个数的机会相等. 随机数的一个重要应用就是用计算机产生随机数来模拟设计实验. 模拟是利用模型来研究某些现象的性质的一种有效方法，可以节约大量的人力、物力. 典例分析： 考点一 古典概型的概念 问题1．判断下列命题正确与否： ()1 掷两枚硬币，可能出现“两个正面” ，“两个反面”，“一正一反”3种结果；()2某袋中装有大小均匀的三个红球、两个黑球、一个白球，那么每种颜色的球被摸到的可能行相同；()3从4,3,2,1,0,1,2----中任取一数，取到的数小于0和不小于0的可能性相同； ()4分别从3名男同学，4名女同学中各选一名做代表，那么每个同学当选的可能性相同； ()55人抽签，甲先抽，乙后抽，那么乙与甲抽到某中奖签的可能性肯定不同.
动态规划的原理及应用 班级：计科1302班 小组成员：王海涛蔡佳韦舒 蒋宪豪尹卓 完成时间：2015年5月26日
动态规划的原理及应用 学生：算法设计第5组，计算机系 指导教师：甘靖，计算机系 摘要：动态规划是解决多阶段决策过程最优化问题的一种方法。特点是把多阶段决策问题变换为一系列相互联系的单阶段问题，然后逐个加以解决。其基本思想就是把全局的问题化为局部的问题，为了全局最优必须局部最优，适用于在解决问题过程中需要多次重复解决子问题的问题。其应用领域广泛，涉及到管理学、经济学、交通、军事和计算机等多个领域，将动态规划思想正确地应用于实践，将对我们的生活带来便利，甚至带给我们的社会和国家以保障。 关键词：动态规划；最优决策；应用；领域 The Principle and Application of Dynamic Programing The dynamic programing is a way to solve optimization problem in the process of multi-stage decision,whose feature is alter the multi-stage decision problems to single phase problems which are connected with each other,and then solve them one by one.The basic idea is to change the overall problem into partcial problem.And the partcial one must keep the best in order to promise the quality of overall one,which splies to repeatedly solving subproblem throughout the whole process.It is spreading to many fields,like management,economics,traffic,military and computer. Put the idea of dynamic programing correctly into practice will bring a lot of convenience to our daily life,our society as well as our country.
泛型(Generic) —泛形的作用 JDK5中的泛形允许程序员在编写集合代码时，就限制集合的处理类型，从而把原来程序运行时可能发生问题，转变为编译时的问题，以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。 注意：泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。 泛形的基本术语，以ArrayList
几何概型 【学习目标】 1.了解几何概型的概念及基本特点; 2.熟练掌握几何概型中概率的计算公式; 3.会进行简单的几何概率计算; 4.能运用模拟的方法估计概率，掌握模拟估计面积的思想 【要点梳理】 要点一：几何概型 1.几何概型的概念: 对于一个随机试验，我们将每个基本事件理解为从某个特定的几何区域内随机地取一点，该区域中每一点被取到的机会都一样；而一个随机事件的发生则 理解为恰好取到上述区域内的某个指定区域中的点.这里的区域可以是线段，平 面图形，立体图形等.用这种方法处理随机试验，称为几何概型 2.几何概型的基本特点: (1)试验中所有可能出现的结果(基本事件)有无限多个; (2)每个基本事件出现的可能性相等. 3.几何概型的概率: 般地，在几何区域D中随机地取一点，记事件"该点落在其内部一个区域 d内"为事件A，贝y事件A发生的概率P(A) = D的测度. 说明: (1)D的测度不为0 ； ⑵ 其中"测度"的意义依D确定，当D分别是线段，平面图形，立体图形时，相应的"测度"分别是长度，面积和体积
(3)区域为＂开区域＂； (4)区域 D 内随机取点是指：该点落在区域内任何一处都是等可能的，落在 任何部分的可能性大小只与该部分的测度成正比而与其形状位置无关 要点诠释： 几种常见的几何概型 (1)设线段l是线段L的一部分，向线段L上任投一点，若落在线段l上的点 数与线段l的长度成正比，而与线段l在线段L上的相对位置无关，则点落在线段l上的概率为: P=的长度/L的长度 (2)设平面区域g是平面区域G的一部分，向区域G上任投一点，若落在区 域g上的点数与区域g的面积成正比，而与区域g在区域G上的相对位置无关, 则点落在区域g上概率为: P=g的面积/G的面积 (3)设空间区域上v是空间区域V的一部分，向区域V上任投一点，若落在 区域v上的点数与区域v的体积成正比，而与区域v在区域V上的相对位置无 关，则点落在区域v上的概率为: P=v的体积N的体积 要点二:均匀随机数的产生 1.随机数的概念 随机数是在一定范围内随机产生的数，并且得到这个范围内任何一个数的机会是均等的.它可以帮助我们模拟随机试验，特别是一些成本高、时间长的试验，用随机模拟的方法可以起到降低成本，缩短时间的作用 2.随机数的产生方法 (1) 实例法. 包括掷骰子、掷硬币、抽签、转盘等.
动态规划的特点及其应用 摘要:本文的主要内容就是分析它的特点。第一部分首先探究了动态规划的本质，因为动态规划的特点是由它的本质所决定的。第二部分从动态规划的设计和实现这两个角度分析了动态规划的多样性、模式性、技巧性这三个特点。第三部分将动态规划和递推、搜索、网络流这三个相关算法作了比较，从中探寻动态规划的一些更深层次的特点。文章在分析动态规划的特点的同时，还根据这些特点分析了我们在解题中应该怎样利用这些特点，怎样运用动态规划。这对我们的解题实践有一定的指导意义。本文介绍了动态规划的基本思想和基本步骤，通过实例研究了利用动态规划设计算法的具体途径，讨论了动态规划的一些实现技巧，并将动态规划和其他一些算法作了比较，最后还简单介绍了动态规划的数学理论基础和当前最新的研究成果。 关键词: 动态规划，阶段 1 引言 动态规划是运筹学的一个分支，是求解决策过程最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman 等人在研究多阶段决策过程(multistep decision process)的优化问题时，提出了著名的最优化原理(principle of optimality)，把多阶段过程转化为一系列单阶段问题，逐个求解，创立了解决这类过程优化问题的新方法——动态规划。1957年出版了他的名著Dynamic Programming，这是该领域的第一本著作。 动态规划问世以来，在经济管理、生产调度、工程技术和最优控制等方面得到了广泛的应用。例如最短路线、库存管理、资源分配、设备更新、排序、装载等问题，用动态规划方法比用其它方法求解更为方便。 虽然动态规划主要用于求解以时间划分阶段的动态过程的优化问题，但是一些与时间无关的静态规划(如线性规划、非线性规划)，只要人为地引进时间因素，把它视为多阶段决策过程，也可以用动态规划方法方便地求解。 2 动态规划的基本思想 一般来说，只要问题可以划分成规模更小的子问题，并且原问题的最优解中包含了子问题的最优解（即满足最优子化原理），则可以考虑用动态规划解决。动态规划的实质是分治思想和解决冗余，因此，动态规划是一种将问题实例分解
————————————————————————————— 动态代理原理简析 一、概述 1.动态编译https://www.doczj.com/doc/3f4569581.html,pilationTask 动态编译想理解自己查API文档 2.反射被代理类主要使用Method.invoke(Object o,Object... args);对带有指定参数的指定对象调用由此Method 对象表示的底层方法。 3.类的加载URLClassLoader可以加载硬盘任意位置的.java文件。class.getClassLoader只能加载classPath目录下的类。 动态代理可以理解为动态生成发射代理的类。这其中可以动态增加逻辑操作。比如日志的打印，事物的处理等。spring的AOP操作也是动态代理的。 二、创建业务接口 假设我们有一个接口GrowAble可成长的。 1.package https://www.doczj.com/doc/3f4569581.html,; 2. 3.public interface GrowAble { 4. void growUp(); 5.} 一棵小树苗实现了这个接口 1.package https://www.doczj.com/doc/3f4569581.html,; 2.public class Tree implements GrowAble { 3. @Override 4. public void growUp() { 5. System.out.println('I am a tree , I'm grow up!'); 6. } 7. 8.} 这时我们想不在不改变源码的情况下想知道树长了多少这个操作？ 我们需要一个转换接口。
————————————————————————————— 1.package https://www.doczj.com/doc/3f4569581.html,; 2.import https://www.doczj.com/doc/3f4569581.html,ng.reflect.Method; 3. 4.public interface InvactionHandle { 5. void invoke(Object o,Method m); 6.} 一个实现接口类。 01.package https://www.doczj.com/doc/3f4569581.html,; 02.import https://www.doczj.com/doc/3f4569581.html,ng.reflect.Method; 03.import java.util.Random; 04. 05.public class HeightInvactionHandle implements InvactionHandle { 06. @Override 07. public void invoke(Object c, Method m) { 08. try { 09. m.invoke(this.o); 10. System.out.println('这棵树长了' + new Random().nextInt(9527)+'米！！！' ); 11. } catch (Exception e) { 12. e.printStackTrace(); 13. } 14. } 15. private Object o; 16. public HeightInvactionHandle(Object o) { 17. super(); 18. this.o = o; 19. } 20.} 三、其他重要类 现在最重要的Proxy类了。把上述两个接口接口起来。 01.package https://www.doczj.com/doc/3f4569581.html,;
一.相关类及其方法: https://www.doczj.com/doc/3f4569581.html,ng.reflect.Proxy, Proxy 提供用于创建动态代理类和实例的静态方法. newProxyInstance() 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序 (详见api文档) https://www.doczj.com/doc/3f4569581.html,ng.reflect.InvocationHandler, InvocationHandler 是代理实例的调用处理程序实现的接口。 invoke() 在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。 (详见api文档) 二.源代码: 被代理对象的接口及实现类: package com.ml.test; public interface Manager { public void modify(); } package com.ml.test; public class ManagerImpl implements Manager { @Override public void modify() {
System.out.println("*******modify()方法被调用"); } } 业务代理类: package com.ml.test; import https://www.doczj.com/doc/3f4569581.html,ng.reflect.InvocationHandler; import https://www.doczj.com/doc/3f4569581.html,ng.reflect.Method; public class BusinessHandler implements InvocationHandler { private Object object = null; public BusinessHandler(Object object) { this.object = object; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("do something before method"); Object ret = method.invoke(this.object, args); System.out.println("do something after method"); return ret; } }
人教版高中数学必修三 知识点梳理 重点题型（常考知识点）巩固练习 几何概型 【学习目标】 1.了解几何概型的概念及基本特点； 2.熟练掌握几何概型中概率的计算公式； 3.会进行简单的几何概率计算； 4.能运用模拟的方法估计概率，掌握模拟估计面积的思想. 【要点梳理】 要点一：几何概型 1.几何概型的概念： 对于一个随机试验，我们将每个基本事件理解为从某个特定的几何区域内随机地取一点，该区域中每一点被取到的机会都一样；而一个随机事件的发生则理解为恰好取到上述区域内的某个指定区域中的点.这里的区域可以是线段，平面图形，立体图形等.用这种方法处理随机试验，称为几何概型. 2.几何概型的基本特点： (1)试验中所有可能出现的结果(基本事件)有无限多个； (2)每个基本事件出现的可能性相等. 3.几何概型的概率： 一般地，在几何区域D 中随机地取一点，记事件＂该点落在其内部一个区域d 内＂为事件A ，则事件A 发生的概率()d P A D 的测度的测度 . 说明： (1)D 的测度不为0； (2)其中＂测度＂的意义依D 确定，当D 分别是线段，平面图形，立体图形时，相应的＂测度＂分别是长度，面积和体积. (3)区域为＂开区域＂； (4)区域D 内随机取点是指：该点落在区域内任何一处都是等可能的，落在任何部分的可能性大小只与该部分的测度成正比而与其形状位置无关. 要点诠释： 几种常见的几何概型 (1)设线段l 是线段L 的一部分，向线段L 上任投一点，若落在线段l 上的点数与线段l 的长度成正比，而与线段l 在线段L 上的相对位置无关，则点落在线段l 上的概率为： P=l 的长度/L 的长度 (2)设平面区域g 是平面区域G 的一部分，向区域G 上任投一点，若落在区域g 上的点数与区域g 的面积成正比，而与区域g 在区域G 上的相对位置无关，则点落在区域g 上概率为： P=g 的面积/G 的面积 (3)设空间区域上v 是空间区域V 的一部分，向区域V 上任投一点，若落在区域v 上的点数与区域v 的体积成正比，而与区域v 在区域V 上的相对位置无关，则点落在区域v 上的概率为： P=v 的体积/V 的体积
动态规划的基本概念 基本概念 设我们研究某一个过程,这个过程可以分解为若干个互相联系的阶段。每一阶段都有其初始状态和结束状态,其结束状态即为下一阶段的初始.状态。第一阶段的初始状态就是整个过程的初始状态,最后一阶段的结束状态就是整个过程的结束状态。在过程的每一个阶段都需要作出决策,而每一阶段的结束状态依赖于其初始状态和该阶段的决策。动态规划问题就是要找出某种决策方法, 使过程达到某种最优效果。 这种把问题看作前后关联的多阶段过程称为多阶段决策过程, 可用图9.1表示。下面介绍动态规划的术语和基本概念。 (l)阶段 把所研究的过程恰当地分为若干个互相联系的相对独立过程。 (2)状态变量 用来描述系统所处状态的变量称为状态变量。通常用s k 表示第k 阶段的初始状态，则s k +1表示第k 阶段结束时(也就是第k+l 阶段开始时)过程的状态。 通常要求状态变量具有无后效性, 即过程在第k 阶段以后的变化只与该阶段结束时的状态有关, 而与系统如何到达此状态的过程无关。 (3)决策变量的状态转移方程。系统在第k 阶段中的变化过程, 通常我们并不关心，但我们希望知道该阶段的初始状态与结束状态之间的关系。我们用以影响该系统的手段，也用一个变量x k 表示，称为决策变量， 则第k 阶段结束时的状态s k +1是决策变量x k 和初始状态s k 的函数, 即 s k +1=T (s k ,x k ) (9-1) (9-1)称为状态转移方程。 (4)权函数 反映第k 阶段决策变量x k 的效益函数W k (s k ,x k ) 称为权函数。 (5)指标函数 判断整个过程优劣的数量指标称为指标函数。当第k 阶段初始状态为s k 时,设我们在此阶段及以后各阶段均采取最优策略时,所获得的效益为f k (s k ), 那么有 ))}(),,(({)(11++∈=k k k k k k D x k k s f x s W F opt s f k k (9-2) 其中opt 表示最优,按具体问题可取为max 或min , D k 是决策变量x k 的定义域;F k 是某一个函数; s k +1=T (s k ,x k ). 图9.1
前言，在Java运行时刻，能否知道一个类的属性方法并调用改动之？对于任意一个对象，能否知道他的所属类，并调用他的方法？答案是肯定的。这种动态的获取信息及动态调用方法的机制在Java中称为“反射”（reflection）。 Java反射机制主要提供以下功能： 在运行时判断任意一个对象所属的类； 在运行时构造任意一个类的对象； 在运行时判断任意一个类所具有的成员变量和方法； 在运行时调用任意一个对象的方法。 Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces（例如Serializable），也包括fields和methods的所有信息，并可于运行时改变fields内容或调用methods。 一般而言，开发者社群说到动态语言，大致认同的一个定义是：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。 在JDK中，主要由以下类来实现Java反射机制，这些类都位于 https://www.doczj.com/doc/3f4569581.html,ng.reflect包中： Class类：代表一个类； Field 类：代表类的成员变量（成员变量也称为类的属性）； Method类：代表类的方法； Constructor 类：代表类的构造方法； Array类：提供了动态创建数组，以及访问数组的元素的静态方法； 例程DateMethodsTest类演示了Reflection API的基本作用，它读取命令行参数指定的类名，然后打印这个类所具有的方法信息，代码如下： Java代码 1.public class DateMethodsTest 2.{ 3. public static void main(String args[]) throws Exception 4. { 5. // 加载并初始化命令行参数指定的类 6. Class classType = Class.forName("java.util.Date"); 7. // 获得类的所有方法 8. Method methods[] = classType.getDeclaredMethods(); 9. for (int i = 0; i < methods.length; i++) 10. { 11. System.out.println(methods[i].toString());
动态代理实现Authorization（授权） * https://www.doczj.com/doc/3f4569581.html,ng.reflect包中的 Proxy和InvocationHandler接口提供了创建（指定类[接口更准确些]的）动态代理类的能力。 我们知道，对象是类的实例，一般使用内存来模拟对象，对象是依据类为模板来创建的，创建时使用new来分配一块内存区（其布局 参考相应类的内存布局），为变量做一些赋值便是对象的初始化了。我们知道通常类是设计时的产物，在设计时我们编写对象的模板（即——类），运行时 产生类的实例。类所处的文件是 .java文件——源文件，之后编译为jvm-----java虚拟机可解释执行的.class字节码文件，在类解析 过程中这些.class文件由类加载器加载到虚拟机（可实现自己的类加载器来加载处于特定路径下的类，或加载用某种加密算法加密过的类文件---这样 便于进行安全控制——具体描述参考（Core java ——Java核心卷二））。在遇到创建对象的指令时使用加载的类来创建对象内存 空间。动态代理是不用创建类文件（当然也不用创建java源文件），就能在虚拟机中构造出类文件区域来（相当于使用Proxy类来 创建一块类内存区域，该区域中的内容相当于加载某个.class文件产生的区域；比如我们在使用DOM技术时，从一个XML文件构造一个 DOM内存表示，它是XML文件的内存表示，但我们也可以直接使用DOM API在内存中构建一个dom树，最终结果就是一个内存DOM树，你不用关心 这个dom树是来自于xmL文件还是直接的运行时构造）。 * ** 关于代理设计模式，这里不再敷述。代理和被代理类（目标类）实现共同的接口。我们在调用时不需区别它是否是真正的目标对象。 代理会转发请求到目标对象的。比如互联网上的代理服务器，我们不必关心它是不是代理，就当它不存在一样。对客户调用端 他是不关心具体是谁来提供这个服务功能；在服务端选择使用代理的原因可能是：安全，日志，防火墙等。就是说代理可提供一些 非功能性功能，比如缓存功能____来加速服务的响应的速度。在面向方面技术（AOP）中这些非功能性需求被称作“方面”他们横切于功能类 的实现中，比如：某个SubServerImpl（子服务实现）中的某个服务方法： subServer.doService(){ //在日志输出中常有类似的代码出现于多个类实现中 loger.log("