总的来说，问题的原因就在于，struts是在第一次收到对action的请求（注意：不包括jsp的请求）时，提取这个请求的url的路径信息，把相应模块的mapping信息设置到请求中去。如果在进入一个模块时，第一次访问的是一个jsp页面，而在这个jsp页面中提交到该模块的一个action，就会出现找不到action mapping的情况。这就是因为，在进到这个模块时，访问的是jsp，这个模块的任何一个action都没有被访问到，所以struts的ActionServlet还没有来得及把这个模块的mapping设置到请求中，自然找不到该模块的action。

        因此，这就引出一个约定，就是系统中尽量避免对Jsp的直接访问，如果要访问也要通过action来forward。虽然看起来麻烦一点，但是安全性、健壮性都会有所提高。

        关于以上提到的模块mapping的设置原理，具体的文章在这里（不长），值得收藏：

        原文链接：http://202.100.72.44/news/itschool/pro/pro44134.htm

select   *   from  ( select  newtable. * ,rownum rownum_  from  ( select   *   from  s_emp) newtable  where  rownum  <=   20 )  where  rownum_  >   5

rownum在用于大于号时，不可以，必须先造一个table把rownum这个伪列当作这个新造出的表中的一个字段，才能进行特定行之间的查询。



DML Data manipulation language
   insert update delete

DDL Data definition language
   create alter drop rename trancate

Transaction control
   commit rollback savepoint

DCL
   GRANT REVOKE

==========================

 Name                                      Null?    Type
 ----------------------------------------- -------- ----------------------------
 ID                                        NOT NULL NUMBER(7)
 LAST_NAME                                 NOT NULL VARCHAR2(15)
 FIRST_NAME                                         VARCHAR2(15)
 USERID                                             VARCHAR2(8)
 START_DATE                                         DATE
 COMMENTS                                           VARCHAR2(15)
 MANAGER_ID                                         NUMBER(7)
 TITLE                                              VARCHAR2(20)
 DEPT_ID                                            NUMBER(7)
 SALARY                                             NUMBER(11,2)
 COMMISSION_PCT                                     NUMBER(4,2)

select last_name,salary, 12*salary + 100 from s_emp;

支持操作符

支持别名

select last_name ln from s_emp;

支持Concatenation，级联操作符

select first_name||last_name from s_emp


对于NULL值

select  last_name,title,salary * commission_pct / 100  COMM  from  s_emp;

这样查询会有很多NULL值

有一个NVL函数，以便在NULL出现时，给予一个默认值。

select  last_name,title, salary * NVL(commission_pct, 0 ) / 100  COMM  from  s_emp;

commission_pct，出现NULL，就会被0替换。

Eliminate duplicate rows by using distinct in select clause;

select   distinct  name  from  s_dept;

=============================================================

SQL> select name,salary,deptno from ( select concat(last_name,first_name) name,salary,department_id deptno,rank() over (partition by department_id order by salary desc) rnk from employees) where rnk = 2 or rnk = 3;

NAME                                              SALARY     DEPTNO
--------------------------------------------- ---------- ----------
FayPat                                              6000         20
KhooAlexander                                       3100         30
BaidaShelli                                         2900         30
WeissMatthew                                        8000         50
KauflingPayam                                       7900         50
ErnstBruce                                          6000         60
AustinDavid                                         4800         60
PataballaValli                                      4800         60
PartnersKaren                                      13500         80
ErrazurizAlberto                                   12000         80
KochharNeena                                       17000         90

NAME                                              SALARY     DEPTNO
--------------------------------------------- ---------- ----------
De HaanLex                                         17000         90
FavietDaniel                                        9000        100
ChenJohn                                            8200        100
GietzWilliam                                        8300        110

15 rows selected.

SQL>

SQL> desc employees;
 Name                                      Null?    Type
 ----------------------------------------- -------- ----------------------------
 EMPLOYEE_ID                               NOT NULL NUMBER(6)
 FIRST_NAME                                         VARCHAR2(20)
 LAST_NAME                                 NOT NULL VARCHAR2(25)
 EMAIL                                     NOT NULL VARCHAR2(25)
 PHONE_NUMBER                                       VARCHAR2(20)
 HIRE_DATE                                 NOT NULL DATE
 JOB_ID                                    NOT NULL VARCHAR2(10)
 SALARY                                             NUMBER(8,2)
 COMMISSION_PCT                                     NUMBER(2,2)
 MANAGER_ID                                         NUMBER(6)
 DEPARTMENT_ID                                      NUMBER(4)

