1. 程式人生 > 其它 >JAVA關鍵字與使用方法

JAVA關鍵字與使用方法

技術標籤:JAVA基礎學習java

Java關鍵字:

運算子:>>二進位制位右移,如>>1表示右移一位,10>>1(00001010---> 00000101)變成5
		<<二進位制位左移,左移右側補零。
static   :  靜態的,只能類名.訪問
extends  :繼承,用於繼承關係(class A extends B(){})
private  : 私有的。用private修飾的屬性只能在本類中直接
			呼叫,出了本類需要用set和get方法進行訪問和修改。
boolean  :布林型別。只有true和false兩個變數,一個為真一個為假
instanceof  :屬於二元操作符用於判斷左邊的物件是否是右邊的型別
			 例:if(A instanceof Cat) 如果A物件是Cat型別返回true 不是返回false
			 多用於向下轉型判斷
			 C c = new D();
			 if(c instanceof D){
				D d1 = (D)c;
			 }
this  :表示本物件,this.表示本物件的 this()用於構造方法中,只能有一個並且只能在第一行
		用於無參構造方法呼叫有參構造方法完成初始化。一般可以省略
super :表示父類特徵,super可以呼叫父類的構造引數,子類構造引數第一行會預設有super()
		還可以用super.呼叫父類的方法或屬性。this()和super()只能有一個。
final : 最終的,無法修改的 用final 修飾的類無法被繼承,用final修飾的方法無法被覆蓋
		final修飾的區域性變數,一旦被賦值,無法被修改(理解為常量)
		final修飾的引用(將引用理解為變數)引用只能指向一個物件,並且只能指向該物件
		但是物件內部資料仍然能夠修改。
		final修飾的例項變數再由static修飾,則為常量;
		public static final String CHANGLIANG="常量語法";
abstract :   抽象類。只能被繼承,無法建立物件。
			抽象類可以沒有抽象方法,但是抽象方法必須在抽象類中。
			抽象類:public abstract class ChouXiangLei(){}
			抽象方法: public abstract void chouXiangFangFa();
			※非抽象類extends抽象類必須將抽象類裡的抽象方法實現。
interface :介面。[修飾符列表] interface 介面名(){} 介面中只能包含常量或者抽象方法。
			介面中抽象方法可以省略public abstract。介面中的都是公開的。 介面支援多繼承。介面中常量public static final 可以省略。
			介面有兩種,一種是普通的介面,另一種是一個標誌,沒有方法,
			只是一個標誌性介面,沒有方法,起到標識和標誌作用,其作用
			是給JVM,使其給它生成一個序列化版本號
implements: 實現。類實現介面。class A implements B{}
類和類之間的關係:is a :
						Cat is a Animal(貓是一個動物)繼承關係
						A extends B{}
				  has a:
						I has a pen(我有一個筆)表示關聯關係 以屬性形式存在
						A{
							B b;
						}
				  like a:	
						cooker like a foodmenu(廚師像選單)表示實現關係,類實現介面。
						A implements B{}
三目運算子:方法? "true怎麼樣":"false的話怎麼樣";
陣列(Array): 靜態定義法:int[] a = {1,2,3,4};
	   動態初始化:int[] a = new int[10];
Array工具類: java.util.Arrays
			
氣泡排序:	for(int i=a.length-1;i<0;i++){//n個數據迴圈n-1次
				for(int j=0 ; j<i ;j++){//裡面比較迴圈n-1-1次
					if(a[j]>a[j+1]){
						int t=a[j];
						a[j]=a[j+1];
						a[j+1]=t;
					}
				}
			}
選擇排序:	for(int i=0;i<a.length-1;i++){
				int min=i;
				for(int j=i+1;j<a.length;j++){
					if(a[i]<a[min]){
						min = j;
					}
				}
				if(min != i){
					int t=a[min];
					a[min]=a[i];
					a[i]=t;
				}
			}
二分法查詢:	public static int binarySearch(int[] a,int ele){
					int begin=0;
					int end = a.length-1;
					while(begin<=end){
						int mid= (begin+end)/2;
						if(a[mid]==ele){
							return mid;
						}else if(a[mid]<ele){
							begin = mid+1;
						}else{
							end = mid -1;
						}
					}
					return -1;
				}
