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。我們假設(shè)現(xiàn)在有這樣一個域名，它用一個靜態(tài)的getByName來重新獲得一個InetAddress，然后得到可以讀出的IP地址。下面的代碼是非常基本的命令行。  閱讀全文

在使用JDBC連接數(shù)據(jù)庫的時，我們會采用executeQuery(String sql)獲得一個結(jié)果集。當(dāng)數(shù)據(jù)庫結(jié)構(gòu)變化或者獲得其他數(shù)據(jù)庫表結(jié)果集的時候我們需要將ResultSet結(jié)果集根據(jù)不同的數(shù)據(jù)結(jié)構(gòu)重新遍歷。
如何才能建立一個與數(shù)據(jù)庫結(jié)構(gòu)無關(guān)的JDBC連接呢？我們可以通過使用ResultSetMetaData()方法獲得表結(jié)構(gòu)。然后使用Object[]數(shù)組遍歷結(jié)果集。當(dāng)我們要取得相應(yīng)的結(jié)果時，我們可以使用Iterator迭代器。只要遍歷迭代器就可以取出結(jié)果。
下面是我寫的一個方法：
  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            //獲取數(shù)據(jù)庫表結(jié)構(gòu)
 74            ResultSetMetaData rsm = rs.getMetaData();
 75            //取得數(shù)據(jù)庫的列數(shù)
 76            int col = rsm.getColumnCount();
 77            //生成col長度的Object數(shù)組
 78            Object[] obj = new Object[col];
 79            //遍歷結(jié)果集，將結(jié)果存入Object數(shù)組
 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        //遍歷迭代器，取出結(jié)果  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 匿名類:當(dāng)你需要創(chuàng)建和使用一個類，而又不需要給出它的名字或者再次使用的使用，就可以利用匿名類。
　　Anonymous inner classes 匿名內(nèi)部類:匿名內(nèi)部類是沒有類名的局部內(nèi)部類  閱讀全文

     摘要: 這段時間又回頭補了遍java基礎(chǔ)，結(jié)合javaapi一些零碎的總結(jié)如下：

System.exit(0);程序的退出代碼，因為方法執(zhí)行結(jié)束了，但是線程并沒有結(jié)束。習(xí)慣上非零狀態(tài)嗎表示有錯誤

java.text.Numberformat類:
NumberFormat 是所有數(shù)字格式的抽象基類。此類提供了格式化和分析數(shù)字的接口。NumberFormat 還提供了一些方法，用來確定哪些語言環(huán)境具有數(shù)字格式，以及它們的名稱是什么。 如下面的類就是Numberformat類的簡單實現(xiàn)：  閱讀全文

. this是指當(dāng)前對象自己。
當(dāng)在一個類中要明確指出使用對象自己的的變量或函數(shù)時就應(yīng)該加上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 ");
}
}

運行結(jié)果s =  MCP Bootcamp
1 -> this.s =   MCP certifications
2 -> this.s =  MCP Bootcamp !
在這個例子中，構(gòu)造函數(shù)A中，參數(shù)s與類A的變量s同名，這時如果直接對s進行操作則是對參數(shù)s進行操作。若要對類A的變量s進行操作就應(yīng)該用this進行引用。運行結(jié)果的第一行就是直接對參數(shù)s進行打印結(jié)果；后面兩行分別是對對象A的變量s進行操作前后的打印結(jié)果。

2. 把this作為參數(shù)傳遞
當(dāng)你要把自己作為參數(shù)傳遞給別的對象時，也可以用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!");
}
}
運行結(jié)果：
Hello from A!
Hello from B!
在這個例子中，對象A的構(gòu)造函數(shù)中，用new B(this)把對象A自己作為參數(shù)傳遞給了對象B的構(gòu)造函數(shù)。

3. 注意匿名類和內(nèi)部類中的中的this。
有時候，我們會用到一些內(nèi)部類和匿名類。當(dāng)在匿名類中用this時，這個this則指的是匿名類或內(nèi)部類本身。這時如果我們要使用外部類的方法和變量的話，則應(yīng)該加上外部類的類名。如下面這個例子：
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 函數(shù)里用到了外部類的 run 函數(shù)。這時由于函數(shù)同名，直接調(diào)用就不行了。這時有兩種辦法，一種就是把外部的 run 函數(shù)換一個名字，但這種辦法對于一個開發(fā)到中途的應(yīng)用來說是不可取的。那么就可以用這個例子中的辦法用外部類的類名加上 this 引用來說明要調(diào)用的是外部類的方法 run。