SQL 排名问题

找出部门工资排名第二，三的员工

=====================

复习一下外连接Outer Join

SQL> desc s_emp;
 Name                                      Null?    Type
 ----------------------------------------- -------- ----------------------------
 ID                                        NOT NULL NUMBER(7)
 LAST_NAME                                 NOT NULL VARCHAR2(15)
 FIRST_NAME                                         VARCHAR2(15)
 USERID                                             VARCHAR2(8)
 START_DATE                                         DATE
 COMMENTS                                           VARCHAR2(15)
 MANAGER_ID                                         NUMBER(7)
 TITLE                                              VARCHAR2(20)
 DEPT_ID                                            NUMBER(7)
 SALARY                                             NUMBER(11,2)
 COMMISSION_PCT                                     NUMBER(4,2)

SQL> desc s_customer
 Name                                      Null?    Type
 ----------------------------------------- -------- ----------------------------
 NAME                                      NOT NULL VARCHAR2(25)
 ZIP_CODE                                           VARCHAR2(20)
 CREDIT_RA                                          VARCHAR2(25)
 SAL                                                NUMBER
 ID                                                 NUMBER(5)

客户表里的SAL字段是s_emp的外键。表示该客户的销售代表。

那么要想查出所有客户（包括没有销售代表的）所对应的销售代表记录。

  1  select e.last_name,e.id,c.name
  2  from s_emp e,s_customer c
  3  where e.id(+) = c.sal
  4* order by e.id

LAST_NAME               ID NAME
--------------- ---------- -------------------------
_dumas                  12 athletes attic
_dumas                  12 great athletes
_dumas                  12 bj athletics
_dumas                  12 athletic for all
_dumas                  12 sports,inc
                           athletics two
                           athletics one
                           shhes for sports
                           athletic attire
                           toms sporting goods

可以看到相应的部分客户并不存在销售代表也出现在结果集中，而用等值链接是不能查出的。

  1  select e.last_name,e.id,c.name
  2  from s_emp e,s_customer c
  3  where e.id = c.sal(+)
  4* order by e.id

查出所有销售代表所对应的客户。

LAST_NAME               ID NAME
--------------- ---------- -------------------------
_dumas                   8
hui                      8
aaa                     10
%ss                     11
_dumas                  11
_dumas                  12 sports,inc
_dumas                  12 athletic for all
_dumas                  12 bj athletics
_dumas                  12 great athletes
_dumas                  12 athletes attic
_dumas                  13

LAST_NAME               ID NAME
--------------- ---------- -------------------------
_dumas                  15
_dumas                  16
_dumas                  17
_dumas                  18
_dumas                  19
_dumas                  21
payn                    23
_dumas                  25
_dumas                  47
_dumas                  70
_dumas                  76

LAST_NAME               ID NAME
--------------- ---------- -------------------------
_dumas                  95
liganfeng              112
lgf                    122
lgf                    134
Biri                   333
qu                     555
_dumas                2271
tarena               25999
tarena               26999

空的旧更多了。

也就是哪边缺，哪边方加号。

这就是外连接。

import javax.ejb.*;
import java.rmi.*;
//business   remote
public interface Compute extends EJBObject{
    public double add(double a,double b) throws RemoteException;
}

import javax.ejb.*;
import java.rmi.*;

public interface ComputeHome extends EJBHome{
    public Compute create() throws RemoteException,CreateException;
}

import javax.ejb.*;