String類: String a="test";中a中儲存的是"test"的記憶體地址,
			所有""擴著的都是物件儲存在方法區,常量字串池中
StringBuffer類: 減少物件建立,方法區記憶體佔用;
				StringBuffer s = new StringBuffer();//初始化為長度為16的byte[]陣列
				//字串拼接
				s.append(填要追加的字串);
				優化StringBuffer方法初始化給夠長度,減少陣列擴容次數。
				StringBuffer和StringBuilder區別,StringBuffer在
				多執行緒環境是安全的
Date(日期類):使用 Date a = new Date();//表示此時系統時間
				日期格式化 :其中yyyy:年、MM:月、dd:日、HH:時、mm:分、ss:秒、SSS:毫秒
							SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
							String a = sdf.format(傳入Date的物件);
				獲取毫秒數:自1970-1-1 00:00:00 000 到系統現在時間所經歷的毫秒數。
							靜態方法,使用類名.呼叫 返回一個long型別的值
							long begin = System.currentTimeMillis();
DecimalFormat(數字類):數字格式化: ###,###.##表示加入千分位,保留兩位小數
								   ###,###.0000表示加入千分位,保留四位小數,不夠補零
Random(隨機數):產生隨機數	Random r = new Random();
							int random = r.nextInt();括號裡可加數字,表示某一範圍
							如r.nextInt(101)表示在[0,100]之間產生隨機數,不加的話代表在int範圍內產生隨機數。
enum(列舉):1.列舉一枚一枚舉出來。
			2.列舉是一個引用資料型別。
			3.列舉型別如何定義,語法是?
			enum 列舉名{
				列舉值1,列舉值2(列舉值大寫)
			}
BigDecimal:財務系統使用精度更高。加減需要呼叫類中方法,無法直接加減。
Exception(異常處理):有兩種方法:throws and try {} catch(){}
			         throws:上拋異常,將異常上拋給上一級呼叫者(沒人處理最後會拋給JVM虛擬機器,然後程式停止執行),
					使用格式為:public static void **() throws 接異常名(如Exception等){}
					throws只會丟擲異常無法解決異常。
					try{}catch(){}:捕捉異常,可以處理異常狀況,
					可以理解為:嘗試執行括號中的程式碼,遇到異常停止執行try中程式碼跳到catch語句塊中
					使用格式:try{
									嘗試執行的程式碼塊,遇見異常跳轉到catch語句塊,下面的語句不執行
								}catch(異常型別 異常名稱){
									遇到錯誤執行的命令
								}
					異常中方法:	獲取異常簡單的描述資訊:
										String msg = exception.getMessage();
									列印異常追蹤的堆疊資訊:
										exception.printStackTrace();
					使用例項:					
								public class ExceptionTest08 {
									public static void main(String[] args) {
										// 這裡只是為了測試getMessage()方法和printStackTrace()方法。
										// 這裡只是new了異常物件,但是沒有將異常物件丟擲。JVM會認為這是一個普通的java物件。
										NullPointerException e = new NullPointerException("空指標異常SSSSSS");
										// 獲取異常簡單描述資訊:這個資訊實際上就是構造方法上面的String引數。
										String msg = e.getMessage();
										System.out.println(msg);
										
										// 列印異常堆疊資訊。
										// java後臺答應異常堆疊追蹤資訊的時候,採用了非同步執行緒的方式列印的。
										e.printStackTrace();
										System.out.println("Hello World!");
									}
								}
					finally :	接在try語句中,在裡面的程式碼必定執行的,多用於對資源的釋放。
								try{
								
								}catch(Exception e){
								
								}finally{
								
								}//執行順序先執行try再執行finally最後執行catch,可以只有try和finally。
					throw:手動丟擲異常。throw new Exception("丟擲異常");
					定義一個異常:1.繼承Exception或者RuntimeException
								  2.寫一個無參構造方法,寫一個有參構造方法,有參傳一個String變數。
