JAVASE初級筆記

  第一步：新建一個文本文檔，文件名爲Hello

  第二步：修改文件後綴名爲 .java

  第三步：在Hello.java文件中，寫入這樣一段代碼：

public class Hello{       public static void main(String args[]){            System.out.println("作人沒有夢想，那跟鹹魚有什麼分別");       } }

 

 

 

 

 

 

  注意：代碼中的中括號大括號分號等，都必須是英文字符

  第四步：打開一個DOS窗口，使用javac命令編譯java源文件

  注意：使用javac命令的前提是要正確的配置path環境變量

  第五步：確保生成Hello.class文件，使用java命令運行字節碼文件

if(a[i] > a[j]) {        int t = 0 ;     t = a[i];     a[i] = a[j];      a[j] = t; }大括號內的語句都屬於if語句塊

 

 

  幾款代碼編輯工具

  UltraEdit、Notepad++、EditPlus

 

  變量：intx=4;

n 局部變量：

u 定義在方法內的變量，或語句塊內的變量

u 局部變量必須賦初始值，不然沒法使用。

n 成員變量：

u 定義在類裏面，方法的外面，屬於對象，每一個對象擁有本身的成員變量，互相不衝突

u 成員變量未初始化時，系統會自動初始化，給默認值。

n 靜態變量：（也叫類變量）

u 定義在類裏面，方法的外面，static關鍵字修飾。屬於類，全部對象共享一個變量

n 常量: final int y = 6;

  JAVA的命名規範：

n 不可跟關鍵字重複

n 只能包含數字、字母、下劃線、$，其中數字不能夠開頭

  關鍵字：

  數據類型：

 

 

 

 

 

 

 

 

n 分爲兩大類：基本數據類型和引用數據類型

n 引用類型的變量也叫指針，它保存了一個對象的內存地址

n Student  stu =  new Student（）;

stu 就是引用變量，把一個對象賦給stu，也就意味着stu此刻保存了對象的地址。咱們能夠經過stu來調用這個對象的方法，或者訪問對象的屬性。 注意引用變量也是有類型區分的，stu 的類型是Student,所以有時咱們會說stu這個對象是Student類型的。

 

 

 

 

 

 

 

 

  基本數據類

n Int 整數型 4字節

n Short 短整型 2

n Byte 字節型 1

n Long 長整型 8

n Float 單精度浮點型 4

n Double 雙精度浮點型 8

n Char 字符型 2

n Boolean布爾型 1

  類型轉換

u char型、short型、byte型運算時，只能轉換爲int型

u 自動轉型(類型的自動提高)的原則範圍由小到大、精度由低到高

u int a =4, b=5;

u (float) (a*b) 注意在類型轉換時，運算的優先級：

u 若是寫成了(float)a*b,則會先把a轉成float類型再與b進行計算，那跟咱們想要的結果就不同了，所以這裏要特別當心。

  轉義字符： \反斜線加上字符

n \t         \n        \\         \」

  運算符：

n 算術運算符

u + 、-、*、/、% 取模 求餘數

n 關係運算符

u >、<、==、!=、>=、<=、

n 一元運算符

u +、-、~、！

n 賦值運算符

u =

n 邏輯運算符

u &&、|| 、!

n 遞增、遞減運算符

u ++、--

n  三目運算符

u (布爾表達式) ？ 表達式1 ： 表達式2

u 布爾表達式的值爲真時，運算結果爲表達式1，不然結果爲表達式2

u 例1： (a == 30)  ?  x +=5 : x = 0;

l 若是a等於30，則執行x+=5，不然執行x=0;

u 例2：String str = (a == 30)  ?  「哈哈」 : 「呵呵」 ;

l 若是a等於30，str的值是 哈哈，不然 呵呵

  運算符的優先級關係

 

  if語句的使用

n  If語句接受一個邏輯表達式，判斷真假

