设置时间伟2008年8月8号12:00# date -s "2008-08-08 12:00:00"修改完后,记得执行clock -w，把系统时间写入CMOS
<script type="text/javascript" >
(function(){
i=10;
function aa(){
i=2;
}
aa();
alert(i);
})();
(function(){
i=10;
function aa(){
var i=2;
}
aa();
alert(i);
})();
</script>
在同一个js文件中，使用匿名函数，可以定义方法名相同的方法。
在函数里面没有var声明的变量会直接影响全局的变量，是因为在js中，如果某个变量没有var声明，
会自动到上一层作用域中去找这个变量的声明语句，如果找到，就使用，如果没有找到，继续向上查找，
一直查找到全局作用域为止。如果全局中仍然没有这个变量的声明语句，那么会自动在全局作用域进行声明，
这个就是js的作用域链 。
外部访问函数内部的变量是闭包实现的，函数内部的变量访问外部的变量是作用域链实现的
<html>
<script type="text/javascript">
/*作为普通函数来调用时，this的值指向window，
准确的说，this为null，但被解释成window
alert(window.xx);
function t(){
this.xx = 2;
}
t();
alert(window.xx);
*/
/*作为对象的方法来调用
this指向方法的调用者，就是该对象
var obj = {xx:11,yy:22,t:function(){alert(this.xx);}};
obj.t();
var dog = {xx:33};
dog.t = obj.t;
dog.t();
*/
/*this作为方法调用时，this指向其调用者，即母体对象，
不管被调用函数声明时属于方法还是属于函数
var dog = {xx:33};
show = function(){
alert('show=' +this.xx);
}
dog.t = show;
dog.t();
*/
/*函数作为构造函数调用时
js中没有类的概念，创建对象是用构造函数完成
或者直接用json格式来创建对象
new对象发生的步骤
a:系统创建空对象{}，空对象的constructor属性指向构造感受
b:把函数的this指向该空对象
c:执行该函数
d:返回该对象
*/
function Pig(){
this.age = 2;
return 'a';
}
var pig = new Pig();
//返回Pig对象，因为函数作为构造函数运行时，
//return的值是忽略的，还是返回对象
</script>
</html>
<html>
<script type="text/javascript">
/*arguments是一个对象，一个长得很像数组的对象*/
/*arguments内容是函数运行时期的实参列表*/
/*arguments.callee 属性代表当前运行的函数*/
/*题目：不用函数名，使用匿名函数，完成递归*/
alert((function(n){
if (n<=1){
return n;
}else{
return n+arguments.callee(n-1);
}
})(100));
/*
函数运行期内，关键的三个函数
1：ao 如果本函数ao上没有属性，则继续去外层函数的ao
上找，直到全局对象，叫做作用域链
2：arguments 每个函数有自己的callee属性，但不向外层
接着找arguments相关属性，不形成链
*/
</script>
</html>
<html>
<script type="text/javascript">
function t1(){}
//t2=function(){}
/*这2种方式效果是不同的
t1是函数声明，全局内得到一个t1变量，值是function
t2只是一个赋值过程，值是右侧的表达式的返回结果，即函数
function（）{}在js看来，就和3*3一样，是个表达式，返回一个结果
因此t1,t2两种方式在词法分析时，有着本质区别
前者在词法分析阶段就发挥作用
后者在运行阶段才发挥作用
*/
(function(window,undefined){alert(window);})(window);
</script>
</html>
<html>
<script type="text/javascript">
function a(b){
alert(b);
function b(){
alert(b);
}
b();
}
//a(1);
/*ao{b=fun}*/
function aa(b){
alert(b);
b=function (){
alert(b);
}
b();
}
aa(1);
/*
0:ao={}
1:分析参数 ao={b=undefined}，马上变成ao={b=1}
2：分析var声明，没有
3：分析函数声明，没有
（注：b=function(){}是一个赋值过程，在执行期才有用）
*/
/*词法分析
分析3样东西
第一步：先分析参数
第二步：再分析变量声明
第三步：分析函数声明
一个函数能使用的局部变量，就从3步而来
具体步骤：
0：函数运行前的一瞬间，生成active object
1：a.把声明的参数作为ao对象的属性，值都是undefined
b.接收实参，形成ao对应属性的值
2：分析变量声明，如var
如果ao上还没有此变量声明，则把此变量作为ao属性，
值是undefined
如果ao上已经有了此属性，则不做任何影响
3：分析函数声明，如function t（）{}
则把此函数作为ao的属性
注：如果此前ao已经有了t属性，则以前的t被覆盖
*/
function t1(age){
alert(age);
}
//t1(1);
function t2(age){
var age = 99;
alert(age);
}
//t2(1);
function t3(g){
var g = 'hello';
alert(g);
function g(){
}
alert(g);
}
//t3();
</script>
</html>
<html>
<script type="text/javascript">
function a(b){
alert(b);
function b(){
alert(b);
}
b();
}
//a(1);
/*ao{b=fun}*/
function aa(b){
alert(b);
b=function (){
alert(b);
}
b();
}
aa(1);
/*
0:ao={}
1:分析参数 ao={b=undefined}，马上变成ao={b=1}
2：分析var声明，没有
3：分析函数声明，没有
（注：b=function(){}是一个赋值过程，在执行期才有用）
*/
/*词法分析
分析3样东西
第一步：先分析参数
第二步：再分析变量声明
第三步：分析函数声明
一个函数能使用的局部变量，就从3步而来
具体步骤：
0：函数运行前的一瞬间，生成active object
1：a.把声明的参数作为ao对象的属性，值都是undefined
b.接收实参，形成ao对应属性的值
2：分析变量声明，如var
如果ao上还没有此变量声明，则把此变量作为ao属性，
值是undefined
如果ao上已经有了此属性，则不做任何影响
3：分析函数声明，如function t（）{}
则把此函数作为ao的属性
注：如果此前ao已经有了t属性，则以前的t被覆盖
*/
function t1(age){
alert(age);
}
//t1(1);
function t2(age){
var age = 99;
alert(age);
}
//t2(1);
function t3(g){
var g = 'hello';
alert(g);
function g(){
}
alert(g);
}
//t3();
</script>
</html>
<html>
<script type="text/javascript">
/*作用域
在js中，函数嵌套是非常普遍的，在函数嵌套中，
对变量是如何寻找的？
答：首先在函数内部寻找，如果需找不到，则在外层寻找。
直到……全局（window）区域.从里往外寻找
*/
var c=5;
function t1(){
var d=6;
function t2(){
var e =7;
alert(c+d+e);
}
t2();
}
//t1();//18
function t3(){
var d=6;
function t2(){
var e =7;
d =3;
alert(c+d+e);
}
t2();
}
//t3();//15
/*声明变量,var的作用
var 是在函数运行的上下文中，声明一个变量，
如果不加var，则是一个赋值操作，
但是不要狭隘的理解为声明了一个全局变量
*/
//alert(window.d);
//alert(window.e);
function t(){
d=5;//d没有加var，仅仅是一个赋值操作，寻找
//t域内的函数，如果没找到，继续向外寻找……到window
//如果window中还没有d，创建d变量并赋值
var e=6;
}
//t();
//alert(window.d);
//alert(window.e);
function t4 (){
var d;
function t2(){
d=5;
e=6;
}
t2();
}
//t4();
//alert(window.d);//undefined
//alert(d);// d is not defined
//alert(e);
/*
注意：以window.xxx引用全局变量，寻找不到，
作为window的属性不存在，返回undefined。
直接以xxx引用，寻找不到，则报xxx is not defined
*/
var s1='g';
function t5(){
alert(s1);//g
alert(s2);//is not defined
s2 = 'lo';
}
// t5();
/*
在t5中寻找s2，没有找到s2的变量声明，到window上寻找s2的变量声明，
还是没有找到，报is not defined
*/
function t6(){
alert(s1);//g
alert(s2);//undefined
var s2 = 'lo';
}
t6();
/*
解释：
js代码自上而下执行，但是js代码的整体运行分为：
词法分析期和运行期
自上而下执行之前，先有一个词法分析过程。
词法分析t6函数：
声明了s2变量，但是没有对s2赋值，只有在运行期才赋值
因此s2=undefined。
执行t6函数：
alert(s1);//g
alert(s2);//undefined
s2 = 'lo';
*/
</script>
</html>
/**
* 任务实体类
*/
@Entity
@Table(name = "t_task")
public class Task implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
private Long id;
private String name;
//计划开始时间
private Date plan_startTime;
private Project project;
//父任务
private Task parent;
// 子任务
private Set<Task> children = new HashSet<Task>();
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id")
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Temporal(TemporalType.TIMESTAMP)
public Date getPlan_startTime() {
return plan_startTime;
}
public void setPlan_startTime(Date plan_startTime) {
this.plan_startTime = plan_startTime;
}
@ManyToOne(optional = false, cascade = {CascadeType.REFRESH, CascadeType.MERGE})
@JoinColumn(name = "projectId")
public Project getProject() {
return project;
}
public void setProject(Project project) {
this.project = project;
}
@ManyToOne(cascade = {CascadeType.REFRESH, CascadeType.MERGE})
@JoinColumn(name = "parentId")
public Task getParent() {
return parent;
}
public void setParent(Task parent) {
this.parent = parent;
}
@OrderBy("id ASC")
@OneToMany(mappedBy = "parent", fetch = FetchType.LAZY, cascade = {CascadeType.ALL})
public Set<Task> getChildren() {
return children;
}
public void setChildren(Set<Task> children) {
this.children = children;
}
}
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
public String key();
public String value();
}
@MyAnnotation(key = "k", value = "v")
public class UserAnnotation {
@MyAnnotation(key = "km", value = "vm")
public void sayHello() {
System.out.println("111");
}
public static void main(String[] args) throws Exception {
Class<?> cla = Class
.forName("com.kaishengit.annotation.UserAnnotation");
Method[] methods = cla.getMethods();
boolean flag = cla.isAnnotationPresent(MyAnnotation.class);
System.out.println(flag);
if (flag) {
MyAnnotation mya = (MyAnnotation) cla
.getAnnotation(MyAnnotation.class);
System.out.println(mya.key() + "====" + mya.value());
}
Set<Method> set = new HashSet<Method>();
for (int i = 0; i < methods.length; i++) {
boolean otherflag = methods[i]
.isAnnotationPresent(MyAnnotation.class);
if (otherflag) {
set.add(methods[i]);
System.out.println(methods[i].getName());
}
}
for (Method method : set) {
MyAnnotation name = method.getAnnotation(MyAnnotation.class);
System.out.println(name.key());
System.out.println("value===:" + name.value());
}
}
}