集合:實現Collection的類中分為List和Set,其中List有序可重複(存進去什麼樣取出來什麼樣);Set類中無序不可重複(存進去跟取出來順序不一樣)。放在集合中的元素需要重寫equals方法。
		******集合發生改變,迭代器要重新獲取,不然呼叫next()方法會發生異常。
	  Collection方法:Collection c = new ArrayList();
					  1.add():將資料放入集合  例:c.add(100);
					  2.size():輸出集合中元素個數 例:int a = c.size();
					  3.clear():清空集合 例:c.clear();
					  4.contains(Object a );判斷集合中是否包含元素a,返回boolean型別資料 例:c.contains(a);判斷時會自動呼叫equals方法。
					  5.remove():刪除指定元素 例:c.remove(100);表示刪除100這個元素,執行時呼叫元素的equals方法。
					  6.isEmpty():判斷集合是否為空,返回boolean型別資料 例:c.isEmpty();true表示集合為空。
					  7.toArray():將集合轉化為陣列。例:Object[] obj= c.toArray();
	   集合遍歷/迭代:以方法通用,在Collection中可以使用,但是MAP中不能使用。
					  Collection c = new HashSet();
					  //新增元素
					  c.add("abc");
					  c.add("ads");
					  c.add(100);
					  //獲取迭代器
					  Iterator it = c.iterator();
					  //判斷是否有元素可以迭代
					   if(c.hasNext()){
					   //如果有元素可以迭代,使用next方法返回物件。
						Object obj = c.next();
					  }
					  Iterator中方法:boolean hasNext()如何仍有元素可以迭代,返回true
									  Object  next()返回迭代下一個元素。
	List中特有的方法:	void add(int index, E element)在指定下標增加元素,使用不多,效率低
						Object get(int index)根據下標獲取元素
						int indexOf(Object o)獲取指定物件第一次出現處索引
						int lastIndexOf(Object o)獲取指定物件最後一次出現處索引
						Object remove(int index)刪除指定下標位置的元素
						Object set(int index,Object element)修改指定位置的元素
		 Map常用方法:Map和Collection沒有繼承關係,Map集合以key和value形式存在,即鍵值對
					  1.void clear()清空Map集合
					  2.boolean containsKey(Object key)判斷集合中是否包含某個key
					  3.boolean containsValue(Object value)判斷集合中是否包含某個value
					  4.V get(Object key)獲取對應key的value
					  5.boolean isEmpty()判斷集合是否為空,返回boolean型別資料
					  6.Set<K> keySet()獲取Map集合所有key,返回一個Set型別的集合
					  7.V put(K key,V value)向集合中新增鍵值對
					  8.V remove(Object key)刪除key指定元素
					  9.int size()獲取元素個數
					  10.Collection<V> values()獲取所有value返回一個Collection
					  11.Set<Map.Entry<K,V>> entrySet()將Map集合轉化為Set集合
					  HashMap初始容量16載入因子0.75當資料達到75%時開始擴容,初始化容量為2的倍數。JDK8之後如果雜湊表單向連結串列中元素大於8個單項鍊表會變成二叉樹,當二叉樹節點資料小於6時會吧二叉樹重新變成單向連結串列。HashMap執行緒非安全。
					  
					 TreeMap:底層二叉樹,遍歷使用中序遍歷,存進TreeMap key中的資料需要實現Comparator方法,或者寫比較器
					如果比較規則只有一個的時候,建議實現Comparable介面即類中對Comparable介面
					如果比較規則多個,且需要頻繁切換,則建議使用Comparator介面。即新寫一個比較類實現Comparator介面。
	Collections(集合工具類):
					將集合變成執行緒安全的:Collections.sysnchronizedList(需要修改的集合);
					排序:Collections.sort();自定義類需要實現Comparable介面。
