Java
Download
1 / 180

Java 的发展历史 - PowerPoint PPT Presentation


  • 147 Views
  • Uploaded on

Java 的发展历史. 1 Java 的起源 Java 是 Sun 公司1995年正式推出的新一代面向对象程序设计语言, 特别适合于 Internet 应用程序开发, 具有平台无关性。 Java 来自于1991年 Sun 公司的一个叫 Green 的项目, 其原先的目的是为家用消费电子产品开发一个分布式代码系统, 可以把 E-mail 发给电冰箱、 电视机等家用电器, 对它们进行控制。开始, 准备采用 C++, 但 C++ 太复杂, 安全性差, 最后基于 C++ 开发了一种新的语言 Oak(Java 的前身), Oak 是一种用于网络的精巧而安全的语言。

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Java 的发展历史' - garth-guy


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Java的发展历史

1 Java的起源

Java是Sun公司1995年正式推出的新一代面向对象程序设计语言, 特别适合于Internet应用程序开发, 具有平台无关性。

Java来自于1991年Sun公司的一个叫Green的项目, 其原先的目的是为家用消费电子产品开发一个分布式代码系统, 可以把E-mail发给电冰箱、 电视机等家用电器, 对它们进行控制。开始, 准备采用C++, 但C++太复杂, 安全性差, 最后基于C++开发了一种新的语言Oak(Java的前身), Oak是一种用于网络的精巧而安全的语言。

1994年下半年, Internet的快速发展, 促进了Java语言研制的进展, Green项目组成员用Java编制了HotJava 浏览器, 触发了Java进军Internet,使得它逐渐成为Internet上受欢迎的开发与编程语言,现已发展成为一种重要的Internet平台。


2 java
2 关于Java 的大事


Java风云人物


Java著名产品


3 java
3 Java语言的特点

  • 简单易学:

    1)风格类似于C++, 基本语法与C语言类似;

    2)摒弃了C++中容易引发程序错误的地方, 如指针和内存管理;

    3)提供了丰富的类库。

  • 面向对象:支持静态和动态风格的代码继承及重用,是完全 面向对象的, 它不支持类似C语言那样的面向过程 的程序设计技术。

  • 解释执行:Java解释器(运行系统)能直接运行目标代码指令。

  • 平台无关:Java源程序被编译成一种高层次的与机器无关的 byte-code格式语言, 被设计在Java虚拟机上运行。


  • 性能优异:Java可以在运行时直接将目标代码翻译成机器指令, Sun用直接解释器一秒钟内可调用300,000个过程, 翻译目标代码的速度与C/C++的性能没什么区别。

  • 分布式:Java包括一个支持HTTP和FTP等基于TCP/IP协议的子库。因此, Java应用程序可凭借URL打开并访问网络上的对象, 其访问方式与访问本地文件系统几乎完全相同。

  • 可移植:Java应用程序可以在配备了Java解释器和运行环境的任何计算机 系统上运行, 通过定义独立于平台的基本数据类型及其运算, Java数据得以在任何硬件平台上保持一致。

  • 多线程:Java提供的多线程功能使得在一个程序里可同时执行多个小任务。 多线程带来的好处是可以有更好的 交互性能和实时控制性能。


  • 健壮:Java致力于检查程序在编译和运行时的错误。

    类型检查帮助检查出许多开发早期出现的错误。

    Java自已操纵内存减少了内存出错的可能性。

    Java还实现了真数组, 避免了覆盖数据的可能。

  • 安全:Java的安全性可从两个方面得到保证。一方面, 在Java语言里, 象指针和释放内存等C++功能被删除, 避免了非法内存操作。 另一方面, 当Java用来创建浏览器时, 语言功能和一些浏览器本身提供的功能结合起来, 使它更安全。

  • 动态:Java的动态特性是其面向对象设计方法的拓展, 它允许程序动态地装入运行过程中所需要的类。


4 与Java语言相关的应用

  • Java Application ( Java应用程序):

    用Java语言编写的通过独立的Java解释器来解释运行的桌面应用程序(类似于其它高级语言编制的应用程序)。

  • Java Applet (Java小程序):

    用Java语言编写的、嵌入在HTML编写的Web页面中的非独立程序,由Web浏览器内部包含的Java解释器来解释运行,是动态、安全、跨平台的网络应用程序。


  • JSP (JavaServer Pages, Java 服务器页):

    是一种实现普通静态HTML和动态HTML混合编码的技术,是在Sun公司倡导及多个公司参与下共同建立的一种动态网页标准,实现了Web动态内容与其显示的分离,用于构建动态Web网站,JSP文件运行于服务器端,JSP的脚本语言是Java,其平台无关性使得JSP一次编写,各处运行。

  • 最新应用——Java为用户推出了游戏、天气预报、地图等一系列紧俏时髦的应用,它能够帮助汽车司机避免交通阻塞,还能让公司对即将出行的销售人员进行跟踪。目前在移动通讯中被广泛使用,如手机抓捕图象、手机游戏等。


5 java
5 与Java相关的几个常见名词

  • Java EE—— Java Platform, Enterprise Edition (Java 企业版)

    Java EE首先是一种构架,它包罗了Java的多种先进的技术,最合适使用MVC的方法来构建系统,其表现层使用JSP,控制层可以使用Servlet或Session Bean,用于实现业务逻辑,Entity Bean则对业务实体进行抽象。此外它还使用JAAS实现安全机制,JNDI用于查询资源,JDBC和JTA访问数据库和管理事务;JMS实现企业的消息处理;JavaMail实现与企业外界的联系。今年10月份将发布的最新版本为Java EE 5.0。


  • Java SE——Java Platform, Standard Edition (Java 标准版),是Java最核心的技术。

  • Java ME——Java Platform, Micro Edition (Java 袖珍版), 是一个重要的用于无线方面的 Java 平台,它从可移植的、以网络为中心的 Java 虚拟机转变而来。

  • JVM——Java Virtual Machine (Java虚拟机),它通过采用一种被称之为Java虚拟机的虚拟微处理器的规范,用软件在计算机芯片内模拟出一个假芯片,然后开始运行程序,为Java程序提供统一的脱离软、硬件平台的运行环境。


  • JDK——Java Development Kit (Java开发工具包),由Sun公司免费发行的,JDK有多个版本,大体经历过1.02、1.1.x、1.2、1.3、1.4、1.5几个系列。

  • JSDK——Java Server Development Kit (Java服务器开发工具包),是JDK 的一个典型的扩展工具包。

  • JDBC——Java DataBase Connectivity(Java数据库连接),是一种用于执行SQL语句的Java API(应用程序接口),可以为多种关系数据库提供统一访问,是由一组用Java语言编写的类和接口组成。


  • Applet——Java Applet 是用 Java 语言编写的、包含在网页里的“小 应用程序”,通常被放在 Web 服务器上。当有人上网浏览时,Applet 随网页一起 下载到客户端的浏览器中,并借助浏览器中的 Java 虚拟机(JVM)运行工作。

  • Servlet——Servlet是用Java编写的Server端程序,它与协议和平台无关。Servlet运行于Java-enabled Web Server中。Java Servlet可以动态地扩展Server的能力,并采用请求-响应模式提供Web服务。 Servlet与Jsp之间的交互为开发Web服务提供了优秀的解决方案。


  • Swing与 AWT(抽象窗口工具包)——是Java设计 GUI (图形用户界面)的基础 。

    AWT设计有严重缺陷,不能满足发展的需要。

    Swing是在AWT基础上发展起来的,为Java GUI编程提供了强大丰富的API和灵活的结构设计,提供了替代AWT重量组件的轻量组件,Swing 中大部分是轻量级组件。Swing 几乎无所不能,不但有各式各样先进的组件,而且更为美观易用。二者最好不要混用。


  • EJB(Enterprise JavaBeans)—Java EE核心组件,EJB并不是一个产品。它是Java服务器端服务框架的规范,软件厂商根据它来实现EJB服务器。

    Enterprise Bean 与 JavaBean 不同。JavaBean 是使用 java.beans 包开发的,它是 Java SE的一部分。JavaBean 是一台机器上同一个地址空间中运行的组件,是进程内组件。Enterprise Bean 是使用 javax.ejb 包开发的,它是标准 JDK 的扩展,是 Java EE 的一部分。Enterprise Bean 是在多台机器上跨几个地址空间运行的组件,是进程间组件。JavaBean 通常用作 GUI 窗口小部件,而 Enterprise Bean 则用作分布式商业对象。


Javascript vbscript jscript
JavaScript、VBScript 、 JScript辨异

  • JavaScript是由Netscape公司发明的一种Web脚本编制语言(基本语法和C语言非常类似) ,最初叫作 LiveScript,可嵌入在HTML文件中,用来处理以客户端环境为基础的动态信息,但不能访问服务器端资源, 只要浏览器支持JavaScript,用JavaScript编写的脚本就可以正确执行。尽管JavaScript采用与Java类似的语法,但二者并无直接的联系。

  • VBScript是Microsoft公司开发的一种通用的Web脚本语言,其基本语法与Basic语言类似,但它只能被IE浏览器所支持。VBScript是ASP(Active Server Pages)默认的脚本语言,使用ASP可以创建和运行动态、交互的Web服务器应用程序。ASP需要Microsoft 的IIS(Internet信息服务器)的支持才可以运行。

  • JScript 是Microsoft 公司推出的一种解释型的、基于对象的脚本语言, JScript 脚本只能在某个解释器上运行,该解释器可以是 Web 服务器,也可以是 Web 浏览器。 可以用JScript 来编写ASP页面。


1 1 java
1.1 Java的开发环境

  • JDK的安装

    产生如下目录结构

    \bin的目录下包含义下主要文件:

    javac: Java编译器, 用来将java程序编译成

    Bytecode

    java: Java编译器,执行已经转换成Bytecode的

    java应用程序.

    appletviwer : Java解释器, 用来解释已经转换成

    Bytecode的java小应用程序.


