黑馬程序員———基礎預備知識

------Java培訓、Android培訓、iOS培訓、.Net培訓、期待與您交流！ -------

Java語言基礎組成：

關鍵字

注意：main不是關鍵字，卻是被虛擬機識別的，比較特殊。

標識符

1. 1. a-z A-Z 0-9 _ $
  2. 數字不能開頭，起名儘量有意義
  3. 包名：xxxyyyzzz
  4. 類名接口名：XxxYyyZzz
  5. 變量名和函數名：xxxYyyZzz
  6. 常量名：XXX_YYY_ZZZ。多單詞時，用下劃線連接。

註釋

可以註解程序和調試程序

注意：先寫註釋，再寫代碼

常量和變量

整數常量
小數常量
布爾型常量
字符常量
字符串常量
null常量

運算符
- 算術運算符
- 賦值運算符
- 比較運算符
- 邏輯運算符
- 位運算符
- 三元運算符
- 算術運算符
% 取模 5%2 = 1

x % y

x<y 則結果爲x

x=y 結果爲0

y=1，結果爲0

1 % -5 結果爲？？ 1

-1 % 5 結果爲？？ -1

只看左邊的正負。面試的邊邊角角。

++ 自增

-- 自減

int a = 3, b;

b = a++;

先賦值給b，再自增

System.out.println(b);3

System.out.println(a);4

b = ++a;

先自增，再賦值

字符串數據和任何數據使用+都是相連接，最終都會變成字符串。

字符串連接符 +

System.out.println("5+5="+5+5);//打印爲"5+5=55"
- 注意：代碼閱讀性重要。
- 轉義字符：
通過\來轉變後面字母或者符號的含義。

\n:換行。

\b:退格。相當於backspace。

\r:按下回車鍵。window系統，回車符是由兩個字符來表示\r\n

\t:製表符。相當於tab鍵。

轉義字符寫在被轉義的字符前面

System.out.println("\"hello\"");//打印"hello"帶雙引號的

char c h= '\n';//可以的，像'\'',打印爲'

char c = '你’;//可以裝中文的
- 賦值運算符：
+= -= *= /= %=

short s = 4;

s = s + 5;//編譯失敗，因爲s被提升爲int類型，運算後結果還是int類型，無法

賦值給short類型。

short是2個8位，5是4個8位。會丟失精度

s += 5;//編譯通過，因爲+=運算符在給s賦值時，自動

完成了強轉動作。

int a,b,c;

a = b = c = 5;//比較少見的形式。
- 比較運算符：
！=       <     >   <=     >=     ==   instanceof

邏輯運算符：

&     AND(與)

|     OR(或)

^     XOR(異或)

！     Not(非)

&&     AND(短路)

||     OR(短路)

&：只要兩邊有一個爲false，則爲false。

|：只要有一方爲true，則爲true。

^：和|有點不一樣，當true ^ true 則爲false。

兩邊相同結果爲假，兩邊不同，結果爲真。

int a = 2;

a>3 & a<6;

a>3 && a<6;//短路，當判斷到前面的爲false，則停止運算，直接輸出false

&：無論左邊是true還是false，右邊都運算。

&&：當左邊爲false，右邊不運算。

|：兩邊都參與運算。

||：左邊爲true，右邊不運算。
- 位運算符：
<<

>>

>>> 無符號位移

&     與運算

|     或運算

^     異或運算

~     反碼

example：

     3<<2 = 12;

         0000-0000 0000-0000 0000-0000 0000-0011

左移兩位： 00-0000 0000-0000 0000-0000 0000-001100

     6>>1 = 3;

     0000-0000 0000-0000 0000-0000 0000-0110

     000000-0000 0000-0000 0000-0000 0000-01

<<:其實就是乘以2的移動的位數次冪。3<<2--> 3*2^2

>>:其實就是除以2的移動位數次冪。6>>1--> 6/2^1

添0，以最高位是1還是0來補。

而>>>,無論最高位是1還是0，都拿0補。

位運算運算速度最快，但侷限性是隻能是2的倍數增減。