IO流:I:Input O:Output 通過IO對硬碟的讀和寫
			以記憶體為參照物,進記憶體叫輸入(Input)。或叫讀(Read)
							出記憶體叫輸出(Output)。或叫寫(Write)
			流的分類:輸入流、輸出流
					  位元組流(萬能流)、字元流(只能讀txt檔案)
			流的四大家族:java.io.InputStream	位元組輸入流
						  java.io.OutputStream  位元組輸出流
						  java.io.Reader		字元輸入流
						  java.io.Writer		字元輸出流
						  以Stream結尾的是位元組流,以Reader/Writer結尾的是字元流
			java要掌握的流:
							檔案專屬:
							java.io.File(四種:InputStream、OutputStream、Reader、Writer)
							轉換流(位元組流轉換為字元流)
							java.io.InputStreamReader
							java.io.OutputStreamWriter
							緩衝專屬流:
							java.io.Buffered(四種:InputStream、OutputStream、Reader、Writer)
							資料流專屬:
							java.io.DataInputStream 資料位元組輸入流
							java.io.DataOutputStream 寫檔案,可以吧資料型別寫進去,但是隻能拿DataFileInputStream拿出來
							兵且要以資料的輸入順序一個一個輸出
							標準輸出流:
							java.io.PrintWriter
							java.io.PrintStream
							物件專屬流:
							java.io.ObjectInputStream  
							反序列化(DeSerialize):將硬碟上的資料重新恢復到記憶體當中,恢復
							成Java物件。反序列化必須使其序列化版本號相同,版本號不同,無法
							反序列化
							Java判斷是否相同,先看類名,類名相同,在看序列化版本號,只有
							兩個引數都相同才是同一個類。序列化版本號,是用來區分類的。
							java.io.ObjectOutputStream 
							序列化(Serialize):將Java物件儲存到檔案中,將Java物件儲存下來
							的過程。多物件序列化需要使用集合,將物件儲存到集合中,再將集合
							序列化到硬碟中
							***** 序列化只能序列化一個物件,第二個會報錯,想要將多個物件序列化
							需要存到集合中
							***** 序列化要讓需要序列化的型別需要實現Serializable,這個介面
							只是一個標誌性介面,沒有方法,起到標識和標誌作用。
							介面有兩種,一種是普通的介面,另一種是一個標誌,沒有方法,
							只是一個標誌性介面,沒有方法,起到標識和標誌作用,其作用
							是給JVM,使其給它生成一個序列化版本號
							由記憶體到硬碟是一個序列化過程,由硬碟到記憶體是一個反序列化過程
							物件在序列化時會被切割為一個一個小檔案傳輸到硬碟,在再硬碟中
							組合起來
			java.io.FileInputStream(檔案位元組輸入流):萬能的位元組輸入流,從硬碟中讀取
			java.io.File:1.File和四大家族無關,File無法完成檔案的讀寫
						 2.File物件 是檔案和路徑名的抽象表示形式
			File常用方法:boolean exists() 判斷是否存在
						 void createNewFile() 以檔案形式創建出來
						 void mkdir() 以目錄的方式進行建立
						 void mkdirs() 以多重目錄形式建立
						 String getParent() 獲取檔案父路徑
						 String getAbsolutePath() 獲取檔案絕對路徑
						 String getName() 獲取檔名
						 boolean isDirectory() 判斷是否為路徑
						 boolean isFile() 判斷是否為檔案
						 long lastModified() 獲取檔案最後一次修改時間,自1970-1-1到現在毫秒數
						 String length() 檔案大小,以位元組數表示。
						 Flie[] listFiles() 獲取當前目錄下所有子檔案
						 
			IO+Properties: 以後經常改變的資料直接存到檔案中,用Properties進行讀取
							等號左邊的為Key 右邊的為Value 
							FileInputStream in = new FileInputStream("");//建立位元組輸入流
							Map properties = Properties();//建立Properties集合
							properties.load(in);//將檔案中資料通過管道傳給Properties物件
							以上機制檔案被稱為配置檔案
							當配置檔案格式為
							Key = Value
							時稱為屬性配置檔案,這種檔案建議以.properties結尾其中Propertis稱
							為屬性配置檔案的類。屬性配置檔案中重複的話會覆蓋。
							屬性配置檔案中#是註釋,裡面最好不要有空格,也可以用:隔開
System(系統類):System.gc 啟動gc回收器
				System.currentTimeMillis 自1970-1-1到現在所經歷毫秒數
				System.arraycopy() 拷貝陣列
				System.setOut() 將輸出方向改為檔案而不是控制檯
泛型:在JDK5.0後的新特性,使用泛型是對集合元素進行指定
	List<Animal> a = new ArrayList<Animal>();//對集合中資料型別進行指定,只允許存Animal型別的資料
	優點:使用後使集合中資料更加統一了
		  在一定程度上不需要進行強制型別轉換
		  缺點:使集合儲存資料少了多樣性。
		  JDK8.0後擁有新特性:自動推斷
		  List<Animal> a = new ArrayList<Animal>();//後面的Animal可以不用寫了,會進行自動推斷
		  自定義泛型:在類後面加<自定義識別符號>裡面方法傳自定義識別符號,一般寫E,或T
			public class<自定義識別符號>{
				public void doSome(自定義的識別符號 o){
					System.out.println(o);
				}
			}
		  定義後不使用泛型,就會自動變成Object型別。
