java世界

插入排序：

　　package org.rut.util.algorithm.support;
　　import org.rut.util.algorithm.SortUtil;
　　/**
　　* @author treeroot
　       @since  310-301
　　* @version  920-533　
        **/
　　　public class InsertSort implements SortUtil.Sort
　　{
　　　/* (non-Javadoc)
　　　* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
　　　*/
　　　public void sort(int[] data)
　　　{
　　　　int temp;
　　　　for(int i=1;i for(int j=i;(j>0)&&(data[j] SortUtil.swap(data,j,j-1);
　　　}
　　}

　　冒泡排序：

　　package org.rut.util.algorithm.support;
　　import org.rut.util.algorithm.SortUtil;
　　/**
　　* @author treeroot
　　* @since 2006-2-2
　　* @version 1.0
　　*/
　　public class BubbleSort implements SortUtil.Sort
　　{
　　　/* (non-Javadoc)
　　　* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
　　　*/
　　　public void sort(int[] data)
　　　{
　　　　int temp;
　　　　for(int i=0;i for(int j=data.length-1;j>i;j--)
　　　　{
　　　　　if(data[j] SortUtil.swap(data,j,j-1);
　　　　}
　　　}
　　}

　　选择排序：

　　package org.rut.util.algorithm.support;
　　import org.rut.util.algorithm.SortUtil;
　　/**
　　* @author treeroot
　　* @since 2006-2-2
　　* @version 1.0
　　*/
　　public class SelectionSort implements SortUtil.Sort
　　{
　　　/*
　　　* (non-Javadoc)
　　　*
　　　* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
　　　*/
　　　public void sort(int[] data)
　　　{
　　　　int temp;
　　　　for (int i = 0; i < data.length; i++)
　　　　{
　　　　　int lowIndex = i;
　　　　　for (int j = data.length - 1; j >i; j--)
　　　　　{
　　　　　　if (data[j] < data[lowIndex])
　　　　　　{
　　　　　　　lowIndex = j;
　　　　　　}
　　　　　}
　　　　　SortUtil.swap(data,i,lowIndex);
　　　　}
　　　}
　　}

     摘要: 如何用Java获得一个域名的IP地址呢?提供这个功能的类叫做java.net.InetAddress。我们假设现在有这样一个域名，它用一个静态的getByName来重新获得一个InetAddress，然后得到可以读出的IP地址。下面的代码是非常基本的命令行。  阅读全文

在使用JDBC连接数据库的时，我们会采用executeQuery(String sql)获得一个结果集。当数据库结构变化或者获得其他数据库表结果集的时候我们需要将ResultSet结果集根据不同的数据结构重新遍历。
如何才能建立一个与数据库结构无关的JDBC连接呢？我们可以通过使用ResultSetMetaData()方法获得表结构。然后使用Object[]数组遍历结果集。当我们要取得相应的结果时，我们可以使用Iterator迭代器。只要遍历迭代器就可以取出结果。
下面是我写的一个方法：
  1import java.math.BigDecimal;
  2import java.sql.Connection;
  3import java.sql.DriverManager;
  4import java.sql.ResultSet;
  5import java.sql.ResultSetMetaData;
  6import java.sql.SQLException;
  7import java.sql.Statement;
  8import java.util.ArrayList;
  9import java.util.Iterator;
 10import java.util.List;
 11
 12public class newJdbc {
 13    private String url = "jdbc:oracle:thin:@localhost: 310-301 :nitpro";
 14
 15    private String dbUserName = "scott";
 16
 17    private String dbUserPassword = "tiger";
 18
 19    private Connection conn = null;
 20
 21    private Statement stmt = null;
 22
 23    private ResultSet rs = null;
 24
 25    public newJdbc() {
 26        try {
 27            Class.forName("oracle.jdbc.driver.OracleDriver");
 28        } catch (ClassNotFoundException e) {
 29            e.printStackTrace();
 30        }
 31    }
 32
 33    public Connection getConnection() {
 34        try {
 35            conn = DriverManager.getConnection(url, dbUserName, dbUserPassword);
 36        } catch (SQLException e) {
 37            e.printStackTrace();
 38        }
 39        return conn;
 40    }
 41
 42    public void close(ResultSet rs, Statement stmt, Connection conn) {
 43        if (rs != null) {
 44            try {
 45                rs.close();
 46            } catch (SQLException e) {
 47                e.printStackTrace();
 48            }
 49        }
 50        if (stmt != null) {
 51            try {
 52                stmt.close();
 53            } catch (SQLException e) {
 54                e.printStackTrace();
 55            }
 56        }
 57        if (conn != null) {
 58            try {
 59                conn.close();
 60            } catch (SQLException e) {
 61                e.printStackTrace();
 62            }
 63        }
 64    }
 65
 66    public List query(String sql) {
 67        List list = new ArrayList();
 68
 69        conn = this.getConnection();
 70        try {
 71            stmt = conn.createStatement();
 72            rs = stmt.executeQuery(sql);
 73            //获取数据库表结构
 74            ResultSetMetaData rsm = rs.getMetaData();
 75            //取得数据库的列数
 76            int col = rsm.getColumnCount();
 77            //生成col长度的Object数组
 78            Object[] obj = new Object[col];
 79            //遍历结果集，将结果存入Object数组
 80            while (rs.next()) {
 81                for (int i = 0; i < col; i++) {
 82                    obj[i] = rs.getObject(i + 1);
 83                }
 84                list.add(obj);
 85            }
 86        } catch (SQLException e) {
 87            e.printStackTrace();
 88        } finally {
 89            this.close(rs, stmt, conn);
 90        }
 91        return list;
 92    }
 93
 94    public void update(String sql) {
 95        try {
 96            conn = this.getConnection();
 97            stmt = conn.createStatement();
 98            stmt.executeUpdate(sql);
 99        } catch (SQLException e) {
100            e.printStackTrace();
101        }
102    }
103
104    public static void main(String args[]) {
105        newJdbc nj = new newJdbc();
106        String sql = "select * from users";
107        List list = nj.query(sql);
108        //返回list的迭代器
109        Iterator it = list.iterator();
110        //遍历迭代器，取出结果  1z0-147
111        while (it.hasNext()) {
112            Object[] o = (Object[]) it.next();
113            int id = ((BigDecimal) o[0]).intValue();
114            System.out.println(id);
115        }
116
117    }
118}

     摘要: Abstract class 抽象类:抽象类是不允许实例化的类，因此一般它需要被进行扩展继承。

　　Abstract method 抽象方法:抽象方法即不包含任何功能代码的方法。

　　Access modifier 访问控制修饰符:访问控制修饰符用来修饰Java中类、以及类的方法和变量的访问控制属性。

　　Anonymous class 匿名类:当你需要创建和使用一个类，而又不需要给出它的名字或者再次使用的使用，就可以利用匿名类。
　　Anonymous inner classes 匿名内部类:匿名内部类是没有类名的局部内部类  阅读全文

     摘要: 这段时间又回头补了遍java基础，结合javaapi一些零碎的总结如下：

System.exit(0);程序的退出代码，因为方法执行结束了，但是线程并没有结束。习惯上非零状态吗表示有错误

java.text.Numberformat类:
NumberFormat 是所有数字格式的抽象基类。此类提供了格式化和分析数字的接口。NumberFormat 还提供了一些方法，用来确定哪些语言环境具有数字格式，以及它们的名称是什么。 如下面的类就是Numberformat类的简单实现：  阅读全文

. this是指当前对象自己。
当在一个类中要明确指出使用对象自己的的变量或函数时就应该加上this引用。如下面这个例子中:
public class A {
String s = " MCP certifications ";
public A(String s) {
System.out.println("s = " + s);
System.out.println("1 -> this.s = " + this.s);
this.s = s;
System.out.println("2 -> this.s = " + this.s);
}

public static void main(String[] args) {
new A(" MCP Bootcamp ");
}
}

运行结果s =  MCP Bootcamp
1 -> this.s =   MCP certifications
2 -> this.s =  MCP Bootcamp !
在这个例子中，构造函数A中，参数s与类A的变量s同名，这时如果直接对s进行操作则是对参数s进行操作。若要对类A的变量s进行操作就应该用this进行引用。运行结果的第一行就是直接对参数s进行打印结果；后面两行分别是对对象A的变量s进行操作前后的打印结果。

2. 把this作为参数传递
当你要把自己作为参数传递给别的对象时，也可以用this。如：
public class A {
public A() {
new B(this).print();
}
public void print() {
System.out.println("Hello from A!");
}
}
public class B {
A a;
public B(A a) {
this.a = a;
}
public void print() {
a.print();
System.out.println("Hello from B!");
}
}
运行结果：
Hello from A!
Hello from B!
在这个例子中，对象A的构造函数中，用new B(this)把对象A自己作为参数传递给了对象B的构造函数。

3. 注意匿名类和内部类中的中的this。
有时候，我们会用到一些内部类和匿名类。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。如下面这个例子：
public class A {
int i = 1;
public A() {
Thread thread = new Thread() {
public void run() {
for(;;) {
A.this.run();
try {
sleep(1000);
} catch(InterruptedException ie) {
}
}
}
};
thread.start();
} 
public void run() {
System.out.println("i = " + i);
i++;
}
public static void main(String[] args) throws Exception {
new A();
}
}
在上面这个例子中, thread 是一个匿名类对象，在它的定义中，它的 run 函数里用到了外部类的 run 函数。这时由于函数同名，直接调用就不行了。这时有两种办法，一种就是把外部的 run 函数换一个名字，但这种办法对于一个开发到中途的应用来说是不可取的。那么就可以用这个例子中的办法用外部类的类名加上 this 引用来说明要调用的是外部类的方法 run。

1、对于原始数据类型，也就是int、 long、char之类的类型，是传值的，如果你在方法中修改了值，方法调用结束后，那个变量的值没用改变。
2、对于对象类型，也就是Object的子类，如果你在方法中修改了它的成员的值，那个修改是生效的，方法调用结束后，它的成员是新的值，但是如果你把它指向一个其它的对象( 70-305  )，方法调用结束后，原来对它的引用并没用指向新的对象。
代码如下：
public class Tester {
    public static void main(String[] args) {
        int primitive = 2;
        changePrimitive(primitive);
        //primitive的值依然是2
        MyClass myClass = new MyClass();
        changeObject(myClass);
        //myClass仍然指向的是执行changeObject之前的那个对象
        //但是myClass.i等于3了
    }

    public static void changePrimitive(int primitive) {
        primitive = 3;
    }

    public static void changeObject(MyClass myClass) {
        myClass.i = 3;
        myClass = new MyClass();
    }
}

class MyClass {
    int i;
}

对于远程调用，350-018  无论是什么类型，调用结束后，传入的参数和以前没用任何变化（当然前途是直接调用远程方法，如果中间经过其它的Proxy类或者Facade类，不能保证那些类对对象没用修改）。至于是通过Local接口进行调用的，也应该属于本地调用，和上面说的情况应该是一致的。

我们在定义常量的时候，可以把常量定义在接口里面，如：

package org.zy.demo.base;

public interface InterfaceDemo {

    final String name="this is my name";
    
}

上面是我定义的接口和常量。
常量的定义没有指明 public static 

我实现此接口：
package org.zy.demo.base;

public class InterfaceImpl  implements InterfaceDemo{
    
}

那么我们如何访问呢？
我做了一个demo:

package org.zy.demo.base;

public class MainDemo {

    public static void  main(String[] args){
        InterfaceImpl ii=new InterfaceImpl();
        String name = InterfaceDemo.name;
        System.out.println(name);
        String n=ii.name;
        String  exams =642-453 ;
        System.out.println(n);
    }
}
执行的结果如下：
this is my name
this is my name

在上面的程序中，我们使用了两种不同的方法来取得了 name的值。
由第一种方法我们可以知道：
    其实接口内定义的所有的属性和方法都是public类型的。如果是属性，其默认是
    Public static 的
通过第二种方法我们可以知道，此属性是公有的。否则我们怎么能直接访问呢？
由上面的结论我们可以知道为什么我们定义接口中的方法的时候，不用添加public,如泥可以定义如下方法：
Public Interface A{
    A();
}
当然你也可以：
Public Interface A{
    Public A();
}

java是基于面向对象设计的，java的特性肯定继承了面向对象的特性。下面我们就来结合面向对象来学习一下java的特性。

1.抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。070-447
2.继承：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3.封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
4.多态
最后讨论多态是因为多态和其他三个特性相比，应该是比较难理解的。
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。642-414 
多态有两种表现形式：重载和覆盖
首先说重载（overload），是发生在同一类中。与什么父类子类、继承毫无关系。    
  标识一个函数除了函数名外，还有函数的参数（个数和类型）。也就是说，一个类中可以有两个或更多的函数，叫同一个名字而他们的参数不同。    
  他们之间毫无关系，是不同的函数，只是可能他们的功能类似，所以才命名一样，增加可读性，仅此而已！  
    
  再说覆盖(override),是发生在子类中！也就是说必须有继承的情况下才有覆盖发生。 70-223 
  
  我们知道继承一个类，也就有了父类了全部方法，如果你感到哪个方法不爽，功能要变，那就把那个函数在子类中重新实现一遍。  
  这样再调用这个方法的时候，就是执行子类中的过程了。父类中的函数就被覆盖了。（当然，覆盖的时候函数名和参数要和父类中完全一样,不然你的方法对父类中的方法就不起任何作用，因为两者是两个函数，毫不关系） 

     摘要: Java总有它的千般好处使你选择它，但这些随便翻翻书或在网上逛一圈就能找到答案。在本文中，笔者把自己学习Java的一些切身体会和过程写出来，供初学者做个参考。

我在学习Java的过程中主要围绕以下几个方面来学习：

1．时刻提醒自己Java是一种OOP语言工具，而不仅仅是编码，只有这样才能总体把握和运用Java。

  阅读全文