與運算，或運算，異或運算

      ： 6 & 3 = 2; 6 | 5 = 7;      6 ^ 5 = 3;

         110          110             110

     & 011          | 101          ^ 101

         -------       --------          -------

         010 = 2;     111 = 7;     011 = 3;

驗證：System.out.println(6 ^ 5);//結果爲3

反碼：

負數的二進制表現形式爲取反+1；

     000......000110   = 6;

     111......111001   取反

     000......000001   +1;

     111......111000   = -7;

     (因爲 000......000111爲7)

     ~6 = -7;

另外：7 ^ 4 ^ 4 = 7;

7 ^ 4 ^ 4:

111

^100                  加密

----

011

^100                  解密

----                   4相當於祕鑰

111

一個數異或同一個數兩次，結果還是那個數。

2 * 8 =

    0000

* 0010

-------------

    0000

   1000

------------

   10000 = 16；就是下面的第一位與上面四位相乘，依次第二位與

上面4位相乘。

高效：

2<<<3

0000-0010 2

0001-0000 16

交換兩整數

1.temp = n;

n = m;

m = temp;

2. n = n + m;

   m = n - m;

   n = n - m;

3.n = n ^ m;

m = n ^ m;

n = n ^ m;

======================================

public static void main(String[] args){

     int num = 60;

     //獲取60的最低4位，通過&15

     int n1 = num & 15;

     System.out.println(n1>9?(char)n1-10+'A')":n1);



     //要獲取下一組四位，將60右移4位。

     int temp = 60 >>> 4;

     //對temp的值進行最低4位的獲取。

     int n2 = temp & 15;

     System.out.println(n2>9?(char)n1-10+'A')":n2);

/*

               0-9 'A'-   - -   -   -'F'

ASCII表現形式：     65 66 67

                     10 11 12

     12 - 10 = 2；

        2 + 'A' = 67;

     char(67);

(獲取4最低四位，&15，獲取最低8位，&255)

*/
- 三元運算符：
(條件表達式)?表達式1：表達式2;

true返回表達式1

false返回表達式2

語句：
程序流程控制：
1. 順序結構：
2. 判斷結構：
3. 選擇結構：
4. 循環結構：
- 判斷結構：
if語句：

如果if控制的語句只有1條，則大括號可以不寫。

若不寫大括號且有幾條語句，則控制離他最近的語句。

三種格式：

     if（條件表達式）{

     }

     if（條件表達式）{

     }

     else{

     }

     if（條件表達式）{

     }

     else if(條件表達式){

     }

     else{

     }

if else簡寫格式：變量 = （條件表達式）？表達式1：表達式2；

三元運算符：

     好處：可以簡化if else代碼

     弊端：因爲是一個運算符，所以運算完必須要有一個結果。

int a = 9, b;

b = (a>1)?100:200;

if(a>1)

   b =100;

else

   b=200;

============================

需求：根據用戶指定月份，打印該月份所屬的季節，

用switch和ifelse的形式。代碼得敲，得熟，知識點得熟。

=============
- 選擇結構：
switch語句：4個關鍵字

格式：

     switch(表達式)

     {

     case 取值1：執行語句；

     break；

     case 取值2:執行語句；

        。。。

     default：

     執行語句；

     break；//可不寫

     }
- 特點：
1選擇的類型只有四種：byte，short，int，char。
2case之間與default沒有順序，先執行第一個case，沒有
匹配的case執行default。
3結束switch語句的兩種情況：遇到break，執行到switch語句結束。
4如果匹配的case或者default沒有對應的break，那麼
程序會繼續向下執行，運行可以執行的語句，直到遇到break或者switch結尾結束。

int a = 3,b = 2;

char ch = '+';

switch(ch)

{

     case '-':

          sop(a-b);

     break;

     case '+':

          sop(a+b);

     break;

     case '*':

          sop(a*b);

     break;

     case '/':

          sop(a/b);

     break;

     default:

          sop("非法輸入");

     break;

}

if和switch語句很像。

具體什麼場景下，應用哪個語句呢？

如果判斷的具體數值不多，而且符合byte，short，int，char這四種類型。

雖然兩個語句都可以使用，但建議使用switch語句，因爲效率稍高。

其他情況：對區間判斷：對結果爲boolean類型判斷，使用if，if的
使用範圍更廣。

switch類型在1.4可以對字符串進行判斷。
而在1.5則可以對枚舉進行選擇。

==============================
- 循環結構：
while do while for
- while語句格式：
while(條件表達式)

{

執行語句;

}

do while語句格式:

do

{

執行語句;

}while(條件表達式);

do while特點是條件無論是否滿足，循環體至少被執行一次
- while語句中：
          定義初始化表達式：
          while(條件表達式)
          {
              循環體（執行語句）；
          }

int x = 1;

while(x<10)

{

     Sop("x"+x);

     x++;

}

do while語句中：

     int x=1;

     do{

          sop("do:x="+x);

          x++;

     }

     while(x<3);
while的特點：先判斷條件，只有條件滿足才執行循環體。
do while的特點：先執行循環體，在判斷條件，條件滿足，
再執行循環體。就是無論條件是否滿足，循環體至少執行一次。
while的後面要麼是{}，要麼是;
- for語句：
for(初始化表達式;循環條件表達式;循環後的操作表達式）

{

     執行語句;

}

for(int x = 0;x<3;x++)

{

     sop("x="+x);

}

//sop（"x============="+x）;

//變量x作用域在for循環的大括號內。

//x在內存生成後就，又隨着for循環的結束而消失。

解析： A:int x = 0;--->在內存中開闢一塊空間

        B:x<3?--->若滿足，

     C:則執行語句。

     D:x++---->x自增

     E:x<3?-->繼續判斷

     F:執行語句

     G：x++--->x繼續自增

     H:x<3?再判斷,不滿足

     I:跳出循環

int y = 0;

while(y<3)

{

     SOP("y="+y);

     y++;

}

sop("y==========="+y);

//y在內存中生成後，再執行while循環，循環結束後，y仍然在內存中。
- 兩者有什麼區別呢？
1，變量有自己的作用域，對於for來講，如果將用於控制循環

增量定義在for語句中。那麼該變量只在for語句內有效。

for語句執行完畢。該變量在內存中被釋放。

2，for和while可以進行互換，如果需要定義循環增量，用for

更爲合適。
- 總結：
什麼時候使用循環結構？
當要對某些語句執行很多次時，就是用循環結構。
- 無限循環的最簡單表達形式：
* for(;;)

* {

* }

*

* while(true)

* {

* }

注意嵌套循環的使用。
- 其他流程控制語句：
break(跳出)，continue(繼續)

break語句：應用範圍：選擇結構和循環結構

continue語句：應用於循環結構。
- 注意：
a.這兩個語句離開應用範圍，沒有存在的意義。

     b.這兩個語句單獨存在，下面都不可以有語句，因爲執行不到。

     c.continue語句是結束本次循環繼續下次循環。

     d.標號的出現，可以讓這兩個語句作用於指定的範圍。
函數
- 函數的定義
- 函數的特點
- 函數的應用
- 函數的重載（特性）overload
- 函數的定義：
1. 什麼是函數？
     函數就是定義在類中的具有特定功能的一段
     獨立小程序。
     函數也稱爲方法。
2. 函數的格式：

     修飾符返回值類型函數名（參數類型形式參數1，參數類型形式參數2）
     {
          執行語句;
          return 返回值;
     }

返回值類型：函數運行後的結果的數據類型。

參數形式：是形式參數的數據類型。

形式參數：是一個變量，用於存儲調用函數時傳遞給函數的實際參數。

return：用於結束函數。

返回值：該值會返回給調用者。
- 函數的特點：
定義函數可以將功能代碼進行封裝

便於對該功能進行復用

函數只有被調用纔會被執行

函數的出現提高了代碼的複用性

對於函數沒有具體返回值的情況，返回值類型用關鍵字void表示，

那麼該函數中的return語句如果在最後一行可以省略不寫

注意：

函數中只能調用函數，不可以在函數內部定義函數。

定義函數時，函數的結果應該返回給調用者，交由調用者處理。
- 如何定義一個函數呢？
1.既然函數是一個獨立的功能，那麼該功能的運算結果是什麼？先明確。

2.在明確在定義該功能的過程中，是否需要未知的內容參與運算？

   可以這麼理解：主函數就是調用函數，來測試這段功能代碼。

例子：

需求：定義一個功能完成3+4的運算，並將結果返回給調用者

          思路：1.明確功能結果是3+4的和，既一個整數的和

          2.在實現該功能的過程中，沒有未知內容參與運算。

         其實這兩個功能就是在明確函數的定義。

          1.明確函數的返回值類型。

          2.明確函數的參數列表。（參數類型，參數個數）

主函數就是調用函數，來測試這段功能代碼。

返回值類型爲void的情況，不能再主函數中輸出，

應爲System.out.println並不明確該函數的返回值類型。
- 函數的重載：overload
重載的概念：

     在同一個類中，允許存在一個以上的同名函數，只要讓他們的參數個數或者參數類型不同即可。

重載的特點：

     與返回值類型無關，只看參數列表。

重載的好處：

     方便於閱讀，優化了程序的設計。

什麼時候用重載？

  當定義的功能相同，但參與運算的未知內容不同。則定義一個函數名稱以表示其功能，方便閱讀。

而通過參數列表的不同來區分多個同名函數。
數組
- 數組的定義
- 數組的內存分配及特點
- 數組操作常見問題
- 數組常見操作
- 數組中的數組
- 數組的定義：
概念：

     同一種類型數據的集合。其實數組就是一個容器。

數組的好處：

     可以自動給數組中的元素從0開始編號，方便操作這些元素。

格式1：

     元素類型[] 數組名 = new 元素類型[元素個數或數組長度];

     示例： int[] arr = new int[5];

格式2：

     元素類型[] 數組名 = new 元素類型[]{元素,元素,元素.....};

     示例：int[] arr = new int[]{3,6,5,7};

           int[] arr = {3,6,5,7};
- 數組的內存分配及特點：
內存結構：

     java程序在運行時，需要在內存中分配空間。爲了提高運算效率，

     又對空間進行了不同區域的劃分，因爲每一片區域都有特定

     的處理數據方式和內存管理方式。

棧內存：

     用於存儲局部變量，當數據使用完，所佔空間會自動釋放。

堆內存：

     數組和對象，通過new建立的實例都存放在堆內存中。

     每一個實體都有內存地址值

     實體中的變量都有默認初始化值

     實體不在被使用，會在不確定的時間內被垃圾回收器回收

方法區，本地方法區，寄存器

數組中的選擇排序：

          1：先拿0角標的元素依次和其他角標比較，若比0角標元素小，則0角標替換成該元素。
               在0角標位置產生了最小值，
          2：再拿1角標的元素依次比較，1角標位置產生最小值。
          3：依次類推。
          （內循環結束一次，最值出現在頭角標位置上）

          數組中的冒泡排序：面試中比較常見。
          1.相鄰的兩個元素進行比較，如果符合條件就換位。第一圈：最值出現在最後位。

          提供了一種排序方式：Arrays.sort(arr);

數組的查找：
拆半查找。如：34；1~200--》猜100.   1~100--》猜50 。。。。。

數組中十進制轉成其他進制：

  Integer.toBinaryString(3)
          Integer.toHexString(60)
          Integer.toOctalString(4)

還有二維數組：

int[][] arr1 = new int[3][4];//二維數組，有3個一維數組，每個一維數組有四個元素。

          int[][] arr2 = new int[3][];

          arr2[0] = new int[3];

          arr2[1] = new int[2];

          arr2[2] = new int[5];



          System.out.println(arr2.length);//打印的是二維數組的長度。

          System.out.println(arr2[0].length);//打印二維數組中第一個一維數組的長度。

另外:

int[] x,y[];//x一維，y二維分解後爲：int[] x; int[] y[];

int[] x; int x[];

int[][] y; int[] y[]; int y[][];

------Java培訓、Android培訓、iOS培訓、.Net培訓、期待與您交流！ -------

黑馬程序員———基礎預備知識

Don't publicly announced personal goals

感興趣的文章和專家

軟件開發常用英語詞彙

網頁設計-----DIV+CSS規則

黑馬程序員———基礎預備知識

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結