1、對于原始數(shù)據(jù)類型，也就是int、 long、char之類的類型，是傳值的，如果你在方法中修改了值，方法調(diào)用結(jié)束后，那個變量的值沒用改變。
2、對于對象類型，也就是Object的子類，如果你在方法中修改了它的成員的值，那個修改是生效的，方法調(diào)用結(jié)束后，它的成員是新的值，但是如果你把它指向一個其它的對象( 70-305  )，方法調(diào)用結(jié)束后，原來對它的引用并沒用指向新的對象。
代碼如下：
public class Tester {
    public static void main(String[] args) {
        int primitive = 2;
        changePrimitive(primitive);
        //primitive的值依然是2
        MyClass myClass = new MyClass();
        changeObject(myClass);
        //myClass仍然指向的是執(zhí)行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;
}

對于遠程調(diào)用，350-018  無論是什么類型，調(diào)用結(jié)束后，傳入的參數(shù)和以前沒用任何變化（當(dāng)然前途是直接調(diào)用遠程方法，如果中間經(jīng)過其它的Proxy類或者Facade類，不能保證那些類對對象沒用修改）。至于是通過Local接口進行調(diào)用的，也應(yīng)該屬于本地調(diào)用，和上面說的情況應(yīng)該是一致的。

我們在定義常量的時候，可以把常量定義在接口里面，如：

package org.zy.demo.base;

public interface InterfaceDemo {

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

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

我實現(xiàn)此接口：
package org.zy.demo.base;

public class InterfaceImpl  implements InterfaceDemo{
    
}

那么我們?nèi)绾卧L問呢？
我做了一個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);
    }
}
執(zhí)行的結(jié)果如下：
this is my name
this is my name

在上面的程序中，我們使用了兩種不同的方法來取得了 name的值。
由第一種方法我們可以知道：
    其實接口內(nèi)定義的所有的屬性和方法都是public類型的。如果是屬性，其默認是
    Public static 的
通過第二種方法我們可以知道，此屬性是公有的。否則我們怎么能直接訪問呢？
由上面的結(jié)論我們可以知道為什么我們定義接口中的方法的時候，不用添加public,如泥可以定義如下方法：
Public Interface A{
    A();
}
當(dāng)然你也可以：
Public Interface A{
    Public A();
}

java是基于面向?qū)ο笤O(shè)計的，java的特性肯定繼承了面向?qū)ο蟮奶匦浴Ｏ旅嫖覀兙蛠斫Y(jié)合面向?qū)ο髞韺W(xué)習(xí)一下java的特性。

1.抽象：
抽象就是忽略一個主題中與當(dāng)前目標無關(guān)的那些方面，以便更充分地注意與當(dāng)前目標有關(guān)的方面。抽象并不打算了解全部問題，而只是選擇其中的一部分，暫時不用部分細節(jié)。抽象包括兩個方面，一是過程抽象，二是數(shù)據(jù)抽象。070-447
2.繼承：
繼承是一種聯(lián)結(jié)類的層次模型，并且允許和鼓勵類的重用，它提供了一種明確表述共性的方法。對象的一個新類可以從現(xiàn)有的類中派生，這個過程稱為類繼承。新類繼承了原始類的特性，新類稱為原始類的派生類（子類），而原始類稱為新類的基類（父類）。派生類可以從它的基類那里繼承方法和實例變量，并且類可以修改或增加新的方法使之更適合特殊的需要。
3.封裝：
封裝是把過程和數(shù)據(jù)包圍起來，對數(shù)據(jù)的訪問只能通過已定義的界面。面向?qū)ο笥嬎闶加谶@個基本概念，即現(xiàn)實世界可以被描繪成一系列完全自治、封裝的對象，這些對象通過一個受保護的接口訪問其他對象。
4.多態(tài)
最后討論多態(tài)是因為多態(tài)和其他三個特性相比，應(yīng)該是比較難理解的。
多態(tài)性是指允許不同類的對象對同一消息作出響應(yīng)。多態(tài)性包括參數(shù)化多態(tài)性和包含多態(tài)性。多態(tài)性語言具有靈活、抽象、行為共享、代碼共享的優(yōu)勢，很好的解決了應(yīng)用程序函數(shù)同名問題。642-414 
多態(tài)有兩種表現(xiàn)形式：重載和覆蓋
首先說重載（overload），是發(fā)生在同一類中。與什么父類子類、繼承毫無關(guān)系。    
  標識一個函數(shù)除了函數(shù)名外，還有函數(shù)的參數(shù)（個數(shù)和類型）。也就是說，一個類中可以有兩個或更多的函數(shù)，叫同一個名字而他們的參數(shù)不同。    
  他們之間毫無關(guān)系，是不同的函數(shù)，只是可能他們的功能類似，所以才命名一樣，增加可讀性，僅此而已！  
    
  再說覆蓋(override),是發(fā)生在子類中！也就是說必須有繼承的情況下才有覆蓋發(fā)生。 70-223 
  
  我們知道繼承一個類，也就有了父類了全部方法，如果你感到哪個方法不爽，功能要變，那就把那個函數(shù)在子類中重新實現(xiàn)一遍。  
  這樣再調(diào)用這個方法的時候，就是執(zhí)行子類中的過程了。父類中的函數(shù)就被覆蓋了。（當(dāng)然，覆蓋的時候函數(shù)名和參數(shù)要和父類中完全一樣,不然你的方法對父類中的方法就不起任何作用，因為兩者是兩個函數(shù)，毫不關(guān)系） 

     摘要: Java總有它的千般好處使你選擇它，但這些隨便翻翻書或在網(wǎng)上逛一圈就能找到答案。在本文中，筆者把自己學(xué)習(xí)Java的一些切身體會和過程寫出來，供初學(xué)者做個參考。

我在學(xué)習(xí)Java的過程中主要圍繞以下幾個方面來學(xué)習(xí)：

1．時刻提醒自己Java是一種OOP語言工具，而不僅僅是編碼，只有這樣才能總體把握和運用Java。

  閱讀全文