对象为何如此伟大?
    面向对象思想的成功是由于它仿照了现实中的事物和事物的联系.事物有属性和方法.如果我们描述一个台灯.我们会说它的高度和宽度,比如12CM."开灯"这个动作是它的方法.当它是处于开着的状态时.它可以被调亮一点或暗一点(也就是亮度这个属性值变大或变小).
   
javascript 给予了为WEB应用程序创建对象的能力.对象在需要的时候相应的事件会被触发,代码封装后,它能被实例化很多次.在javascript里有几种创建对象的方法,在不同的场合可用不同的方法

1.1JS创建对象方式之一用 new Object() 来创建对象

.最简单的就是用new 操作符,例如:
<script language="javascript" type="text/javascript">
person = new Object()
person.name = "Tim Scarfe"
person.height = "6Ft"
person.run = function() {
       this.state = "running"
       this.speed = "4ms^-1"
}
</script>
我们在这个例子里定义了person这个对象,然后加入了它的属性和方法.在这个例子里,自定义的方法里有两个属性.

1.2.用文字记号Literal Notation创建对象
用文字记号也可以创建对象,但要javascript 1.2以上版本.它的创建形式是多样的.
<script language="javascript" type="text/javascript">
// Object Literals
timObject = {
      property1 : "Hello",
      property2 : "MmmMMm",
      property3 : ["mmm", 2, 3, 6, "kkk"],
      method1 : function(){
         alert("Method had been called" + this.property1)
       }
};
timObject.method1();
alert(timObject.property3[2]) // 结果为3

var circle = { x : 0, y : 0, radius: 2 } // another example
// 嵌套也是允许的哦.
var rectangle = {
          upperLeft : { x : 2, y : 2 },
         lowerRight : { x : 4, y : 4}
}
alert(rectangle.upperLeft.x) // 结果为2
</script>
文字记号可是是数组,也可以是任意的javascript表达式或值.
用 new 操作符或文字记号创建一个自定义对象都是简单的,也是符合逻辑的.但它最大的缺点就是结果不可复用.也不能很容易的用不同的版本初始化创建对象.例如上面的第一个例子,如果 person 的 name 不是 "Tim Scarfe",那样我们不得不重新定义整个对象,仅仅为了适应它的一点点改变.

1.3.对象的构造和原型
   在OOP的世界里,用先前的方法定义对象在许多场合都有限制.我们需要一种创建对象的方法,类型可以被多次使用而不用重新定义.对象在实例化时每次都可以按需分配不同的值.实现这个目标的标准方法是用对象构造器函数.

   一个对象构造器只不过是个有规则的javascript函数,它就象一个容器(定义参数,调用其他函数等等).它们两者所不同的是构造器函数是由 new 操作符调用的.(你将在下面的例子中看到).基于函数语法形式的对象定义,我们可以使它工作得最好.

让我们用现实世界中的猫来举个例子.猫的 name 和 color 是猫的属性.meeyow(猫叫)是它的一个方法.重要的是任何不同的猫都可能有不同的 name 和 meeyow 的叫声.为了建立适应这些特征的对象类,我们将使用对象构造器.
<script language="javascript" type="text/javascript">
function cat(name) {
       this.name = name; 
       this.talk = function() {
              alert( this.name + " say meeow!" )
       }
}
cat1 = new cat("felix")
cat1.talk() //alerts "felix says meeow!"
cat2 = new cat("ginger")
cat2.talk() //alerts "ginger says meeow!"
</script>
在这里,函数 cat() 是一个对象构造器,它的属性和方法在函数体里用this来定义,用对象构造器定义的对象用 new 来实例化.主意我们如何非常容易的定义多个cat 的实例.每一个都有自己的名字,这就是对象构造器带给我们的灵活性.
构造器建立了对象的蓝图.并不是对象本身.

在原型里增加方法.
在上面我们看到的例子里,对象的方法是在构造器里定义好的了.另外一种实现的途径是通过原型(prototype).xxx
原型是javascript继承的一种形式.我们可以为对象定义好后,再创造一个方法.原来所有对象的实例都将共享.
让我们来扩展最初的 cat 对象.增加一个改名的方法.用 prototype 的方式.
<script language="javascript" type="text/javascript">