public class ComputeBean implements SessionBean
{
    public void setSessionContext(SessionContext ctx)
                       throws EJBException,
                              java.rmi.RemoteException{
    }
    public void ejbRemove()
               throws EJBException,
                      java.rmi.RemoteException{
    }
    public void ejbActivate()
                 throws EJBException,
                        java.rmi.RemoteException{
    }
    public void ejbPassivate()
                  throws EJBException,
                         java.rmi.RemoteException{
    }
    public void ejbCreate() throws CreateException{
    }
    public double add(double a,double b){
        return a*b;
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE ejb-jar PUBLIC "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN" "http://java.sun.com/dtd/ejb-jar_2_0.dtd">
<ejb-jar>
    <enterprise-beans>
        <session>
            <display-name>Compute</display-name>
            <ejb-name>abc</ejb-name>

            <home>ComputeHome</home>
            <remote>Compute</remote>
            <ejb-class>ComputeBean</ejb-class>

            <session-type>Stateless</session-type>
            <transaction-type>Container</transaction-type>     
        </session>
    </enterprise-beans>
    <assembly-descriptor>
        <container-transaction>
            <method>
                <ejb-name>abc</ejb-name>
                <method-name>*</method-name>
            </method>
            <trans-attribute>Required</trans-attribute>
        </container-transaction>
        
    </assembly-descriptor>
</ejb-jar>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE weblogic-ejb-jar PUBLIC '-//BEA Systems, Inc.//DTD WebLogic 8.1.0 EJB//EN' 'http://www.bea.com/servers/wls810/dtd/weblogic-ejb-jar.dtd'>
<weblogic-ejb-jar>
    <weblogic-enterprise-bean>
        <ejb-name>abc</ejb-name>        
        <jndi-name>efg</jndi-name>
    </weblogic-enterprise-bean>
</weblogic-ejb-jar>

想编译EJB，需要j2ee jar，那就用\bea\weblogic81\server\lib\weblogic.jar

做一个META-INF放置两个xml文件

jar -cvf Compute.jar *.class META-INF/*.xml

c创建,v看到它创建的过程,f文件名



部属EJB，看看Weblogic帮助吧。

=============================

那么会发现jar文件中并没有出现_stub或者_skeleton文件阿，那是因为由容器在运行EJB时动态创建在容器内部了。

那么怎么才能看到呢？我们要分析阿。

java weblogic.appc ejb.jar

如果抱错，在classpath中添加\jdk142_04\lib\tools.jar

如果想看原文件的话，就是-keepgenerated



===============================

开始分析EJB工作原理

看下面一张图，就清楚了，实际就是两次RMI 调用。



要细致来说。

基本是这样的。

定义Home接口，主要是为让客户端有可能在创建EJB Bean对象时，给予初始化。

import javax.ejb.*;
import java.rmi.*;

public interface ComputeHome extends EJBHome{
    public Compute create() throws RemoteException,CreateException;
}

这只是一个接口，weblogic.appc会生成一个HomeImpl，并生成Stub和Skeleton对象。在客户端JNDI查找时，返回就是这个HomeImpl的Stub对象，注意类文件也会动态下载的。

create()与ejbcreate()方法是对应的。

可有参数。

//Bean

   public void ejbCreate(String param) throws CreateException {
        // TODO Auto-generated method stub
        this.userName = param;
    }


//Home

public com.infogo.interfaces.Shopping create(java.lang.String param)
      throws javax.ejb.CreateException,java.rmi.RemoteException;

===========

那么客户端实际调用的是HomeImpl的Stub对象的方法，通过网络传送到服务器上的Skeleton，Skeleton再调用真正的HomeImpl对象的方法，创建一个创建Bean对象放入实例池，Impl调用Bean的ejbcreate方法，初始化参数。

并且HomeImpl，还要创建一个业务业务接口的实现类，并把业务接口实现类(EOImpl)对象的Stub返回给客户端。

客户端拿到Stub，调用响应服务方法(别忘了，真正的服务方法实现可是在Bean类里)，所以调用Stub方法，通过网络传递EOImpl的Skeleton对象，然后调用EOImpl的响应方法。

这是注意，EOImpl被称为请求拦截器，因为它会在这时察看ejb-jar.xml，看一看方法声明的事务类型，并调用容器提供的API（安全、事务等）。所以这种服务器或者容器叫做隐式容器，它有工具生成的类来调用容器相关API。而不是用户直接调用。

在EOImpl调用完容器API之后，就会调用Bean的业务方法。

最后将接口-Skeleton-Stub-客户端。

所以是两次RMI调用。

这就是EJB工作原理。

import javax.naming.*;
import java.util.*;
import javax.rmi.*;


public class Client
{
    public static void main(String[] args) throws Exception
    {
        Hashtable hash = new Hashtable();
        hash.put(Context.INITIAL_CONTEXT_FACTORY,"weblogic.jndi.WLInitialContextFactory");
        hash.put(Context.PROVIDER_URL,"t3://localhost:7001");
        InitialContext ic = new InitialContext(hash);
        
        ComputeHome home = (ComputeHome)ic.lookup("efg");
        
        //(ComputeHome)ProtableRemoteObject.narrow(ic.lookup("efg"),ComputeHome.class);
       /**//*
        * 客户端从服务器获得HomeImpl_stub .class文件,并获得HomeImpl_stub的对象
        * 
        * home.create()-->HomeImpl_stub.create()-->网络发送-->HomeImpl_skel.create()-->HomeImpl创建ComputeBean对象-->ComputeBean.ejbcreate()&&HomeImpl还要创建EOImpl_stub对象,返回HomeImpl_skel--->[网络往回传输]--->HomeImpl_stub--->客户端拿到EOImpl_stub对象。
        *
        * 这时完成了第一次rmi
        *
        * c获得了EOImpl_Stub对象,
        * 
        * c.add(32,32)----> EOImpl_Stub.add()--->网络发送--->EOImpl_Skel.add()--->EOImpl--->[根据xml描述的事务,进行事务描述]--->判断add方法是否开始事务--->调用创建好Bean对象的add方法---->方法结果给EOImpl_Skel---->网络往回传输---->EOImpl_Stub----客户端拿到结果。
        *
        * 第二次rmi完成。
        */
        
        
        
        Compute c = home.create();
        System.out.println(c.add(32,32));
        
    }   
}

