1. 方法名稱有多個單詞，則第一個單詞首字母小寫，其他首字母大寫
2. 實參和形參，可變引數：用陣列的方式來傳遞可變個數的引數

public void printInfo(String[] args) {
    for(int i=0; i<args.length; i++) {
        System.out.println(args[i]);
    }
}

獲取長度直接.length()即可，例如："dnqoedno".length()

上例必須傳入引數，即使為空陣列，不能傳入Null（不同於空陣列）

下例可以傳入Null

public void printInfo1(String... args) {
	for(int i=0; i<args.length; i++) {
		System.out.println(args[i]);
	}
}
 

• 如果一個方法有多個的形參，可變的形參（...這種的引數）一定要放在所有的引數最後

• 棧：基礎資料型別(具體值)和物件的引用(地址)
• 堆：所有的物件(包括自己定義的物件和字串物件)
• 方法區：所有的class和static變數

5. 一個類寫了有參構造後，一定要有無參構造（雖然不會報錯）
6. 若構造器被封裝了，即構造器私有化，是為了實現單例模式
7. 什麼是JavaBean：一個可複用的類，
   （1）類是公共的
   （2）有一個無參的公共的構造器
   （3）有屬性，屬性一般是私有的，且有對應的get、set方法
8. 過載和重寫的區別，重寫方法丟擲的異常不能大於父類該方法的異常,過載是方法名相同
9. 類物件，子類物件的例項化，基本資料型別建立，字串建立過程記憶體怎麼載入的
10. Object類：public String toString(){} 用於把所有的型別都轉為字串進行輸出，用於列印輸出
11. = 與equals()的區別是什麼
12. 包裝類

//字串轉為其他型別
int   i   = Integer.parseInt("123");
float   f = Float.parseFloat("0.123");
boolean b = Boolean.parseBoolean("false");
//其他型別轉化成字串型別：
String istr=(String)i;       // 錯誤
String istr=String.valueOf(i);
String fstr=String.valueOf(f);
String bstr=String.valueOf(true);
 

13. 介面與介面之間是繼承要用extends，類與介面之間是實現，用implements
14. 什麼是預設方法？是為了實現修改介面而不影響子類
    1. 介面中不能有public void test(){.....}，只能用default預設方法代替前者
    2. 介面中存在什麼？
       1. 非靜態abstract方法，無方法體 呼叫： 子類 . 方法名
       2. 非靜態default方法 ， 有方法體 呼叫： 父類/子類 . 方法名
       3. 靜態方法，不能被子類修改的default 呼叫： 父類 . 方法名
       4. 不允許有public void test(){.....}
       5. 不允許有靜態屬性，屬性一定為常量，是被那三個修飾的 呼叫：屬性名，前面無"."
       6. 私有方法，只是為了解決介面程式碼重複問題 不可呼叫
          1. 私有靜態方法：解決靜態方法之間......的問題
          2. 私有非靜態方法：解決非靜態方法.....的問題
       7. 不允許有靜態程式碼塊
       8. 不允許有構造方法
15. 例子：

public interface Sender {
	public void Send();
}


public class MailSender implements Sender {
	@Override
	public void Send() {
		System.out.println("this is mailsender!");
	}
}


public class SmsSender implements Sender {
	@Override
	public void Send() {
		System.out.println("this is sms sender!");
	}
}

• 建工廠類：方法返回的是Sender型別，所以方法必須要用Sender修飾

public class SendFactory {
	public Sender produce(String type) {
		if ("mail".equals(type)) {
			return new MailSender();
		} else if ("sms".equals(type)) {
			return new SmsSender();
		} else {
			System.out.println("請輸入正確的型別!");
			return null;
		}
	}
}

• 測試下：注意接收的物件要用介面Sender修飾

public class FactoryTest {
	public static void main(String[] args) {
		SendFactory factory = new SendFactory();
		Sender sender = factory.produce("sms");
		sender.Send();
	}
}
// 輸出：this is sms sender!

16. 成員內部類，區域性內部類，怎麼呼叫內部類方法屬性？

public class Test4 {
	public int n = 0;
	public void test() {
		System.out.println("Test4");
	}
	
	class A{
		public int n =10;
		public void test() {
			System.out.println("A");
		}
	}
	
	public void test1() {
		int n = 11;
		System.out.println("test1");
		class B{
			int n = 100;
			public void test() {
				System.out.println("test1_B");
			}
		}
		System.out.println("test1_B_n : " + new B().n);
		System.out.println("test1_n : " + n);
	}
}

• new Test4().new A().test();

public class Test5 {
	public static void main(String[] args) {
		System.out.println(new Test4().n);
		new Test4().test();
		System.out.println("===================");
		System.out.println(new Test4().new A().n);
		new Test4().new A().test();
		System.out.println("===================");
		new Test4().test1();
	}
}

17. 匿名內部類： 匿名內部類和匿名物件不是一回事

• 先定義一個介面 Interface()
• 有名字的匿名內部類：

1. 尾部有分號
2. 並沒有建立新類
3. 可以多次使用obj . method()；

Interface obj = new Interface(){
    @Override
    public void method(){
        .........
    }
};
obj.method();

3. 沒名字的匿名內部類

new Interface(){
    @Overrride
    public void method(){
        ........
    }
}.method();

• 末尾直接 . method()；
• 只能使用一次

int num = new Scanner(System.in).nextInt;

int num = new Random().nextInt(2) + 2;

19. 物件陣列

錯誤： Person1[] p = new Peron1[3]();
錯誤： p[0] = Person1(11,"????");

Person1[] p = new Person1[3];
p[0] = new Person1(11,"????");

使用多型的好處

舉例：

1. 有一父類Employee員工類, n個子類講師類，助教類，教授類等
2. Employee有抽象方法work()，每個子類都重寫work()
3. 建立每個物件：

Employee one  = new Teacher();
Employee two  = new Assiatant();
Employee three  = new Professor();

4. 帶來了統一性，每個物件都相當於一個類例項化來的，而且還有其特有的work方法
5. 無論"="右邊new的時候換成哪個子類物件，等號左邊呼叫方法，屬性都不會變化
6. 每個物件都統一起來了，他們除了work之外都有相通的屬性方法，比如身高，體重，專業等

上下轉型

1. 向上轉型：其實就是多型寫法，向上轉型一定是安全的，
   父類名稱 物件名 = new 子類名稱()；
2. 向下轉型：還原向上轉型
   子類名稱 物件名 = （子類名稱）父類物件；

Animal animal = new Dog()；
if (animal instanceof Dog){   // 看清大小寫
    Dog dog = (Dog) animal；
}

3. 前提：
   向上轉型，只有向上轉型後才可以使用向下轉型
向下轉型使用的子類名必須是向上轉型的子類名
4. 切記：下述程式碼錯誤

Animal animal = new Animal()；
Dog dog = (Dog) animal； // 報錯，只有向上轉型後才可以用向下轉型

Animal animal = new Cat()；
Dog dog = (Dog) animal； // 報錯

5. 為什麼要向下轉型：當使用多型（向上轉型）後，需要呼叫子類特有的方法
6. 轉型需要配合 instanceof 使用：

• 向上向下轉型有什麼意義？
  當傳入的引數不知道是什麼類時，可以用最底層父類修飾：

public static void giveMeAPet(Animal animal){
    if (animal instanceof Dog){
        Dog dog = (Dog) animal;
        dog.watchHouse;
    }
    if (animal instanceof Cat){
        Cat cat = (Cat) animal;
        cat.catchMouse;
    }
}