foreach(增強for迴圈):JDK5.0新特性	
					  語法:for(元素型別 變數名:陣列或集合){
								System.out.println(變數名);
							}
					  foreach缺點:沒有下標,在需要使用下標的時候不建議使用。
transient(遊離的):被其標識的變數不參與序列化。
serialVersionUID(序列化版本號):用來區分兩個類是否為一個類,自動生成序列化版本號,會導致
								後續程式碼不能修改,因為修改程式碼後序列化版本號會改變,所有要
								手動新增序列化版本號
						手動序列化:private static final long serialVersionUID = 1L(隨意定);
Thread(執行緒):程序是一個應用
		執行緒是一個程序中執行場景/執行單元
		一個程序可以有多個執行緒
		程序和程序之間記憶體資源不共享,執行緒和執行緒共享資源共享堆但是不共享棧,每有一個執行緒
		多一個棧。
		實現執行緒的方法:
			1.寫一個類繼承Thread重寫run方法,在主方法中New執行緒物件,呼叫物件.start()
			方法啟動執行緒,start方法主要任務是開闢一個新棧空間,程式碼執行後會瞬間結束
			啟動執行緒會自動呼叫run方法
			public class MyThread exdent Thread{
				public void run(){
				
				}
			}
			MyThread my = new MyThread();
			my.start();
			2.編寫一個類去實現Runnable介面(建議使用這種,因為繼承只支援單繼承)
				public class MyRunnable implements Runnuble{
						public void run (){
						} 
				}
				public static void main(String[] args){
					MyRunnable m = new MyRunnable();
					Thread t = new Thread(m);
					t.start();
				}
			3.編寫一個程式實現Callable介面,這種方法可以獲取執行緒返回值
				建立一個“未來任務類”
				FutureTask ft = new FutureTake(new Callable(){
						public Object call()throws Exception{
							//需要實現的方法
						}
				});//這裡採用了匿名內部類方法
				Thread t = new Thread(ft);
				Object obj = ft.get();//獲取執行緒返回值,可能會導致main執行緒受阻,主執行緒
				會等get方法執行結束後再執行下面的方法,缺點效率低,優點可以獲取返回值。
			執行緒在就緒<------>執行狀態來回切換。
			執行緒五大狀態:
				新建狀態:剛new出來的執行緒物件
				就緒狀態:當start()執行後執行緒進入就緒狀態
				執行狀態:run()方法執行搶到CPU時間片,進入執行狀態,當時間片用完
				再次進入就緒狀態重新搶奪CPU時間片,再次搶到後接著執行上一次時間片
				未執行完的任務。
				阻塞狀態:當一個執行緒在執行狀態遇到阻塞事件,列如接受使用者鍵盤輸入等
				方法,阻塞狀態的執行緒會放棄之前搶佔的CPU時間片。阻塞解除後會進入就緒
				狀態,重新搶奪時間片。
				死亡狀態:run()方法執行結束
		執行緒方法:
				void  .setName("");//修改執行緒名字
				String .getName();//獲取執行緒名字,預設名字Thread-0~n 有一個加一
				Thread c = Thread.curentThread();獲取當前執行緒物件,靜態方法,哪個執行緒執
				行這個方法,返回哪個方法。
				static void sleep(long millis);//讓當前執行緒進入休眠,出現在那,誰執行
				休眠。效果可以設定每隔多久執行一次
				void interrupt();//干擾,使用異常中斷睡眠
				static void yield()讓位,由執行狀態轉化為就緒狀態
				void join();執行緒合併,各個執行緒存在等待關係
		終止執行緒:public class MyThread implements Runnuble{
						boolean run = true;
						//判斷程序是否繼續執行
						if(run){
							....
						}else{
							//return結束run執行即中斷程序
							return;
						}
				  }
				  直接在main方法中new完執行緒後,想要終止直接.run = fales;就終止了
		執行緒安全:解決執行緒安全,使用執行緒同步機制,實際上就是執行緒不併發了,執行緒排隊執行
				 非同步程式設計模型:執行緒併發(同時)執行
				 同步程式設計模型:執行緒排隊執行
				 Java三大變數:
					例項變數:在堆中
					靜態變數:在方法區中
					區域性變數:在棧中
					只有區域性變數不會存線上程安全問題
				 synchronized:
					synchronized(多個執行緒的共享物件){
						//需要排隊的語句塊
					}
				public synchronized void run(){}
				出現在例項方法中鎖的是this,不靈活並且可能會無故擴大
				同步範圍,這中方法不常用,如果同步的是this,則建議使
				用在方法體中
		守護執行緒:void setDaemo(true);設定為守護執行緒,當主執行緒結束,守護執行緒同樣結束。
		  定時器:間隔特定的時間執行特定的程式
					java.util.Timer Java類庫中定時器類
		生產者和消費者:Object有兩方法wait()和notify(),兩者因為是Object方法所以會被所有類繼承
						wait();//作用:讓佔用本物件物件鎖的程序進行等待,並歸還物件鎖,且沒有
						notify喚醒則會一直等待
						notify();//喚醒使用本物件的執行緒,但是不會釋放物件鎖
						notifyAll();//喚醒所有使用本物件的執行緒
						wait()和notify()一般與synchronized一同使用。
