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:  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。

  閱讀全文