Java兩種核心機制:java虛拟機垃圾收集機制
源程式(*.java)---java編譯器---位元組碼(*.class)—作業系統平台
Java虛拟機可以了解成一個位元組碼為機器指令的cpu
對于不同的運作平台,有不同的虛拟機
Java虛拟機制屏蔽了底層運作平台的差别,實作了”一次編譯,随處運作”
Java是解釋型語言
J2SDK(軟體開發包) JRE(java運作環境) 開發需要JDK 使用者需要JRE
Bin二進制
Dos中輸入java –version現在用的jdk版本
Path:window系統執行指令時要搜尋的路徑
Classpath:java在編譯和運作時要找的class所在的路徑
1.Helloworld.java
Public class HelloWorld{
Public static void main(String[] args){
System.out.println(“HelloWorld”);
}
d:
cd java//切換到java目錄
javac HelloWorld.java
java HelloWorld
詳細資訊 工具 檔案夾 應用到所有檔案夾
顯示所有檔案和檔案夾
不隐藏已知檔案類型拓展名
在位址欄顯示完整路徑
類體 方法體
一個原檔案中最多有一個public類 每個類對應一個class
源檔案的名必須和public類名相同
Java語言注釋三種注釋方式:
//
/* */
/**
*
*/
Java.lang.NoclassDefound
IDE內建開發環境
J2se基礎文法
<b>辨別符</b>:凡是自己可以起名字的 由字母 下劃線 美元符 或數字組成
應以字母,數字,美元符
見名知意
關鍵字:專門用途,小寫英文
<b>Java</b><b>常量</b>:用字元串表示,區分為不同的類型
Eg 整型常量123
實型常量3.14
字元常量’a’
邏輯常量true false
字元串常量”helloworld”
“常量”這個名詞還會用在另外其它語境中表示值不可變的變量參見Final關鍵字
<b>Java</b><b>變量</b>是程式中最基本的存儲單元,其要素包括變量名,變量類型和作用域
Java程式中每一個變量都屬于特定的資料類型,在使用前必須對其聲明.
從本質上講,變量其實是記憶體中的一小塊區域,使用變量名來通路這塊區域,是以,每一個變量使用前<b>必須要先申請</b><b>(</b><b>聲明),</b><b>然後必須進行指派(</b><b>填充内容),</b><b>才能使用</b>.
程式執行過程 load到記憶體 找到main方法開始執行
執行過程管理<b>:code segment</b><b>存放代碼 data segment </b><b>靜态變量字元串常量</b>
<b> Stack</b><b>局部變量 heap new</b><b>出來的東西(</b><b>記憶體分的四部分)</b>
Java變量的分類
<b>按被聲明的位置劃分:</b>
局部變量:方法或語句塊内部定義的變量(包含方法參數)
成員變量:方法外部,類的内部定義的變量
類外面不能有變量的聲明
大括号裡聲明的變量,出了大括号就沒人認識大括号裡聲明的變量
<b>按所屬的資料類型劃分:</b>
基本資料類型變量4類8種
邏輯型boolen true false 不可以以0或非0的整數替代
文本型 字元型char \u後邊的數是十六進制的編碼 \n換行符 \r回車符
整數型 byte1 short1 int4 long8 八進制0開頭 十六進制 0x 或0X開頭×××預設為int型,聲明long型常量可以後加l或L
浮點數型 兩種表示形式 十進制 科學記數
Float4 double8 預設double聲明float型常量可以後加f或F
引用資料類型變量
基本資料類型轉換:boolean不可以轉換為其他資料類型
×××,字元型,浮點型在混合運算中互相轉換
<b>Infinity</b>無小的轉換成大的自動轉化 大的轉換成小的強制轉換
Byte short char 轉換成int處理
程式應該主義的問題
1. 大括号對其
2. 遇到{縮進,Tab/shift+Tab
3. 程式塊之間加空格
4. 并排語句之間加空格
5. 運算符兩側加空格
6. {前面有空格
7. 成對程式設計
運算符
算術運算符 邏輯運算符 指派運算符 字元串連接配接符
<b>“+”</b><b>運算符兩側的操作數中隻要有一個是字元串類型,</b><b>系統會自動将另一個操作數轉換為字元串然後在進行連接配接</b>
<b>當進行列印的時候,</b><b>無論任何類型都自動轉換為字元串進行列印</b>
Print不換行 println換行
<b>表達式</b>
表達式的類型和值 表達式的運算順序
三目條件運算符 x?y:z x 為boolean類型 為true結果為y 否則為z
<b>語句</b>
條件語句
If
If..else..
If..else if..else..
<b>For</b>循環語句
<b>1+3+5+…+99</b>
public class OddSum{
long result = 0;
for(int i=1; i<=99; i+=2){
result +=i;
System.out.println(“result=”+restult);
}
Int result=0;
For(int i=1;i<=99;i+=2)
{result+=i}
Tab shift+tab
While do while
Break continue
<b>1 100</b><b>内前5</b><b>個可以被3</b><b>整除的數</b>
<b>輸出101 200</b><b>内的質數</b>
應該由哪些類對象
應該具有的屬性方法
類和類之間的關系
<b>Static</b><b>關鍵字</b>
用static聲明的成員變量為靜态成員變量,它為該類的公用變量,在第一次使用時被初始化,對于該類的所有對象來說,static成員變量隻有一份.
可以通過對象引用或類名(不需要執行個體化)通路靜态成員
用static聲明的方法為靜态方法,在調用該方法時,不會将對象的引用傳遞給它,是以在static方法中不可通路非static的成員.靜态方法不再是針對于某個對象調用,是以不能通路非靜态成員
<b>Package </b><b>和import</b><b>語句</b>
class檔案的最上層包的父目錄位于classpath下
執行一個類需要寫全包名
<b>J2SDK</b>
Java.lang 包含一些java語言的核心類,如string,math,integer,system和thread,提供常用功能
Java.awt 包含了構成抽象視窗工具集的多個類,這些類被用來建構和管理應用程式的圖形使用者界面(GUI)
Java.applet包含applet運作所需的一些類
Java.net 包含執行與網絡相關的操作的類
Java.io 包含能提供多種輸入/輸出功能的類
Java.util 包含一些實用工具類,如定義系統特性,使用與日期月曆相關的函數
Java.lang不需引入
Dos中打jar包的指令 jar –cvf xx.jar *.*
<b>繼承和權限控制</b>
Extends
通過繼承,子類自動擁有了基類的所有成員(成員變量和方法)
Java隻支援單繼承,不允許多繼承.一個子類隻能有一個基類 一個基類可以派生多個子類
Private 類内部
Default 類内部同一個包
Protected 類内部同一個包子類
Public 類内部同一個包子類任何地方
<b>方法的重寫</b>
在子類中可以根據需要從基類中繼承來的方法進行重寫
重寫方法和被重寫方法具有相同方法名稱,參數清單和傳回類型
重寫方法不能使用比被重寫方法更嚴格的通路權限
<b>Super</b><b>關鍵字</b>
在java類中使用super來引用基類的成分,eg 引用方法
<b>繼承中的構造方法 </b>
子類的構造過程中必須調用其基類的構造方法
子類可以在自己的構造方法中使用super調用基類的構造方法
使用this調用本類的另外的構造方法
如果調用super,必須寫在子類構造方法的第一行
如果子類的構造方法中沒有顯示的調用基類構造方法,則系統預設調用基類無參數的構造方法
如果子類構造方法中既沒有顯式調用基類構造方法,而基類中又沒有無參的構造方法,則編譯出錯.
<b>Object</b><b>類</b>
<b>Object</b>類是所有java類的根基類
Clone()
equals(Object obj)
finalize()
getClass() 拿到編譯好的class檔案
hashCode()
notify()
toString() 傳回代表這個對象的字元串
<b>toString</b><b>方法</b>
object 類中定義有<b>public String toString()</b>方法,其傳回值是String類型,描述目前對象的有關資訊.
在進行String與其它類型資料的連接配接操作是(如:System.out.println)(“info”+person),将自動調用該對象類的toString()方法.
可以根據需要在使用者自定義類型中重寫toString()方法.
Public class TestToString{
Dog d = new Dog();
System.out.println(“d:=”+d.toString); //object類預設是哈希編碼
}
Class Dog{
Public String toString(){
Return “I’m a cool Dog!”
哈希編碼: 獨一無二的代表一個對象.并且通過哈希編碼可以獨一無二的找到這個對象的位置.
在java虛拟機運作時需找到運作對象的位址,會用一張表記錄每一個對象的位置,根據編碼可以找到對象.
<b>equals()</b><b>方法</b>
<b>重寫Public boolean equals(Object obj){}</b>
public class TestEquals{
public static void main(String[] args){
Cat c1 = new Cat(1,2,3);
Cat c2 = new Cat(1,2,6);
System.out.println(c1 = c2); //比較的是引用中的内容,不可能相同
System.out.println(c1.equals(c2));
//上為object類
//下為string類 string類中的equals方法 序列一樣就相等
String s1 = new String(“hello”);
String s2 = new String(“hello”);
System.out.println(s1 ==s2);
System.out.println(s1.equals(s2));
Class Cat{
Int color;
Int height,weight;
public Cat(int color,int height,int weight){
this.color = color;
this.height = height;
this.weight = weight;
Public boolean equals(Object obj){
if(obj = = null) return false;
else{
if(obj instanceof Cat){
Cat c = (Cat) obj;
If(c.color==this.color&&c.height==this.height&&c.weight ==this.weiget)
Return true;
Return false;
Object 的equals方法定義為:x.equals(y) 當x和y是同一個對象的應用是傳回true否則傳回false.
<b>對象轉型(casting)</b>
一個基類的引用類型變量可以”指向”其子類的對象.
一個基類的引用不可以通路其子類對象新增加的成員(屬性和方法)
可以使用引用變量instanceof 類名 來判斷該引用型變量所指向的對象是否屬于該類或該類的子類
子類對象可以當做基類的對象來使用稱作向上轉型(upcasting),反之稱為向下轉型(downcasting).
<b>動态綁定和多态</b>
動态綁定是指在執行期間(而非編譯期)判斷所引用對象的實際類型,根據其實際的類型調用其相應的方法.
實際中new的誰就調用誰的方法,實際中的位址才會綁定到相應方法之中的位址上面
多态的條件:
1 有繼承 2 有重寫 3 父類引用指向子類對象
多态特性對于系統可擴充性有重要影響
<b>抽象類</b>
用abstract關鍵字來修飾一個類時,這個類叫做抽象類,用abstract來修飾一個方法時,該方法叫做抽象方法.
含有抽象方法的類必須被聲明為抽象類,抽象類必須被繼承,抽象方法必須被重寫.
抽象類不能被執行個體化
抽象方法隻需聲明,不需實作
Eg:public abstract void enjoy();
<b>Final</b><b>關鍵字</b>
Final的變量值不能夠被改變
Final的成員變量
Final的局部變量(形參)
Final的類不能夠被繼承
Final的方法不能夠被重寫
Public class TestFianl{
Public static void main(String[] args){
T t = new T();
t.i = 9;
Final Class T{
Final int t = 8;
Public final void m(final int j){
Class TT extends T{
Public void m(){
<b>接口interface</b>
多個無關的類可以實作同一個接口
一個類可以實作多個無關的接口
與繼承關系類似,接口與實作類之間存在多态性
接口是抽象方法和常量值的定義的集合
從本質上講,接口是一種特殊的抽象類,這種抽象類中隻包含常量和方法的定義,而沒有變量和方法的實作
<b>接口特性</b>
接口可以多重實作
接口中聲明的屬性預設為public static final 的;也隻能是public static final 的;
接口中隻能定義抽象方法,而且這些方法預設為public的,也隻能是public的;
接口可以繼承其它的接口,并添加新的屬性和抽象方法.
<b>異常處理</b>
運作期出現的錯誤
Eg: int[] a = {1,2,3};
Try{
System.out..println(arr[4]);
Catch(ArrayIndexOutofBoundsException ar){
System.out.println(“系統正在維護”);
ar.printStackTrace();
<b>Java.lang.ArrayIndexOutofBoundsException </b><b>數組下标越界</b>
<b>printStackTrace();</b>
j2sdk中定義了很多異常類
Throwable (1)error 不可處理(2)exception / RuntimeException經常出現的錯誤,可以捕獲也可以不捕獲./另一類必須被catch
Try{}
Catch(someException1 e){}
Catch(someException2 e){}
Finally{}//通常在其中進行資源的清除工作
Void f() throws<b> FileNotFoundException,IOException</b>{}
Void f2(){
Try{
f(0);
}catch(FileNotFoundException e){
System.out.println{e.getMessage()}}
Catch(IOException e){
e.printStackTrace();}
ArithmeticException
Try catch finally throws throw
使用自定義異常一般有如下步驟;
1 通過繼承java.lang.Exception類聲明自己的異常類
2 在方法适當的位置生成自定義異常的執行個體,并用throw語句抛出
3 在方法的聲明部分用throws語句聲明該方法可能抛出的異常
注意:重寫方法需要抛出與原方法所抛出異常類型一緻異常或不抛出異常
<b>數組</b>
一維數組的聲明方式: type var[] 或type[] var
數組對象的建立:
Java中使用關鍵字new建立數組對象,格式為:數組名 = new 數組元素的類型 [數組元素的個數]
Eg public class test{
Public static void main(String args[]){
Int[] s;
S = new int[5];
For(int i = 0; i < 5; i++){
S[i] = 2*i+1;
注意:數組元素為引用資料類型的數組中的每一個元素都需要執行個體化.
Public class Test{
Date[] days;
days=new Date[3];
for(int i=0;i<3;i++){
days[i]=new Date(2004,4,i+1);
class Date{
int year; int month; int day;
Date(int y, int m, int d){
Year = y;
Moth = m;
Day = d;
數組初始化
動态初始化:數組定義與為數組元素配置設定空間和指派的操作分開進行.
Eg public class Test{
Public static void main(String args[]){
Int a[];
A = new int[3];
A[0]=3,a[1]=9,a[2]=8;
Date days[];
Days = new Date[3];
Days[0]=new Date(1,4,2004);
Days[1]=new Date(2,4,2004);
Days[2]=new Date(3,4,2004);
Class Date{
Int year,month,day;
Date(int y,int m,int d){
year=y,month=m,day=d;
靜态初始化:在定義數組的同時就為數組元素配置設定空間并指派.
Public class test{
Int a[] = {3,9,8};
Date days[] = {new Date(1,4,2004), new Date(2,4,2004),new Date(3,4,2004)}
數組元素的預設初始化
數組是引用類型,它的元素相當于類的成員變量,是以數組配置設定空間後,每個元素也被按照成員變量的規則被隐式初始化.
Int a[] = new int[5];
Date[] days = new Date[3];
System.out.println(a[3]);
System.out.println(days[2]);
Class date{
Year=y;
Month=m;
Day=d;
輸出結果:0,null
數組元素的引用
定義并用運算符new為之配置設定空間後,才可以引用數組中的每個元素,數組元素的引用方式為:arrayName[index]
Index可以為數組元素下标,可以是×××常量或×××表達式.eg a[3] b[i] c[6*i]
數組元素下标從0開始;長度為n的數組的合法下标取值範圍為0~n-1
每個數組都有一個屬性length指明它的長度,例如
a. length的值為數組a的長度(元素個數)
public class TestArray{
public static void main(String[] args){}
int[] a = {2,4,6,7,3,5,1,9,8};
for(int i=0;i<a. .length;i++){
System.out.println(a[i] + “ ”);
For(int i=0;i<args.length;i++){
System.out..println(args[i]);
Public class TestArgs{
If(args.length<3){
System.out.println(“usage:java Test \”n1\” \”op\” \” n2\””);
System.exit(-1); //非正常退出
double d1 = Double.parseDouble(args[0]);
double d2 = Double.parseDouble(args[2]);
double d = 0;
if(args[1].equals(“+”)) d = d1+d2;
else if(args[1].equals(“-”)) d = d1-d2;
else if(args[1].eauals(“×”)) d=d1*d2;
else if(args[1].equals(“/”)) d=d1/d2;
else{
System.out.println(“Error operator!”);
System.exit(-1);
System.out.println(d);
*******************
Public class NumSort{
int[] a = new int[args.length];
//讀進來
for(int i=0;i<args.length;i++){
a[i] = Integer,parseInt(args[i]);
print(a);
selectionSort(a);
Private static void selectionSort(int[] a){
int k,temp;
For(int i=0;i<a.length;i++){
k = i;
for(int j=k+1;j<a.length;j++){
If(a[j]<a[k]){
k = j;
If(k!=i){
temp=a[i];
a[i]=a[k];
a[k]=temp;
Private static void print(int[] a){
System.out.print(a[i] + “ “);
System.out.println();
Date[] days = new Date[10];
Date day = new Date(2004,4,6);
Int year,month,day;
Date(int y,m,d){}
<b>二維數組</b>
可以看成以數組為元素的數組
多元數組的聲明和初始化應該按從高維到低維的順序進行.
Eg int a[][] = new int[3][ ]
A[0] = new int[2];
A[1] =new int[4];
A[2] = new int[3]
<b>資料的拷貝</b>
使用java.lang.System類的靜态方法
Public static void arraycopy(object src,int srcPos,object dest,int destPos,int length)
可以用于數組src從第srcPos項元素開始的length個元素拷貝到目标數組從destPos項開始的length個位置.
如果源資料數目超過目标數組邊界會抛出IndexOutOfBoundsException異常.
![Qt 中實作在控件中點選滑鼠，就在滑鼠點選處加載圖檔的方法[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)