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