cat.prototype.changeName = function(name) {
          this.name = name;
}
firstCat = new cat("pursur")
firstCat.changeName("Bill")
firstCat.talk() //alerts "Bill says meeow!"
</script>
就象你所看到的.我们仅只用了 关键字 prototype 实现了在对象定义后马上增加了changeName方法.这个方法被所有的实例共享.

用原型(prototype) 重载 javascript 对象
原型 在自定义对象和有选择性的重载对象上都可以工作.比如 Date() 或 String .这可能是无止境的.

1.4.子类和超类
下面一个例子演示了如何继承
<script language="javascript" type="text/javascript">
function superClass() {
         this.supertest = superTestMethod; //attach method superTest
}

function superTestMethod() {
         return "superTest";
}

function subClass() {
         this.inheritFrom = superClass;
         this.inheritFrom();
         this.subtest = subTestMethod; //attach method subTest
}

function subTestMethod() {
        return "subTest";
}

var newClass = new subClass();
alert(newClass.subtest()); // 弹出"subTest"
alert(newClass.supertest()); // 弹出 "superTest"
</script>
1.5.访问对象属性
正如你所知, (.)操作符能够用来操作对象属性和方法,而([]) 操作符用来操作数组.
<script language="javascript" type="text/javascript">
// 这两种用法是相同的
object.property
object["property"]
</script>
<script language="javascript">
function Circle (xPoint, yPoint, radius) {
       this.x = xPoint;
       this.y = yPoint;
       this.r = radius;
}
var aCircle = new Circle(5, 11, 99);
alert(aCircle.x);
alert(aCircle["x"]);
</script>
我们可以通过for in循环来遍历对象的属性。
<script language="javascript" type="text/javascript">
var testObj = {
      prop1 : "hello",
      prop2 : "hello2",
      prop3 : new Array("hello",1,2)
}
for(x in testObj) {
     alert( x + "-" + testObj[ x ] )
}
</script>
<script language="javascript">
var Circle = { // another example
       x : 0,
       y : 1,
      radius: 2
}

for(p in Circle) {
       alert( p + "-" + Circle[ p ] )
}
</script>

请哪位知道的高手务必指导一下小弟,谢谢!

1    Test test = new Test();
2        test.setName("energykk");
3        //此时的test对象处于Transient(自由状态)并没有被Hibernate框架所管理
4        

Transaction tr = session.beginTransaction();
        session.save(test);
        //此时的test对象已经处于Persistent(持久状态)它被Hibernate纳入实体管理容器
        tr.commit();
        Transaction tr2 = session.beginTransaction();
        test.setName("xukai");
        //在这个事务中我们并没有显示的调用save()方法但是由于Persistent状态的对象将会自动的固化到
        //数据库中,因此此时正处在Persistent状态的test对象的变化也将自动被同步到数据库中
        tr2.commit();

处于Persistent状态的实体可以简单的理解为:如果一个实体对象与session发生了关联,并且处于session的有效期内,那么这个实体对象就处于Persistent状态.

3.游离状态(Detached)
处于Persistent状态的实体对象,其对应的session关闭以后,那么这个实体就处于Detached状态.
我们可以认为session对象就是一个Persistent的宿主,一旦这个宿主失效,那么这个实体就处于Detached状态.

session.close();
        //与test对象关联的session被关闭,因此此时的test对象进入Detached(游离状态)
        
        session2 = HibernateSessionFactory.getSession();
        Transaction tr3 = session2.beginTransaction();
        session2.update(test);
        //此时正处于Detached状态的test对象由于再次借助与session2被纳入到Hibernate的实体管理容器所以此时的
        //test对象恢复到Persistent状态
        test.setName("jjjj");
        tr3.commit();
        
        session2.close();

   end;
   使用该存储过程
   call insertstudent(1,'张三');
 －＞使用输出参数:
  Example:
   create or replace getstudentname(i_studentid in int,o_studentname out vachar);
   as
   begin
    select name into o_studentname from student where studentid = i_studentid;
   end;
  
   使用该存储过程
   set severout on --单独执行
   declare
    studentname vachar(50);--变量声明
   begin
    getstudentname(1,studentname);
    dbms_output.put_line(studentname);
   end;

   着输出结果为:张三