反射機制:
	反射機制相關的類:
		java.lang.Class//代表整個位元組碼
		java.lang.reflect.Method//代表位元組碼中方法位元組碼
		java.lang.reflect.Constructor//代表位元組碼中構造方法位元組碼
		java.lang.reflect.Field//代表位元組碼中屬性位元組碼
	獲取位元組碼的三種方式;
		1.Class.forName("完整類名");
			靜態方法,方法引數一個字串,字串需要是完整類名,完整類名必須帶有包名
			Class c1 = Class.forName("java.lang.String");c1代表的是String.class檔案
		2.String b ="abc"
		  Class a = b.getClass();//每個類都繼承了Object類都有getClass()方法。getClass()獲取
		  Class檔案
		3.Class a = String.class;//每個型別都有.class屬性。
	反射機制作用:增加程式靈活度,降低程式耦合度,可以通過修改配置檔案來建立不同的物件
				  只執行靜態程式碼塊	Class.forName("需要執行靜態程式碼塊的類名");
				  因為Class.forName()執行時進行了類載入。
				  src是類的根路徑
				獲取檔案的當前路徑: 
				String path = Thread.curentThread().getContextClassLoader().getResource("檔名").getPath();
				解釋:Thread.curentThread()獲取當前執行緒物件
					  getContextClassLoader()是執行緒物件的方法,可以獲得當前執行緒的類載入器物件
					  getResource()[獲取資源]類載入器方法,當前執行緒的類載入器預設從根路徑下載入資源
				以流的形式獲取當前路徑:
				InputStream in = Thread.currentThread().getContextClassLoader().getResourecAsStream("檔名");
	(重點)如何通過反射機制訪問屬性:
				Class a = Class.forName("java.lang.String");//獲取類
				Object obj = a.newInstance();//呼叫無引數構造方法建立物件
				Field field = a.getDeclareField("屬性名");//獲取屬性
				field.set(obj,屬性值);給obj物件的屬性賦值。
				field.get(obj)//獲取obj物件的屬性值。 
				field.Accessible(true);//打破封裝
	可變長度引數:int...args (一定要為三個.)
				可以傳進去引數為1~n個,並且可變長引數只能出現一個並且只能是最後一個
				可變長度引數可以當成陣列看待。
	(重點)通過反射機制如果呼叫方法:
				CLass a = Class.forName("java.lang.String");
				Object obj = a.newInstance();
				Method b = obj.getDeclaredMethod("方法名",String.class,String.class);
				b.invoke(obj,"方法引數");//呼叫方法
	通過反射機制建立物件:
				Class c = Class.forName();
				Object obj = c.newInstance();
				Constructor con = c.getDeclaredConstructor(int.class,String.class);//構造方法引數
				Object newobj = con.newInstance(構造引數);//new有參構造物件
	通過反射機制獲取實現的介面和父類:
				Class c = Class.forName("java.lang.String");
				Class superClass = c.getSuperclass();//獲取父類
				Class[] interface = c.getInterfaces();//獲取類實現的介面
				