<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">
    

</web-app>

然后部署servlet，在WEB-INF文件夹中，建立一个classes的目录，然后，将带目录结构的.class文件放入该文件夹，然后修改web.xml

<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">
    
     <servlet>
        <servlet-name>TimeServlet</servlet-name>
        <servlet-class>imshark.servlet.basic.TimeServlet</servlet-class>
    </servlet>
    
     <servlet-mapping>
        <servlet-name>TimeServlet</servlet-name>
        <url-pattern>/getTime.jsp</url-pattern>
    </servlet-mapping>

</web-app>

http://localhost:8080/imshark/getTime.jsp

所以可看出getTime.jsp是一个虚拟的路径地址，并不实际存在，完全有web.xml构造的。

以上就是最基本的Servlet的知识点。

#include <iostream>
using namespace std;

int main(int argc,char** argv, char** env)
{
        while(env&&*env){
                cout << *env << endl;
                ++env;
        }
        return 0;
}

c++，一个字符串数组，以char**的指针代表的。


所以遍历时，既要判断env指向的指针数组是否为空，也要判断*env是不是到末端。

=======================================

Unix 系统调用函数，getenv。

man getenv （或者man -k getenv    man -a getenv）

SYNOPSIS
     #include <stdlib.h>

     char *getenv(const char *name);

得到函数原型和需要包含的头文件。

RETURN VALUES
     If successful, getenv() returns a pointer to  the  value  in
     the  current  environment;  otherwise,  it  returns  a  null
     pointer.

#include <stdlib.h>
#include <iostream>

using namespace std;

int main()
{
        char javahome[200];
        strcpy(javahome,getenv("JAVA_HOME"));
        cout << javahome << endl;
        return 0;
}

#include <iostream>
using namespace std;
inline int isnumber(char ch)
{
       return ((ch >= '0' && ch <='9')? 1:0);       
} 

int main()
{
    char in; 
    while(true){ 
        cout << "please input a char:(input q to exit) >";
        in = cin.get();
        if(isnumber(in))
        {
              cout << "you input is num " << in - '0' << endl;                 
        }
        else
        {
              if(in == 'q')
                    break; 
              cout << "you input is not num " << endl;     
        } 
        cin.ignore(100,'\n'); 
    } 
    cout << "please input any key to exit" << endl; 
    cin.get(); 
    cin.get(); 
    return 0;    
}
 