1 1 java1
1.1 Java的开发环境

  • \lib子目录 系统类库

  • 设置路径

    1. PATH c:\…\bin

    2. CLASSPATH=. ; c:\...\lib\; c:\myclasses;

    运行程序的时候必须找到相应的类,就要求设置环境变量,在我的电脑 属性 高级 环境变量 CLASSPATH 中设置 .为当前目录,加一分号可以设置其它的类目录.


public class app //公共类 main方法必为公共类,便于外部访问

{

public static void main(String[] args) //static意味main是类方法

{ //,非对象方法,可以直接访问,是静态的不用创建对象

System.out.println ("Hello from Java: ");

}//使用java.lang包的系统类out字段(类的数据成员)的println方法

}//(类的成员函数)//可以作为单行注释/*和*/则可以跨越多行

C:\>java app

Hello from Java

程序的编译

C:\> javac app.java

1.2 创建第一个应用程序


前面的程序没有导入包或者类是因为编译器自动导入了前面的程序没有导入包或者类是因为编译器自动导入了java.lang包,该类构成java的基本核心语句,如果使用其它类,则必须自己导入.

import java.util.Date;//导入Date类 使用*可以导入所有类

public class app //两种导入都是指示位置,不影响文件大小

{

public static void main(String[] args)

{

System.out.println (“Today= “+new Date());//创建对象

}

}

C:\>java app

Today=Mon Aug 02 12:15:13 EDT 2000

1.3包和类的导入


前面的程序没有导入包或者类是前面的程序没有导入包或者类是因为编译器自动导入了java自己带的包或者类,java知道在哪里找相关的包或者类.但自己的类怎么处理?

下面是一个名为printer.java的文件,内有一个printer类,该类有一个print方法.

package abc;

public class printer

{

public void print()

{

System.out.println(“hello from java!”);

}

}

怎么能够在另外一个应用程序中使用这个类?

下面是使用该类的对象方法print的一个应用程序.

导入自己的类1


import abc.printer;//前面的程序没有导入包或者类是因为编译器自动导入了导入printer类

public class app

{

public static void main(String[] args)

{

(new printer()).print();//这里用new操作符创建printer类的新对

} //象,并使用该对象的print方法

}

导入类如果在当前目录,则java可以自动搜索到,如果在别的位置如c:\classes的目录下则必须设置CLASSPATH环境变量,把该目录包含进去,如CLASSPATH=.;c:\classes;

导入自己的类2


1 4 applet

创建前面的程序没有导入包或者类是因为编译器自动导入了applet 需要导入java.applet包中的 Applet类

由于paint方法是AWT的一部分,所以我们这里也导入java.awt包中的AWT类

import java.applet.Applet;

import java.awt.*;

public class applet extends Applet //类applet继承自Applet类

{

public void paint(Graphics g) //Graphics类的 g 对象传递给paint

{

g.drawString ("hello from java !",60,100); //开始位置

} //用g对象的drawString方法实际绘制文本

}

1.4 创建Applet


1 5 applet

<前面的程序没有导入包或者类是因为编译器自动导入了HTML>

<HEAD>

<TITLE>APPLET</TITLE>

</HEAD>

<BODY>

<CENTER>

<APPLET

CODE=applet.class

WIDTH=200

HEIGHT=200>

</APPLET>

</CENTER>

</BODY>

<HTML>

文件名字为applet.html 可以直接显示,也可以用appletviewer查看

C:\>appletviewer applet.html

1.5 运行Applet


Applet

/*将标记直接放入前面的程序没有导入包或者类是因为编译器自动导入了applet.java文件中,可以不用Web页面测试,创建

<APPLET // class文件后 可以用c:\>appletviewer applet.java观看

CODE=applet.class

WIDTH=200

HEIGHT=200>

</APPLET>*/

import java.applet.Applet;

import java.awt.*;

public class applet extends Applet

{

public void paint(Graphics g)

{

g.drawString ("hello from java !",60,100);

}

}

在代码中嵌入<APPLET>标记


1 6 1

import java.awt.*; 前面的程序没有导入包或者类是因为编译器自动导入了

import java.awt.event.*;

class AppFrame extends Frame //类AppFrame继承自Frame类

{

public void paint(Graphics g) //Graphics类的 g 对象传递给paint

{

g.drawString ("hello from java !",60,100); //开始位置

} //用g对象的drawString方法实际绘制文本

}

public class app

{

public static void main(String[] args)

{

1.6创建窗口化应用程序1


AppFrame f = new AppFrame();前面的程序没有导入包或者类是因为编译器自动导入了

f.setSize(200,200);

f.addWindowListener(new WindowAdapter() {public void

windowClosing(WindowEvent e) {System.exit(0);}});

f.show(); //0代表正常退出

}// addWindowListener方法的作用是应用程序窗口关闭时,

//应用程序本身也关闭

} // Java app 就可以运行了

创建窗口化应用程序2


Java前面的程序没有导入包或者类是因为编译器自动导入了开发类库组成

  • Java提供了丰富的标准类来帮助程序设计者更方便快捷地编写程序,这些标准类组成了类包,主要有:

    • java.lang java.awt

    • java.applet java.awt.image

    • java.awt.peer java.io

    • java.net java.util

  • 除了java.lang之外,其余类包都不是java语言所必须的。


Java前面的程序没有导入包或者类是因为编译器自动导入了开发类库组成

  • (1)java.lang

  • 本类包中包含了各种定义java语言时必须的类,这些类能够以其他类不能使用的方式访问java的内部。任何java程序都将自动引入这个包。其中的类包括:

    • Object类:java中最原始、最重要的类,每个java类都是它的子类,它实现了每个类都必须具有的基本方法。

    • 基本类型包装器:Boolean, Character, Number, Double, Float, Integer, Long。

    • String类:字符串类。

    • Math类:数学函数的集合。

    • 执行线程:类Thread, ThreadGroup, 接口Runable。

    • 异常和错误:类Exception, Error, 接口Throwable。


Java前面的程序没有导入包或者类是因为编译器自动导入了开发类库组成

  • 运行环境:可以通过类Runtime和System访问外部系统环境。System类的两个常用功能就是访问标准输入/输出流和错误流、退出程序。

  • 其他类:接口Cloneable、运行时的类等。

    (2)java.applet

    Java Applet是Java编程的一个主要魅力,java.applet类包提供了Applet的运行机制以及一些编写Applet非常有用的方法。


Java前面的程序没有导入包或者类是因为编译器自动导入了开发类库组成

(3) java.awt

本类包是各种窗口环境的统一界面(AWT代表Abstract Windows Toolkit,即抽象窗口工具包),其中的类使得创建诸如窗口、菜单、滚动条、文本区、按钮以及复选框等图形用户界面(GUI)的元素变得非常容易。

(4) java.awt.image

类包能够以独立于设备的方式加载并过滤位图图象。

(5) java.awt.peer

java.awt.peer是全部awt组件的对等对象接口的集合,每个接口都提供了机器相关基本的方法,awt使用这些方法来实现GUI,而不必关心是何种机器或操作系统。


Java前面的程序没有导入包或者类是因为编译器自动导入了开发类库组成

(6) java.io

Java的输入/输出模式是完全建立在流的基础之上的。流是一种字节从一个地方到另一个地方的单向流动,可以把流附加于文件、管道和通信链路等。 java.io类包中定义的许多种流类通过继承的方式进行组织,其中也包括一些用来访问本地文件系统上的文件的流类。

(7) java.net

java.net类包用来完成与网络相关的功能:URL、WWW连接以及更为通用的Socket网络通信。

(8) java.util

java.util类包包含了一些实用类和有用的数据结构,如字典(Dictionary)、散列表(Hashtable)、堆栈(Stack)、向量(Vectro)以及枚举类(Enumeration)等。


面向对象编程前面的程序没有导入包或者类是因为编译器自动导入了

基本概念

面向对象编程就是将数据和方法封装于对象中,使每个对象半自治化,包装私有的(即纯粹内部的)数据和方法,使它们不会造成整体名称空间的混乱。然后,通过公共的(即可以从外部调用的)方法定义的良好接口,对象可以和程序的其余部分交互。

封装就是将一个需要投入很多关注的复杂系统转变为一个对象,对象在其内部处理所有工作并能够容易地概念化。

类(class)是一个模版,可以从它创建对象。可以认为类是对象的类型。

对象(object)是类的实例,这很象变量是数据类型的实例。可以把类看做对象的类型,而把对象看做类的实例。对象封装了方法和实例变量。


概念前面的程序没有导入包或者类是因为编译器自动导入了

数据成员(data member)是类中的变量,它们可以存储对象使用的数据。

对象支持实例变量(其值是此对象特有的)和类变量(其值是由这个类的对象共享的)。对象的数据成员称为实例数据成员或者实例变量。由一个类的所有对象共享的数据项目称为类数据成员或者类变量。

数据成员可以从对象外部访问,或者可以使它们位于对象的内部,以供对象之内的方法私有地使用。


方法(前面的程序没有导入包或者类是因为编译器自动导入了method)是类或者对象内置的函数。

可以有实例方法(instance method)和类方法(class method)。可以对对象使用实例方法,但是可以只通过引用类的名称来使用类方法——这里不需要对象。

通常将方法分类为:那些在类内部使用的,称为私有方法(private method);那些在类外部使用的,称为公共方法(public method);而那些由类和这个类派生出的类使用的,称为保护方法(protected method)

有两种类型的方法:类方法和实例方法。实例方法就是在对象上调用的方法。类方法直接在类上调用,不需要创建对象。

概念


概念前面的程序没有导入包或者类是因为编译器自动导入了

