摘要: 集合java.util.*一個對象，容納多個對象，用于維護一系列相似對象。數組是一種簡單集合。程序中，如何管理數據，需要一種數據結構。（數組是一種線形結構）。Java的集合框架是通過一系列接口和一些層級類形成的一套體系。通過接口來查看整個集合框架，并分類來進行學習和研究。
概述：
Collection接口的一個對象會把數據按照一維線形組織。里面都是對象。List代表，會按照元素的相應順序來組織...
閱讀全文
posted @
2005-12-06 23:13 北國狼人的BloG 閱讀(921) |
評論 (1) |
編輯 收藏
摘要: 內部類，使用內部類使編程更有層次，結構更清晰，但一切能用內部類解決的問題，外部類都能解決，只是編碼是否繁瑣的問題。內部類，是作為外部類的成員。內部類，修飾符可以為private protected static四種內部類成員內部類 局部內部類 靜態內部類 匿名內部類1.成員內部類，可以作為外部類的...
閱讀全文
posted @
2005-12-03 19:59 北國狼人的BloG 閱讀(439) |
評論 (0) |
編輯 收藏
面向對象高級
static,可以修飾屬性、方法、代碼塊。
每個對象稱為類的實例，對象之間的存儲區互不干涉。
static int data;是類變量（共享），為類開辟一個空間。共享存儲區域。
訪問類變量，通過類名訪問。一個對象引用也可以使用靜態成員，與它的編譯時類型的類訪問，一致。
MyClass m = new MyClass();
m.data 《= 》MyClass.data;
靜態方法-〉沒有當前對象概念-〉也就不允許訪問的類中的非靜態成員（實例變量）
主方法之所以是靜態的，它是程序入口，JVM最初沒有對象，必須通過使用類名調用方法，主方法必須為靜態的。
靜態方法不能被覆蓋。
靜態代碼塊只執行一次。
static 用于單例模式Singleton模式
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();
posted @
2005-12-02 00:03 北國狼人的BloG 閱讀(402) |
評論 (0) |
編輯 收藏面向對象三大基石：封裝，繼承，多態。面試會問到。
Overriding 覆蓋 只存在于父子類之間，一定。
什么時候才是覆蓋呢?
class Father{
public void run(){
}
}
class Son extends Father{
public void run(int a){
}
}
注意：這是方法的重載，不是覆蓋！只是這個重載發生在父子類之間。
覆蓋是，子類參數列表與返回值都與父類相同，并且子類在覆蓋父類方法時，不能給出更嚴格的訪問控制，并且子類方法例外的類型是等于父子方法拋出的異常類型，或者是其子類型。
The exceptions thrown by an overriding method must be equal to or a subset of the exceptions thrown by the overridden method.
注意構造方法根本不能繼承，所以不存在覆蓋的問題。
訪問控制
private 本類內部可見
default 同類同包
protected 同包+不同包子類
要構造一個對象，先構造父類對象，再構造子類對象
構造一個對象的執行過程。
1.遞歸的構造父類對象-----------〉也就是說父類本身也要走這樣的步驟。
2.順序調用成員屬性賦初值語句
3.調用本類構造方法
后來課程領悟，類加載與構造對象是兩回事，類加載過程，1.static靜態成員加載，2運行static一次，靜態代碼塊，3如果有靜態內部類，賦值，對靜態內部類的賦值是指編譯產生的Employee$SomeInner.class文件的讀取。
如果類有靜態變量或者靜態塊，而且用到時（static初始化只有在必要的時候才會進行），那么就會在第一步之前執行一遍，先靜態變量，然后靜態塊，以后再怎么new都不會執行，回到創建父類開始。
======〉引用Think In Java
在這里有必要總結一下對象的創建過程。請考慮一個名為Dog的類：
(1) 類型為Dog的一個對象首次創建時，或者Dog類的static方法／static字段首次訪問時，Java解釋器必須找到Dog.class（在事先設好的類路徑里搜索）。
(2) 找到Dog.class后（它會創建一個Class對象，這將在后面學到），它的所有static初始化模塊都會運行。因此，static初始化僅發生一次——在Class對象首次載入的時候。
(3) 創建一個new Dog()時，Dog對象的構建進程首先會在內存堆（Heap）里為一個Dog對象分配足夠多的存儲空間。
(4) 這種存儲空間會清為零，將Dog中的所有基本類型設為它們的默認值（零用于數字，以及boolean和char的等價設定）。
(5) 進行字段定義時發生的所有初始化都會執行。
(6) 執行構建器。正如第6章將要講到的那樣，這實際可能要求進行相當多的操作，特別是在涉及繼承的時候。
=====================
多態-1.編譯時多態 方法重載
2.運行時多態 一個對象可能會具有多個類型
對象是客觀的。
人類對對象的認識是主觀的
當人看到一個不能識別的，有生命的，區別人的東西時，會類來認識該事物。
也就是Animal a = new Dog();子類對象可以使用父類對象來引用。
Animal被稱為編譯時類型，而a真正的對象類型是運行時類型。
3個原則：
1.對象不變（運行時類型不變）（客觀的肯定不會改變）
2.只能調用編譯時類型的方法，方法調用時，檢查編譯時類型內部是否定義了該方法。
也就是說，在你以一個一個動物來看待一只狗時，你是不會知道它有散步的方法的。
3.RTTI，運行時，動態類型判定（看運行時類型），子類覆蓋了（Overriding）父類方法，那么調用運行時類型對象的方法。
a instanceof 類名（編譯時類型）
a為對象變量
判斷a是否被聲明為后面類的對象。
用在強制類型轉換之前。如果轉換錯了，java.lang.ClassCastException 運行時例外
記住，方法只有覆蓋時，調用尋找運行時類型。而Overloading ->編譯時多態->看編譯時類型。
屬性，重載阿，都要看編譯時類型。
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，完蛋了。
posted @
2005-11-29 21:37 北國狼人的BloG 閱讀(405) |
評論 (0) |
編輯 收藏面向過程是以時間為順序的，組成單位是函數。
面向對象是一套思想。它來源于人類對于客觀世界的認識的一般規律。
1什么是對象？
什么都是對象！客觀存在的就是對象。
對一個事物來說，一是它有什么？（屬性）二是它能做什么？（方法）
2為什么面向對象
它人類看待客觀事物的一般規律。
人看到事物，首先會想到它能做什么，功能，存在的價值。并不太關心它的屬性。
========================================
要注意聯系實際來搞懂面向對象，比如面試這件事，實際上，公司是想測試你是否能提供 公司需要的方法，公司并不關心你實現的細節。錄用后，就是開始去調用你的方法。如果不能很好的實現方法，就可能被辭退。
那么那些筆試、測試就是想看你是否有知識，知識就是屬性，記住屬性與方法之間是有聯系的，也就是沒有公司所需的知識，可以斷定這個人肯定不會有公司需要的方法。
一個事物的方法的實現細節是對外界屏蔽的。
那么，之前提交的簡歷是什么呢，那就是一個方法列表阿，API。比如年齡22，表明你的方法可以很好的被調用；未婚，告訴別人，你可以加班，放心用。
項目1，2，3，每個項目后面一定要寫上你在項目中用到什么語言，否則HR的人是不知道你想告訴他們什么，他們只關心公司想要一個有JSP開發經驗，或者什么什么技術有經驗的人。您敘述一大堆項目的事情，沒有任何意義。所以簡歷不要瞎寫。
面試是什么，就是想真正調用一下你的方法，測試一下。
=======================================
那么社會的運轉就是各個對象的方法的相互調用。
方法列表公開，方法的實現細節屏蔽。
屬性，可見和不可見
一個方法的實現細節誰知道呢？只有這個對象的生成者。
那么人看待客觀世界的認識，就是通過類。人類認識的是類。
類是一系列對象的抽象，對象的模版。
一類事物，屬性、方法。這類對象也肯定有這些屬性和方法。
為什么面向對象的第二點，就是使得開發的系統各思其職，各盡所能。也就是低耦合，高內聚。
為什么，電腦中的部件可以很容易的更換成為其他廠商的，就是因為主板與具體部件的連接是松散的；那為什么，可以很容易的換到其他廠商的呢，是因為各個廠商遵循著標準接口。
比如硬盤的use(電源接口，數據接口），每個廠商都必須實現，而且硬盤是一個類的概念，有屬性，比如尺寸。
各個廠商不能在別處下功夫，只能對硬盤內部進行調整，提高性能，才會免予被替換。
高內聚是指完成功能的最小化。
低耦合表現在提高了對象的復用性，比如中間件。
最后總結一下，面向過程是先有算法，后有數據結構。由若干個過程相互調用完成。
面向對象，則是先有數據結構，后有算法，以對象為中心，開發一系列類，拿到特定對象，通過對象之間通信，對象設計要簡單。
類（共性）--〉對象（類允許對象在滿足共性的同時，存在個性）
一個類，則是一個新的數據類型。
實例變量與局部變量命名沖突，則使用局部變量，除非使用this.來指定某個屬性。
調用構造器只是生成對象步驟的最后一步，不是構造對象本身。
方法中使用了this，this表示當前對象，當前對象就是誰調用該方法，誰就是當前對象。
class TestClass{
String name;
public void printAll(String name)
{
this.name = name;
}
}
上面必須添加上this.來引用實例變量name。因為在局部變量和實例變量沖突時，使用局部變量。
finalize()不是析構方法，因為不能存在真正的釋放空間操作。
方法參數，簡單類型傳值，對象類型傳引用（一個實際存儲[堆中]的首地址）。
假如方法中，引用賦予一個新的對象，那么方法執行完以后，該引用和實際地址消失。傳入引用所指向的對象屬性不變。
Overloading，修飾符和返回值可以不同，但參數列表（參數類型個數或者排列順序）一定要不同。
Overloading，是編譯時多態。那么它要看編譯時類型。
Overloading，也存在于父與子的關系當中。父有方法，子類可以有同名方法，只有參數列表不同才是重載。
構造器（構造方法可以重載），通過this();可以調用本類無參構造方法。
在其他構造器調用其它構造器，那么需要this關鍵字，并且必須放置于第一行。
如果一個類不寫任何構造函數，系統會默認添加無參空構造方法。不要依賴系統默認行為！自己最好寫上。javap查看實際代碼。
對于簡單類型，如果調用方法傳入參數的類型不存在，那么就采用向上匹配原則進行查找。
m(byte)不存在，就用m(short)。（實際上long是int的父類，int是short的父類）
封裝
屬性盡可能私有。
方法盡可能公開。
private只有類內部本身能訪問。
default只有同包能訪問。
protected只有存在繼承關系，才能訪問。
posted @
2005-11-28 23:43 北國狼人的BloG 閱讀(510) |
評論 (2) |
編輯 收藏模式是什么？
模式是一個范式，一個在相同環境或者狀況下的一種通用解決辦法，解決方案。就好像孫子兵法，對于某種特定戰局，戰況下的一種派兵布陣策略和實施步驟的總結。
模式需要什么呢？
模式需要一個名字，一個問題域（要解決的問題），要有一個解決的方案，最后要達到什么樣的結果。
長話短說，Observer模式，所要解決的問題就是，一個事物，當它自身的狀態改變了，那么它要通知其他的事物，而它又不能夠事先知道要通知誰，只有在Runtime時才能知道。
舉個例子吧，鐘表和人的關系就是這樣，鐘表自身的狀態，也就是時刻改變了，它通知某些人，某些人看到或者聽到后，會做出不同的行為。而鐘表在商店里時，并不知道要通知誰？只有買主把鐘表買回家，買主的家人注冊到這個鐘表，這時，鐘表的狀態改變才會通知到家里的人，那么家人有大人、小孩，他們看到或者聽到這個鐘表的時間改變，會有不同的行為。
那么將上面的例子可以化解為對象。鐘表是個源，它是抽象的概念，可以很多形式的表，手表、掛鐘、鬧鐘等，而家人們都是監聽器，實現了監聽器接口，監聽器方法就是listen()和see()，當人每個人實現了接口會有不同的行為，這些鐘表并不關心，它只會在整點時通知之前注冊到它內部的家人實例的監聽器方法。
那是什么時候注冊的呢？就是主人買回家，告訴家人這是新的鐘表，也就是Timer.registerListener(Listener l)
那么鐘表就是observable，就是那個常說的Subject，而家人就是具體的Observer，實現了Oberver接口的方法。
package com.javapatterns.observer;
public abstract class AbstractTimer {
public void attach(){};
public void detach(){};
void notifyObservers(){};
}
package com.javapatterns.observer;
import java.util.Enumeration;
import java.util.Vector;
public class ConcreteTimer extends AbstractTimer {
private Vector observersVector = new java.util.Vector();
public void attach(Listener observer)
{
observersVector.addElement(observer);
}
public void detach(Listener observer)
{
observersVector.removeElement(observer);
}
public void notifyObservers()
{
Enumeration enumeration = observers();
while (enumeration.hasMoreElements())
{
Listener l = (Listener)enumeration.nextElement();
l.see();
l.hear();
}
}
public Enumeration observers()
{
return ((Vector) observersVector.clone()).elements();
}
}
下面是Listner接口，是一個概念模型，提供給Timer，Timer只關心，自身改變狀態后，要調用的觀察者什么行為，并不關心觀察者本身。所以提取人的若干行為，抽象成為接口。
package com.javapatterns.observer;
public interface Listener {
void see();
void hear();
}
package com.javapatterns.observer;
public class Host implements Listener {
private String name;
private short age;
private String sex;
public Host(String name,short age,String sex){
this.name = name;
this.age = age;
this.sex = sex;
}
public void see() {
// TODO add see default behavior
}
public void hear() {
// TODO add hear default behavior
}
public void otherBehavior(){
}
public short getAge() {
return age;
}
public void setAge(short age) {
this.age = age;
}
public String getName() {
return name;
}
public String getSex() {
return sex;
}
}
這是一個主人的類，也就是一類具體的Observer。
接口java.util.Observer和類java.util.Observable是Java本身對于觀察者模式的支持。
其實這種模式就是一種回調的應用，就是想其它類中注冊自己的接口，到特定時候調用自己的方法。
就好像古詩詞中，“有朋自遠方來不亦樂乎”，意思是說，如果好友光臨到門口，叫一聲自己，就會很高興，也就是說，告訴朋友到達自己住處，這個狀態滿足，那么就叫一聲自己，自己就會為朋友開門，高興等行為就會進行。 如果不采用觀察者模式，那就是自己需要不斷的到門口察看朋友是否到了，是一種輪循的方式，當然也能達到效果，但會影響自己的事情。
posted @
2005-11-27 11:26 北國狼人的BloG 閱讀(443) |
評論 (0) |
編輯 收藏
第一次使用Linux,在這上做Java開發.
在Fedora Core 3的發行版中，附帶的是GNU版的JRE,下載的最新的
Eclipse SDK 3.1.1，解壓以后，根本不能正常啟動界面。
由于我們一般能夠獲取的Linux發行版本都是免費的版本，而不是Professional或者Enterprise
Server級別的，這些版本對Sun的JDK支持都很有限
版本檢查
我們這個時候可以打開一個命令行終端，輸入"java -version"，可以看到如下信息：
[ljl@localhost ~]$ java -version
java version "1.4.2"
gij (GNU libgcj) version 4.0.0 20050519 (Red Hat 4.0.0-8)
Copyright (C) 2005 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
看到了吧？這并非Sun官方的Java。
我們需要到Sun的網站上下載最新的JDK，目前的版本是JDK 5.0 Update
5，注意，這里有兩個版本：jdk-1_5_0_05-linux-i586-rpm.bin和jdk-1_5_0_05-linux-
i586.bin，根據Fedora Core 3的Release Notes說明，應該使用后者，也就是不帶rpm的版本。(我用的是jdk-1_5_0_05-nb-4_1-linux-ml.bin,連NetBeans4.1都帶了,哈哈)
同時，我們也需要到eclipse.org上下載最新的Eclipse
SDK，目前版本3.1.1。需要根據你的系統環境選擇合適的下載包，如：我的電腦是x86的，X Window系統用的是GNOME
2.10.0，那么自然應該選「x86/GTK
2」，文件名eclipse-SDK-3.1.1-linux-gtk.tar.gz。需要說明一下，FC3默認的X
Window系統是GNOME，但是在KDE環境下，照樣可以正常使用GTK的應用程序。
安裝和配置
我們現在打開一個命令行終端，輸入命令su，提供root用戶密碼，進入管理員操作模式。然后用ls
-l看一下剛剛下載的jdk-1_5_0_05-linux-i586.bin，可以看到它的權限是-rw-r--r--，所有者為sean。為了能夠執
行它，需要更改它的權限設置。敲入命令chmod +x
jdk-1_5_0_05-linux-i586.bin，再看權限，-rwxr-xr-x，可以執行了。
切換到/opt/目錄，運行jdk-1_5_0_05-linux-i586.bin即可。注意：在Linux默認PATH不包含當前目錄，即"."，因
此執行當前目錄的文件，正確的方法是在文件名前面加上"./"。成功以后可以發現在/opt/目錄下多了一個jdk1.5.0_05子目錄，這就是我們的
JAVA_HOME。
到這里還沒完，在終端里檢查java
-version找到的仍然是原來的GNU版本，我們還需要配置系統的環境變量PATH。檢查目前PATH內容的方式是echo
$PATH，為了能夠直接找到我們自己的java，需要把/opt/jdk1.5.0_05/bin目錄加入PATH，并且要在GNU版本的前面，最保險
的辦法當然是放到最前面了。方法是PATH="/opt/jdk1.5.0_05/bin:$PATH"。這之后再敲java
-version，出來的就是正確的了：
[sean@localhost Java]$ java -version
java version "1.5.0_05"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_05-b05)
Java HotSpot(TM) Client VM (build 1.5.0_05-b05, mixed mode, sharing)
為了今后登錄的時候就把這個路徑加到環境中，需要修改一下.bash_profile，先cd ~進入自己的主目錄，然后用emacs或者vi編輯這個文件，找到PATH這一行，改成：
PATH=/opt/jdk1.5.0_05/bin:$PATH:$HOME/bin
保存，退出，注銷然后重新登錄。
接下來要做的就是把Eclipse解壓到一個你認為合適的路徑。
開始使用
有很多方式運行我們的Eclipse：命令行或文件瀏覽器直接打開都可以。我這里告訴大家一個在GNOME里面比較方便的一種途徑：從文件瀏覽器把eclipse運行文件拖放到系統的面板上，給它一個名字和圖標，今后就可以直接點這個面板圖標啟動Eclipse了。
親切的Eclipse又出現了,Great!Let's JAVA!
posted @
2005-11-26 19:23 北國狼人的BloG 閱讀(497) |
評論 (0) |
編輯 收藏
從我第一次認識達內,就是公開課,當然也是免費的.但質量很高,都是資深專家進行講座.這是達內認真做事的一種側面表現.
在這里,有經驗的精英會和你分享經驗,這是無私的,他們原意告訴你IT業界的動態,幫您分析您所處位置,進入IT行業,或者提升職位,要做哪些努力.無論您是否參加達內培訓,都可以進行深入交流.
有一點,大家也要注意,達內各個級別的員工都是每周六不休息的,咨詢專家,技術專家,人力資源資深專家,每周都有會提供給大家講座,提供交流的機會.這是
一種反應公司理念的態度.如果再次選擇,我仍然選擇達內,因為至少我在達內的每時每刻,我永遠不會感受到無助.我反倒是覺得現在怎么問題少了,沒問題請教
達內的精英,呵呵.
就到這了,假如您在IT職場遇到困惑,可以考慮去聽一聽,會有收獲的.
posted @
2005-11-26 16:51 北國狼人的BloG 閱讀(848) |
評論 (1) |
編輯 收藏作為程序員，思維要縝密，對于技術人員，創造只是一小部分，大部分還是要腳踏實地。
所以每個問題一定要想到各種情況，測試人員可能會用你想不到的數據進行測試。
練習1：計算某數的階乘！
package com.ljl;
public class Factorial {
public static void main(String[] args)
{
try{
int num = Integer.parseInt(args[0]);
if(num < 0)
{
System.out.println("please input positive number!");
System.exit(0);
}
if(num > 170)
{
System.out.println("this program can't calculate this num!");
System.exit(0);
}
double result = 1d;
for(int i = 2; i <= num; i++)
{
result *= i;
}
System.out.println("The factorial of " + num + " is " + result);
}
catch(Exception ex)
{
if(ex instanceof ArrayIndexOutOfBoundsException)
{
System.out.println("Please input the num to calculate!");
System.exit(0);
}
if(ex instanceof NumberFormatException)
{
System.out.println("Please input a number!");
System.exit(0);
}
System.out.println("error occured!please run it again!");
System.exit(0);
}
}
}
那么對于數據輸入的合法性判斷，對于數據是否合理，對于程序是否能夠計算所有的數，有無上界。
記住，即使不能計算，也要告訴用戶，決不能給用戶提供錯誤的答案！！
result 類型如果為int只能算到12，如果為long能算到20，如果為float只能算到32，如果為double，則可以算到170。
為什么double和long同占用8個字節，為什么表示數的范圍差那么多？因為double類型支持科學計算法。
The factorial of 170 is 7.257415615307994E306
所以可能用指數方式來表達大數。
那么如果表示170以后的數的階乘呢？可以猜用類，也可以找兩個變量，一個存底數，一個存指數。
=================================
數組
int[] mark = new int[10];40字節存儲空間。
-----------------------
對于局部變量，需要初始個值。
而局部變量的數組，不需要初值，會根據類型給定相應默認值。數值為0/0.0，布爾false，對象null，char /u0000
----------------------
mark 是一個int[]數組類型的對象，它保存的是那40字節存儲空間的首地址。
Java中，引用和地址都保存在棧中，而具體的值開辟的空間存儲在堆中。
System.arraycopy(a,0,b,0,a.length);
int[] a = {1,2,3,4,5}
int[] b = new int[10];
a.length
數組特點
1.不可變長
2.可以保存簡單類型數據
3.查找快，插入和刪除效率低。
2維數組
int[][] a = {{1,2},{3,4},{5,6}};
int[][] a = new int[3][];
a[0] = new int[2];
a[1] = new int[3];
a[2] = new int[1];
a類型？是一個對象，但是是虛擬機級別對象，無法用getClass().getName()顯示。
哥德巴赫猜想
package com.ljl;
public class Goldbach {
public static void main(String[] args)
{
int num = Integer.parseInt(args[0]);
if(num < 6)
{
System.out.println("the num must larger than six!");
System.exit(0);
}
if(num%2 != 0)
{
System.out.println("it should be a even!");
System.exit(0);
}
for(int i = 1; i <= num/2; i++)
{
if(isZhiShu(i)&&isZhiShu(num-i)){
System.out.println(num + "=" + i + "+" + (num-i));
break;
}
}
}
private static boolean isZhiShu(int num)
{
for(int i = 2; i <= (int)Math.sqrt(num); i++)
{
if(num%i == 0)
return false;
}
return true;
}
}
posted @
2005-11-25 23:35 北國狼人的BloG 閱讀(306) |
評論 (0) |
編輯 收藏
變量
1.對局部變量，要先賦值，后使用。
2.一個局部變量，作用域，是定義它的
代碼塊！
public class Test{
public static void main(String[] args){
{
int a = 4;
}
System.out.println(a);
}
}
a的作用域在main里面的兩個括號之間。所以，此程序編譯不通過。cannot resolve symbol
3.對于兩個局部變量，在同一作用域內不允許兩個同名變量出現。
public class Test{
public static void main(String[] args){
int a = 6;
{
int a = 4;
}
System.out.println(a);
}
}
在小代碼塊，重了。Duplicate local variable a。
------------------------------
命名規范
1.語義
2.包，所有字母小寫
3.類，所有單詞首字母大寫
4.變量、方法，首字母小寫，其余單詞首字母大寫
5.常量，所有字母大寫
byte b=1;
b=b+1;報錯，因為b+1運算后，系統轉為int，無法隱式轉換
b+=1;不報錯。請查看JVM，字節碼差異。
>> 右移 除2，左補符號位
<< 左移 乘2，右補0
>>> 右移，左永遠補0
雖然比乘除運算符快，但是有問題。
12>>32
回變為12。
12&9 按位與
12|9 或
12^9 異或
(a>b)&(c>d)
非短路方式，都判斷，并不會因為a>b為假而不進行后面表達式的判斷。
(a>b)&&(c>d)
短路方式，a>b為假，后面不執行，直接返回false。
int i = 3;
int count = (i++)+(i++)+(i++);
count = 3 + 4 + 5
i=4 i=5 i=6
int i =3;
i = i++;
那么流程如下
i++這個表達式的值是3。然后執行i自加1，變為4（因為++操作比賦值優先級高），最后i 再次被賦值為3。
不記運算符優先級，最好用括號老解決，很明白，否則像這樣的b+++a表達式，實際上(b++)+a。
posted @
2005-11-24 23:26 北國狼人的BloG 閱讀(386) |
評論 (0) |
編輯 收藏