首先我们在要了解Orcale9i之前必须要清楚以下几点:
就Oracle9i本身而言主要可以区分为两个部分:
1.cale Instance(Orcale实例).
2.cale9i Databases Files(Orcale数据库文件).
Orcale Instance是指数据库服务器的内存以及相关处理程序
Orcale Instance又包括SGA(系统全局区)以及Background Processes(后台处理程序)

SGA又包括几个重要的区域(在内存中划分)
1.Database Buffer Cache(块缓冲区高速缓存):用来存放读取自数据文件的副本或者简而理解为用户曾经处理过的数据,这样就能大大的提高数据存取的效率因为他有效的减少了数据在硬盘上的I\O操作.
2.Redo Log Buffer(重做日志缓冲区):记录数据库内所有的数据修改区简而言之就是对数据库的任何修改都会他记录,这样以便数据库被损坏时可以进行必要的修复同时因为他是内存到内存的操作所以又加快
了数据库的操作速度.
3.Shared Pool(共享池):为什么叫他共享池而不叫他共享区呢?我这样认为:因为他其中还包括了两个缓冲区:
 ->Library Cache(SQL语句缓冲区):当用户向Orcale提交一个SQL语句时,该缓冲区就将这条SQL语句进行分析,这个过程类似于编译,这会消耗较多的时间,当Orcale完成对这条SQL语句分析过后,Orcale
   自动将其分析结果保存到Library Cache中,这样当Orcale第二次执行该SQL时,Orcale将自动跳过这个分析过程,从而降低了系统运行的时间.
 ->Data Dictionary(数据字典缓冲区):是Orcale特地为数据字典准备的一块缓冲区,紧供Orcale内部使用储存Orcale系统信息,我们用对他进行太多的细究.
注:Shared Pool是Orcale Instance最关键的内存片段.
4.其他的缓冲区.

Background Processes(后台处理程序)其中主要的几个进程:
1.DBWR(数据写进程):将Database Buffer Cache内改动过的数据块写入到硬盘内的数据文件.
2.LGWR(日志写进程):将重做日志缓冲区内的更改写入到硬盘中的重做日志文件.
3.SMON(系统监控):在因为各种原因造成Orcale数据库不正常的被关闭,下一次激活数据库时SMON将尽行必要的修复.
4.PMON(进程监控):在一个Orcale进程失败时PMON将对资源进行清理.
5.CKPT(检查点进程):在每当Database Buffer Cache中的更改永久性的记录在硬盘中时,更新控制文件和数据文件中的数据库状态信息.
6.ARCH(归档进程):在每次日志切换时把已满的日志组进行备份或归档.

..................

Orcale9i Databases Files是指主要放在计算机硬盘上的各种Orcale9i数据库文件其中包括:
1.数据文件
2.控制文件
3.日志文件
以上三个文件是由进程DBWR与LGWR对他们进行操作
4.归档日志文件
5.参数文件
6.口令文件,用户的应用权限

Orcale 数据库结构:
1.逻辑结构:
 构成的主要由以下几个逻辑部件:
 ->的储存单位块(data block).
 ->区(extends).需要注意的是Oracle9i在配置储存空间时是以区为单位的而不是最小的储存单位块!
 ->段(segement),由许多区构成
 ->表空间(Tablespace),Orcale9i数据库最大的储存空间,许多段构成.
 Orcale9i各逻辑部件存在一种阶层关系:
 ->数据存在每个数据块内,数据读写以块为单位
 ->空间配置是以区为单位,一个区由一连串数据块所构成
 ->依实际数据量的多少,数据由多个区组成
 ->数据表空间可以划分为不同的区段,每个段又包括了许多区
 ->在每个Orcale9i数据库内可划分不同的表空间,用以存放不同类型的数据
2.物理结构:
由各种Orcale9i数据库文件构成.

注意:一个实例最多只能安装和打开在一个数据库上,而一个数据库能对应多个实例,所以在建立数据库之前,必须先指定Orcale实例的系统表示符(System Identifier),即Orcale SID 因为用来区分不同数据库所以SID必须是唯一的.
实例主要负责数据库的相应操作并与用户交互.