继承(inheritance)是从一个称为基类(base class)的类派生另一个称为派生类(derived class)的类的过程,而且可以在派生类中使用基础类的方法。(基类就是旧类,派生类是新类)

主要作用是在新类中附加你所希望添加的东西,以便使新类具有比基类更多的定制功能。

java不支持多重继承,替换方式是使用接口。


声明和创建对象前面的程序没有导入包或者类是因为编译器自动导入了

public class app

{ public static void main(String[] args)

{ String s1; //声明对象

s1=new String(“Hello from Java!”);//创建对象

String s2= new String(“Hello from Java!”);//声明并创建

char c1[]={‘H’,‘i’,‘ ’,‘t’,‘h’,‘e’,‘r’,‘e’};

String s3=new String(c1);//这里重载,参数类型和个数不同

double double1=1.23456789;

String s4=String.valueOf(double1);//不用new转换成对象

String s5;//将s1中的对象引用复制到s5,实际上s1和s5指向

s5=s1; //同一个对象。改动s1中的实例数据,s5也会改变,

System.out.println(s1); System.out.println(s2);

System.out.println(s3); System.out.println(s4);

System.out.println(s5);

}}


输出结果前面的程序没有导入包或者类是因为编译器自动导入了

Hello from java!

Hello from java!

Hi there

1.23456789

Hello from java!


声明和定义类前面的程序没有导入包或者类是因为编译器自动导入了

class printer //声明类

{ public void print() //类定义是类的实际实现

{

System.out.println("Hello from Java!");

}}

public class app

{ public static void main(String[] args)

{ // static可将变量转变为类变量,将方法转变为类方法便于

printer printer1=new printer();//直接使用,不用创建对象

printer1.print(); //使用上面的类的对象的print方法

}}

结果 Hello from Java!

这里在同一个文件中声明和定义了两个类,printer和app。在一个文件中只有一个类可以声明为公共的,这里是app。这里文件名必须和该公共类名字相同。


上例分成两个文件问题前面的程序没有导入包或者类是因为编译器自动导入了

class printer //printer.java

{ public void print()

{

System.out.println("Hello from Java!");

}}

public class app

{ public static void main(String[] args)

{

printer printer1=new printer();

printer1.print();

}}

结果 Hello from Java!


创建实例变量前面的程序没有导入包或者类是因为编译器自动导入了

class Data //声明类

{

public String data_string=“Hello from Java!”;//类中存储实例变量

}

public class app

{ public static void main(String[] args)

{

Data data=new Data();

String string=data.data_string;//引用实例变量

System.out.println(string);

}

}

结果 Hello from Java!


访问说明符的说明前面的程序没有导入包或者类是因为编译器自动导入了

声明类成员为public时,在你程序的任何地方都可以访问它。

声明为private,它只在成员所在的类之内能够访问。

声明为protected,它对于当前类,在同一包内的其它类以及从这个类派生出的类是可用的。

如果没有使用访问说明符,类成员的默认访问是对于成员所在的类,从这个类派生出的在同一包中的类以及同一包中的其它类可见。

位置 private 未指定 protected public

同一类 x x x x

同一包中的子类 x x x

同一包中的非子类 x x x

另一个包中的子类 x x

另一个包中的非子类 x


设置变量访问前面的程序没有导入包或者类是因为编译器自动导入了

class Data //声明类

{

private String data_string="Hello from Java!";//类中存储实例变量

}

public class app

{ public static void main(String[] args)

{

Data data=new Data();

String string=data.data_string;//引用实例变量

System.out.println(string);

}

}

由于访问说明符的变化导致编译错误


class data前面的程序没有导入包或者类是因为编译器自动导入了

{

public static int intdata=0;//名为intdata的类数据变量

}

public class app

{ public static void main(String[] args)

{

data a,b;

a=new data();

b=new data();

a.intdata=1;// 设置为1,则结果b.intdata值为显示

System.out.println("The value of b.intdata = " +b.intdata);

}

}

结果 The value of b.intdata = 1

创建类变量


public class app 前面的程序没有导入包或者类是因为编译器自动导入了

{ public static void main(String[] args) //String对象数组为参数

{ System.out.println("Command line arguments...");

for(int loop_index=0;loop_index<args.length;loop_index++)

{System.out.println("Argument "+loop_index+" = "+

args[loop_index]);

}

}

}

c:\>java app a b c d //传递给main的数组的四个元素

Command line arguments…

Argument 0 = a

Argument 1 = b

Argument 2 = c

Argument 3 = d

传递给main的命令行参数


class calculator 前面的程序没有导入包或者类是因为编译器自动导入了

{

int addem(int op1,int op2)

{return op1+op2;}//使用return语句

}

public class app

{ public static void main(String[] args)

{calculator calc=new calculator();

System.out.print("addem(2,2)="+calc.addem(2,2));

}

}

结果 addem(2,2)=4

从方法返回值


class calculator 前面的程序没有导入包或者类是因为编译器自动导入了

{

static int addem(int op1,int op2)//关键字static使方法成为类方法

{return op1+op2;}

}

public class app

{ public static void main(String[] args)

{

System.out.print("addem(2,2)="+ calculator.addem(2,2));

} // 直接调用类方法

}

上面并没有创建对象,当然创建对象可以使用对象方法。

创建类方法


为类创建构造前面的程序没有导入包或者类是因为编译器自动导入了器:在类中加上一个和这个类同名的方法,不需要任何访问说明符或者返回类型。

class data

{

private String data_string;

data() //无参数构造器

{data_string ="Hello from Java!";}

public String getData()

{return data_string;}

}

public class app

{ public static void main(String[] args)

{System.out.print((new data()).getData());

}

} //结果 Hello from Java!

创建构造器


Java前面的程序没有导入包或者类是因为编译器自动导入了对象包含一个名为this的数据成员,就是对当前对象的引用

class Data //该例Data类有printData方法,通过把当前对象传递给

{ private String data_string;//另一个对象的print方法,它输出当

Data(String s){data_string=s; } //前对象的数据。

public String getData()

{return data_string;}

public void printData()

{printer p=new printer();

p.print(this);}}//关键字this引用当前对象

class printer

{void print(Data d)

{System.out.println(d.getData());}}

public class app

{ public static void main(String[] args)

{(new Data("Hello from Java!")).printData();

}}//结果 Hello from Java!

使用this关键字


继承 内部类前面的程序没有导入包或者类是因为编译器自动导入了

使用继承,可以从另一个类,称为基类(base)或者超类

(superclass),派生出一个类,称为派生类(derived class)或者子类(subclass)。所有子类可以访问超类的非私有成员,而且可以添加它们自己的成员。它们能够覆盖(override)超类的非私有成员,将它们替换为自己的代码。

我们可以创建必须被作为超类对待的类,这些类称为抽象类(abstract class)。不能够直接将抽象类实例化为对象;作为替换,必须首先从抽象类派生新的类,覆盖那些特别声明为抽象的成员。使用抽象类来迫使开发者定制一个类的一些或者全部成员。


子类以两个或者更多超类为基础被称为多重继承(multiple

Inheritance),但Java并不支持多重继承(c++支持)。我们只能够对一个类使用关键字extends。这里要使用关键字implements来实现。就是通过关键字implements将别的类作为接口(interface)来实现。

import java.applet.Applet;

import java.awt.*;

import java.awt.event.*;

public class clicker extends Applet implements ActionListener

