Java 实现连接sql server 2000（JDBC数据库访问例子）

1. 接口注入（不推荐）
2. getter，setter方式注入（比较常用）
3. 构造器注入（死的应用）

•  autowire="defualt"
•  autowire=“byName”
•  autowire="bytype"

工厂模式定义:提供创建对象的接口.

为何使用?
工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。

为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象， 如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩 展性和尽量少的修改量。

我们以类Sample为例， 如果我们要创建Sample的实例对象:

Sample sample=new Sample();

可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等。

首先，我们想到的是，可以使用Sample的构造函数，这样生成实例就写成:

Sample sample=new Sample(参数);

但是，如果创建sample实例时所做的初始化工作不是象赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那你的代码很难看了（就需要Refactor重整）。

为什么说代码很难看，初学者可能没有这种感觉，我们分析如下，初始化工作如果是很长一段代码，说明要做的工作很多， 将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有背于Java面向对象的原则，面向对象的封装 (Encapsulation)和分派(Delegation)告诉我们，尽量将长的代码分派“切割”成每段，将每段再“封装”起来(减少段和段之间偶合 联系性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。

在本例中，首先，我们需要将创建实例的工作与使用实例的工作分开, 也就是说，让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。

这时我们就需要Factory工厂模式来生成对象了，不能再用上面简单new Sample(参数)。还有,如果Sample有个继承如MySample, 按照面向接口编程,我们需要将Sample抽象成一个接口.现在Sample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下:

Sample mysample=new MySample();
Sample hissample=new HisSample();

随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的.

但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了.

工厂方法
你会建立一个专门生产Sample实例的工厂:

public class Factory{

　　public static Sample creator(int which){

　　//getClass 产生Sample 一般可使用动态类装载装入类。
　　if (which==1)
　　　　return new SampleA();
　　else if (which==2)
　　　　return new SampleB();

　　}

}

那么在你的程序中,如果要实例化Sample时.就使用

Sample sampleA=Factory.creator(1);

这样,在整个就不涉及到Sample的具体子类,达到封装效果,也就减少错误修改的机会,这个原理可以用很通俗的话 来比喻:就是具体事情做得越多,越容易范错误.这每个做过具体工作的人都深有体会,相反,官做得越高,说出的话越抽象越笼统,范错误可能性就越少.好象我 们从编程序中也能悟出人生道理?呵呵.

使用工厂方法 要注意几个角色，首先你要定义产品接口，如上面的Sample,产品接口下有Sample接口的实现类,如SampleA,其次要有一个factory类，用来生成产品Sample，如下图，最右边是生产的对象Sample：

进一步稍微复杂一点，就是在工厂类上进行拓展，工厂类也有继承它的实现类concreteFactory了。

抽象工厂
工厂模式中有: 工厂方法(Factory Method) 抽象工厂(Abstract Factory).

这两个模式区别在于需要创建对象的复杂程度上。如果我们创建对象的方法变得复杂了,如上面工厂方法中是创建一个对象Sample,如果我们还有新的产品接口Sample2.

这里假设：Sample有两个concrete类SampleA和SamleB，而Sample2也有两个concrete类Sample2A和SampleB2

那么，我们就将上例中Factory变成抽象类,将共同部分封装在抽象类中,不同部分使用子类实现，下面就是将上例中的Factory拓展成抽象工厂:

public abstract class Factory{

　　public abstract Sample creator();

　　public abstract Sample2 creator(String name);

}

public class SimpleFactory extends Factory{

　　public Sample creator(){
　　　　.........
　　　　return new SampleA
　　}

　　public Sample2 creator(String name){
　　　　.........
　　　　return new Sample2A
　　}

}

public class BombFactory extends Factory{

　　public Sample creator(){
　　　　......
　　　　return new SampleB
　　}

　　public Sample2 creator(String name){
　　　　......
　　　　return new Sample2B
　　}

}

从上面看到两个工厂各自生产出一套Sample和Sample2,也许你会疑问，为什么我不可以使用两个工厂方法来分别生产Sample和Sample2?

抽象工厂还有另外一个关键要点，是因为 SimpleFactory内，生产Sample和生产Sample2的方法之间有一定联系，所以才要将这两个方法捆绑在一个类中，这个工厂类有其本身特 征，也许制造过程是统一的，比如：制造工艺比较简单，所以名称叫SimpleFactory。

在实际应用中，工厂方法用得比较多一些，而且是和动态类装入器组合在一起应用，

举例

我们以Jive的ForumFactory为例，这个例子在前面的Singleton模式中我们讨论过，现在再讨论其工厂模式:

public abstract class ForumFactory {

　　private static Object initLock = new Object();
　　private static String className = "com.jivesoftware.forum.database.DbForumFactory";
　　private static ForumFactory factory = null;

　　public static ForumFactory getInstance(Authorization authorization) {
　　　　//If no valid authorization passed in, return null.
　　　　if (authorization == null) {
　　　　　　return null;
　　　　}
　　　　//以下使用了Singleton 单态模式
　　　　if (factory == null) {
　　　　　　synchronized(initLock) {
　　　　　　　　if (factory == null) {
　　　　　　　　　　　　......

　　　　　　　　　　try {
　　　　　　　　　　　　　　//动态转载类
　　　　　　　　　　　　　　Class c = Class.forName(className);
　　　　　　　　　　　　　　factory = (ForumFactory)c.newInstance();
　　　　　　　　　　}
　　　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　　　return null;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}
　　　　}

　　　　//Now, 返回 proxy.用来限制授权对forum的访问
　　　　return new ForumFactoryProxy(authorization, factory,
　　　　　　　　　　　　　　　　　　　　factory.getPermissions(authorization));
　　}

　　//真正创建forum的方法由继承forumfactory的子类去完成.
　　public abstract Forum createForum(String name, String description)
　　throws UnauthorizedException, ForumAlreadyExistsException;

　　....

}

因为现在的Jive是通过数据库系统存放论坛帖子等内容数据,如果希望更改为通过文件系统实现,这个工厂方法ForumFactory就提供了提供动态接口:

private static String className = "com.jivesoftware.forum.database.DbForumFactory";

你可以使用自己开发的创建forum的方法代替com.jivesoftware.forum.database.DbForumFactory就可以.

在上面的一段代码中一共用了三种模式,除了工厂模式外,还有Singleton单态模式,以及proxy模 式,proxy模式主要用来授权用户对forum的访问,因为访问forum有两种人:一个是注册用户 一个是游客guest,那么那么相应的权限就不一样,而且这个权限是贯穿整个系统的,因此建立一个proxy,类似网关的概念,可以很好的达到这个效 果.  

看看Java宠物店中的CatalogDAOFactory:

public class CatalogDAOFactory {

　　/**

　　* 本方法制定一个特别的子类来实现DAO模式。
　　* 具体子类定义是在J2EE的部署描述器中。
　　*/

　　public static CatalogDAO getDAO() throws CatalogDAOSysException {

　　　　CatalogDAO catDao = null;

　　　　try {

　　　　　　InitialContext ic = new InitialContext();
　　　　　　//动态装入CATALOG_DAO_CLASS
　　　　　　//可以定义自己的CATALOG_DAO_CLASS，从而在无需变更太多代码
　　　　　　//的前提下，完成系统的巨大变更。

　　　　　　String className =(String) ic.lookup(JNDINames.CATALOG_DAO_CLASS);

　　　　　　catDao = (CatalogDAO) Class.forName(className).newInstance();

　　　　} catch (NamingException ne) {

　　　　　　throw new CatalogDAOSysException("
　　　　　　　　CatalogDAOFactory.getDAO: NamingException while
　　　　　　　　　　getting DAO type : \n" + ne.getMessage());

　　　　} catch (Exception se) {

　　　　　　throw new CatalogDAOSysException("
　　　　　　　　CatalogDAOFactory.getDAO: Exception while getting
　　　　　　　　　　DAO type : \n" + se.getMessage());

　　　　}

　　　　return catDao;

　　}

}

CatalogDAOFactory是典型的工厂方法，catDao是通过动态类装入器className获得 CatalogDAOFactory具体实现子类，这个实现子类在Java宠物店是用来操作catalog数据库，用户可以根据数据库的类型不同，定制自 己的具体实现子类，将自己的子类名给与CATALOG_DAO_CLASS变量就可以。

由此可见，工厂方法确实为系统结构提供了非常灵活强大的动态扩展机制，只要我们更换一下具体的工厂方法，系统其他地方无需一点变换，就有可能将系统功能进行改头换面的变化。

设计模式如何在具体项目中应用见《Java实用系统开发指南》

在java中，定义一个接口，声明计算长方形面积和周长的抽象方法，再用一个类去实现这个接口，再编写一个测试类去使用这个接口。

calrect.java

public interface calrect
{//定义接口，接口包含抽象类
 public abstract int calarea();
 public abstract int calgirth();
 public abstract int getx();
 public abstract int getY();
 
}

RRect.java

public class RRect implements calrect{

 public RRect()
 {
  x=3;y=4;
 }
 
 
 public  int calarea()//实现抽象类时，不用再写public abstract int calarea()
 {
  return x*y;
 }
 public  int calgirth()
 {
  return x*2+y*2;
 }
 public  int getx()
 {
  return x;
 }
 public  int getY()
 {
  return y;
 }
 
private int x;
private int y;
 
}

Class1.java

public class Class1 {

 RRect rect;
 public static void main(String[] args)
 {
  RRect rect = new RRect();
  System.out.println("巨星的长"+rect.getx());
  System.out.println("巨星的宽"+rect.getY());
  System.out.println("巨星的面积"+rect.calarea());
  System.out.println("巨星的周长"+rect.calgirth());
  
 }
}

将它们放在一个包中运行Class.java输出结果如下：

巨星的长3
巨星的宽4
巨星的面积12
巨星的周长14

一个软件设计的好坏，我想很大程度上取决于它的整体架构，而这个整体架构其实就是你对整个宏观商业业务的抽象框架，当代表业务逻辑的高层抽象层结构 合理时，你底层的具体实现需要考虑的就仅仅是一些算法和一些具体的业务实现了。当你需要再开发另一个相近的项目时，你以前的抽象层说不定还可以再次利用 呢，面对对象的设计，复用的重点其实应该是抽象层的复用，而不是具体某一个代码块的复用，是不是一下子感觉自己对复用理解的高度又上升了一层？^_^

说到了抽象，我就不能不提到曾让我头痛的Java接口和Java抽象类了，这也是本文我想说的重点。

既然面向对象设计的重点在于抽象，那Java接口和Java抽象类就有它存在的必然性了。

Java接口和Java抽象类代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。OOP面向对象的编程，如果要提高程序的复用率，增加程序 的可维护性，可扩展性，就必须是面向接口的编程，面向抽象的编程，正确地使用接口、抽象类这些太有用的抽象类型做为你结构层次上的顶层。

Java接口和Java抽象类有太多相似的地方，又有太多特别的地方，究竟在什么地方，才是它们的最佳位置呢？把它们比较一下，你就可以发现了。

1、Java接口和Java抽象类最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现，而Java接口不可以，这大概就是Java抽象类唯一的优点吧，但这个优点非常有用。
如 果向一个抽象类里加入一个新的具体方法时，那么它所有的子类都一下子都得到了这个新方法，而Java接口做不到这一点，如果向一个Java接口里加入一个 新方法，所有实现这个接口的类就无法成功通过编译了，因为你必须让每一个类都再实现这个方法才行，这显然是Java接口的缺点。

2、一个抽象类的实现只能由这个抽象类的子类给出，也就是说，这个实现处在抽象类所定义出的继承的等级结构中，而由于Java语言的单继承性，所以抽象类作为类型定义工具的效能大打折扣。
在这一点上，Java接口的优势就出来了，任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型，而一个类可以实现任意多个Java接口，从而这个类就有了多种类型。

3、从第2点不难看出，Java接口是定义混合类型的理想工具，混合类表明一个类不仅仅具有某个主类型的行为，而且具有其他的次要行为。

4、结合1、2点中抽象类和Java接口的各自优势，具精典的设计模式就出来了：声明类型的工作仍然由Java接口承担，但是同时给出一个Java 抽象类，且实现了这个接口，而其他同属于这个抽象类型的具体类可以选择实现这个Java接口，也可以选择继承这个抽象类，也就是说在层次结构中，Java 接口在最上面，然后紧跟着抽象类，哈，这下两个的最大优点都能发挥到极至了。这个模式就是“缺省适配模式”。
在Java语言API中用了这种模式，而且全都遵循一定的命名规范：Abstract ＋接口名。

Java接口和Java抽象类的存在就是为了用于具体类的实现和继承的，如果你准备写一个具体类去继承另一个具体类的话，那你的设计就有很大问题了。Java抽象类就是为了继承而存在的，它的抽象方法就是为了强制子类必须去实现的。

     最近老有种怀才不遇的感觉。呵呵，也许是自己有些心浮气躁了。开始还觉得自己很喜欢这种工作氛围，慢慢的觉得有些时候受到些不公平待遇，觉得自己被冷落。我给自己说：这样的心态很危险，要拥抱变化，融入团队。可是脑海中却有另一个我在说，怎么可以这样，怎么是这样的团队。之前一直在考虑，自己能给团队带来什么。考虑了些许觉得目前也许不能创造明显的价值，但至少不会出漏子，会让产品保质保量的上去。现在觉得要在团队中汲取些东西，也许是为了将来可以跳出这个框框。想学很多东西，每天在跟时间奔跑。

     感觉6：30起床也不是那么困难的事，以前总会睡到8点的样子才起来，到公司会9点多一点。现在巴不得晚上不要休息了。又有了读书时代的狂想，要是人可以连续工作7天然后集中休息一天该多好。呵呵，不要有黑夜，光明的日子一大把。

      前方的路很艰难，每个人都很努力，大部分人会死在今天晚上。现在感觉把这些感受写出来自己心里会舒服些，像是在跟另一个自己聊天，解读自己。我想如果要离开，那也是最辉煌的时刻离开，因为我不要别人看到我的落魄。所以，收起自己的恐惧和抱怨，埋头苦干，相信自己，我会成功！

      最近做一个日常，跟开发合作感觉很郁闷。我发现的问题给他提bug，他在自己本机试验了下，说我这是OK的。然后颠颠的跑过来，我给他演示一遍，他说明白了，我去看下代码。半天那个bug还是new，该bug影响了我后续测试的执行。我问他：改好了吗？他说：还没找到问题，不确定是环境问题还是代码问题。我感觉莫名的恼火，但也不好意思发火。任务很多，他修复不了我等下去也会延续后续的任务，这样推下去不是办法。末了，我想起另外一个开发，以前项目中合作过，感觉他能力很强，把问题反馈给他，他帮我查了下，2下就搞定了查处了问题。我反馈给和我合作的这个开发，他说：辛苦了，是这个问题。之后，他去修复，又过了半天，我问他：好了吗？他说：还没好。我说：是什么原因？他说：要找人审批。我心里想，这么半天了还没弄好么，我说：那你问问身边的人吧。过了会，他给我回复：已经找人了。又过了半天，我问他，他说：应该好了。我试了下，还是没好，反馈给他，他说他催下。他总不会主动回复我，每次我都要去追着问他，又问，答：应该好了吧。我说：你试下好了修复后我再验证。过了会，他说：给我个宝贝。我很晕！给了他宝贝，他说还没好。然后。。。。。。我催他，他催别人，然后。。。。。。终于听到好了，你验证下。我验证了下，这回确实是OK了。

      看了我这么多废话，你们有没遇到这样的情况，这样的开发真的很让人恼火。同时，我也在想，作为测试，要做这么多工作，肩负很重的责任。到底怎样才能保证质量，提高效率。靠我们来推动力量是很渺小的，那不是我们，是who？不再想想那么多了，自己先提高自身的能力，学好编码，以后希望可以跟开发说，这个bug你应该修改程序中的哪行代码。。。。。。

      我想，这样的目标并不遥远，在不久的将来我就能实现。相信自己，坚持下去，努力再努力。

冒泡

public class maopao{
public static void main(String args[])
{
 
int a[]={32,46,78,21,56,89,61};
int temp;
int i,j;

for (i=0;i<6;i++)
{
for(j=i+1;j<7;j++)
if(a[i]>a[j])
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}

for(i=0;i<7;i++)
{
System.out.println(a[i]);

}
}
}

执行结果：
21
32
46
56
61
78
89

　　例如一个java源程序可以是如下结构，该源程序命名为HelloWorldApp.java：
　　　package javawork.helloworld; /*把编译生成的所有.class文件放到包
　　　　　　　　　　　　　　　　　　 javawork.helloworld中*/
　　　import java.awt.*; 　//告诉编译器本程序中用到系统的AWT包
　　　import javawork.newcentury; /*告诉编译器本程序中用到用户自定义
　　　　　　　　　　　　　　　　　　的包javawork.newcentury*/
　　　public class HelloWorldApp{......} /*公共类HelloWorldApp的定义，
　　　　　　　　　　　　　　　　　　　　　 名字与文件名相同*/
　　　class TheFirstClass{......} //第一个普通类TheFirstClass的定义
　　　class TheSecondClass{......} //第二个普通类TheSecondClass的定义
　　　　　　　　　　　　　　...... //其它普通类的定义
　　　interface TheFirstInterface{......} /*第一个接口
　　　　　　　　　　　　　　　　　　　　　　TheFirstInterface的定义*/
　　　　　　　　　　　　　　　　　...... //其它接口定义

　　package语句：由于java编译器为每个类生成一个字节码文件，且文件名与类名相同，因此同名的类有可能发生冲突。为了解决这一问题，java提供包来管理类名空间，包实际提供了一种命名机制和可见性限制机制。而在java的系统类库中，把功能相似的类放到一个包（package）中，例如所有的图形界面的类都放在java.awt这个包中，与网络功能有关的类都放到java.net这个包中。用户自己编写的类（指.class文件）也应该按照功能放在由程序员自己命名的相应的包中，例如上例中的javawork.helloworld就是一个包。包在实际的实现过程中是与文件系统相对应的，例如javawork.helloworld所对应的目录是path\javawork\helloworld，而path是在编译该源程序时指定的。比如在命令行中编译上述HelloWorldApp.java文件时，可以在命令行中敲入"javac -d f:\javaproject HelloWorldApp.java"，则编译生成的HelloWorldApp.class文件将放在目录f:\javaproject\javawork\helloworld\目录下面，此时f:\javaprojcet相当于path。但是如果在编译时不指定path，则生成的.class文件将放在编译时命令行所在的当前目录下面。比如在命令行目录f:\javaproject下敲入编译命令"javac HelloWorldApp.java"，则生成的HelloWorldApp.class文件将放在目录f:\javaproject下面，此时的package语句相当于没起作用。

　　但是，如果程序中包含了package语句，则在运行时就必须包含包名。例如，HelloWorldApp.java程序的第一行语句是：package p1.p2；编译的时候在命令行下输入"javac -d path HelloWorldApp.java"，则HelloWorldApp.class将放在目录path\p1\p2的下面，这时候运行该程序时有两种方式：
　　第一种：在命令行下的path目录下输入字符"java p1.p2.HelloWorldApp"。
　　第二种：在环境变量classpath中加入目录path，则运行时在任何目录下输入"java p1.p2.HelloWorldApp"即可。

　　import语句：如果在源程序中用到了除java.lang这个包以外的类，无论是系统的类还是自己定义的包中的类，都必须用import语句标识，以通知编译器在编译时找到相应的类文件。例如上例中的java.awt是系统的包，而javawork.newcentury是用户自定义的包。比如程序中用到了类Button，而Button是属于包java.awt的，在编译时编译器将从目录classpath\java\awt中去寻找类Button，classpath是事先设定的环境变量，比如可以设为：classpath=.；d:\jdk1.3\lib\。 classpath也可以称为类路径，需要提醒大家注意的是，在classpath中往往包含多个路径，用分号隔开。例如classpath=.；d:\jdk1.3\lib\中的第一个分号之前的路径是一个点，表示当前目录，分号后面的路径是d:\jdk1.3\lib\，表示系统的标准类库目录。在编译过程中寻找类时，先从环境变量classpath的第一个目录开始往下找，比如先从当前目录往下找java.awt中的类Button时,编译器找不着，然后从环境变量classpath的第二个目录开始往下找，就是从系统的标准类库目录d:\jdk1.3\lib开始往下找java.awt的Button这个类，最后就找到了。如果要从一个包中引入多个类则在包名后加上".*"表示。

　　如果程序中用到了用户自己定义的包中的类，假如在上面程序中要用到javawork.newcentury包中的类HelloWorldApp，而包javawork.newcentury所对应的目录是f:\javaproject\javawork\newcentury，classpath仍旧是classpath=.；d:\jdk1.3\lib\，则编译器在编译时将首先从当前目录寻找包javawork.newcentury，结果是没有找到；然后又从环境变量classpath的第二个目录d:\jdk1.3\lib\开始往下找，但是仍然没有找到。原因在于包javawork.newcentury是放在目录f:\javaproject下面。因此，需要重新设定环境变量classpath，设为classpath=.；d:\jdk1.3\lib\；f:\javaproject\ 。所以编译器从f:\javaproject开始找包javawork.newcentury就可以找到。

　　源文件的命名规则：如果在源程序中包含有公共类的定义，则该源文件名必须与该公共类的名字完全一致，字母的大小写都必须一样。这是java语言的一个严格的规定，如果不遵守，在编译时就会出错。因此，在一个java源程序中至多只能有一个公共类的定义。如果源程序中不包含公共类的定义，则该文件名可以任意取名。如果在一个源程序中有多个类定义，则在编译时将为每个类生成一个.class文件

public class hello
{
 public static void main(String[] args)
 {
  //System.out.println("hello,");
  byte b;
  b=3;//-128到+127
  b=(byte)(b*3);//运算时自动数据类型转换为Int类型，会报错，对运算结果用byte做强制类型转换
  System.out.println(b);//print自动根据输入类型打印
  
  
  /*
  short s;//-32768到32767
  
  int i;//4个字节
  long l;//8个字节
  char ch;//2个字节，无符号0-65535
  ch='a';//字符存储的是ASCII码，以整数形式存储，同ch=97
  System.out.paintln(ch);
  float f=1.3f;//4个字节，加f表明1.3是浮点数，不会报错
  double d;//8个字节，
  boolean bool;
  bool=true|false;
  
  /*if(true)
  {
  }*/
  
  //java数组在定义时不能分配空间
  int num[];
  num=new int[3]; //直接定义int num[]=new int[3];
  num[0]=1;
  num[1]=12;
  num[2]=32;
  System.out.println(num[0]);
  int[] num;//java建议采用此方法，从定义上一目了然
  int [] num={1,2,3};//只能在定义时对其进行分配空间
  int [] num=new int[]{1,2,3}//OK
  
  //java二维数组
  int num[][]=
  int [][] num;
  num=new num[3][4];
  num[0][1]=12;//第一行第二个元素赋值
  
  //
  int i=3;
  System.out.println(i++);
  
  if()
  {
  }
  while(true)
  {
  }
  do
  {
  }while{true};
   
   for(int i=0;i<10;i++)
   {
   }
  //在for语句外不能引用i
 }
}

p  段落 paragraph[pærəɡrɑ:f]

div 层

a 链接标签

ul 列表

li 列表内容

tr 表格行

td 表格列

table 表格

<br>换行            <!--This is a comment-->注释

<a href="url">Text to be displayed</a>

<a href="http://www.w3school.com.cn/">Visit W3School!</a>

<a href="http://www.w3school.com.cn/" target="_blank">Visit W3School!</a>

<a name="label">Text to be displayed</a>

<a name="tips">Useful Tips Section</a>

<a href="http://www.w3school.com.cn/html/html_links.asp#tips">
Jump to the Useful Tips Section
</a>

框架
通过使用框架，你可以在同一个浏览器窗口中显示不止一个页面。每份HTML文档称为一个框架，并且每个框架都独立于其他的框架。
使用框架的坏处：
开发人员必须同时跟踪更多的HTML文档 
很难打印整张页面 
框架结构标签（<frameset>） 
框架结构标签（<frameset>）定义如何将窗口分割为框架 
每个 frameset 定义了一系列行或列 
rows/columns 的值规定了每行或每列占据屏幕的面积 
编者注：frameset 标签也被某些文章和书籍译为框架集。
框架标签（Frame）
Frame. 标签定义了放置在每个框架中的 HTML 文档。
在下面的这个例子中，我们设置了一个两列的框架集。第一列被设置为占据浏览器窗口的 25%。第二列被设置为占据浏览器窗口的 75%。HTML 文档 "frame_a.htm" 被置于第一个列中，而 HTML 文档 "frame_b.htm" 被置于第二个列中：
<frameset cols="25%,75%">
   <frame. src="frame_a.htm">
   <frame. src="frame_b.htm">
</frameset>
基本的注意事项 - 有用的提示：
假如一个框架有可见边框，用户可以拖动边框来改变它的大小。为了避免这种情况发生，可以在 <frame> 标签中加入：noresize="noresize"。
为不支持框架的浏览器添加 <noframes> 标签。
重要提示：不能将 <body></body> 标签与 <frameset></frameset> 标签同时使用！不过，假如你添加包含一段文本的 <noframes> 标签，就必须将这段文字嵌套于 <body></body> 标签内。（在下面的第一个实例中，可以查看它是如何实现的。）