java基礎零碎練手
用到了java，所以的最近得把Java補補，很基礎，但是萬丈高樓平地起，記一下吧！主要供自己複習，原理和語法大體和C++類似，java高手請繞行，說不定什麼時候就用上了。。。有錯誤的地方歡迎高手斧正，不勝感激！
1、列舉型別的使用方法：
ENUM的用法及得到相應的值：public enum ResponseStatusEnum { PARAM_ERROR (101, "引數不正確"), SERVER_EXCEPTION (500, "系統異常請稍後再試"), private int status; private String message; ResponseStatusEnum(int status, String message){ this.status = status; this.message = message; } public int getStatus() { return status; } public void setStatus(int status) { this.status = status; } public String getMessage() { return message; } public void setMessage(String message) { this.message = message; } //列舉引數的使用 public static void setResult(BaseRes baseRes, ResponseStatusEnum statusEnum) { baseRes.setMsg(statusEnum.getMessage()); baseRes.setStatus(statusEnum.getStatus()); } }
2、 常亮的定義；public enum MemberEnum { NOT_OPEN (1, "尚未開通"), OPEN_SUCCESS (2, "開通成功"); private int value; private String desc; //建構函式； CoopMemberEnum(int value, String desc) { this.value = value; this.desc = desc; } public int getValue() { return value; } public String getDesc() { return desc; } //返回常亮所代表的的常亮資訊； public static MemberEnum getByValue(int value) { for (MemberEnum coopMemberEnum : MemberEnum.values()) { if (MemberEnum.getValue() == value) { return MemberEnum; } } return NOT_OPEN; } }
public class Constant {
public static final int ID = 1;
public static final String REFERENCE_URL = "修改資訊ref:http://baidu.com";
public static final String PASSWD = "1123";
}
3、this的呼叫
//this的應用
4、靜態函式的呼叫class TThis { int i; TThis(int i ) { this.i = i; } TThis increase() { i++; return this; //返回自身的一個引用； } void print() { System.out.println("this兩次呼叫後的值為："+this.i); } } main： TThis th = new TThis(100); th.increase().increase().print(); //this的應用，返回的是自身的這個物件；
//static 資料區，屬於類，只有一份，共享，類名直接呼叫，作用域，計數
static class SStatic{
public static int i = 0;
int b;
SStatic()
{
b = 100;
}
}
main：
SStatic ss = new SStatic();
ss.i = 100; //靜態的成員直接可以呼叫；● 靜態程式碼塊只能定義在類裡面，它獨立於任何方法，不能定義在方法裡面。
● 靜態程式碼塊裡面的變數都是區域性變數，只在本塊內有效。
● 靜態程式碼塊會在類被載入時自動執行，而無論載入者是JVM還是其他的類。
● 一個類中允許定義多個靜態程式碼塊，執行的順序根據定義的順序進行。
● 靜態程式碼塊只能訪問類的靜態成員，而不允許訪問例項成員。
靜態程式碼塊甚至在main方法之前就被執行。在main()方法中可以完成的任務在靜態程式碼塊中都可以完成。但是二者在執行上仍然有一些區別，main方法是整個程式啟動的入口，而靜態程式碼塊是存在於某個類中的一個過程。實際上，static塊的執行發生在“初始化”的階段。初始化階段，jvm主要完成對靜態變數的初始化，靜態塊執行等工作。
參考：http://blog.csdn.net/jiese1990/article/details/40154329
public class Fu {
static {
System.out.print(1);
}
public Fu() {
System.out.print(2);
}
}
public class Zi extends Fu {
static {
System.out.print("a");
}
public Zi() {
System.out.print("b");
}
}
public class demo {
public static void main(String[] args) {
Fu fu = new Zi();
fu = new Zi();
}
}總結：靜態優先執行，父類優先於子類執行，靜態程式碼塊是在JVM載入類的時候執行的，而且靜態程式碼塊執行且僅執行一次；
5、過載與重寫
a、重寫方法的規則：
（1）、引數列表必須完全與被重寫的方法相同，否則不能稱其為重寫而是過載。
（2）、返回的型別必須一直與被重寫的方法的返回型別相同，否則不能稱其為重寫而是過載。
（3）、訪問修飾符的限制一定要大於被重寫方法的訪問修飾符（public>protected>default>private）
（4）、重寫方法一定不能丟擲新的檢查異常或者比被重寫方法申明更加寬泛的檢查型異常。例如：
父類的一個方法申明瞭一個檢查異常IOException，在重寫這個方法是就不能丟擲Exception,只能丟擲IOException的子類異常，可以丟擲非檢查異常。
b、過載的規則：
（1）、必須具有不同的引數列表；
（2）、可以有不責罵的返回型別，只要引數列表不同就可以了；
（3）、可以有不同的訪問修飾符；
（4）、可以丟擲不同的異常；
6、許可權的設定:
//許可權設定 public private protected default
class Access{
private int i = 1; //私有的繼承類，但是不能使用；
protected int j = 2;
public int k = 3;
int m =4; //同一個目錄和包下面就可以訪問，包許可權；同一個包裡的類可以訪問
public void accessi()
{
i = 11;
}
}7、super的應用：
//super關鍵字的使用
class SuperClass{
private int i;
SuperClass()
{
System.out.println("Superclass()" + this.i);
}
SuperClass(int _i)
{
this.i = _i;
System.out.println("SuperClass(int n)" + this.i);
}
}
class Subclass extends SuperClass{
private int i;
Subclass()
{
super(100); // 呼叫父類的有引數的建構函式；
System.out.println("Subclass()" + this.i);
}
Subclass(int _i)
{
this.i = _i; //預設呼叫父類沒有引數的建構函式；
System.out.println("Subclass(int i)" + this.i);
}
}
//super test
Subclass sub = new Subclass(); // 100 0
Subclass sub1 = new Subclass(200); //0 100類的繼承，如果想呼叫父類的建構函式，則需要使用super來呼叫父類的建構函式來初始化，這樣只需要初始化自己新新增的屬性的值；其中的呼叫過程有點兒類似於遞迴呼叫；
8、toString()方法
//toString方法的測試
Dog d = new Dog();
System.out.println("toString" + d); //類名+雜湊編碼
class Dog{
public String toString() //重寫父類的toString
{
return "I am a cool Dog!";
}
}下面請看valueOf(x)方法的原始碼
public static String valueOf(Object obj)
{
return (obj == null) ? "null" : obj.toString();
}多型的定義：指允許不同類的物件對同一訊息做出響應。即同一訊息可以根據傳送物件的不同而採用多種不同的行為方式。（傳送訊息就是函式呼叫）
多型存在的三個必要條件
一、要有繼承；
二、要有重寫；
三、父類引用指向子類物件【向上轉型】。
//多型的測試
abstract class Animal{ // 抽象類；
private String name;
Animal(){}
Animal(String _name)
{
name = _name;
}
/*
void enjoy()
{
System.out.println("Animal: " + this.name);
}
*/
public abstract void enjoy(); //抽象方法；
}
class Cat extends Animal{
private String name;
Cat(String _name)
{
super("Animal");
this.name = _name;
}
public void enjoy()
{
System.out.println("cat :" + this.name);
}
}
class BigDog extends Animal{
private String name;
BigDog(String _name)
{
super("Animal");
this.name = _name;
}
public void enjoy()
{
System.out.println("BigDog:"+this.name);
}
}
class Lady{
private String name;
private Animal pet;
Lady(String _name, Animal _pet)
{
this.name = _name;
this.pet = _pet;
}
public void mypetenjoy()
{
pet.enjoy();
}
}
// 多型的測試 main：
//Animal aa = new Animal("Animal"); //抽象類不能例項化；
Animal bb = new Cat("cat");
Animal cc = new BigDog("BigDog");
Lady cao = new Lady("cao", bb);
Lady li = new Lady("li", cc);
cao.mypetenjoy();
li.mypetenjoy();（1） 介面有什麼好處，這種定義方式就有什麼好處
當然你可以用 ArrayList list = new ArrayList()，但是一般不這麼用
（2） 設計模式中有對依賴倒置原則。程式要儘量依賴於抽象，不依賴於具體。
從Java語法上，這種方式是使用介面引用指向具體實現。
比如，你若希望用LinkedList的實現來替代ArrayList的話，只需改動一行即可：
List list = new LinkedList()；
而程式中的其它部分不需要改動，這樣比較靈活
這個如果你想把儲存結構該為LinkedList的時候，只要把List list ＝ new ArrayList（）改為list ＝ new LinkedList（）
而其他的所有的都不需要改動。這也是一種很好的設計模式.一個介面有多種實現,當你想換一種實現方式時,你需要做的改動很小.
假設你開始用 ArrayList alist = new ArrayList(), 這下你有的改了，特別是如果你使用了 ArrayList特有的方法和屬性。
如果沒有特別需求的話,最好使用List list = new LinkedList(); ,便於程式程式碼的重構. 這就是面向介面程式設計的好處
（3） 面向介面程式設計
（4） 提高程式寬展性,以後修改維護好些
詳細解釋：
ArrayList不是繼承List介面，是實現了List介面。
你寫成ArrayList arrayList = new ArrayList();這樣不會有任何問題。和List list = new ArrayList();相比這2個寫是有區別的。arrayList是一個ArrayList物件，它可以使用ArrayList的所有方法。
List是介面，它是不可以被例項化的（介面是個抽象類），所以必須以它的實現類去例項化它。list物件雖然也是被例項化為ArrayList但是它實際是List物件，list只能使用ArrayList中已經實現了的List介面中的方法，ArrayList中那些自己的、沒有在List介面定義的方法是不可以被訪問到的。
我們說，用介面去做是有它的好處的，如果你把型別定義成ArrayList(也就是一個具體的實現類)那麼你就只能接收這一種型別的資料了，如果你要是定義為List那麼你不僅可以接收ArrayList的物件還可以接收LinkedList的物件，這樣你的程式就靈活了。
15、final關鍵字的測試
//final關鍵字的測試 const類似 類不能被繼承，變數不可改變，方法不可重寫 java.lang 中的String
final class FinalTest{ //不可繼承
final int i = 9; //變數不能改變其值；
public final void test() //不可重寫
{
System.out.println("this class cant change!");
}
}
10、final關鍵字的好處
（1）final關鍵字提高了效能。JVM和Java應用都會快取final變數。
（2）final變數可以安全的在多執行緒環境下進行共享，而不需要額外的同步開銷。
（3）使用final關鍵字，JVM會對方法、變數及類進行優化。
ps：final成員變數必須在宣告的時候初始化或者在構造器中初始化，否則就會報編譯錯誤。
參考：http://www.importnew.com/7553.html