{ TextField text1;

Button button1;

public void init() {

text1=new TextField(20);add(text1);

button1=new Button("Click Here!");add(button1);

button1.addActionListener(this);}

概念


public void actionPerformed(ActionEvent event){ 子类以两个或者更多超类为基础被称为多重继承(

String msg=new String("Welcom to Java");

if(event.getSource()==button1){

text1.setText(msg);}

}}

可以实现任意数量的接口,下面部分程序用来实现三个监听器,使程序能够处理按钮点击和鼠标动作。

import java.awt.Graphics;

import java.awt.*;

import java.awt.event.*;

import java.lang.Math;

import.java.applet.Applet;

public class dauber extends Applet imliements ActionListener ,

MouseListener,MouseMotionListener{

概念


pic 子类以两个或者更多超类为基础被称为多重继承(


内部类:在类之内创建类,被封装的类被称为内部类。(inner class)。

import java.awt.*;

import java.awt.event.*;

class AppFrame extends Frame //类AppFrame继承自Frame类

{ public void paint(Graphics g) //Graphics类的 g 对象传递给paint

{ g.drawString ("hello from java !",60,100); //开始位置

} } //用g对象的drawString方法实际绘制文本

public class app

{ public static void main(String[] args)

{ AppFrame f=new AppFrame();

f.setSize(200,200);

f.addWindowListener(new WindowAdapter() //匿名内部类继

//自类WindowAdapter

{public void windowClosing(WindowEvent e)

{System.exit(0);}});

f.show(); }}

概念


class vehicle 内部类:在类之内创建类,被封装的类被称为内部类。(

{public void start()

{System.out.println("Starting…");}}

class car extends vehicle

{public void drive()

{System.out.println("Driving…");}}

public class app

{ public static void main(String[] args)

{System.out.println("Creating a car…");

car c = new car();

c.start(); c.drive();

}}

结果: Creating a car…

Starting…

Driving…

创建子类


class a // 内部类:在类之内创建类,被封装的类被称为内部类。(超类

{ a()//构造器

{System.out.println("In a\'s constructor…");}}

class b extends a //子类

{ b(String s) //子类构造器

{System.out.println("In b\'s String constructor…");

System.out.println(s);}}

public class app //调用a和b的构造器

{public static void main (String[] args)

{ b obj=new b("Hello from Java!");

}

}

//结果 In a's constructor…

In b's String constructor…

Hello from Java!

调用超类构造器


没有参数的构造器被称为类的默认构造器( 内部类:在类之内创建类,被封装的类被称为内部类。(default constructor),

实例化类的子类时,Java会自动调用它。如果希望调用类具有参数的构造器,而不是默认构造器。可通过调用子类的构造器中的super方法实现。

class a

{ a() {System.out.println("In a\'s constructor…");}

a(String s) {System.out.println("In a\'s String constructor…");

System.out.println(s);}}

class b extends a

{ b(String s)

{ super(s); System.out.println("In b\'s String constructor…");

System.out.println(s);}}

public class app

{public static void main (String[] args)

{ b obj=new b("Hello from Java!");}

}

调用超类构造器


输出结果 内部类:在类之内创建类,被封装的类被称为内部类。(

In a's String constructor…

Hello from Java!

In b's String constructor…

Hello from Java!

注意 :如果使用super 调用超类的构造器,做这个工作的那一行代码必须是构造器的第一行。这是Java寻找它的位置。


class vehicle 内部类:在类之内创建类,被封装的类被称为内部类。(

{public void start()

{System.out.println("Starting…");}}

class car extends vehicle

{public void drive()

{System.out.println("Driving…");}}

class aircraft extends vehicle

{public void fly()

{System.out.println("Flying…");}}

class whirlybird extends aircraft

{public void whirl()

{System.out.println("Whirling…");}}

class jet extends aircraft

{public void zoom()

{System.out.println("Zooming…");}}

创建多层继承


public class app 内部类:在类之内创建类,被封装的类被称为内部类。(

{

public static void main (String[] args)

{

System.out.println("Creating a car…");

car c=new car();

c.start();c.drive();

System.out.println();

System.out.println("Creating a jet…");

jet j=new jet();

j.start();j.fly(); j.zoom();

}

}

实例化类的对象


输出结果 内部类:在类之内创建类,被封装的类被称为内部类。(

Creating a car…

Starting…

Driving…

Creating a jet…

Starting…

Flying…

Zooming…


class a 内部类:在类之内创建类,被封装的类被称为内部类。(

{ a() {System.out.println("constructing a…");}}

class b extends a

{ b() {System.out.println("constructing b…");}}

class c extends b

{ c() {System.out.println("constructing c…");}}

class d extends c

{ d() {System.out.println("constructing d…");}}

public class app

{public static void main (String[] args)

{ d obj=new d();//整体从基类到子类的方向调用构造器

}}//结果 constructing a…

constructing b…

constructing c…

constructing d…

处理多层构造器


class animal 内部类:在类之内创建类,被封装的类被称为内部类。(

{public void breathe()

{System.out.println("Breathing...");}}

class fish extends animal

{public void breathe() //覆盖基类的breathe方法

{System.out.println("Bubbling...");}}

public class app

{ public static void main(String[] args)

{System.out.println("Creating an animal...");

animal a=new animal();

a.breathe();

System.out.println();

System.out.println("Creating a lungfish...");

fish f=new fish();

f.breathe();

}

}

覆盖方法


输出结果 内部类:在类之内创建类,被封装的类被称为内部类。(

Creating an animal...

Breathing...

Creating a lungfish...

Bubbling...


class animal 内部类:在类之内创建类,被封装的类被称为内部类。(

{

public void breathe()

{System.out.println("Breathing...");}}

class fish extends animal

{public void breathe()//覆盖基类的breathe方法

{System.out.println("Bubbling...");}

public void newbreathe() {super.breathe();}}//访问基类的

public class app //breathe方法

{public static void main(String[] args)

{System.out.println("Creating an animal...");

animal a=new animal();

a.breathe();

System.out.println();

System.out.println("Creating a lungfish...");

fish f=new fish();

f.newbreathe();}}

访问被覆盖的成员


输出结果 内部类:在类之内创建类,被封装的类被称为内部类。(

Creating an animal...

Breathing...

Creating a lungfish...

Breathing...


class vehicle 内部类:在类之内创建类,被封装的类被称为内部类。(

{public void start()

{System.out.println("Starting…");}}

class car extends vehicle

{public void drive()

{System.out.println("Driving…");}}

class aircraft extends vehicle

{public void fly()

{System.out.println("Flying…");}}

class whirlybird extends aircraft

{public void whirl()

{System.out.println("Whirling…");}}

class jet extends aircraft

{public void zoom()

{System.out.println("Zooming…");}}

和子类对象一起使用超类变量


public class app 内部类:在类之内创建类,被封装的类被称为内部类。(

{public static void main (String[] args)

{

System.out.println("Creating a car…");

car c=new car();

c.start();c.drive();

System.out.println();

System.out.println("Creating a jet…");

jet j=new jet();//可以换为 vehicle j=new jet();

j.start();}} //结果 Creating a car…

Starting…

Driving…

Creating a jet…

Starting…

和子类对象一起使用超类变量


class a 内部类:在类之内创建类,被封装的类被称为内部类。(

{ public void print() {System.out.println("Here's a…");}}

class b extends a

{ public void print() {System.out.println("Here's b…");}}

class c extends b

{ public void print() {System.out.println("Here's c…");}}

class d extends c

{ public void print() {System.out.println("Here's d…");}}

public class app

{

public static void main (String[] args)

{ a a1=new a(); b b1=new b(); c c1=new c(); d d1=new d();a aref;

aref=a1; aref.print(); aref=b1; aref.print(); //注意类型的一致

aref=c1; aref.print(); aref=d1; aref.print();//及覆盖

}

}

动态方法调度


输出结果 内部类:在类之内创建类,被封装的类被称为内部类。(

Here's a…

Here's b…

Here's c…

Here's d…


在编写类的时候,你可能会遇到这样的情况:你只提供一般的代码,需要开发者从你的类派生子类来定制它。为了保证开发者定制你的代码,你可以使方法成为抽象(abstract)的,这就是说开发者必须覆盖你的方法;否则,Java会报错,为了使方法成为抽象的,应该使用abstract关键字。如果你使类中的方法成为抽象的,你还必须使这个类本身也成为抽象的。

abstract class a//抽象方法要求类也必须是抽象的

{abstract String getData();//开发者必须实现此方法

public void print(){System.out.println(getData());}}

class b extends a

{String getData() {return “Hello from Java!”;}}

public class app

{public static void main (String[] args)

{b b1=new b();b1.print();}}//结果Hello from Java!

注意:抽象类是不能直接进行实例化的类。

创建抽象类


使用 在编写类的时候,你可能会遇到这样的情况:你只提供一般的代码,需要开发者从你的类派生子类来定制它。为了保证开发者定制你的代码,你可以使方法成为抽象(final终止覆盖

class animal

{ final void breathe()

{

System.out.println("Breathing...");

}

}上面将方法标记为final,以后该方法将不能够覆盖,否则出错。

使用final终止继承

final class animal

{ public void breathe()

{

System.out.println("Breathing...");

}

}上面将类标记为final,将不能从此类继承创建子类,否则出错。


Final

使用 在编写类的时候,你可能会遇到这样的情况:你只提供一般的代码,需要开发者从你的类派生子类来定制它。为了保证开发者定制你的代码,你可以使方法成为抽象(final创建常量

public class app

{

public static void main(String[] arfs)

{

final int a=5;

a=6;//不能对最终变量(常量)赋值。

}

}

上面将变量标记为final,此变量将不能被赋值,否则出错。


Java 在编写类的时候,你可能会遇到这样的情况:你只提供一般的代码,需要开发者从你的类派生子类来定制它。为了保证开发者定制你的代码,你可以使方法成为抽象(中的每一个类都自动从java.lang.Object类派生。下例用

getClass方法判断aref中对象的类,无论它是哪个子类的对象。

class a

{ public void print() {System.out.println("Here's a…");}}

class b extends a

{ public void print() {System.out.println("Here's b…");}}

class c extends a

{ public void print() {System.out.println("Here's c…");}}

class d extends a

{ public void print() {System.out.println("Here's d…");}}

public class app

{public static void main (String[] args)

{ a a1=new a(); b b1=new b(); c c1=new c(); d d1=new d();a aref;

aref=a1;

System.out.println("aref\'s class is now "+aref.getClass());

aref.print();

aref=b1;

Java对象类


System.out.println("aref\'s class is now "+aref.getClass()); 在编写类的时候,你可能会遇到这样的情况:你只提供一般的代码,需要开发者从你的类派生子类来定制它。为了保证开发者定制你的代码,你可以使方法成为抽象(

aref.print();

aref=c1;

System.out.println("aref\'s class is now "+aref.getClass());

aref.print();

aref=d1;

System.out.println("aref\'s class is now "+aref.getClass());

aref.print();

}}

结果aref’s class is now class a

Here's a…

aref’s class is now class b

Here's b…

aref’s class is now class c

Here's c…

aref’s class is now class d

Here's d…

Java对象类


我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(inner class)是非静态的嵌套类。

class a

{ b obj ; a() {obj=new b();obj.print();}

class b //内部类

{public void print() {System.out.println("Inside b...");}}

}

public class app

{ public static void main(String[] arfs)

{a obj=new a();}

}

结果 Inside b...

创建内部类


class a 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(

{ a() {(new b() {public void print() //b是产生子类的类或接口的名字

{System.out.println("Hello from Java!");}}).print();}

}//类a内部创建的匿名内部类是类b的子类,并定义了print方法

class b{} //且马上调用了该方法

public class app

{

public static void main(String[] args)

{

a obj=new a();

}

}

结果 Hello from Java!

创建匿名内部类


Java RMI 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(技术

RMI基本原理: RMI能让一个Java程序调用网络中另外一台计算机的Java对象的方法,效果就像这个远程计算机上的对象方法在本地机上一样。

RMI采用客户/服务器通信方式

RMI应用的开发步骤:

1.创建远程接口

远程接口必须继承java.rmi.Remote类。

接口中方法必须抛出java.rmi.RemoteException异常。

2.创建远程类

实现远程接口

远程类的命名是远程接口类名加上“Impl”(不是必须),例如,远程接口Upper类对应的远程接口实现类名为UpperImpl。


3.创建服务器程序 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(

服务器程序的一大任务就是向rmiregistry注册表注册远程对象。

4.创建客户程序

运行RMI应用:

  • 启动注册表 start rmiregistry

    默认监听1099端口,可使用命令

    start rmiregistry 8000监听别的端口如8000

    程序中服务器帮定对象和客户查找远程对象都要变更端口rmi://localhost:8000/…

    2. 启动服务器程序 start java SimpleServer

    3. 启动客户程序 java SimpleClient


例1:开发一个远程方法 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(upperCase(String str),它把客户(调用者)提供的字符串传送给服务者,服务者把它全部转变成大写字符串后返回给客户。

1.创建远程接口 Upper.java

import java.rmi.*;

public interface Upper extends Remote { String upperCase(String s) throws RemoteException;}


2. 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(创建远程类 UpperImpl.java

import java.rmi.*;

import java.rmi.server.UnicastRemoteObject;

public class UpperImpl

extends UnicastRemoteObject implements Upper

{

public UpperImpl() throws RemoteException {

}

public String upperCase(String s) throws RemoteException {

return s.toUpperCase(); //字符串类的方法

}

}


3.创建服务器程序 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(UpperServer.java

import java.rmi.*;

import javax.naming.*;

public class UpperServer{

public static void main( String args[] ){

try {

Upper service = new UpperImpl();

Context namingContext=new InitialContext();

namingContext.rebind( "rmi:Upper1", service);

System.out.println("服务器注册了一个Upper对象" );

}

catch (Exception e) { e.printStackTrace();

}

}}


4.创建客户程序 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(UpperClient.java

import java.rmi.*;

import javax.naming.*;

public class UpperClient {

public static void main(String[] arg) {

String url="rmi://localhost/";

try {

Context namingContext=new InitialContext();

Upper service=(Upper)namingContext.lookup(url+"Upper1");

//利用参数“abc”远程调用方法upperCase()

System.out.println(service.upperCase("abc"));

}

catch (Exception e) {e.printStackTrace();} }}


例2: 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(

1.创建远程接口 HelloService.java

import java.util.Date;

import java.rmi.*;

public interface HelloService extends Remote{

public String echo(String msg) throws RemoteException;

public Date getTime() throws RemoteException;

}


2. 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(创建远程类 HelloServiceImpl.java

import java.util.Date;

import java.rmi.*;

import java.rmi.server.UnicastRemoteObject;

public class HelloServiceImpl extends UnicastRemoteObject implements HelloService{

private String name;

public HelloServiceImpl(String name)throws RemoteException{

this.name=name;

}


public String echo(String msg)throws RemoteException{ 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(

System.out.println(name+":调用echo()方法");

return "echo:"+msg +" from "+name;

}

public Date getTime()throws RemoteException{

System.out.println(name+":调用getTime()方法");

return new Date();

}

}


3.创建服务器程序 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(SimpleServer.java

import java.rmi.*;

import javax.naming.*;

public class SimpleServer{

public static void main( String args[] ){

try{

HelloService service1 = new HelloServiceImpl("service1");

HelloService service2 = new HelloServiceImpl("service2");


Context namingContext=new InitialContext(); 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(

namingContext.rebind( "rmi:HelloService1", service1 );

namingContext.rebind( "rmi:HelloService2", service2 );

System.out.println( "服务器注册了两个HelloService对象" );

}catch(Exception e){

e.printStackTrace();

} }

}


4.创建客户程序 我们可以在类的定义内部嵌套类的定义,嵌套的类可以是静态的或者非静态的,但静态类不能直接引用其包含类的成员,作为替换,必须实例化并使用对象。内部类(SimpleClient.java

import java.rmi.*;

import javax.naming.*;

public class SimpleClient{

public static void main( String args[] ){

String url="rmi://localhost/";

try{

Context namingContext=new InitialContext();

HelloService service1=(HelloService)namingContext.lookup(url+"HelloService1");

HelloService


service2=(HelloService)namingContext.lookup(url+"HelloService2");

System.out.println(service1.echo("hello"));

System.out.println(service1.getTime());

System.out.println(service2.echo("hello"));

System.out.println(service2.getTime());

}catch( Exception e){

e.printStackTrace();

}

}

}


SimpleServer 端的打印结果如下:


SimpleClient 端的打印结果如下:


Corba

CORBA

CORBA(Common Object Request Broker Architecture,公共对象请求代理结构) 是OMG (Object Management Group,对象管理组织)制定的一个基于开放标准的分布式计算解决方案,它的主要目的是支持用户在计算机硬件、操作系统、程序设计语言和网络通信协议异构的情况下方便地开发健壮的、可伸缩的、面向对象的分布式应用。


CORBA 和Java都采用面向对象技术,因此,可以很容易地用Java语言开发CORBA应用,或将Java应用以及JavaBean对象集成到CORBA应用环境中;CORBA和Java都适用于开发分布式应用,所不同的是:CORBA偏重于通用的分布式应用开发,而Java注重于WWW环境中的分布式应用开发。 CORBA 采用客户/服务器模式。

CORBA独立于任何编程语言,独立于任何操作系统平台。在Linux中用Java编写的CORBA对象可以与Windows操作系统中用C++编写的CORBA对象通信。

IDL语言是一种接口定义语言。IDL语言不同于所有已有的程序设计语言,它是一种描述性语言,也就是说,用它描述得到的接口是不能直接被编译执行。 IDL独立于任何其他编程语言。


创建 CORBA程序的步骤:

1.创建IDL接口

2.创建IDL接口的实现类

3.创建服务器程序

创建并注册CORBA对象

orbd.exe是 JDK提供的一个CORBA的命名服务器程序

4.创建客户程序

运行CORBA程序:

1. 编译IDL接口

idlj -fall HelloService.idl

2. 启动命名服务器程序

start orbd -ORBInitialPort 1050

1050为命名服务器监听的端口


3. 启动服务器程序

start java hello.HelloServer -ORBInitialPort 1050 -ORBInitialHost localhost

4. 运行客户程序

java hello.HelloClient -ORBInitialPort 1050 -ORBInitialHost localhost

例1: 利用Java与CORBA技术开发一个远程方法upperCase(string str),它把客户(调用者)传送来的字符串全部转变成大写字符串后返回给客户。

1.创建IDL接口 UpperModule.idl

module UpperModule {

interface Upper {

string upperCase(in string str);

};

};


2. 创建IDL接口的实现类UpperImpl.java

package UpperModule;

public class UpperImpl extends UpperPOA {

public UpperImpl() {

}

public String upperCase (String str) {

//返回结果:

return str.toUpperCase();

}

}


3.创建服务器程序 UpperServer.java

package UpperModule;

import java.io.*;

import org.omg.CORBA.*;

import org.omg.CosNaming.*;

import org.omg.PortableServer.*;

import org.omg.PortableServer.POA;

import org.omg.CosNaming.NamingContextPackage.*;

public class UpperServer

{ public static void main(String args[]) {

try{


// 初始化 ORB对象

ORB orb = ORB.init(args, null);

// 建立接口实现类UpperImpl对象,并与ORB连接

UpperImpl upperImpl= new UpperImpl();

//取得RootPOA引用,并激活POAManager

POA rootpoa = POAHelper.narrow( orb.resolve_initial_references("RootPOA"));

rootpoa.the_POAManager().activate();

//取得对象引用

org.omg.CORBA.Object ref = rootpoa.servant_to_reference(upperImpl);


Upper href = UpperHelper.narrow(ref);

//获得命名服务的Context

org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");

NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);

//绑定对象引用

String name = "Upper";

NameComponent path[] = ncRef.to_name( name );

ncRef.rebind(path, href);


System.out.println("UpperServer ready ....");

// 等待客户调用

orb.run();

}

catch(Exception e)

{

System.err.println("ERROR: " + e);

e.printStackTrace(System.out);

}

}

}


4.创建客户程序 UpperClient.java

package UpperModule;

import java.io.*;

import org.omg.CORBA.*;

import org.omg.CosNaming.*;

import org.omg.CosNaming.NamingContextPackage.*;

public class UpperClient

{ public static void main(String args[])

{ try {

String str;


// 初始化 ORB对象

ORB orb = ORB.init(args, null);

//使用命名服务获得NamingContext。NameService 是所有ORB命名的总称。

org.omg.CORBA.Object objRef =

orb.resolve_initial_references("NameService");

//用NamingContextExt代替NamingContext

NamingContextExt ncRef =

NamingContextExtHelper.narrow(objRef);

//用名称解析对象引用

String name = "Upper";


Upper upper= UpperHelper.narrow(ncRef.resolve_str(name));

//调用远程方法upperCase()

str= upper.upperCase("abc");

System.out.println(str);

}

catch(Exception e)

{System.out.println("ERROR : " + e);

e.printStackTrace(System.out);

}

}

}


例2:

1.创建IDL接口 HelloService.idl

module hello{

interface HelloService{

string sayHello();

};

};


2. 创建IDL接口的实现类HelloServiceImpl.java

package hello;

import org.omg.CosNaming.*;

import org.omg.CosNaming.NamingContextPackage.*;

import org.omg.CORBA.*;

import org.omg.PortableServer.*;

import org.omg.PortableServer.POA;

import java.util.Properties;

public class HelloServiceImpl extends HelloServicePOA {

public String sayHello() {

return "\nHello world !!\n"; }}


3.创建服务器程序 HelloServer.java

package hello;

import org.omg.CosNaming.*;

import org.omg.CosNaming.NamingContextPackage.*;

import org.omg.CORBA.*;

import org.omg.PortableServer.*;

import org.omg.PortableServer.POA;

import java.util.Properties;

public class HelloServer {

public static void main(String args[]) {

try{


//创建和初始化 ORB

ORB orb = ORB.init(args, null);

//获得根POA的引用,并且激活POAManager

POA rootpoa =POAHelper.narrow(orb.resolve_initial_references("RootPOA"));

rootpoa.the_POAManager().activate();

//创建一个HelloServiceImpl对象,并且把它与ORB关联

HelloServiceImpl helloServiceImpl = new HelloServiceImpl();


//获得 HelloServiceImpl对象的CORBA类型的对象引用

org.omg.CORBA.Object ref = rootpoa.servant_to_reference(helloServiceImpl);

HelloService href = HelloServiceHelper.narrow(ref);

//获得命名服务的Context

org.omg.CORBA.Object objRef =

orb.resolve_initial_references("NameService");

NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);


//把 HelloService对象与“HelloService”名字绑定

String name = "HelloService";

NameComponent path[] = ncRef.to_name( name );

ncRef.rebind(path, href);

System.out.println("HelloServer ready and waiting ...");

//等待客户端访问HelloService对象

orb.run();

}catch (Exception e) {

System.err.println("ERROR: " + e);

e.printStackTrace(System.out);

} }}


4.创建客户程序 HelloClient.java

package hello;

import org.omg.CosNaming.*;

import org.omg.CosNaming.NamingContextPackage.*;

import org.omg.CORBA.*;

public class HelloClient{

static HelloService helloServiceImpl;

public static void main(String args[]){

try{

//创建和初始化ORB

ORB orb = ORB.init(args, null);


//获得命名服务的 Context

org.omg.CORBA.Object objRef =

orb.resolve_initial_references("NameService");

NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);

//获得名为“HelloService”的HelloService对象的远程引用

String name = "HelloService";

helloServiceImpl = HelloServiceHelper.narrow(ncRef.resolve_str(name));


//调用 HelloService对象的远程方法

System.out.println(helloServiceImpl.sayHello());

}catch (Exception e) {

System.out.println("ERROR : " + e) ;

e.printStackTrace(System.out);

}

}

}


抽象类、接口和程序包

  • 抽象类与抽象方法

    用abstract关键字来修饰一个类时,该类叫做抽象类;用abstract来修饰一个方法时,该方法叫做抽象方法。

    抽象类必须被继承,抽象方法必须被重写。

    抽象类不能被直接实例化。因此它一般作为其它类的超类,与final类正好相反。

    抽象方法只需声明,而不需实现。定义了抽象方法的类必须是抽象类。


  • 两个类 Circle和Rectangle,完成相关参数的计算

class Circle extends Shape

{

public float r;

Circle(float r)

{

this.r = r; //this指"这个对象的"

}

public double area()

{

return 3.14*r*r;

}

}

class Rectangle extends Shape

{

public float width,height;

Rectangle (float w, float h)

{

width = w; //这里不需"this"

height = h;

}

public double area()

{

return width*height;

}

}


  • 假设有若干个 Circle,以及若干个Rectangle,希望计算它们的总面积,直截了当的做法是将它们分别放到两个数组中,用两个循环,加上一个加法,这种做法是不漂亮的。

  • 如果还有其它形状:triangle,ellipses等,上述方法显得“累赘”。我们希望有一种统一的表示,例如用一个数组shapeArea[],接受所有的形状,然后用:for (i=0; i< shapeArea.length; i++)

    {

    area_total += shapeArea[i].area();

    }


abstract class Shape

{

abstract double area();

}

class Circle extends Shape

{

public float r;

Circle(float r)

{

this.r = r; //this指"这个对象的"

}

public double area()

{

return 3.14*r*r;

}

}

class Rectangle extends Shape

{

public float width,height;

Rectangle (float w, float h)

{

width = w; //这里不需"this"

height = h;

}

public double area()

{

return width*height;

}

}


public class AreaSum

{public static void main(String args[])

{Shape[ ] shapeArea=new Shape[4];

double area_total=0;

shapeArea[0]=new Circle(2);

shapeArea[1]=new Circle(3);

shapeArea[2]=new Rectangle (2,3);

shapeArea[3]=new Rectangle (5,6);

for (int i=0; i< shapeArea.length; i++)

{

area_total += shapeArea[i].area();

}

System.out.println(“area_total=”+area_total);

}


  • 接口就是方法定义和常量值的集合。从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有方法的实现。

    通过接口可以实现不相关类的相同行为,而不需要考虑这些类之间的层次关系。

    通过接口可以指明多个类需要实现的方法。

    通过接口可以了解对象的交互界面,而不需了解对象所对应的类。


  • C++不同,Java不支持多重继承,而是用接口实现比多重继承更强的功能。

    多重继承指一个类可以为多个类的子类,它使得类的层次关系不清楚,而且当多个父类同时拥有相同的成员变量和方法时,子类的行为是不容易确定的,这给编程带来困难。而单一继承则清楚地表明了类的层次关系,指明子类和父类各自的行为。

    接口则把方法的定义和类的层次区分开来,通过它可以在运行时动态地定位所调用的方法。同时,接口中可以实现“多重继承”,且一个类可实现多个接口,正是这些机制使得接口提供了比多重继承更简单,更灵活,而且更强健的功能。


    interface Stack

    { void push(object x);

    object pop();}

    class A extends Applet

    implements Stack

    { void push(object x)

    { …;//具体内容

    }

    object pop()

    { …;//具体内容}

    }


    implements子句来表示一个类使用某个接口。

    在类体中可以使用接口中定义的常量,而且必须实现接口中定义的所有方法。

    利用接口可实现多重继承,即一个类可以实现多个接口,在implements子句中用逗号分隔。

    接口的作用和抽象类相似,只定义原型,不直接定义方法的内容。

    接口中的方法定义必须是public的(可以省略)。实现时,public不能省略。


    class FIFOQueue implements Collection

    {

    public void add ( Object obj )

    {

    ……

    }

    publicvoid delete( Object obj )

    {

    ……

    }

    publicObject find( Object obj )

    {

    ……

    }

    publicint currentCount()

    {

    ……

    }

    }

    interface Collection

    {

    int MAX_NUM=100;

    void add (Object obj);

    void delete (Object obj);

    Object find (Object obj);

    int currentCount ( );

    }


  • 由于Java编译器为每个类生成一个字节码文件,且文件名与类名相同,因此同名的类有可能发生冲突。为了解决这一问题,Java提供包来管理类名空间。

  • 程序包相当于其它语言中的库函数。

    • 打包

  • Java中用package语句来将一个Java源文件中的类打成一个包。package语句必须作为Java源文件的第一条语句,指明该文件中定义的类所在的包。(若缺省该语句,则指定为无名包)。它的格式为:

  • package pkg1[.pkg2[.pkg3…]];

  • Java编译器把包对应于文件系统的目录管理,package语句中,用 . 来指明目录的层次。


  • package myclass.graphics;

    class Square {…;}

    class Circle {…;}

    class Triangle {…;}

    package myclass.graphics; 这条语句指定这个包中的文件存储在目录

    path/myclass/graphics 下。

    包层次的根目录path是由环境变量CLASSPATH来确定的。


    path

    myclass

    Square

    为了能使用Java中已提供的类,我们需要用import语句来引入所需要的类。

    import package1[.package2…]. (classname |*);

    例如:

    import myclass.graphics.*;

    import java.io.*;

    graphics

    由环境变量CLASSPATH确定


    • 编译和生成包

    • 如果在程序Test.java中已定义了包p1,编译时采用如下方式:

    • javac -d destpath Test.java

    • 则编译器会自动在destpath目录下建立一个子目录p1,并将生成的.class文件都放到destpath/p1下。

    • destpath可以是环境变量CLASSPATH中的一个。


    Applet1

    applet 应用程序和事件处理

    AWT(Abstract Windowing Toolkit)提供了Java中图形的基础,甚至Swing也是基于AWT 的。Swing组件比AWT组件要多的多,对每个AWT组件都有Swing的替代组件。AWT组件需要耗费较多的系统资源,Swing组件是发展方向,但Swing是基于AWT的,我们需要对AWT了解。

    applet就是特别为在Web浏览器中显示图形而编写的类文件,使用HTML的<APPLET>标记在Web页面中嵌入applet。在Web中运行时,Java的applet被自动的下载并由浏览器运行。

    使用AWT的过程:我们一般以java.applet.Applet类为基础,创建一个新applet,java.applet.Applet类以AWT的Component类为基础。


    如果浏览器的版本相对于 Java的版本落后,则需要下载Java插件。

    AWT窗口化应用程序以AWT的Frame类为基础,它创建具有框架的显示按钮和标题的窗口。

    当用户做某种动作时,Java将这看作一个事件,然后进行相关事件处理,达到用户和程序交互的目的。

    最基础的AWT类是java.awt.Component类,所有的AWT可视组件都以它为基础。Java.awt.Component类本身是直接从java.lang.Object类派生出来的。

    另一个重要的AWT类是Container类。这个类是从Component类派生出来的,是AWT容器的基础,可以包含其它组件。

    概念


    处理非 Java浏览器

    当所使用浏览器不支持Java的时候,可以将提示语言放在<APPLET>标记之中,显示该文本。

    <APPLET

    CODE=applet.class

    WIDTH=200

    HEIGHT=200>

    Sorry,you don’t have Java,so you can’t see my beautiful applet.

    </APPLET>


    Applet2

    applet 方法

    init—被调用的第一个方法;它只被调用一次,在这里初始化applet。

    start—在init之后被调用。每次applet再次出现在屏幕上时调用这个方法。也就是如果用户转移到另一个页面然后又回来,就再一次调用start方法。

    stop—当浏览器转移到另一个页面时调用。可以使用这个方法来停止你的applet可能启动的附加执行线程。

    destory—当要从内存中删除 applet时调用。

    paint—当重新绘制applet时调用。这个方法得到Graphics类的一个对象,可以使用这个对象的方法在applet中绘图。

    update—当重新绘制applet的一部分时调用。


    Applet3

    下例的背景色被改为红色,一般默认为灰色。

    import java.applet.Applet;

    import java.awt.*;

    public class applet extends Applet

    { public void init()

    {setBackground (Color.red);}

    public void start()

    {}

    public void paint(Graphics g)

    {g.drawString ("hello from java !",60,100);}

    public void stop()

    {}

    public void destroy()

    {}

    }

    applet方法


    1 标准的事件处理 下例的背景色被改为红色,一般默认为灰色。

    import java.applet.Applet;

    import java.awt.*;

    import java.awt.event.*;

    public class applet extends Applet implements ActionListener

    { TextField text1; Button button1;

    public void init()

    { text1=new TextField(20); add(text1);

    button1= new Button("Click here!"); add(button1);

    button1.addActionListener(this);}//添加动作监听器

    public void actionPerformed(ActionEvent event)

    // actionPerformed是ActionListener 接口的方法,ActionEvent 是

    //该方法接受的事件对象的类型

    {String msg=new String("Hello from Java!");

    if(event.getSource()==button1){text1.setText(msg);}}

    }// getSource返回导致事件的对象,检查事件是否由button1产生

    事件处理


    适配器类( 下例的背景色被改为红色,一般默认为灰色。adapter class)是已经实现了各种事件接口的类,每个方法为空代码,只需覆盖需要的方法。MouseListener接口有五个方法需要实现,我们只用mouseClicked,所以使用MouseAdapter类代替。

    import java.applet.Applet;

    import java.awt.*;

    import java.awt.event.*;

    public class applet extends Applet

    { public String s= "Hello from Java!";

    public void init()

    { addMouseListener(new ma(this));}//添加鼠标监听器

    public void paint(Graphics g)

    {g.drawString(s,60,100);}}

    class ma extends MouseAdapter{ applet a ;

    ma(applet appletobject){a=appletobject;}

    public void mouseClicked(MouseEvent me)

    {a.s= "Hello to Java!";a.repaint();}}

    使用适配器类


    import java.applet.Applet; 下例的背景色被改为红色,一般默认为灰色。

    import java.awt.*;

    import java.awt.event.*;

    public class applet extends Applet

    {

    public String s= "Hello from Java!";

    public void init()

    { // MouseAdapter是派生出匿名内部类的父类

    addMouseListener(new MouseAdapter(){

    public void mousePressed(MouseEvent me){

    s= "Hello to Java!";

    repaint();}});

    }

    public void paint(Graphics g)

    {g.drawString(s,60,100);}

    }

    使用匿名内部适配器类


    和编写 下例的背景色被改为红色,一般默认为灰色。applet不同,编写窗口化应用程序时候,要自己创建窗口,在其中显示应用程序。

    类继承从父到子:java.lang.Object java.awt.Component

    java.awt.Container java.awt.Window java.awt.Frame

    import java.awt.*;

    import java.awt.event.*;

    class AppFrame extends Frame

    {public void paint(Graphics g)

    {g.drawString("Hello from Java!",60,100);}

    }

    public class app

    { public static void main(String [] args)a

    {AppFrame f=new AppFrame();

    f.setSize(200,200);

    f.show();}

    }

    创建窗口化的应用程序


    WindowAdapter 下例的背景色被改为红色,一般默认为灰色。类用WindowListener接口中每个方法的空实现来实现WindowListener接口。

    import java.awt.*;

    import java.awt.event.*;

    class AppFrame extends Frame

    {public void paint(Graphics g)

    {g.drawString("Hello from Java!",60,100);}

    }

    public class app

    { public static void main(String [] args)

    {AppFrame f=new AppFrame();

    f.setSize(200,200);

    f.addWindowListener(new WindowAdapter() {public void

    windowClosing(WindowEvent e) {System.exit(0);}});

    f.show();}//这里用匿名内部适配器类且覆盖windowClosing

    } //事件,添加的代码是System.exit(0)。0代表正常终止。

    当应用程序窗口关闭时退出应用程序


    Applet4

    如果在 下例的背景色被改为红色,一般默认为灰色。applet中添加一个main方法,这个applet既可以作为applet运行,也可以作为应用程序运行;当它作为applet运行时,Java会忽略main方法;当它作为应用程序运行时,会运行mian方法。

    import java.applet.Applet;

    import java.awt.*;

    import java.awt.event.*;

    public class applet extends Applet

    { public static void main(String [] args)

    {AppFrame f=new AppFrame(); f.setSize(200,200);

    f.addWindowListener(new WindowAdapter() {public void

    windowClosing(WindowEvent e) {System.exit(0);}});f.show();}

    public void paint(Graphics g)

    {g.drawString("Hello from Java!",60,100);} }

    class AppFrame extends Frame

    {public void paint(Graphics g)

    {g.drawString("Hello from Java!",60,100);}}

    可以作为applet运行的应用程序


    Java 下例的背景色被改为红色,一般默认为灰色。中默认的布局管理器是流布局管理器(flow layout manager),用流的方式来排放组件,形成组件流(flow of component)。也可以采用其它的布局管理器,也可以不使用布局管理器。如代码所示:

    setLayout(null);

    text1=new TextField(20);

    text1.setSize(200,50);

    text1.setLocation(20,20);

    add(text1);

    这样把大小(200,50)的文本域添加到容器(如applet窗口)的(20,20)位置上。

    和布局一起使用的一种非常有用的AWT容器是Panel组件。可以在板中添加组件,然后在applet或者应用程序的布局中添加板本身。

    布局


    使用 下例的背景色被改为红色,一般默认为灰色。FlowLayout字段来指定对齐方式

    CENTER LEADING LEFT RIGHT TRAILING

    LEADING 每行对齐前沿 TRAILING 每行对齐后沿

    import java.applet.Applet;

    import java.awt.*;

    public class flow extends Applet {

    TextField text1, text2, text3;

    public void init()

    {

    setLayout(new FlowLayout(FlowLayout.RIGHT));

    text1 = new TextField(10); add(text1);

    text2 = new TextField(10); add(text2);

    text3= new TextField(10); add(text3);

    }

    }

    流布局


    import java.applet.Applet; 下例的背景色被改为红色,一般默认为灰色。

    import java.awt.*;

    import java.awt.event.*;

    public class multiplier extends Applet implements ActionListener {

    TextField text1, text2, text3;

    Label multiplylabel; Button b1;

    public void init()

    {

    text1 = new TextField(10); add(text1);

    multiplylabel = new Label("*"); add(multiplylabel);

    text2 = new TextField(10); add(text2);

    b1 = new Button("="); add(b1);

    b1.addActionListener(this);

    text3= new TextField(10); add(text3);

    }

    流布局


    public void actionPerformed(ActionEvent e) 下例的背景色被改为红色,一般默认为灰色。

    {

    if(e.getSource() == b1)

    {

    int product = Integer.parseInt(text1.getText()) *

    Integer.parseInt(text2.getText());

    text3.setText(String.valueOf(product));

    }

    }

    }

    流布局


    1 jdbc
    1 下例的背景色被改为红色,一般默认为灰色。JDBC概述

    • 什么是JDBC

      • JDBC(Java Database Connectivity)是实现Java程序与数据库系统互连的标准API,它允许发送SQL语句给数据库,并处理执行结果。

    • JDBC驱动程序

      • 类型1驱动程序:JDBC-ODBC桥,通过ODBC数据源进行与数据库的连接

      • 类型2驱动程序:通过本地库与数据库进行连接的纯Java驱动程序

      • 类型3驱动程序:通过中间件服务器与数据库建立连接的驱动程序

      • 类型4驱动程序:直接与数据库相连的纯Java驱动程序


    1 jdbc1
    1 下例的背景色被改为红色,一般默认为灰色。JDBC概述

    • JDBC驱动程序

      • 类型1驱动程序


    1 jdbc2
    1 下例的背景色被改为红色,一般默认为灰色。JDBC概述

    • JDBC驱动程序

      • 类型2驱动程序


    1 jdbc3
    1 下例的背景色被改为红色,一般默认为灰色。JDBC概述

    • JDBC驱动程序

      • 类型3驱动程序


    1 jdbc4
    1 下例的背景色被改为红色,一般默认为灰色。JDBC概述

    • JDBC驱动程序

      • 类型4驱动程序


    2 jdbc
    2 下例的背景色被改为红色,一般默认为灰色。JDBC接口

    • java.sql.Driver

      • 用于读取数据库驱动器的信息,提供connect方法,建立访问数据库 所用的Connection对象。

    • java.sql.DriverManager

      • 管理Driver对象,连接数据库。注册驱动程序、获得连接、向数据库输出流发送信息。


    2 jdbc1
    2 下例的背景色被改为红色,一般默认为灰色。JDBC接口

    • java.sql.Connection

      • 连接Java数据库和Java应用程序之间的主要对象。创建所有的Statement对象,执行SQL语句。

    • java.sql.Statement

      • 代表了一个特定的容器。对一个特定的数据库执行SQL语句。

    • java.sql.ResultSet

      • 用于控制对一个特定语句的行数据的存取。也就是数据库中记录或行组成的集合。


    3 数据库应用开发过程 下例的背景色被改为红色,一般默认为灰色。

    • 建立数据源;

    • 装载驱动程序

      • JDBC/ODBC桥:

        Class.forName(”sun.jdbc.odbc.JdbcOdbcDriver”);

      • 类名jdbc.DriverName:Class.forName(“jdbc.DriverName”) 。


    3 数据库应用开发过程 下例的背景色被改为红色,一般默认为灰色。

    • 建立连接

      • Connection con=DriverManager.getConnection(url,Login,password);

    • 建立语句对象

      • Statement stmt= conn.createStatement();

    • 书写具体的SQL语句

      • 数据处理

        • next

        • beforeFirst

        • last

      • 获取元数据


    3 数据库应用开发过程 下例的背景色被改为红色,一般默认为灰色。

    • 关闭对象

      • 关闭对象使用close()方法,并且按照ResultSet-Statement-Connection的顺序依次关闭所使用的对象。

    • 处理异常和警告

      • 装载驱动时,处理的异常类是ClassNotFoundException,其它的要处理的异常类是SQLExeption。


    4 实例 下例的背景色被改为红色,一般默认为灰色。

    • 实例

      • 建立一个学生表student ,包括三个属性:学号、姓名和年龄,其创建语句如下:

        create table student (id varchar(10) primary key,name varchar(20), age int);

      • 实现的功能:

        • 向表student中插入一条记录id=000099988,name=zhhdhh,age=45

        • 输出显示所有的记录。

      • 实现方式:

        • 纯Java驱动

        • JDBC-ODBC桥


    5 数据库连接池 下例的背景色被改为红色,一般默认为灰色。

    • 存在的问题

      • 当访问量增大时(WEB程序的访问量通常是很大的),频繁地建立连接和关闭连接,系统开销是非常大的。而且如果连接不能正常关闭,也会引发数据库系统的安全问题。

    • 解决的办法-连接池

      • 首先建立一些连接放置于内存对象中以备使用,当程序中需要建立数据库连接时,只须从内存中取一个来用而不用新建。同样,使用完毕后,只需放回内存即可。而连接的建立、断开都有连接池自身来管理 。


    Jdbcodbcdemo
    JDBCODBCDemo 下例的背景色被改为红色,一般默认为灰色。

    import java.sql.*;

    public class JDBCODBCDemo

    { private String dbURL;

    private String user;

    private String password;

    public static void main(String args[])

    { try

    {

    JDBCODBCDemo bridge=new JDBCODBCDemo();

    bridge.setURL("jdbc:odbc:datasource");

    bridge.setUser("");


    bridge.setPassword(""); 下例的背景色被改为红色,一般默认为灰色。

    Connection con=bridge.getConnection();

    System.out.println(con.getCatalog());

    con.close(); }

    catch(Exception e)

    { System.out.println(e.toString()); }

    }

    public Connection getConnection()

    { try

    {

    Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");


    return DriverManager.getConnection(dbURL,user,password); } 下例的背景色被改为红色,一般默认为灰色。

    catch (Exception e)

    { System.out.println(e.toString()); }

    return null;

    }

    public void setURL(String dbURL)

    { this.dbURL=dbURL; }

    public void setUser(String user)

    { this.user=user; }

    public void setPassword(String password)

    { this.password=password; } }


    Dboperation
    DBOperation 下例的背景色被改为红色,一般默认为灰色。

    import java.sql.*;

    public class DBOperation

    { private Statement sta;

    public static void main(String args[])

    { try

    {

    JDBCODBCDemo bridge=new JDBCODBCDemo();

    DBOperation operator=new DBOperation();

    ResultSet rs;

    String sqlCommand;

    bridge.setURL("jdbc:odbc:datasource");

    bridge.setUser(""); bridge.setPassword("");

    Connection con=bridge.getConnection();


    operator.setStatement(con); sqlCommand="SELECT * FROM STUDENTS"; System.out.println("\n######### Query #########"); System.out.println("input SQL command"+sqlCommand+"\n"); rs=operator.executeQuery(sqlCommand);

    rs.next();

    for(int i=0;i<rs.getRow();i++)

    { System.out.println(rs.getString("NAME"));

    rs.next();

    }

    sqlCommand="UPDATE STUDENTS SET AGE=22 WHERE NAME=\'Andy\'";


    System.out.println("\n######### modify #########"); System.out.println("input SQL command"+sqlCommand+"\n"); operator.executeUpdate(sqlCommand); sqlCommand="SELECT * FROM STUDENTS WHERE NAME=\'Andy\'"; rs=operator.executeQuery(sqlCommand);

    rs.next();

    for(int i=0;i<rs.getRow();i++) {System.out.println(rs.getString("NAME")+ "'s age is now "+rs.getInt("AGE"));

    rs.next();

    }


    sqlCommand="INSERT INTO STUDENTS(ID,NAME,AGE)"+ #########"); System.out.println("input SQL command"+sqlCommand+"\n"); operator.executeUpdate(sqlCommand); sqlCommand="SELECT * FROM STUDENTS WHERE NAME=\'Andy\'"; rs=operator.executeQuery(sqlCommand);

    "VALUES(\'5\',\'Lilei\',1)"; System.out.println("\n######### Add #########"); System.out.println("??SQL??"+sqlCommand+"\n"); operator.executeInsert(sqlCommand); sqlCommand="SELECT * FROM STUDENTS WHERE ID=\'5\'"; rs=operator.executeQuery(sqlCommand);

    rs.next();

    for(int i=0;i<rs.getRow();i++)

    { System.out.println("ID "+rs.getString("ID")+ " added "+rs.getString("NAME"));

    rs.next();

    }


    sqlCommand="DELETE FROM STUDENTS WHERE ID=\'5\'"; System.out.println("\n######### Delete #########"); System.out.println("input SQL command "+sqlCommand+"\n"); operator.executeDelete(sqlCommand); sqlCommand="SELECT * FROM STUDENTS WHERE ID=\'5\'"; rs=operator.executeQuery(sqlCommand);

    rs.next();

    if(!rs.next())

    { System.out.println("ID = 5 doesn't exists");

    }

    rs.close(); operator.closeStatement();

    con.close();

    }


    catch(Exception e) ID=\'5\'"; System.out.println("\n######### Delete #########"); System.out.println("input SQL command "+sqlCommand+"\n"); operator.executeDelete(sqlCommand); sqlCommand="SELECT * FROM STUDENTS WHERE ID=\'5\'"; rs=operator.executeQuery(sqlCommand);

    { System.out.println(e.toString()); } }

    public void setStatement(Connection con)

    { try

    { this.sta=con.createStatement(); }

    catch(Exception e)

    { System.out.println(e.toString()); }

    }

    public ResultSet executeQuery

    (String sqlCommand)

    { try

    { return sta.executeQuery(sqlCommand); }

    catch(Exception e)

    { System.out.println(e.toString()); }


    return null; } ID=\'5\'"; System.out.println("\n######### Delete #########"); System.out.println("input SQL command "+sqlCommand+"\n"); operator.executeDelete(sqlCommand); sqlCommand="SELECT * FROM STUDENTS WHERE ID=\'5\'"; rs=operator.executeQuery(sqlCommand);

    public void executeUpdate(String sqlCommand)

    { try

    { sta.executeUpdate(sqlCommand);

    }

    catch(Exception e)

    { System.out.println(e.toString()); }

    }

    public void executeInsert(String sqlCommand)

    { try

    { sta.executeUpdate(sqlCommand); }

    catch(Exception e)

    { System.out.println(e.toString());}

    }


    public void executeDelete(String sqlCommand) ID=\'5\'"; System.out.println("\n######### Delete #########"); System.out.println("input SQL command "+sqlCommand+"\n"); operator.executeDelete(sqlCommand); sqlCommand="SELECT * FROM STUDENTS WHERE ID=\'5\'"; rs=operator.executeQuery(sqlCommand);

    { try

    { sta.executeUpdate(sqlCommand); }

    catch(Exception e)

    { System.out.println(e.toString()); }

    }

    public void closeStatement()

    { try

    { sta.close(); }

    catch(Exception e)

    { System.out.println(e.toString()); }

    }

    }


    Jdbcdemo
    JDBCDemo ID=\'5\'"; System.out.println("\n######### Delete #########"); System.out.println("input SQL command "+sqlCommand+"\n"); operator.executeDelete(sqlCommand); sqlCommand="SELECT * FROM STUDENTS WHERE ID=\'5\'"; rs=operator.executeQuery(sqlCommand);

    import java.sql.*;

    public class JDBCDemo

    { private String dbURL;

    private String user;

    private String password;

    public Connection getConnection()

    { try

    { Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");


    Jdbcdemo1
    JDBCDemo ID=\'5\'"; System.out.println("\n######### Delete #########"); System.out.println("input SQL command "+sqlCommand+"\n"); operator.executeDelete(sqlCommand); sqlCommand="SELECT * FROM STUDENTS WHERE ID=\'5\'"; rs=operator.executeQuery(sqlCommand);

    return DriverManager.getConnection(dbURL,user,password);

    }

    catch (Exception e)

    { System.out.println(e.toString()); }

    return null;

    }

    public void setURL(String dbURL)

    { this.dbURL=dbURL; }

    public void setUser(String user)

    { this.user=user; }


    public void setPassword(String password) ID=\'5\'"; System.out.println("\n######### Delete #########"); System.out.println("input SQL command "+sqlCommand+"\n"); operator.executeDelete(sqlCommand); sqlCommand="SELECT * FROM STUDENTS WHERE ID=\'5\'"; rs=operator.executeQuery(sqlCommand);

    { this.password=password; }

    public static void main(String args[])

    { try

    {

    JDBCDemo driver=new JDBCDemo();

    driver.setURL("jdbc:sqlserver://192.168.88.88:1433;DatabaseName=student");

    driver.setUser("sa"); driver.setPassword("sa");


    Connection con=driver.getConnection(); System.out.println(con.getCatalog());

    con.close();

    }

    catch(Exception e)

    { System.out.println(e.toString()); }

    }

    }


    ad