#ifndef FIB_H
#define FIB_H 
double fib( int );
double fi( int );
#endif

double fib( int n )
{
    if( n<1 )
        return 0;
    if( n<3 )
        return 1;
    return fib( n-1 ) + fib( n-2 );
}

double fi( int n )
{
    if( n<1 )
        return 0;
    if( n<3 )
        return 1;
    double d,d1,d2;
    d1=1;
    d2=1;
    for( int i=3;i<=n;i++ ){
        d=d1+d2;
        d1=d2;
        d2=d;
    }
    return d;
}

主函数文件

#include <iostream>
using namespace std;
#include "fib.h"

int main()
{
    cout<<"please input item no.:";
    int n;
    cin>>n;
    cout<<"item "<<n<<" is "<<fi(n)<<endl;
    return 0;
}

import java.util.*;
public class TestClone{
 public static void main(String[] args)
 {
  Teacher t = new Teacher("Name",22);
  Teacher m = (Teacher)t.clone();
  System.out.println(m);
  
  Student stu = new Student();
  Student deepcloneSTU = (Student)stu.clone();
  stu.courses.put(new Integer(1),"Math");
  deepcloneSTU.courses.put(new Integer(100),"Java");
  disp(stu.courses);
  disp(deepcloneSTU.courses);
  
 }
 
 static void disp(HashMap h)
 {
  Set keySet = h.keySet();
  Iterator it = keySet.iterator();
  while(it.hasNext())
  {
   System.out.println(h.get(it.next()));
  }
 }
}

class Teacher implements Cloneable{
 String name;
 int age;
 Teacher(String name,int age)
 {
  this.name = name;
  this.age = age;
 }
 
 public Object clone()
 {
  try{
   return super.clone();
  }catch(CloneNotSupportedException e)
  {
   throw new Error("This should never happen!"); 
  }
 }
 
 public String toString()
 {
  return name + "  " + age;
 }
}

class Student implements Cloneable{
 HashMap courses = new HashMap();
 Student(){} 
 
 public Object clone()
 {
  try{
   Student stu = (Student)super.clone();
   stu.courses = (HashMap)courses.clone();
   return stu;
  }catch(CloneNotSupportedException e)
  {
   throw new Error("This should never happen!"); 
  }
 }
}

import java.util.*;
import java.io.*;
public class TestClone{
    public static void main(String[] args) throws Exception
    {
        BMW mycar = new BMW();
        ByteArrayOutputStream memoryOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream serializer = new ObjectOutputStream(memoryOutputStream);
        serializer.writeObject(mycar);
        serializer.flush();
        
        ByteArrayInputStream memoryInputStream = new ByteArrayInputStream(memoryOutputStream.toByteArray( ));
        ObjectInputStream deserializer = new ObjectInputStream(memoryInputStream);
        BMW mycopycar = (BMW)deserializer.readObject();

        mycar.add(new String("NB"));
        mycopycar.add(new String("NBNB"));
      System.out.println(mycar.hashCode());
      System.out.println(mycopycar.hashCode());
      System.out.println(mycar.equals(mycopycar));
    }
}

class BMW implements Serializable
{
    private int wheels;
  private String model;
  private ArrayList forTest;
  
  BMW()
  {
      wheels = 4;
      model = "530i";
      forTest = new ArrayList();
  }
  
  public void add(Object o)
  {
      forTest.add(o);
  }
  
  public String toString()
  {
      return "WHEEL:" + wheels + "MODEL:" + model + forTest.toString();    
  }
  
  public int hashCode()
  {
      return wheels + model.hashCode() + forTest.hashCode();    
  }
  
  public boolean equals(Object o)
  {
      if(o == this)
          return true;
      if(o == null)
          return false;
      if(!(o instanceof BMW))
        return false;
      BMW bmw = (BMW)o;
      if(bmw.wheels == wheels&&bmw.model.equals(model)&&bmw.forTest.equals(forTest))
          return true;
      else return false;
  }  
}

记住，如果覆盖了equals方法，应该也覆盖hashCode()，因为如果两个对象相等也就是equals()返回true，那么这两个对象应该有相同的hashCode。

