1.Java基礎(chǔ)概念
Path：windows系
統(tǒng)那個(gè)執(zhí)行命令時(shí)要搜尋的路徑。
classpath：java在編譯和運(yùn)行時(shí)要找的class所在的路徑。
一個(gè)源文件中最多只能有一個(gè)public類，其他類的個(gè)數(shù)不限。
//用于單行注釋
/* */用于多行注釋
/** */用于多行注釋，且可以被doc工具解析
java標(biāo)識(shí)符命名規(guī)則
1.標(biāo)識(shí)符由字母、下劃線"_"、美元符"$"或數(shù)字組成。
2.標(biāo)識(shí)符應(yīng)該以字母、下劃線、美元符開頭。
3.Java標(biāo)識(shí)符大小寫敏感，長度無限制。
Java內(nèi)存管理分為四個(gè)區(qū)域：heap、stack、code segment、data segment
stack ：局部變量
heap： 所有 new 出來的東西
code segment：存放代碼
data segment：靜態(tài)變量，字符串常量
注意：類是靜態(tài)的概念，存在于code segment中；對象是動(dòng)態(tài)的概念，因?yàn)闀r(shí)new出來的，所以位于heap中。
面向?qū)ο蟮脑O(shè)計(jì)思想是：從現(xiàn)實(shí)世界中客觀存在的事物出發(fā)來構(gòu)造軟件系統(tǒng)，并且系統(tǒng)的構(gòu)造中盡可能運(yùn)用人類的自然思維方式。
方法的重載(overload)
一個(gè)類可以有相同的名字，但參數(shù)不同的多個(gè)方法。調(diào)用時(shí)，會(huì)根據(jù)不同的參數(shù)來選擇對應(yīng)的方法。
構(gòu)造方法也可以重載。
this關(guān)鍵字的說明
1.在類的方法定義中使用的this關(guān)鍵字代表使用該方法的對象的引用。
2.當(dāng)必須指出當(dāng)前使用方法的對象是誰的時(shí)候要是用this。
3.有時(shí)使用this可以處理的方法中成員變量和參數(shù)重名的情況
4.this可以看作是一個(gè)變量，它的值是當(dāng)前對象的引用。
static關(guān)鍵字的說明
1.在類中，使用static聲明的成員變量為靜態(tài)成員變量，它為該類的公用變量，在第一次使用那個(gè)是被初始化，對于該類的所有對象來說，static成員變量只有一份。
2.用static聲明的方法為靜態(tài)方法，在調(diào)用該方法時(shí)，不會(huì)將對象的引用傳遞給它，所以在static方法中不可訪問非static的成員。靜態(tài)方法不再是針對某個(gè)對象調(diào)用，所以不能訪問非靜態(tài)成員。
3.可以通過對象引用或類名(不需要實(shí)例化)訪問靜態(tài)成員。
J2SDK中主要的包介紹
1.java.lang----包含一些java的核心類，如String、Math、Integer、System和Thread，提供常用的功能。
2.java.awt----包含了構(gòu)成抽象窗口工具集(abstract window toolkits)的多個(gè)類，這些類被用來構(gòu)建和管理應(yīng)用程序的圖形用戶界面(GUI)
3.java.applet----包含applet運(yùn)行所需的一些類。
4.java.net----包含執(zhí)行與網(wǎng)絡(luò)有關(guān)的操作的類。
5.java.io----包含能提供多種輸入/輸出功能的類。
6.java.util----包含一些使用工具類，如定義系統(tǒng)特性、使用與日期日歷相關(guān)的函數(shù)。
打jar包命令：jar -cvf xxxx.jar *.*
訪問控制
1.Java權(quán)限修飾符 public、protected、private置于類的成員定義前，用來限定其他對象對該類對象成員的訪問權(quán)限。
2.對于class的權(quán)限修飾只可以用public和default.
3.public 類可以在任何地方被訪問。
4.default類之可以被統(tǒng)一個(gè)包內(nèi)部的類訪問。
方法的重寫(overwrite/override)
1.在子類中可以根據(jù)需要對從基類中繼承來的方法進(jìn)行重寫。
2.重寫方法必須和被重寫的方法具有相同的名稱、參數(shù)列表和返回類型。
3.重寫方法不能使用比被重寫的方法更嚴(yán)格的訪問權(quán)限。
繼承中的構(gòu)造方法
1.子類的構(gòu)造的過程中必須調(diào)用其基類的構(gòu)造方法。
2.子類可以在自己的構(gòu)造方法中使用super(argument_list)調(diào)用基類的構(gòu)造方法。
(1)使用this(argument_list)調(diào)用本類的另外的構(gòu)造方法。
(2)如果調(diào)用super，必須寫在子類構(gòu)造方法的第一行。
3.如果子類的構(gòu)造方法中沒有顯示地調(diào)用基類的構(gòu)造方法，則系統(tǒng)默認(rèn)調(diào)用基類無參的構(gòu)造方法。
4.如果子類構(gòu)造方法中既沒有顯示調(diào)用基類構(gòu)造方法，而基類中有沒有無參的構(gòu)造方法，則編譯出錯(cuò)。
Object類的說明
Object類是所有Java類的根基類。如果在類的聲明中未使用extends關(guān)鍵字指明其基類，則默認(rèn)基類為 Object類。
toString方法
1.Object類中定義有public String toString()方法，其返回值是String類型，描述當(dāng)前對象的有關(guān)信息。
2.在進(jìn)行String與其它類型數(shù)據(jù)的連接操作時(shí)，(如：System.out.println("info" +people))，將自動(dòng)調(diào)用該對象的toString()方法。
3.可以根據(jù)需要在用戶自定義類型中重寫toString()方法。
equals方法
1.Object類中定義有：public boolean equals(Object obj)方法
2.Object的equals方法定義為：x.euqals(y)，當(dāng)x和y是統(tǒng)一個(gè)對象的應(yīng)用的時(shí)候返回ture，否則反回false。
3.J2SDK提供的一些類，如String、Date等，重寫了Object的equals方法，調(diào)用這些內(nèi)容的equals方法，x.equals(y)，當(dāng)x和y所引用的對象是同一類對象且屬性內(nèi)容相等時(shí)(并不一定是相同的對象)，返回true，否則返回false。
4.可以根據(jù)需要在用戶自定義的類型中重寫equals方法。
對象轉(zhuǎn)型(casting)
1.一個(gè)基類的引用類型可以"指向"其子類的對象。
2.一個(gè)基類的引用不可以訪問其子類對象新增加的成員(屬性和方法)。
3.可以使用引用 變量 instanceof 類名 來判斷該引用變量所 "指向"的對象是否屬于該類或該類的子類。
4.子類的對象可以當(dāng)作基類的對象來使用 稱為向上轉(zhuǎn)型 (upcasting)，反之稱為向下轉(zhuǎn)型(downcasting)
多態(tài)
1.要有繼承
2.要有重寫
3.父類引用指向子類對象。
抽象類
1.用abstract關(guān)鍵字來修飾一個(gè)類時(shí)，這個(gè)類叫抽象類；用abstract來修飾一個(gè)方法時(shí)，該方法叫做抽象方法。
2.含有抽象方法的類必須被聲明為抽象類，抽象類必須被繼承，抽象方法必須被重寫。
3.抽象類不能被實(shí)例化。
4.抽象方法只需聲明，而不需實(shí)現(xiàn)。
abstract class Person {
private String name;
Person(String name) {
this.name = name;
}
public abstract void study(); //抽象方法只能被聲明
}
final關(guān)鍵字(相當(dāng)于C++中的const)
1.final的變量的值不能被改寫。
2.final的方法不能被重寫
3.final的類不能被繼承。
接口
1.接口是抽象方法和常量值的定義的集合。
2.從本質(zhì)上講，接口是一種特殊的抽象類，這種抽象類中只包含常量和方法的定義，而沒有變量和方法的實(shí)現(xiàn)。
3.接口的特性
1.多個(gè)無關(guān)的類可以實(shí)現(xiàn)同一個(gè)接口。
2.一個(gè)類可以實(shí)現(xiàn)多個(gè)無關(guān)的接口。
3.與繼承關(guān)系類似，接口與實(shí)現(xiàn)類之間存在多態(tài)性。
4.接口中聲明 屬性 默認(rèn)為public static final的，也只能是public static final的
5.接口只能定義 抽象方法，而且這些 方法 默認(rèn)為public的，也只能是public的
6.接口可以繼承其他的借口，并添加新的屬性和抽象方法。
2.關(guān)于包與File的一點(diǎn)注意
就是說生成了一個(gè)File類對象，而這個(gè)程序使用了包 com.xxx.www，那么這個(gè)文件的真實(shí)根路徑就是最外層
包c(diǎn)om所在的路徑。也就是說這個(gè)程序編譯后要想運(yùn)行，使用如下命令java com.xxx.www.程序名稱（也就
是：java 包名.程序名稱），但是生成的file卻在com所在的父路徑下。
3.容器綜述
Set 中的數(shù)據(jù)對象沒有順序且不可以重復(fù)。
List 中的數(shù)據(jù)對象有順序且可以重復(fù)。
Map 接口定義了存儲(chǔ)"鍵(key)-值(value)"映射對的方法。
Collection、Set、List、Map為接口。
注意：所謂的重復(fù)是指兩個(gè)對象equals()；需要進(jìn)入java.util.*包
Collection舉例
********************************************************************************************
1.容器類對象在調(diào)用remove、contains等方法時(shí)需要比較對象是否相等，這會(huì)涉及到對象類型的equals方法 *
和hashCode方法；對于自定義的類型，需要重寫equals和hashCode方法以實(shí)現(xiàn)自定義的對象相等規(guī)則。 *
2.相等的對象應(yīng)該具有相等的hash codes 。 *
********************************************************************************************
import java.util.*;
public class BasicContainer {
public static void main(String[] args) {
Collection c = new HashSet();
c.add("hello");
c.add(new Name("f1","l1"));
c.add(new Integer(100)); //String類重寫了equals()方法，所以會(huì)去除100
c.remove("hello"); //String類重寫了equals()方法，所以會(huì)去除"hello"
c.remove(new Integer(100));
System.out.println
(c.remove(new Name("f1","l1"))); //自己定義的類，要想返回true，必須重寫equals()方法。
System.out.println(c);
}
}
class Name {
private String firstName,lastName;
public Name(String firstName, String lastName) {
this.firstName = firstName; this.lastName = lastName;
}
public String getFirstName() { return firstName; }
public String getLastName() { return lastName; }
public String toString() { return firstName + " " + lastName; }
public boolean equals(Object obj) {
if (obj instanceof Name) {
Name name = (Name) obj;
return (firstName.equals(name.firstName))
&& (lastName.equals(name.lastName));
}
return super.equals(obj); //如果自己處理不了，就交給父類Object去處理。
}
public int hashCode() {
return firstName.hashCode(); //交給了String的hashCode()方法去處理
}
}
Iterator接口
1.所有實(shí)現(xiàn)了Collection接口的容器類都有一個(gè)iterator方法用以返回一個(gè)實(shí)現(xiàn)了Iterator接口的對象。
2.Iterator對象稱為迭代器，用于方便的實(shí)現(xiàn)對容器內(nèi)元素的遍歷操作。
3.Iterator接口定義了如下方法：boolean hasNext() //判斷游標(biāo)右邊是否有元素
Object next() //返回游標(biāo)右邊的元素并將游標(biāo)移動(dòng)到下一個(gè)位置
void remove() //刪除游標(biāo)左邊的元素，在執(zhí)行完next之后該操作只
能執(zhí)行一次。
舉例1：
Collection c = new HashSet();
c.add(new Name("f2","12"));
c.add(new Name("fff3","1113"));
for(Iterator i = c.iterator(); i.hasNext(); ) {
Name name = (name) i.next();
if(name.getFirstName().length() < 3) {
i.remove();
}
}
System.out.println(c);
說明：這個(gè)程序里，雖然Collection也有remove方法，但是不能c.remove(name)，這樣會(huì)出錯(cuò)。
因?yàn)閳?zhí)行這個(gè)程序是，iterator執(zhí)行了鎖定。
增強(qiáng)的For循環(huán) (J2SDK 1.5以后增加的)
import java.util.*;
public class EnhancedFor {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
for(int i : arr) { //將arr中的元素依次拷貝到i中，然后打印i。
System.out.println(i);
}
Collection c = new ArrayList();
c.add(new String("aaa"));
c.add(new String("bbb"));
c.add(new String("ccc"));
for(Object o : c) {
System.out.println(o); //將c中的元素依次拷貝到o中，然后依次打印o。
} //這里的println是調(diào)用了o的toString方法，因?yàn)镾tring類重寫了toString方法
} //了，所以這里就調(diào)用了String類的toString方法，這里面存在多態(tài)。
}
優(yōu)點(diǎn)：對于遍歷Array或Collection的時(shí)候相當(dāng)方便。
缺點(diǎn)：遍歷數(shù)組的時(shí)候不能訪問下標(biāo)。
與使用iterator相比，不能方便的刪除集合中的內(nèi)容。在內(nèi)部也是調(diào)用iterator。
總結(jié)：除了簡單遍歷并讀出其中的內(nèi)容外，不建議使用增強(qiáng)的for。
List常用算法
類java.util.Collections提供了一些靜態(tài)方法實(shí)現(xiàn)了基于List容器的一些常用算法。
1.static void sort(List) 對List容器內(nèi)的關(guān)系排序。
2.static void shuffle(List) 對List容器內(nèi)的對象進(jìn)行隨機(jī)排序。
3.static void reverse(List) 對List 容器內(nèi)的對象進(jìn)行逆序排列。
4.static void fill(List, Object) 用一個(gè)特定的對象重寫整個(gè)List容器。
5.static void copy(List dest, List src) 將src List容器內(nèi)的內(nèi)容拷貝到dest List容器內(nèi)。
6.static int binarySearch(List, Object) 對于順序的List容器，采用折半查找的方法找特定的對象。
Comparable接口
1.問題：上面的算法根據(jù)什么確定容器中的對象的"大小"順序？
2.所以可以"排序"的類都實(shí)現(xiàn)了java.lang.Comparable接口，Comparable接口中只有一個(gè)方法
public int compareTo(object obj)
該方法的返回值為：0 表示this==obj
正數(shù)表示this > obj
負(fù)數(shù)表示this < obj
4.實(shí)現(xiàn)了Comparable接口的類通過實(shí)現(xiàn)compareTo方法從而確定了該類的排序方式。
例子：
import java.util.*;
public class BasicContainer {
public static void main(String[] args) {
Collection c = new HashSet();
c.add("hello");
c.add(new Name("f1","l1"));
c.add(new Integer(100));
c.remove("hello");
c.remove(new Integer(100));
System.out.println
(c.remove(new Name("f1","l1")));
System.out.println(c);
//下面的一段代碼是應(yīng)用comparable的例子
List l = new LinkedList();
l.add(new Name("Karl","L"));
l.add(new Name("Steven","Lee"));
l.add(new Name("Tom","Wang"));
System.out.println(l);
Collections.sort(l); //調(diào)用了Name的compareTo方法
System.out.println(l);
}
}
class Name implements Comparable {
private String firstName,lastName;
public Name(String firstName, String lastName) {
this.firstName = firstName; this.lastName = lastName;
}
public String getFirstName() { return firstName; }
public String getLastName() { return lastName; }
public String toString() { return firstName + " " + lastName; }
public boolean equals(Object obj) {
if (obj instanceof Name) {
Name name = (Name) obj;
return (firstName.equals(name.firstName))
&& (lastName.equals(name.lastName));
}
return super.equals(obj);
}
public int hashCode() {
return firstName.hashCode();
}
public int compareTo(Object o) {
Name n = (Name)o;
int lastCmp =
lastName.compareTo(n.lastName); //調(diào)用了String類的compareTo方法，因?yàn)镾tring類重寫了該方法
return
(lastCmp!=0 ? lastCmp :
firstName.compareTo(n.firstName));
}
}
Array 讀快改慢
Linkded改快讀慢
Hash 兩者之間
Map接口
1.實(shí)現(xiàn)Map接口的類用來存儲(chǔ)鍵-值對
2.Map接口的實(shí)現(xiàn)類有HashMap和TreeMap等。
3.Map類中存儲(chǔ)的鍵-值對通過鍵來標(biāo)識(shí)，所以鍵值不能重復(fù)(必須重寫equals方法和hashCode方法，才能保證不能重復(fù))
自動(dòng)打包/自動(dòng)解包
看下面的例子
import java.util.*;
public class TestMap {
public static void main(String args[]) {
Map m1 = new HashMap();
Map m2 = new TreeMap();
//m1.put("one",new Integer(1));
m1.put("one", 1); //自動(dòng)將int 大包成 Integer類型
//m1.put("two",new Integer(2));
m1.put("two", 2);
//m1.put("three",new Integer(3));
m1.put("three", 3);
//m2.put("A",new Integer(1));
m2.put("A", 1);
//m2.put("B",new Integer(2));
m2.put("B", 2);
System.out.println(m1.size());
System.out.println(m1.containsKey("one"));
System.out.println
//(m2.containsValue(new Integer(1)));
(m2.containsValue(1));
if(m1.containsKey("two")) {
//int i = ((Integer)m1.get("two")).intValue();
int i = (Integer)m1.get("two"); //自動(dòng)將Integer 解包成 int類型
System.out.println(i);
}
Map m3 = new HashMap(m1);
m3.putAll(m2);
System.out.println(m3);
}
}
例子2
import java.util.*; //沒有自動(dòng)打包/解包
public class TestArgsWords {
//private static final Integer ONE = new Integer(1);
private static final int ONE = 1;
public static void main(String args[]) {
Map m = new HashMap();
for (int i = 0; i < args.length; i++) {
Integer freq = (Integer) m.get(args[i]);
m.put(args[i],(freq == null? ONE : new Integer(freq.intValue() + 1)));
}
System.out.println
(m.size() + " distinct words detected:");
System.out.println(m);
}
}
import java.util.*; //修改后的程序，使用了自動(dòng)打包/解包
public class TestArgsWords {
//private static final Integer ONE = new Integer(1);
private static final int ONE = 1;
public static void main(String args[]) {
Map m = new HashMap();
for (int i = 0; i < args.length; i++) {
int freq = (Integer) m.get(args[i]) == null ? 0 : (Integer) m.get(args[i]);
m.put(args[i], freq==0 ? ONE : freq + 1);
}
System.out.println
(m.size() + " distinct words detected:");
System.out.println(m);
}
}
每天都有新的變化，請關(guān)注我的Blog