if(a>30) {     System.out.println("aaaa"); } else if(a < 25){     //……… }

 

 

 

 

   

 

  switch語句

n  只能作等值的判斷（==），而且只能判斷int變量或能夠轉換成int型的變量

n  當心case穿透，記得要加break語句

n  注意理解if和switch的用法上的區別，理解它們的使用場合

 

char c = 'm'; switch(c) {     case 'x' : { System.out.println("x"); System.out.println("x"); break; }     case 'm' : System.out.println("m"); break;     case 'z' : System.out.println("z"); break;     default : System.out.println("默認狀況"); }

 

 

 

 

 

 

 

 

 

  While循環

int i = 0; while(i<100/*循環條件*/) {     System.out.println("循環第"+i+"次");     i++; }

 

 

 

 

 

dowhile循環：第一次執行循環體，不判斷條件！

  For循環

n  99乘法表

u 

for (int i=0; i<=10; i++){       System.out.println(i); } //打印出i的值，觀察結果

第一步：創建一個for循環

u  


 

u 

for (int i=0; i<=10; i++){       for(int j=0; j<=10; j++){            System.out.println( i );            System.out.println( j ); } }//打印出i的值，觀察結果, 打印j的值觀察結果

第二步：創建循環嵌套

u  




 

u 

for (int i=0;i<=10;i++){       for(int j=0; j<=i; j++){            System.out.println( i );            System.out.println( j ); } }//再觀察結果 //打印出i的值，觀察結果

第三步：修改子循環的循環條件，讓子循環的次數變成動態值

u  





 

  break語句和continue語句

n  break： 終止當前循環體，或switch 語句塊

n  continue：終止本次循環，直接進入下一次循環

  DEBUG跟蹤調試程序

n  第一步設置斷點

n  第二步以DEBUG模式來運行程序

 

int[] a = {23, 99, 8, 10}; int[] b = a;

數組的內存結構

 

堆內存

0

1

2

3

23

99

8

10

棧內存

a #9852

b #9852

注意！數組的下標從0開始

數組裏存放的整型數

 

 

 

 

 

 

 

 

 

 

 

 

  數組  若干相同類型的數據的集合

n  double[]  arr = new double[5];

n  double[]arr = {2,6,3,7,8};

n  double[]arr = new double[]{2,6,3,7,8};

n  arr.length得到數組的長度

n  數組的下標從0開始  因此arr[2] 表明數組的第三個元素

  二維數組 一個存放數組的 一維數組

n  int[][]arr = new int[5][5];

arr[0]= new int[5];[A1] 

n  int[][] arr2  =  { {1,2,3}, {2,4,5},  {5,6,7},  {1},  {4,4,4,4}};

n  arr2[0] 表明第一個子數組   也就是 {1,2,3}

n  因此要訪問子數組的第三個元素，應該：arr2[0][A2] [2]

堆內存

0

1

2

3

棧內存

arr

1

2

3

2

4

5

arr[0]

arr[1]

arr[2]

arr[3]

 

 

 

 

 

 

 

 

 

 

 

  多維數組

n  int[][][][]  arr = new int[5][4][3][2];

  冒泡排序、選擇排序法、快速排序

n  數組元素的交換  有元素a、b、

u  首先定義一個臨時的變量temp

u  temp= a;
a = b;
b = temp;

  加強for循環（for-each）

Product[]  plist = {new Product(), new Product(), new Product()}; for( Product  p  :  plist) {        p.toString(); } //加強for循環寫起來很簡便，但也有缺點，因爲它不像for循環有循環變量，所以咱們沒法經過下標去訪問數組，可是，對於上面這個加強for 循環來說，操做對象p，一樣能夠改變數組裏面的對象的屬性，這是爲何呢？

 

 

 

 

 

 

 

  面向對象的基本思想

n  從傳統的面向過程發展而來的。

n  面向過程的思惟：

u  第一步買菜，第二步洗菜，第三步切菜，第四步炒菜

n  面向對象的思惟：

u 

對象

第一步採購員 完成本職工做

u  第二步幫廚     完成本職工做

u  第三步案板      完成本職工做

u  第四步大廚     完成本職工做

n  把不一樣的工做交給不一樣的角色（對象）來處理，每一個對象負責本身的工做。這個過程當中還體現出了封裝的概念！

n  類和對象

u  類就是一個模板，或者能夠看作是咱們本身定義的數據類型

u  對象就是利用模板建立的一個具體事物，或者能夠看作是使用自定義數據類型聲明出來的變量，在JAVA中咱們把對象叫作一個類的實例

n  如何定義一個類？

public  class  Product {        public  static  int  num = 10; }

 

 

 

 

 

l  成員變量： 普通的成員變量和靜態成員變量（類變量）

n  類變量是全部對象共享的，能夠經過類名直接訪問：

n  Product.num 而不須要構造對象

l  如何建立一個對象

n  類名  對象名 = new 類名（）；

n  Product  p1 = new Product();

l  Product()被稱之爲構造方法，它是一個很特殊的方法：

n  構造方法名必須和類名相同

n  構造方法不能夠寫返回值類型

n  構造方法默認狀況下不須要顯示的去聲明，系統幫咱們默認建立

n  調用構造方法必需要跟new關鍵字配合

n  系統默認建立的構造方法是無參的

n  一旦咱們定義了任何一個構造方法，系統默認的會自動失效

n  構造方法能夠同時定義多個：在JAVA中，同一個類裏，多個方法名稱相同，爲了區別，要求參數不能同樣，這種形式叫作方法重載

l  類的繼承

public  class  Product  extends  Object{        public  static  int  num = 10; }

 

 

 

 

n  繼承的最大做用是可以讓子類擁有父類的方法和屬性，全部子類都遵循父類的特性，而且在父類的方法不能知足需求的時候，咱們能夠經過重寫覆蓋父類的屬性和方法。

n  同時，繼承在某種程度上說，也是一種分類的方式，咱們說類是一種模板，經過類來構造對象。那麼模板也是有分類的。

n  例如：動物類能夠分爲：無脊椎動物和脊椎動物
其中脊椎動物又分爲魚類、兩棲類、爬行類、鳥類、哺乳類等。
有了繼承，分類能夠更加明細，更加清晰

n  [A3] 子類繼承父類的屬性和方法

u  靜態屬性是不繼承的

u  私有屬性子類不可以直接訪問

u  JAVA當中只有單繼承

u  建立子類對象的時候，在調用子類構造方法的時候，會先調用父類的構造方法

u  若是父類還有父類，會從最頂層的父類構造方法開始調用，一直到子類的構造方法

n  子類繼承父類的屬性和方法，均可以本身重寫，重寫以後，覆蓋父類的方法，這個叫作方法的重寫

n  權限修飾符：private  public protected  默認(什麼都不寫)

修飾符	同一個類	同一個包	子類	不一樣包
Public	√	√	√	√
Protected	√	√	√
默認	√	√
Private	√

n  類的封裝

u  將某些屬性或方法設爲私有的，防止外界直接訪問
提供一個公有的方法，讓外界經過公有方法間接訪問

u  封裝的主要目的其實在於隱藏，隱藏沒必要要的細節過程。例如一臺電腦，內部結構異常的複雜，生產廠商將內部的細節封裝起來，咱們只能經過鼠標和鍵盤來操做電腦，這樣的好處在於，咱們沒必要了解其內部的複雜構造，而只須要鍵盤簡單的操做就可使用電腦。

u  再好比一臺汽車，咱們操做一臺車只能經過油門、剎車、方向盤。其餘的細節內容都被封裝了起來，發動機內部到底作了什麼事情，咱們沒法得知，固然咱們也不肯意去關心那些細節問題，咱們只須要會使用油門和方向盤就足夠了，這不正是封裝帶來的好處麼？

n  [A4] super、this分別表明：

u  super表明了父類對象的引用

u  this表明了當前對象的引用

n  static關鍵字

u  用static修飾的變量和方法，叫作靜態變量或靜態方法，從屬於類，能夠經過類名直接調用。

n  package關鍵字

n  import關鍵字

n  final關鍵字

u  修飾變量：變量的值不能夠改變！而且必須在定義的時候賦初值

u  修飾方法：這個方法將不可以被子類重寫

u  修飾類：該類將不可以被繼承

l  類的多態：能夠理解爲多樣性，或多種表現狀態

n  方法的重載也算是多態的一種表現形式

n  方法的重寫一樣能夠表現出多態的特性

n  舉例：

      父類   ss =  new 子類();

子類被轉型成父類，因爲父類的層次比子類高，所以這裏能夠進行自動轉型。無需手動干預。

轉型以後，ss爲父類的引用，此時ss只能調用父類的方法，子類特有的方法，ss無權調用。

只有一種特殊狀況可使用子類的方法，就是父類中的方法被子類重寫，此時父類方法被覆蓋，就能夠調用子類方法。

舉例：

 

public class Animal {     public int attack = 100;//攻擊力         public void sound() {//聲音        System.out.println("Animal sound");     } }

 

 

 

 

     

     

有父類Animal，包含一個方法名稱爲sound

子類重寫父類的sound方法

public class Cat extends Animal {     @Override     public void sound() {        System.out.println("喵喵");     }     public void catchMouse() {        System.out.println("抓老鼠");     } }

 

 

 

 

 

 

 

 

此時如有父類引用指向了一個子類對象cat

Animal  animal =  new  Cat();

父類引用調用sound方法，執行的仍然是子類對象的sound方法

   這時，sound方法所表現出來的結果，是多種多樣的，根據子類的不一樣，獲得的結果也不一樣。一樣都是sound 方法，卻有多種結果能夠出現。咱們將這種情形稱之爲多態。

   因此說重載、重寫都是多態的表現，也就是說方法名稱相同，但具體操做不一樣。好比咱們說「吃」這個字，在不一樣的狀況下咱們能夠有多種含義，例如：吃飯、吃釘子、吃官司等，具備相同的名稱，但具體的操做卻不同。再好比「開」這個字，開車、開窗、開飯、開局等等。

瞭解更多詳情請登陸超人學院網站http://www.crxy.cn或者每週日晚八點半相約免費公開課 https://ke.qq.com/course/53102#term_id=100145289  具體詳情請聯繫QQ2435014406