class NULL{
}
NULL n=（NULL）null 對 null是Object類 可以強轉 可以賦值給任何引用變量
2. java 數據類型轉換
boolean 只能賦值給boolean類型
從左到右
System.out.println(3+4+"Java");輸出7Java
System.out.pringln("java"+3+4)；則輸出java34
溢出轉換
int value =233； byte svalue=（byte）value； sualue=-23；當溢出的時候會變爲負數
32位的int強制轉換成8位的byte 截斷前面的24位，只保留右邊的8位，最左邊的1位符號位 表示爲負數
補碼-1=反碼；反碼取反=原碼 所以 10010111 byte值爲-（16+4+2+1）=-23；
默認基本數據類型
float a=5.6；錯誤 5.6默認爲double類型 改成 float a=（double）5.6;
類型自動提升
short value=5； //value會自動提升爲int類型
value-=2；//發生錯誤 int 類型給short會錯誤
int a=3; char c='a'; byte b=40; double=".314";
double result=b+c+i*d //result 值爲144.22 強轉成最高等級操作
但是 int a1=4； int a2=a1/a； //值爲int
System.out.pringln("Hello"+"a"+7);//Helloa7
System.out.pringln("a"+7+"Hello");//104Hello 將a轉換成ascss碼97
String str1="hello";
String str2="hello";
String str3= new String("hello");
str1.equal(str2); 的結果爲 true
str1 == str2 的結果也爲true
str1.equal(str3)；的結果爲true
str1 == str3; 的結果爲false;! 如果new了對象 肯定地址發生了改變
1.abstract class Name {
private String name;
public abstract boolean isStupidName(String name) {}
}
大俠們，這有何錯誤?
答案: 錯。abstract method必須以分號結尾，且不帶花括號。
2.
public class Something {
void doSomething () {
private String s = "";
int l = s.length();
}
}
有錯嗎?
答案: 錯。局部變量前不能放置任何訪問修飾符 (private，public，和protected)。final可以用來修飾局部變量
(final如同abstract和strictfp，都是非訪問修飾符，strictfp只能修飾class和method而非variable)。
3.
abstract class Something {
private abstract String doSomething ();
}
這好像沒什麼錯吧?
答案: 錯。abstract的methods不能以private修飾。abstract的methods就是讓子類implement(實現)具體細節的，怎麼可以用private把abstract
method封鎖起來呢? (同理，abstract method前不能加final)。
4.
public class Something {
public int addOne(final int x) {
return ++x;
}
}
這個比較明顯。
答案: 錯。int x被修飾成final，意味着x不能在addOne method中被修改。
5.
public class Something {
public static void main(String[] args) {
Other o = new Other();
new Something().addOne(o);
}
public void addOne(final Other o) {
o.i++;
}
}
class Other {
public int i;
}
和上面的很相似，都是關於final的問題，這有錯嗎?
答案: 正確。在addOne method中，參數o被修飾成final。如果在addOne method裏我們修改了o的reference
(比如: o = new Other();)，那麼如同上例這題也是錯的。但這裏修改的是o的member vairable
(成員變量)，而o的reference並沒有改變。
6.
class Something {
int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
有什麼錯呢? 看不出來啊。
答案: 正確。輸出的是"i = 0"。int i屬於instant variable (實例變量，或叫成員變量)。instant variable有default value。int的default value是0。
class Something {
public void doSomething() {
public int i;//錯誤編譯不過去 修飾符爲成員變量而用，方法裏的變量使用範圍爲該方法，別的方法不能調用，除非用final定義 內部方法可以使用 而且只有成員變量 在類裏定義的變量纔會默認賦值，方法裏定義的變量不會有默認賦值
System.out.println("i = " + i);
}
}
7.
class Something {
final int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
和上面一題只有一個地方不同，就是多了一個final。這難道就錯了嗎?
答案: 錯。final int i是個final的instant variable (實例變量，或叫成員變量)。final的instant variable沒有default value，必須在constructor (構造器)結束之前被賦予一個明確的值。可以修改爲"final int i = 0;"。
8.
public class Something {
public static void main(String[] args) {
Something s = new Something();
System.out.println("s.doSomething() returns " + doSomething());
}
public String doSomething() {
return "Do something ...";
}
}
看上去很完美。
答案: 錯。看上去在main裏call doSomething沒有什麼問題，畢竟兩個methods都在同一個class裏。但仔細看，main是static的。static method不能直接call non-static methods。可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理，static method不能訪問non-static instant variable。
9.
此處，Something類的文件名叫OtherThing.java
class Something {
private static void main(String[] something_to_do) {
System.out.println("Do something ...");
}
}
這個好像很明顯。
答案: 正確。從來沒有人說過Java的Class名字必須和其文件名相同。但public class的名字必須和文件名相同。
10．
interface A{
int x = 0;
}
class B{
int x =1;
}
class C extends B implements A {
public void pX(){
System.out.println(x);
}
public static void main(String[] args) {
new C().pX();
}
}
答案：錯誤。在編譯時會發生錯誤(錯誤描述不同的JVM有不同的信息，意思就是未明確的x調用，兩個x都匹配（就象在同時import java.util和java.sql兩個包時直接聲明Date一樣）。對於父類的變量,可以用super.x來明確，而接口的屬性默認隱含爲 public static final.所以可以通過A.x來明確。
11.
interface Playable {
void play();
}
interface Bounceable {
void play();
}
interface Rollable extends Playable, Bounceable {
Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
private String name;
public String getName() {
return name;
}
public Ball(String name) {
this.name = name;
}
public void play() {
ball = new Ball("Football");
System.out.println(ball.getName());
}
}
這個錯誤不容易發現。
答案: 錯。"interface Rollable extends Playable, Bounceable"沒有問題。interface可繼承多個interfaces，所以這裏沒錯。問題出在interface Rollable裏的"Ball ball = new Ball("PingPang");"。任何在interface裏聲明的interface variable (接口變量，也可稱成員變量)，默認爲public static final。也就是說"Ball ball = new Ball("PingPang");"實際上是"public static final Ball ball = new Ball("PingPang");"。在Ball類的Play()方法中，"ball = new Ball("Football");"改變了ball的reference，而這裏的ball來自Rollable interface，Rollable interface裏的ball是public static final的，final的object是不能被改變reference的。因此編譯器將在"ball = new Ball("Football");"這裏顯示有錯。
- 爲什麼接口中的變量都用final修飾（常量）
- * 因爲接口本身就是用來定義一個標準、規範，是用來設計用戶可用的細節（public）且不能隨意更改的（final）
- * 那麼接口中的任何東西都應該被定義成統一，那麼定義的數值應該是常量
- * 再次思考：假如接口中可以定義非final，而僅僅是public和static修飾的，那麼被實現的類可以隨便修改（實現類中的static塊中），這樣會造成標準不統一
- * （是不是有點牽強附會？）。
- *
- * 接口還是不要隨意更改，如果可以隨意更改會造成很大的麻煩，比如一個接口被很多類實現，那麼修改接口後，還必須修改實現類，麻煩程度不言而喻。
a = a + b 與 a += b 的區別(答案)
+= 隱式的將加操作的結果類型強制轉換爲持有結果的類型。如果兩這個整型相加，如 byte、short 或者 int，首先會將它們提升到 int 類型，然後在執行加法操作。如果加法操作的結果比 a 的最大值要大，則 a+b 會出現編譯錯誤，但是 a += b 沒問題，如下：
byte a = 127;
byte b = 127;
b = a + b; // error : cannot convert from int to byte
b += a; // ok
3*0.1 == 0.3 將會返回什麼？true 還是 false？(答案) 3*0.1輸出0.30000000000000004
false，因爲有些浮點數不能完全精確的表示出來。. 主要問題是，你用十進制去想，0.7 是一個能準確表示的小數，而二進制卻是循環小數
java 參數傳遞規則
（1）基本數據類型傳值，對形參的修改不會影響實參；
（2）引用類型傳引用，形參和實參指向同一個內存地址（同一個對象），所以對參數的修改會影響到實際的對象；
（3）String, Integer, Double等immutable的類型特殊處理，可以理解爲傳值，最後的操作不會修改實參對象。
時間比較
SimpleDateFormat dfs = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date end = null; try { Date begin=dfs.parse("2018-04-19 11:30:24"); end = dfs.parse("2018-04-20 13:31:40"); long between=(end.getTime()-begin.getTime())/1000; long min=between/60; LogUtil.e("時間",min); } catch (ParseException e) { e.printStackTrace(); }