自己做過的總結的Java面試題，後續還會補充新的，請多多支持，一起討論！
------------------------------------------------------------------------------------------------------------
假設 a 是一個由線程 1 和線程 2 共享的初始值爲 0 的全局變量，則線程 1 和線程 2 同時執行下面的代碼，最終 a 的結果不可能是（）
boolean isOdd = false;
for(int i=1;i<=2;++i)
{
if（i%2==1）isOdd = true；
else isOdd = false；
a+=i*(isOdd?1:-1)；
}
假設兩線程爲A、B，設有3種情況：
1.AB不併發：此時相當於兩個方法順序執行。A執行完後a=-1，B使用-1作爲a的初值，B執行完後a=-2
2.AB完全併發：此時讀寫衝突，相當於只有一個線程對a的讀寫最終生效。相同於方法只執行了一次。此時a=-1
3.AB部分併發：假設A先進行第一次讀寫，得到a=1;之後A的讀寫被B覆蓋了。B使用用1作爲a的初值，B執行完後a=0
------------------------------------------------------------------------------------------------------------
重點：
class A {
double f(double x, double y) {
return x + y;
}
static int g(int n) {
return n * n;
}
}
class B extends A {
double f(double x, double y) {
double m = super.f(x, y);
return m + x * y;
}
static int g(int n) {
int m = A.g(n);
return m + n;
}
}
public class PrintMethod {
public static void main(String[] args) {
A a = new B( );
System.out.println(a.f(10.0,8.0));
System.out.println(a.g(3));
}
}
98.0 9
(m = 18.0 m = 18.0 + 10.0*8.0 = 98.0*8
return 3*3
)
子類可以繼承父類的靜態方法，但是子類不能重寫父類的靜態方法。在這種情況下，子類隱藏了父類的靜態方法。
因爲不能重寫，所以a是A類型的引用時，調用的是父類中的g方法。
------------------------------------------------------------------------------------------------------------
開發與運行Java程序需要經過的三個主要步驟爲
編譯源程序
編譯字節碼
解釋運行字節碼
------------------------------------------------------------------------------------------------------------
關於下列程序段的輸出結果
public class MyClass{
static int i;
public static void main(String argv[]){
System.out.println(i);
}
}
0
類變量在不設置初始值時，會進行默認值賦值，而局部方法中聲明的變量則必須進行初始化，它不會進行默認值賦值。
------------------------------------------------------------------------------------------------------------
Java的數據類型分爲：基本數據類型和引用數據類型
一般關係數據模型和對象數據模型之間有以下對應關係：表對應類，記錄對應對象，表的字段對應類的屬性
接口方法默認爲public，抽象類方法默認爲protected
Java語言中默認整數int,默認浮點數double(而不是float);long和double都佔了64位（64bit）的存儲空間。
哪些情況下需要使用抽象類？
1, 當一個類的一個或多個方法是抽象方法時
2, 當類是一個抽象類的子類，並且不能爲任何抽象方法提供任何實現細節或方法體時
3, 當一個類實現一個接口，並且不能爲任何抽象方法提供實現細節或方法體時
------------------------------------------------------------------------------------------------------------
下列代碼中第幾行的sobj複合垃圾回收標準?
1,Object sobj = new Object();
2,Object sobj = null;
3,Object sobj = new Object();
4,sobj = new Object();
解析：因爲第二行將sobj賦值爲null，所以第一行的sobj符合標準；
而第四行相當於把sobj賦值爲null，所以第三行也符合標準。
如果有一個對象的句柄a，且你把a作爲某個構造器的參數，即
new Constructor(a),則即使你將a賦值爲null，a也不符合垃圾
收集器的收集標準。直到由上面構造器構造的新對象被賦值爲空
時，a纔可以被垃圾收集器收集。
------------------------------------------------------------------------------------------------------------
1，Object aobj = new Object();
2, Object bobj = new Object();
3, Object cobj = new Object();
4, aobj = bobj;
5, aobj = cobj;
6, cobj = null;
7, aobj = null;
解析：這種題型可能是遇到最難的題了；
行1-3分別創建了Object的3個類對象：aobj、bobj、cobj
行4此時對象aobj的句柄指向bobj，所以該行的執行不能使aobj符合收集標準；
行5此時對象aobj的句柄指向cobj，所以該行的執行不能使aobj符合收集標準；
行6：此時仍然沒有任何一個對象符合收集標準；
行7：對象cobj符合垃圾收集器的收集標準，因爲cobj的句柄指向了單一的地址空間。
在第6行的時候，cobj已經爲null，但由於cobj同時指向了aobj(第五行)，cobj也不符合。
而在第7行，aobj所指向的地址空間已經被完全賦予了空值。所以cobj符合收集標準。但
aobj和bobj仍然判斷是否符合收集標準。
總之：在Java中，判斷一塊內存空間是否符合垃圾收集器收集標準只有以下兩個：
(1)給對象賦予了null，以後在沒有調用過；
(2)給對象賦值了新值，即重新分配了內存空間
------------------------------------------------------------------------------------------------------------
RandomAccessFile raf = new RandomAccessFile("myfile.txt", "rw");
上面是RandomAccessFile的正確創建方式
在Java的I/O結構中， RandomAccessFile是比較不尋常的類，直接繼承Object，並不屬於Streams的一部分
------------------------------------------------------------------------------------------------------------
RandomAccessFile raf = new RandomAccessFile("myfile.txt", "rw");
上面是RandomAccessFile的正確創建方式
在Java的I/O結構中， RandomAccessFile是比較不尋常的類，直接繼承Object，並不屬於Streams的一部分
------------------------------------------------------------------------------------------------------------
下面結果會輸出什麼？
class Value{
public int i = 25;
}
public class Test{
public static void main(String[] args){
Test t = new Test();
t.first();
}
public void first(){
int i = 5;
Value v = new Value();
v.i = 25;
second(v,i);
System.out.println(v.i);
}
public void second(Value v,int i){
i = 0;
v.i = 20;
Value val = new Value();
v = val;
System.out.println(v.i+" "+i);
}
}
解析：
方法參數有基本類型，如int等，另外一種是Object對象。JAVA方法
參數傳對象，傳的是這個對象引用的一個副本，即地址值，跟原來
的引用都是指向同一個對象。
在本題中，對象v也是傳一份引用的副本，v.i=20;通過引用的副本
改變原對象的值爲20。但在語句Value val = new Value();中new了一個新的
對象，然後執行v=val；相當於引用的副本指向了一本新的Object。所以，
v.i=15是改變新的Object的值，而不是改變原對象得值。
15 0 20
------------------------------------------------------------------------------------------------------------
下面代碼的輸出結果是？
public static void main(String[] args) {
int num = 32;
System.out.println(num >> 32);
}
進行模32位運算，而二進制中8位是一個循環，所以num>>32相當於num>>0,
num>>33相當於num>>1，所以還是32
------------------------------------------------------------------------------------------------------------
下面代碼的輸出結果是？
public static void main(String[] args) {
char x = 'x';
int i = 10;
System.out.println(false ? i:x);
System.out.println(false ? 10 :x);
}
因爲i是int型，第一個輸出x被提升爲int型了，x的int型爲120，所以第一個輸出120
Java編程規範中提到，當後兩個表達式有一個常量表達式時(本題10)，而後一個類型爲T(本題char)，
常量表達式可以被T表示時，輸出結果爲T類型。
所以10爲常量，可以被char表示，結果輸出char
------------------------------------------------------------------------------------------------------------
下面代碼的輸出結果是？
public class Test｛
public static void main(String[] args)｛
int a = 5;
System.out.println("value is:"+ ((a<5) ? 10.9 :9));
｝
｝
因爲裏面有個10.9，而後面直接跟個9，這是Java就會根據運算符的精度類型
進行自動轉換，由於前面有一個10.9，後面會自動變成9.0
------------------------------------------------------------------------------------------------------------
HashCode被設計用來提高性能。equals()方法與hashCode()方法的區別在於：
1，如果兩個對象相等(equal)，那麼他們一定有相同的哈希值。
2，如果兩個對象的哈希值相同，但他們未必相等(equal)。
設計模式：
代理模式：
定義：爲其他對象提供一種代理，以控制對這個對象的訪問
代理對象起到中介的作用，可去掉功能服務或增加額外的服務
火車票代售點就是火車站售票處的代理
常見的代理模式：
遠程代理: 爲不同地理的對象提供局域網代表對象，
例：客戶端&服務器
虛擬代理： 根據需要將資源消耗很大的對象進行延遲，真正需要的時候進行創建
例：瀏覽帖子，正文優先加載，圖片延遲加載
保護代理： 對權限進行控制
例：只有登錄才能發帖等等
智能引用代理： 提供對目標對象額外服務
例： 火車票代售處提供一些額外服務
以只能引用代理爲例：
靜態代理：代理和被代理對象在代理之前是確定的。他們都實現相同的接口或繼承相同的抽象類
------------------------------------------------------------------------------------------------------------
下列哪種說法是正確的（ ）
A 實例方法可直接調用超類的實例方法
B 實例方法可直接調用超類的類方法
C 實例方法可直接調用其他類的實例方法
D 實例方法可直接調用本類的類方法
選d，類方法就是靜態方法。其它的就是實例方法
實例方法可以對當前對象的實例變量進行操作，也可以對類變量進行操作，
但類方法不能訪問實例變量。實例方法必須由實例對象來調用，而類方法除了可由實例對象調用外，還可以由類名直接調用。
另外，在類方法中不能使用 this 或 super。 關於類方法的使用，有如下一些限制：
1 在類方法中不能引用對象變量。
2 在類方法中不能使用super、this關鍵字。
3 類方法不能調用類中的對象方法。與類方法相比，實例方法幾乎沒有什麼限制：
1 實例方法可以引用對象變量（這是顯然的），也可以引用類變量。
2 實例方法中可以使用super、this關鍵字。
3 實例方法中可以調用類方法。
------------------------------------------------------------------------------------------------------------
關於C++/JAVA類中static 成員和對象成員的說法正確的是？
A static 成員變量在對象構造時生成
B static 成員函數在對象成員函數中無法調用
C 虛成員函數不可能是static成員函數
D static 成員函數不能訪問static成員變量
static爲成員變量或函數，在類初始化是加載完成，可以被成員函數調用或訪問
在java語言中虛函數指代的就是抽象方法，抽象方法中不能用private，static，synchronized，native等修飾詞修飾。
------------------------------------------------------------------------------------------------------------
有如下一段代碼，請選擇其運行結果（）
public class StringDemo{
private static final String MESSAGE="taobao";
public static void main(String [] args) {
String a ="tao"+"bao";
String b="tao";
String c="bao";
System.out.println(a==MESSAGE);
System.out.println((b+c)==MESSAGE);
}
}
Java對String的相加是通過StringBuffer實現的，先構造一個StringBuffer裏面存放”tao”,
然後調用append()方法追加”bao”，然後將值爲”taobao”的StringBuffer轉化成String對象。
StringBuffer對象在堆內存中，那轉換成的String對象理所應當的也是在堆內存中。
MESSAGE成員變量及其指向的字符串常量肯定都是在棧內存裏的
對於字符串常量的相加，在編譯時直接將字符串合併，而不是等到運行時再合併。也就是說
String a = "tao" + "bao" 和String a = "taobao"編譯出的字節碼是一樣的。
所以等到運行時，根據上面說的棧內存是數據共享原則，a和MESSAGE指向的是同一個字符串。
------------------------------------------------------------------------------------------------------------
接口和抽象類：
相同點：都不能被實例化,位於繼承樹的頂端，都包含抽象方法
不同點：1、設計目的：
接口：
體現的一種規範，類似與整個系統的總綱，
制訂了系統各模塊應該遵循的標準，因此接口不應該經常改變，一旦改變對整個系統是輻射性的。
抽象類：
作爲多個子類的共同父類，體現的是一種模板式設計，可以當作系統實現過程中的中間產品，已經實現了系統部分功能。
2、使用不同
（1）接口只能包含抽象方法，抽象類可以包含普通方法。
（2）接口裏不能定義靜態方法，抽象類可以。
（3）接口只能定義靜態常量屬性，不能定義普通屬性，抽象類可以。
（4）接口不包含構造器，抽象類可以（不是用於創建對象而是讓子類完成初始化）。
（5）接口裏不能包含初始化塊，抽象類完全可以。
（6）接口多繼承，抽象類單繼承（只能有一個直接父類）。
總結：
接口所有方法全是抽象方法只能public abstract修飾（默認public abstract修飾）,屬性默認public static final修飾。
抽象類除了包含抽象方法外與普通類無區別。
------------------------------------------------------------------------------------------------------------
關於volatile關鍵字，下列描述
A 用volatile修飾的變量，每次更新對其他線程都是立即可見的 //正確
B 對volatile變量的操作是原子性的 //錯誤
C 對volatile變量的操作不會造成阻塞 //正確
D 不依賴其他鎖機制，多線程環境下的計數器可用volatile實現 //錯誤
------------------------------------------------------------------------------------------------------------
兩個最基本的java回收算法：
複製算法和標記清理算法
複製算法：兩個區域A和B，初始對象在A，繼續存活的對象被轉移到B。此爲新生代最常用的算法
標記清理：一塊區域，標記要回收的對象，然後回收，一定會出現碎片，那麼引出
標記-整理算法：多了碎片整理，整理出更大的內存放更大的對象
兩個概念：新生代和年老代
新生代：初始對象，生命週期短的
永久代：長時間存在的對象
整個java的垃圾回收是新生代和年老代的協作，這種叫做分代回收。
P.S： Serial New收集器是針對新生代的收集器，採用的是複製算法
Parallel New（並行）收集器，新生代採用複製算法，老年代採用標記整理
Parallel Scavenge（並行）收集器，針對新生代，採用複製收集算法
Serial Old（串行）收集器，新生代採用複製，老年代採用標記清理
Parallel Old（並行）收集器，針對老年代，標記整理
CMS收集器，基於標記清理
G1收集器：整體上是基於標記清理，局部採用複製
綜上：新生代基本採用複製算法，老年代採用標記整理算法。cms採用標記清理。
------------------------------------------------------------------------------------------------------------
Java虛擬機功能：
1 通過 ClassLoader 尋找和裝載 class 文件
2 解釋字節碼成爲指令並執行，提供 class 文件的運行環境
3 進行運行期間垃圾回收
4 提供與硬件交互的平臺
------------------------------------------------------------------------------------------------------------
關於ThreadLocal以下說法正確的是？
A ThreadLocal繼承自Thread
//錯誤，ThreadLocal繼承Object，相當於沒繼承任何特殊的。
B ThreadLocal實現了Runnable接口
//錯誤，ThreadLocal沒有實現任何接口
C ThreadLocal重要作用在於多線程間的數據共享
//錯誤
D ThreadLocal是採用哈希表的方式來爲每個線程都提供一個變量的副本 //正確
E ThreadLocal保證各個線程間數據安全，每個線程的數據不會被另外線程訪問和破壞 //正確
線程的角度看，每個線程都保持一個對其線程局部變量副本的隱式引用，只要線程是活動的並且 ThreadLocal 實例是可訪問的；
在線程消失之後，其線程局部實例的所有副本都會被垃圾回收
------------------------------------------------------------------------------------------------------------
以下JAVA程序的輸出是什麼（）
public class HelloSogou{
public static synchronized void main(String[] a){
Thread t=new Thread(){
public void run(){Sogou();}
};
t.run();
System.out.print("Hello");
}
static synchronized void Sogou(){
System.out.print("Sogou");
}
}
A HelloSogou B SogouHello C Hello D 結果不確定
------------------------------------------------------------------------------------------------------------
如果是t.start()，(靜態同步函數的鎖是該類的字節碼文件.class main函數和Sogou方法都是static的，所以持有相同鎖
HelloSogou.class那麼，在main線程（main 是一個線程也是一個進程 ）中又開了一個線程，調用Sogou方法，鎖會衝突。 選D
但是，t.run()只是普通方法，順序執行，選B
------------------------------------------------------------------------------------------------------------
ServerSocket (int port)
創建一個serversocket 綁定在特定的端口
Socket(InetAddress address, int port)
創建一個socket流，連接到特定的端口和ip地址
------------------------------------------------------------------------------------------------------------
一般關係數據模型和對象數據模型之間有以下對應關係：表對應類，記錄對應對象，表的字段對應類的屬性。
------------------------------------------------------------------------------------------------------------
線程通過調用對象的synchronized方法可獲得對象的互斥鎖定；
線程調度算法是平臺獨立的：
線程調度分爲協同式調度和搶佔式調度，Java使用的是搶佔式調度，也就是每個線程將由操作系統來分配執行時間，
線程的切換不由線程本身來決定（協同式調度）。這就是平臺獨立的原因。
------------------------------------------------------------------------------------------------------------
優化Hibernate所鼓勵的7大措施：
1.儘量使用many-to-one，避免使用單項one-to-many
2.靈活使用單向one-to-many
3.不用一對一，使用多對一代替一對一
4.配置對象緩存，不使用集合緩存
5.一對多使用Bag 多對一使用Set
6.繼承使用顯示多態 HQL:from object polymorphism="exlicit" 避免查處所有對象
7.消除大表，使用二級緩存
------------------------------------------------------------------------------------------------------------
class Car extends Vehicle
{
public static void main (String[] args)
{
new Car(). run();
}
private final void run()
{
System. out. println ("Car");
}
}
class Vehicle
{
private final void run()
{
System. out. println("Vehicle");
}
}
首先final聲明的方法是不能被覆蓋的，但是這裏並不錯誤，因爲方法是private的，
也就是子類沒有繼承父類的run方法，因此子類的run方法跟父類的run方法無關，並不是覆蓋。
new Car().run()也是調用子類的run方法。輸出Car。
************************************************************************************************************v
************************************************************************************************************
public class Test2
{
public void add(Byte b){
b = b++;
}
public void test(){
Byte a = 127;
Byte b = 127;
add(++a);
System.out.print(a + " ");
add(b);
System.out.print(b + "");
}
}
public void add(Byte b){ b=b++; } 這裏涉及java的自動裝包/自動拆包(AutoBoxing/UnBoxing)
Byte的首字母爲大寫，是類，看似是引用傳遞，但是在add函數內實現++操作，會自動拆包成byte值傳遞類型，
所以add函數還是不能實現自增功能。也就是說add函數只是個擺設，沒有任何作用。 Byte類型值大小爲-128~127之間。
add(++a);這裏++a會越界，a的值變爲-128 add(b); 前面說了，add不起任何作用，b還是127
************************************************************************************************************
************************************************************************************************************
class C {
C() {
System.out.print("C");
}
}
class A {
C c = new C();
A() {
this("A");
System.out.print("A");
}
A(String s){
System.out.print(s);
}
}
class Test extends A{
Test(){
super("B");
System.out.print("B");
}
public static void main(String[] args) {
new Test();
}
}
//解答1：
初始化過程是這樣的： 父類Ｂ靜態代碼塊->子類Ａ靜態代碼塊->父類Ｂ非靜態代碼塊->父類Ｂ構造函數->子類Ａ非靜態代碼塊->子類Ａ構造函數
1.首先，初始化父類中的靜態成員變量和靜態代碼塊，按照在程序中出現的順序初始化；
2.然後，初始化子類中的靜態成員變量和靜態代碼塊，按照在程序中出現的順序初始化；
3.其次，初始化父類的普通成員變量和代碼塊，在執行父類的構造方法；
4.最後，初始化子類的普通成員變量和代碼塊，在執行子類的構造方法；
（1）初始化父類的普通成員變量和代碼塊，執行 C c = new C(); 輸出C
（2）super("B"); 表示調用父類的構造方法，不調用父類的無參構造函數，輸出B
（3） System.out.print("B");
所以輸出CBB
//解答2：
首先new了一個子類對象，那麼就要調用構造方法來初始化該子類對象，但是該類繼承自A，所以要先調用父類的構造方法，
這裏通過super("B")顯示的調用了父類的帶參構造。
執行父類的帶參構造前要先對父類中的對象進行初始化，對父類中的c成員進行初始化，調用了C類的無參構造，所以調用順序爲：
先調用C類的無參構造
再調用A類的帶參構造
最後調用調用子類的構造
------------------------------------------------------------------------------------------------------------
假設有以下代碼String s = "hello"：String t = “hello”；char c [ ] = {'h','e','l','l','o'}；下列選項中返回false的語句是？
A s.equals (t)；
B t.equals (c)；
C s==t；
D t.equals (new String ("hello"))；
Sting 類保存字符串只是保存所有單單的字符串;
而 char[] 字符數組 會在最後自動加上'\n';
所以B:t.equals(c)會返回fasle；
所以 答案B
------------------------------------------------------------------------------------------------------------
根據下面的代碼，
String s = null;
會拋出NullPointerException異常的有:
A if( (s!=null) & (s.length()>0) ) B if( (s!=null) && (s.length()>0) )
C if( (s==null) | (s.length()==0)) D if( (s==null) || (s.length()==0) )
String s=null;沒有給s開闢任何空間，當執行length()方法時候，
因爲沒有具體指向的內存空間，所以報出NullPointerException沒有指向的錯誤。
A &是與，位運算，兩個都得執行，執行到s.length()自然就報錯了。
B s！=null 結果爲false 整體就爲false ，&& 後面就不會執行。下面的同理。 AC
************************************************************************************************************
************************************************************************************************************
HashMap和Hashtable兩個類都實現了Map接口，二者保存K-V對（key-value對）
HashTable不允許null值(key和value都不可以),HashMap允許null值(key和value都可以)。
Hashtable的方法是Synchronize的，而HashMap不是，在多個線程訪問Hashtable時，不需要自己爲它的方法實現同步，而HashMap就必須爲之提供外同步
迭代 HashMap 採用快速失敗機制，而 HashTable 不是，因爲 HashTable是線程安全的
HashMap把Hashtable的contains方法去掉了,改成 containsvalue 和 containsKey。因爲contains方法容易讓人引起誤解
HashTable使用Enumeration，HashMap使用Iterator
************************************************************************************************************
************************************************************************************************************
例化線程： 1、如果是擴展java.lang.Thread類的線程，則直接new即可。
2、如果是實現了java.lang.Runnable接口的類，則用Thread的構造方法：
public class MyRunnable implements Runnable{
public void run() {
(new Thread(new MyRunnable()).start()
}
}
------------------------------------------------------------------------------------------------------------
<<表示左移位
>>表示帶符號右移位
>>>表示無符號右移
但是沒有<<<運算符
-----------------------------------------------------------------------------------------------------------
CopyOnWriteArrayList適用於讀多寫少的併發場景
ReadWriteLock即爲讀寫鎖，要求寫與寫之間互斥，讀與寫之間互斥，讀與讀之間可以併發執行。在讀多寫少的情況下可以提高效率
ConcurrentHashMap是同步的HashMap，讀寫都加鎖
volatile只保證多線程操作的可見性，不保證原子性
------------------------------------------------------------------------------------------------------------
String str = new String("abc")，"abc"在內存中是怎麼分配的？
A 堆
B 棧
C 字符串常量區
D 寄存器
當你new String("abc")時，其實會先在字符串常量區生成一個abc的對象，然後new String()時會在堆中分配空間，然後此時會把字符串常量區中abc複製一個給堆中的String，故abc應該在堆中和字符串常量
------------------------------------------------------------------------------------------------------------
byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2); /*語句1*/
b6=b4+b5; /*語句2*/
b8=(b1+b4); /*語句3*/
b7=(b2+b5); /*語句4*/
上面代碼片段中，存在編輯錯誤的語句是?
本題答案應爲：B、C、D
Java表達式轉型規則由低到高轉換：
1、所有的byte,short,char型的值將被提升爲int型；
2、如果有一個操作數是long型，計算結果是long型；
3、如果有一個操作數是float型，計算結果是float型；
4、如果有一個操作數是double型，計算結果是double型；
5、被fianl修飾的變量不會自動改變類型，當2個final修飾相操作時，結果會根據左邊變量的類型而轉化。
語句1錯誤：b3=(b1+b2); 自動轉爲int，所以正確寫法爲b3=(byte)(b1+b2);或者將b3定義爲int；
語句2正確：b6=b4+b5; b4、b5爲final類型，不會自動提升，所以和的類型視左邊變量類型而定，即b6可以是任意數值類型；
語句3錯誤：b8=(b1+b4); 雖然b4不會自動提升，但b1仍會自動提升，所以結果需要強轉，b8=(byte)(b1+b4);
語句4錯誤：b7=(b2+b5); 同上。同時注意b7是final修飾，即只可賦值一次，便不可再改變。
------------------------------------------------------------------------------------------------------------
Java類Demo中存在方法func0、func1、func2、func3和func4，請問該方法中，哪些是不合法的定義？( )
public class Demo{
float func0() byte,short,char-> int -> long -> float -> double
{ 小轉大不用強轉，大轉小需要強轉
byte i=1; func1 沒有返回值；func4 大轉小需要強轉
return i;
}
float func1()
{
int i=1;
return;
}
float func2()
{
short i=2;
return i;
}
float func3()
{
long i=3;
return i;
}
float func4()
{
double i=4;
return i;
}
}
------------------------------------------------------------------------------------------------------------
java中除了基本數據類型都是引用數據類型
java中的基本數據類型如下：
byte short int long float double char boolean
除此之外都是引用類型
------------------------------------------------------------------------------------------------------------
可用來實現線程間通知和喚醒：
Object.wait/notify/notifyAll
Condition.await/signal/signalAll
------------------------------------------------------------------------------------------------------------
Statement是sql語句的載體
Statement是標準的Statement類，通過字符串對sql語句進行拼接，但是它存在sql注入的危險
PreparedStatement對sql語句進行了預編譯，可以防止SQL注入
CallableStatement用來調用存儲過程的
BatchedStatement用於批量操作數據庫，BatchedStatement不是標準的Statement類
------------------------------------------------------------------------------------------------------------
面向對象的五大基本原則：
單一職責原則（SRP）
開放封閉原則（OCP）
里氏替換原則（LSP）
依賴倒置原則（DIP）
接口隔離原則（ISP）
------------------------------------------------------------------------------------------------------------
下面有關java實例變量,局部變量,類變量和final變量的說法，錯誤的是？
A 實例變量指的是類中定義的變量，即成員變量，如果沒有初始化，會有默認值 // 正確
B 局部變量指的是在方法中定義的變量，如果沒有初始化，會有默認值 //********局部變量必須有初始值******
C 類變量指的是用static修飾的屬性 //正確
D final變量指的是用final修飾的變量 //正確
------------------------------------------------------------------------------------------------------------
構造函數不可以用private修飾 //錯誤，單例模式中，構造器私有化
構造函數必須與類名相同 //正確
構造方法不能被子類繼承，所以用final修飾沒有意義。
構造方法用於創建一個新的對象，不能作爲類的靜態方法，所以用static修飾沒有意義。
此外，Java語言不支持native或synchronized的構造方法
------------------------------------------------------------------------------------------------------------
Java默認使用Unioncode編碼，即不論什麼語言都是一個字符佔兩個字節
Java的class文件編碼爲UTF-8，而虛擬機JVM編碼爲UTF-16
UTF-8編碼下，一箇中文佔3個字節，一個英文佔1個字節
Java中的char默認採用Unicode編碼，所以Java中char佔2個字節
1(byte)字節=8(bit)位
------------------------------------------------------------------------------------------------------------
floor: 求小於參數的最大整數。返回double類型-----n. 地板，地面
例如：Math.floor(-4.2) = -5.0
ceil: 求大於參數的最小整數。返回double類型-----vt. 裝天花板；
例如：Math.ceil(5.6) = 6.0
round: 對小數進行四捨五入後的結果。返回int類型
例如：Math.round(-4.6) = -5
------------------------------------------------------------------------------------------------------------
Integer i = 42;
Long l = 42l;
Double d = 42.0; 下面爲true的是?
A i == l B i == d
C l == d
D i.equals(d) E d.equals(l) F i.equals(l) G l.equals(42L)
ABC3 個選項很明顯，不同類型引用的 == 比較，會出現編譯錯誤，不能比較。
DEF 調用 equals 方法，因爲此方法先是比較類型，而 i ， d ， l 是不同的類型，所以返回假。
選項 G ，會自動裝箱，將 42L 裝箱成 Long 類型，所以調用 equals 方法時，類型相同，且值也相同，因此返回真
------------------------------------------------------------------------------------------------------------
Java致力於檢查程序在編譯和運行時的錯誤
Java虛擬機實現了跨平臺接口
類型檢查幫助檢查出許多開發早期出現的錯誤
Java自己操縱內存減少了內存出錯的可能性
Java還實現了真數組，避免了覆蓋數據的可能
注意，是避免數據覆蓋的可能，而不是數據覆蓋類型
------------------------------------------------------------------------------------------------------------
java不允許單獨的方法，過程或函數存在,需要隸屬於某一類中
java語言中的方法屬於對象的成員,而不是類的成員。不過，其中靜態方法屬於類的成員
------------------------------------------------------------------------------------------------------------
形式參數可被視爲local variable
對於形式參數只能用final修飾符
形參的值在調用時根據調用者更改，實參則用自身的值更改形參的值（指針、引用皆在此列），也就是說真正被傳遞的是實參