class DBConnection{
   private static DBConnection db = null;
   private DBConnection{}

   public static DBConnection getInstance(){
         if(db == null) db = new DBConnection();
         return db;
   }
}

final 修饰  类、属性、方法

修饰类，无子类，保证用户使用的一致性。典型范例String类。

修饰属性或者变量一旦赋值，不得更改。

对于对象变量来说，是不能再指向其他对象，而现有的对象内部属性可以改变。

会配合static一起使用，只分配一个存储空间，只需要维护一个空间。

public static final，是一个常量。大写。

class SuperClass{
      final int AGE;

      public SuperClass(){
         AGE=10;
      }
}

初始值0不算，需要显示赋一次值。

初始设定在两个地方，1定义时直接赋值，2构造器

静态常量也在两个地方设定，1初始设定，2静态代码块




final方法不能覆盖，由于多态，一个编译时类型对应多个运行时类型，final保证某方法的稳定性。


private
               左边的修饰符有其中一个，系统都默认添加了final修饰符。
static

所以之前的静态方法不能覆盖。

=====================
方法继承是决定于在子类中是否可见。能见到就是继承。

final不决定继承。

实际上如果实例化一个子类对象，它的父类对象的所有属性（包括private成员都创建了，就是访问不了，所以不能成为继承的一部分，也就是不能继承咯）



=====================


abstract 修饰 类 方法

修饰类 -> 这个类必须被继承使用->不能生成对象

用处，把子类最大的共性提取出来放入其中，面向对象一般原则。

虽然不能生成对象（不能作为运行时类型），但可以声明为类型（可作为编译时类型）。

抽象方法，没有实现，留给子类覆盖。

final永远不可能和abstract在一起，那么private和static也不能和abstract联合修饰。

final表示必须不能被继承，不能覆盖；abstract表示必须继承，方法没有实现，必须覆盖使用。所以矛盾。

abstract class SuperClass{
      abstract void print(); //print(){},这是空实现，也是实现，所以不能带大括号。
}

如果类中有抽象方法的话，那么类只能是抽象类。(一个半成品)

如果子类没有实现父类的抽象方法，就会编译出错，因为子类继承了抽象方法，需要声明为抽象类。

SuperClass sc = new SubClass();

sc.print();动态类型判定，运行时类型不会改变，肯定是一个实现抽象方法的类对象。




接口:是同类，同一个层次的数据结构。

interface IA{
   void print();  
   int A = 1;
}

修饰符省略
一个Java文件，只能定义一个公开接口

一个接口等同于一个抽象类

一个特殊的抽象类：
   所有方法都是公开抽象的:public abstract
   所有属性都是公开静态常量:public static final

interface IA{
   void print();  
   int A = 1;
}

等价于

abstract class IA{
   public static final int A=1;
   public abstract void print();
}

这时可要注意，类实现接口时，覆盖方法的访问控制符一定要写上public，接口是省略为public，类不写可是default，根据Overriding规则，覆盖方法的访问控制等于或者大于父类方法的访问控制。

class IAImpl extends java.util.ArrayList implements IA{}

1一个类除了继承类，还可以实现接口（多个）。

2尽管一个类只能继承一个类，一个类可以实现多个接口

3接口与接口之间可以继承并可以多继承，实现多重继承，但复杂度不增加。

interface IC extends IA,IB{}

IC有着IA，IB所有方法的定义

IA，IB可以作为编译时类型。

========================

接口，被用来定义可以***的东西。

                  存储设备                              输入设备
----|----------------|-----                     ----------|-----------
硬盘                  U盘                                 鼠标
----|----
移动硬盘

使用接口来剥离出一部分抽象。

移动硬盘、U盘、鼠标除了间接父类是统一的设备父类外。

他们都是USB设备，这部分抽象就需要用接口定义。

那么机器上的连接器是一个方法，connect(USB接口)，不管你什么具体设备，你都必须实现USB规范，才能往上插。

那么用接口来定义一个规范。


例子2，JDBC，使用Java来访问数据库。

首先，如果由Sun公司自己提供各种数据库的驱动，那么各个DB厂商需要把数据库核心代码提供给Sun，这是不可能的，核心商业机密。