ResourceBundle(資源繫結器):只能繫結.properties檔案,且這個檔案必須在類路徑下
				ResourceBundle bundle = ResourceBundle.getBundle("檔名");//只寫檔名,不寫properties
				String className = bundle.getString("傳Key名");
				System.out.println(className);
Java中類載入器:程式在執行之前會啟動類載入器,Java類載入器一共有三個
				啟動類載入器:首先載入jre/lib/rt.jre
				擴充套件類載入器:通過啟動載入器載入不到,會啟動擴充套件類載入器會載入jre/lib/ext/*.jre
				應用類載入器:如果擴充套件載入器也沒有,那麼應用類載入器會專門載入:classpath中的類。
				Java為了保證類載入的安全,使用了雙親委派機制。
					優先從啟動類載入器,稱為“父”
					其次從擴充套件類載入器,稱為”母“
					最後才會從應用載入器載入。
網路程式設計:網路程式設計三要素:IP:用來定位計算機在網路中的位置
						埠:用來定位應用在計算機中的位置
					通訊協議:交流規則
		   InetAddress類:表示網際網路IP地址。
		   static InetAddress ip = InetAddress.getByName("ip地址或主機名");
		   static InetAddress ip = InetAddress.getLocalHost();//返回自己本地主機ip物件
		   String getHostAddress();//獲取主機ip
		   String getHostName();//獲取主機名
		   
註解(Annotantian):
	註解也叫註釋,是一種引用資料型別
	自定義註解:
	[修飾符列表] @interface 註解型別名{
		String name();//註解屬性,如果寫這個屬性,使用時必須使用這個屬性。
		String age() default 25;//指定預設屬性,使用註解時可以選擇不指定屬性值。
		屬性名是value的話使用時可以省略value。
	}
	註解使用:
	註解使用語法格式:@註解型別名
	註解可以出現在,類上,屬性上,方法上,註解上等。
	JDK註解:
		Deprecated:表示以過時
		Override:這個註解只能註解方法,這個註解是給編譯器參考的,和執行階段沒關係
		這個註解註解的方法必須是父類的方法,如果不是父類方法,報錯,這個是標識型註解。
		suppressWarnings:
	元註解:
		用來註解註解的註解
		常見元註解:
			Target:用來標註被標註的註解可以出現在哪些位置上。
			@Target(Elementype.METHOD)表示被註解的註解只能出現在方法上。
			Retention:用來標註最終儲存在哪裡
			@Retention(RetentionPolicy.SOURCE)//只儲存在Java原始檔中
			@Retention(RetentionPolicy.Class)//儲存在Class檔案中
			@Retention(RetentionPolicy.RUNTIME)//儲存在class中並且可以被反射機制讀取到

面試題:

	finally面試題:
			public static int a(){	反編譯:
				int a = 100;		int i=100;
				try{				int j=i;
					return a;		i++;	
				}finally{			return j;
					i++;
				}
			}//最後返回100,自上而下執行。
	這麼多集合,用哪個集合最多?
		答:ArrayList
			因為ArrayList在末尾增加元素,和查詢元素效率比較高,但是擴容效率比較低。
	Thread sleep面試題:
			在main方法中 new 一個執行緒物件如 Thread a = new MyThread();
			a.sleep();
			問a執行緒會進入休眠嗎?
			答:不會,因為sleep是靜態方法,出現在哪裡哪裡休眠,雖然使用a去調,但是執行的時候
			還會轉化為Thread.sleep()。

IDAE快捷鍵:

Ctrl + D 複製一行
Ctrl + shift + F10 執行
Ctrl + shift + F12 全屏
Alt + insert 新建類,快速構造構造方法,和set and get方法。
Ctrl + shift + / 多行註釋
Ctrl + / 單行註釋
Ctrl + F12 檢視函式屬性和方法
Alt + 回車 檢視錯誤,生成方法,導類

注:感覺csdn好坑,不知道是不是我自己太菜了,這篇文章的內容是我學習Java時的筆記,在文件中都弄好格式了,但是直接複製的部落格上慘不忍睹,稍微優化了一下,應該還能看把,這不能帶格式貼上是真的難受。