設置時間偉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());
}
}
}