而由各个DB厂商自己写的话，会出现方法名的不同，导致如果数据库迁移，代码需要改动。(例如Oracle提供的方法为ConnectOracle()而ms提供的方法为ConnectSQL)。那么无法真正实现Write Once，Run Anywhere，Sun不同意。

怎么办？使用接口。

由Sun和DB联合制定一些一系列接口。

interface Driver()
{
      void connect();
      ...
}

OracleDriver implements Driver
SQLDriver implements Driver

实现不同的connect()逻辑。

用户Driver d = getDriver();
d.connect();

接口是实现Java一次编译，到处运行的重要技术。

保证了Sun制定规范，数据库厂商实现，用户使用。保证架构稳定性（将三方分开）

对于用户来说，接口最大化屏蔽差异。

1.实现不同层次，不同体系的对象的抽象。
2.保证架构稳定性。对用户透明。


==============================

Object 类，所有类的父类（直接，间接父类）

finalize(),当一个对象被垃圾回收的时候，会调用一下。不适合放入释放资源的方法。

toString(),对象的字符串表现形式。

System.out.println(obj);->obj.toString()

自定义类，覆盖该方法，返回一些有意义的信息。

==  判断字面值是否相等，

String a = new String("hello");
String b = new String("hello");
b==a false

String final类，并且它的值也是immutable的。

String a = "A"
a = a + "B"
这两步操作一共产生了3个对象。

JVM内部有一个字符串池，一个独立存储区域，保存已创建的字符串，如果再有相同的，会将引用指向字符串池中的已有对象，不再创建新的，如果没有再创建。

String a = "abc";
String b = "abc";

所以上面的例子是采用new String("abc")方式创建String对象，不会再去池中找，直接在堆中创建新对象。

String a = new String("hello");
String b = "hello";

a为堆地址，b为串池地址，a==b，false。

这种方式，是一种用时间换空间的做法，比如如果程序中有100个"hello"，难道程序要去维护100个对象嘛。

Object.equals   判断对象值是否相等。

/**//*
 * Student.java
 *
 * Created on 2005年12月3日, 上午10:43
 *
 * To change this template, choose Tools | Options and locate the template under
 * the Source Creation and Management node. Right-click the template and choose
 * Open. You can then make changes to the template in the Source Editor.
 */

package javaapplication1;

/** *//**
 *
 * @author Administrator
 */
public class Student {
    
    String name;
    int age;
    
    /** *//** Creates a new instance of Student */
    public Student() {
    }
    
    public Student(String n,int a){
        this.name = n;
        this.age = a;
    }
    
    public boolean equals(Object o)
    {
        Student s = (Student)o;
        if(s.name.equals(this.name)&&s.age == this.age)
            return true;
        return false;
    }
    
}

自定义类如果要进行对象值的比较，覆盖Object的equals方法，自行判断，如果不覆盖，直接调用Object.equals是判断地址。

equals方法覆盖标准流程：

    public boolean equals(Object o)
    {
        if(this == o)
            return true;
        if(o == null)
            return false;
        if(!(o instanceof Student))
            return false;
        Student s = (Student)o;
        if(s.name.equals(this.name)&&s.age == this.age)
            return true;
        return false;
    }

double d = 10000.0d;
Double D_d = new Double(d);
String D_S = D_d.toString();//D + ""
String d_s = String.valueOf(d);//d + ""
double s_d = Double.parseDouble(d_s);
Double S_D = Double.valueOf(d_s);
double d_D = D_d.doubleValue();

package com.ljl;

public class TestClass {
    public void print(B b){
        System.out.println("is B");        
    }
    
//    public void print(A a){
//        System.out.println("is A");
//    }
    
    public static void main(String[] args)
    {
        TestClass tc = new TestClass();
        A a = new B();
        tc.print(a);
    }
}

class A{}

class B extends A{}

为什么子类覆盖父类方法时，访问控制符只能更宽泛。因为如果父类方法为public,子类方法为private，那么多态时，察看父类方法可以调用（可调用编译时类型所定义的方法），而动态类型判断时，调用子类方法，发现为private，完蛋了。