java系統化基礎-day01-基礎語法知識

時間 2019-12-13

標籤 java 系統化基礎 day01 day 語法知識欄目 Java 简体版

原文原文鏈接

1.學前必看

　　該課程將系統化的講解java基礎,可是該課程並不適合零基礎的學員,由於在整個java學習體系中咱們是按照實際生產設計,html

主體思路是以完成某個業務爲主線,用到什麼技術就學什麼技術,即帶着問題去學習某個知識,等到把問題解決完後,在系統化的學習該知識點,這樣既能明白學的知識是作什麼的,還能作到真正的實戰教學,而且大大提升了學習的效率;java

那麼當前課程是基於咱們以前的課程基礎上進行系統化深刻的講解,若是你尚未學過以前的課程能夠點擊如先鏈接進行學習.程序員

　　該課程的上一個階段資料:https://www.cnblogs.com/newAndHui/category/1153640.htmlweb

　　學習方法:請先認真看瀏覽博客課件,知道大致要寫什麼內容,而後根據本身的實際狀況,先按照博客上去學習,帶着問題在結合視頻學習,這樣不但能提升本身的學習能力,還能提升學習效率!面試

2.學前預備知識

　　該課程講解過程當中會提到一些實際生產案例,相對來講內容會偏生,需具有能使用java在web頁面上完成基本的CRUD的基礎,學起來效果會更好.數組

3.基本語法　　

　　1.若是一個源文件中什麼內容都沒有，編譯會不會生成字節碼文件？==>不會，編譯的本質就是將程序員寫的代碼轉變爲計算機能認識的二進制文件，若是連類容都沒有就不會編譯，也就不會有字節碼文件。ide

　　2.若是一個類中沒有主方法，編譯運行會怎麼樣？==>編譯能夠經過，但運行報錯：沒有主方法學習

　　什麼是主方法：是一個特殊的方法，是程序的入口，JVM開始執行的地方ui

　　3. 咱們的代碼最小的存在單位是類spa

　　　　1).類主方法（方法）叫結構性的代碼後面是不須要; （分號）

　　　　2).功能執行語句，例如打印語句後面必須加上;（分號）

　　　　3).類中不可以寫功能執行語句，例如打印語句

　　　　4).全部的標點符號都必須是英文狀態下的

　　　　5).Java代碼中是嚴格區分大小寫

　　　　6).字節碼文件的名字和類名一致，建議源文件名字和類名一致

　　　　7). 一個Java源文件中能夠寫多個並列的類，編譯完畢以後會生成多個獨立的字節碼文件
　　　　　　建議：在實際開發中一個java文件中只寫一個類

　　　　8). 一個類可使用public修飾
　　　　　　若是一個類使用public修飾，必須和源文件名字一致，並且咱們通常也只會在一個java文件裏寫一個類，不建議寫多個類。

　　　　　　一個源文件中，至多隻能有一個類能夠被public修飾

4.java註釋　　

　　1.什麼是註釋，有什麼用
　　　　註釋其實能夠當作是備註，主要是寫給（本身）程序員看的，代碼運行的時候是不會管註釋內容的，能夠加強代碼的可讀性。
　　2.如何寫
　　　　1)// 單行註釋，註釋一行(是以行終止符爲準)
　　　　2)/* */ 多行註釋，能夠註釋多行
　　　　　　每一行前面都加* 只是爲了好看
　　　　3)/** */ 文檔註釋，效果很像多行註釋，也能夠註釋多行，特色：能夠經過一個命令javadoc 把文檔註釋中的內容生產文檔
　　　　　　注意：單行註釋和多行註釋不能相互嵌套
　　3.何時寫在什麼地方寫
　　　　寫代碼時候養成寫註釋的習慣－－》　代碼的可讀性加強
　　　　1)思路　　流程　
　　　　2)關鍵代碼
　　　　類的總體描述；　字段　　方法　　構造方法前面都會寫註釋

5.java中的分隔符　

　　分號（;）：語句的分割，表示一句話結束，比如我們使用的句號。
　　花括號（{}）：表示一個代碼塊，是一個總體，花括號要成對使用。
　　方括號（[]）：定義數組和訪問數組元素時使用。
　　圓括號（()）：使用很普遍，具體用到細講。
　　圓點（.）：類和對象訪問它的成員時使用。
　　空格（）：把一整條語句分割成幾段，空格的次數不限制。
　　通常單詞之間一個空格就能夠了
　　注意：必須都是半角下的英文符號。

6.java中關鍵字、保留字、標識符

　　Java關鍵字： Java語言設計之初，被賦予特殊意義的單詞。

　　一般用來程序控制，錯誤處理，基本類型，類,方法和變量修飾符……等等

　　共同點：全部的字母所有小寫

　　保留字：goto const 在java中如今尚未賦予它特殊意義，之後可能會用，預留起來

　　標識符：爲了加強程序的閱讀性而自定義的名稱。好比：類名，方法名，變量名等

標識符的命名規則：

全部的標識符都應該以字母（A-Z或者a-z）,美圓符（$）、或者下劃線（_），數字（不能以數字開頭）開始
關鍵字不能用做標識符
標識符是大小寫敏感的
合法標識符舉例：age、$salary、_value
非法標識符舉例：123abc、-salary

　　書寫建議：

通常來講都是取一些有意義的單詞
類名首字母必須大寫
方法名，變量名首字母小寫
若是是有多個單詞組成，後面每個單詞首字母大寫（駝峯法命名）

　　總結：嚴格按照==》簡單明瞭，駝峯命名法，除了類名首字母大寫，其餘都採用首字母小寫的駝峯命名法

7.java中的數據類型

7.1.基本數據類型（8種）

　　整數類型

　　各個類型之間的取值範圍
　　A.byte(8位，-2^8--2^8-1範圍是-128到127)
　　B.short（16位，-32768—32767）
　　C.int（32位，-2147483648—2147483647）
　　D.long (64位，-9223372036854775808—9223372036854775807)

　　注意：給long賦值時，由於整數默認是int類型，要轉換爲long類型的值，後面加上l或L
　　上面的byte short int long 最大長度能夠經過jdk文檔去找到具體的範圍。

　　同一個整數可使用不一樣的進製表示：
　　默認的進制10進制
　　二進制：是 0b 或者 0B開頭
　　八進制：是0開頭
　　十六進制： 0X (0x) 開頭

　　浮點型(小數型)

　　A. float(單精度32位) 直接賦值時必須在數字後加上f 或F
　　B. double( 雙精度64位)

　　區別：
　　對於單精度浮點數，運行速度相比double更快，佔內存更小，可是當數值很是大或者很是小的時候會變得不精確。
　　雙精度比單精度表示的位數大精確的位數多,簡單地說, float表示的小數點位數少。
　　默認浮點數的類型是 double

　　表現形式：
　　1.常規 3.14
　　2.科學計數法

　　注意：
　　表示float 類型必須加上f 或者F

　　float double 不能精確表示一個小數，例如 1.3*1.4

　　例如 double num= 1.0, 是一個無限接近1.0的一個值

　　那怎麼更精確的表示浮點數呢？BigDecimal

　　結論：浮點運算不多是精確的，只要是超過精度能表示的範圍就會產生偏差。

　　每每產生偏差不是由於數的大小，而是由於數的精度。

　　所以，產生的結果接近但不等於想要的結果。尤爲在使用 float 和 double 做精確運算的時候要特別當心。

　　字符
　　A:char 16 位[0-65535] (2個字節,16位) 。字符常量使用單引號 ‘’包裹起來。
　　表現形式：
　　1.‘A’最經常使用，最直觀的方式
　　2.使用一個數字表示，對應有一個ASCII碼錶
　　例如:char c = 65;//表示 ’A’ 這個字符
　　能夠當成一個整數來使用，什麼是asscii表，就像化學元素週期表

　　3. 16進製表現形式

　　具體的能夠參看表：ASCII表

　　4. 字符與ASCII碼的相互轉換

 /**
     * ASCII 與字符的相互轉換
     */
    @Test
    public void test5() {
        char c = '愛';
        System.out.println("c=" + c);
        //將字符 ==》 ASCII碼（十進制的數字）
        int i = (int) c;
        System.out.println(" i=" + i);
        //將一個十進制的數字 ==》 字符
        char c2 = (char) i;
        System.out.println("c2=" + c2);
    }

　　布爾類型
　　值只有兩個 true false，不能使用 0 1表示

　　具體的基本類型案例代碼以下：

 1 package com.wfd360.com;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * <p>
 7  * 1.數據類型概述
 8  * 123,3.14
 9  * 在java中不一樣類型的數據有不一樣的數據類型，看看下面的數據類型的分類：
10  * 分類：
11  * 1、基本數據類型 8 種 java預約義的類型(原生數據類型)
12  * 1.整數類型 *4 123
13  * byte 1個字節8位
14  * short 2字節16位
15  * int 4字節32位
16  * long 8字節64位
17  * <p>
18  * 2.小數類型(浮點類型) *2 3.14
19  * float 單精度 4字節32位
20  * double 雙精度 8字節64位
21  * 3.字符類型 *1
22  * char 2字節16位 ‘A’,’B’
23  * 4.布爾類型*1
24  * boolean 倆值 true ,false
25  */
26 public class DataType {
27     /**
28      * 整數類型 4種
29      */
30     @Test
31     public void test1() {
32         //byte 1個字節8位
33         byte b = 6;
34         //short 2字節16位
35         short s = 6;
36         //int 4字節32位 (常用)
37         int i = 6;
38         //long 8字節64位 （一般在取時間毫秒時使用）
39         long l = 6;
40         String format = String.format("b=%s,s=%s,i=%s,l=%s", b, s, i, l);
41         System.out.println(" format=" + format);
42     }
43 
44     /**
45      * 小數類型 2種
46      */
47     @Test
48     public void test2() {
49         // float 單精度 4字節32位,後面必須帶f,大寫也能夠，建議使用小寫
50         float f = 3.14f; //推薦寫法
51         float f2 = 3.14F;
52         // double 雙精度 8字節64位  (常用)
53         double d = 3.14; //推薦寫法  
54         double d2 = 3.14d;
55         double d3 = 3.14D;
56         String format = String.format("f=%s,f2=%s,d=%s,d2=%s,d3=%s", f, f2, d, d2, d3);
57         System.out.println(" format=" + format);
58     }
59 
60     /**
61      * 字符類型 1種
62      */
63     @Test
64     public void test3() {
65         //char 2字節16位 ,例如：‘A’,’B’，注意使用的是單引號，通常不使用，通常使用String類型代替
66         char c = 'A';
67         System.out.println("c=" + c);
68     }
69 
70     /**
71      * 布爾類型 1 種
72      */
73     @Test
74     public void test4() {
75         // boolean 倆值 true ,false
76         boolean b = true;
77         boolean b2 = false;
78         System.out.println("b=" + b + ",b1=" + b2);
79     }
80 }

View Code

7.2.引用數據類型

　　類，數組，接口，枚舉……

 /**
     * 　String類：
     * 　String是 java中已經設計好的一個類，表示的值是字符串（Java中設計的類和咱們本身設計的類的性質是同樣的）
     */
    @Test
    public void test6() {
        String str = "愛老虎油！";
        System.out.println("str=" + str);
    }

7.3.進制（瞭解）　

　　1) 2進制（逢2進1）

　　　　其中的符號能夠是 0 1 110等於10進制的2 第一位1 ==2*’1‘ 2*2 第二位1==2

　　2) 8進制（逢8進1）

　　　　其中的符號能夠是0 1 2 3 4 5 6 7 10等於10進制的8

　　3) 10進制（逢10進1）

　　　　其中的符號能夠是 0 1 2 3 4 5 6 7 8 9 10

　　4) 16進制（逢16進1）

　　　　其中的符號能夠是0 1 2 3 4 5 6 7 8 9 A B C D E F 11等於10進制的17

平時咱們在平常生活中使用的是10進制，計算機底層中大都使用的 2進制，每一種進制之間是能夠相互轉化的，

　　具體轉化，你們能夠參考度娘：進制轉化百度百科

9.數據類型轉換（很是重要）

　　常常出面試題

　　小數默認爲double類型，整數默認爲int類型!
　　在Java中，boolean類型與全部其餘7種類型都不能進行轉換。
　　下面這7種數據類型，它們之間均可以進行轉換，可是可能會存在精度損失或者其餘一些變化：
　　byte --> short ，char --> int --> long --> float --> double

　　若是從小轉換到大，（除了byte不能自動轉換char ，以及char不能自動轉換short）能夠自動完成轉換。而從大到小，必須強制轉換(強制轉換前必須知道被轉換的值在要轉換的類型範圍內)。
　　規律：有包含關係的能夠由低精度賦值給高精度。
　　爲何float 在long 後面？
　　小數(浮點數) 的存儲方式，結構和整數不同

　　案例代碼：

  1  /**
  2      * 類型轉換：自動轉換
  3      */
  4     @Test
  5     public void test7() {
  6         byte b = 65;
  7         //byte自動轉變爲 short
  8         short bs = b;
  9         //short 自動轉變爲 int
 10         int bsi = bs;
 11         //int 自動轉變 long
 12         long bsil = bsi;
 13         //long 自動轉變爲 float
 14         float bsilf = bsil;
 15         //float 自動轉變爲 double
 16         double bsilfd = bsilf;
 17         System.out.println("bsilfd=" + bsilfd);
 18         //也能夠越級 自動轉換，好比：byte 自動 轉換爲 double
 19         double bd = b;
 20         System.out.println("bd=" + bd);
 21     }
 22 
 23     /**
 24      * 類型轉換：強制轉換
 25      */
 26     @Test
 27     public void test8() {
 28         double d = 3.1415926978568412;
 29         //double 強制轉變爲 float
 30         float df = (float) d;
 31         //float 強制轉變爲 long
 32         long dfl = (long) df;
 33         //long 強制轉變爲 int
 34         int dfli = (int) dfl;
 35         //int 強制轉變爲 short
 36         short dflis = (short) dfli;
 37         //short 強制轉變爲 byte
 38         byte dflisb = (byte) dflis;
 39         System.out.println("dflisb=" + dflisb);
 40         //也能夠越級 強制轉換，好比：double 強制 轉換爲 byte
 41         byte db = (byte) d;
 42         System.out.println("db=" + db);
 43     }
 44 
 45     /**
 46      * 運算中自動轉型：在類型不一致的運算中最終會 獲得一個最大的類型
 47      */
 48     @Test
 49     public void test9() {
 50         int num = 10;
 51         double b = 10.01;
 52         double c = num + b;
 53         // 這樣會報錯，由於最後運算完成的類型是double，不能自動轉變爲int
 54         // int  c2 = num + b;
 55         System.out.println(c);
 56     }
 57 
 58     /**
 59      * byte  --> short ，char  --> int  -->   long -->    float  -->    double
 60      * <p>
 61      * char類型向更高長度類型（例如整型）轉換時，會轉換爲對應的ASCII碼值，再作其餘類型的自動轉換
 62      * <p>
 63      * char 不能和byte short 相互自動轉換,應爲取值範圍問題，簡單的能夠這樣理解，char是沒有負數的，而其是有負數的
 64      */
 65     @Test
 66     public void test10() {
 67         char c = 'A'; // 65
 68         int num = 10;
 69         int a = c + num;
 70         System.out.println(a);
 71         //=======================
 72         byte b = 65;
 73         //byte不能自動轉變爲 char
 74         // char bc=b;
 75         //可是，byte是能夠強制轉變爲char的
 76         char bc = (char) b;
 77         System.out.println(" bc=" + bc);
 78         //=======================
 79         char c2 = 'A';// 65
 80         // char 不能自動轉變爲 short
 81         // short c2s=c2;
 82         //可是，char是能夠強制轉變爲short的
 83         short c2s = (short) c2;
 84         System.out.println(" c2s=" + c2s);
 85     }
 86 
 87     /**
 88      * 特例
 89      * byte  b  =  65;//能夠自動轉換
 90      * int  k =65;
 91      * byte b2 =k;//不能轉換，報錯
 92      * 咱們是把一個常量直接賦值給byte變量，因爲編譯器能識別100，知道在byte範圍以內，因此經過編譯。
 93      * byte b2 =k; 在編譯時候，k是int型，但它是一個變量，編譯器不能知道變量中值是多少，因此不能隱式轉換，提示你可能精度損失。
 94      */
 95     @Test
 96     public void test11() {
 97         byte b = 65;//能夠自動轉換
 98         int k = 65;
 99         //byte b2 = k;//不能轉換，報錯
100     }
101 
102     /**
103      * 特例：瞭解
104      * 將一個負數強制轉變爲 char,在將這個char轉變爲整數，會是什麼狀況？
105      */
106     @Test
107     public void test12() {
108         int i = -65;
109         char c = (char) i;
110         System.out.println("c=" + c);
111 
112         int i2 = c;
113         System.out.println("i2=" + i2);
114 
115         char c2 = (char) i2;
116         System.out.println("c2=" + c2);
117 
118     }
119 
120     /**
121      * 特例瞭解
122      * System.out.println((int) (char) (byte) -1);
123      * 它以int數值-1開始，而後從int轉型爲byte，以後轉型爲char，最後轉型回int。
124      * 第一個轉型將數值從32位窄化到了8位，第二個轉型將數值從8位拓寬到了16位，最後一個轉型又將數值從16位拓寬回了32位。
125      * 這個數值最終是回到了起點嗎？若是你運行該程序，你就會發現不是。它打印出來的是65535，可是這是爲何呢？
126      * <p>
127      * 該程序的行爲緊密依賴於轉型的符號擴展行爲。
128      * Java使用了基於2的補碼的二進制運算，所以int類型的數值-1的全部32位都是置位的。
129      * 從int到byte的轉型是很簡單的，它執行了一個窄化原始類型轉化（narrowing primitive conversion），直接將除低8位以外的全部位所有砍掉。
130      * 這樣作留下的是一個8位都被置位了的byte，它仍舊錶示-1。
131      * <p>
132      * 從byte到char的轉型稍微麻煩一點，由於byte是一個有符號類型，而char是一個無符號類型。
133      * 在將一個整數類型轉換成另外一個寬度更寬的整數類型時，一般是能夠保持其數值的，可是卻不可能將一個負的byte數值表示成一個char。
134      * 所以，從byte到char的轉換被認爲不是一個拓寬原始類型的轉換，而是一個拓寬並窄化原始類型的轉換（widening and narrowing primitive conversion）：byte被轉換成了int，而這個int又被轉換成了char。
135      * <p>
136      * 全部這些聽起來有點複雜，幸運的是，有一條很簡單的規則可以描述從較窄的整型轉換成較寬的整型時的符號擴展行爲：
137      * 若是最初的數值類型是有符號的，那麼就執行符號擴展；若是它是char，那麼無論它將要被轉換成什麼類型，都執行零擴展。
138      * 瞭解這條規則可使咱們很容易地解決這個謎題。
139      * <p>
140      * 由於byte是一個有符號的類型，因此在將byte數值-1轉換成char時，會發生符號擴展。
141      * 做爲結果的char數值的16個位就都被置位了，所以它等於2*E16-1，即65535。
142      * 從char到int的轉型也是一個拓寬原始類型轉換，因此這條規則告訴咱們，它將執行零擴展而不是符號擴展。
143      * 做爲結果的int數值也就成了65535，這正是程序打印出的結果。
144      */
145     @Test
146     public void test13() {
147         //=======瞭解==============
148         System.out.println((int) (char) (byte) -0);
149         System.out.println((int) (char) (byte) -1);
150         System.out.println((int) (char) (byte) -2);
151         System.out.println((int) (char) (byte) -3);
152         System.out.println((int) (char) (byte) -4);
153         System.out.println((int) (char) (byte) -5);
154         System.out.println((int) (char) (byte) -6);
155     }
156 
157     /**
158      * 數據類型過長 和 溢出
159      * <p>
160      * 生產上大的數據運算必定要注意
161      */
162     @Test
163     public void test14() {
164         byte b = 127;
165         // byte b1=128;// 錯誤超出範圍  -128 到 127
166 
167         //===============================
168         //獲取當前時間 毫秒
169         long time = System.currentTimeMillis();
170         System.out.println("time=" + time);
171         int i = (int) time;
172         System.out.println("i=" + i);
173 
174         //==============================
175         int a = 129;
176         byte b2 = (byte) a;
177         System.out.println("b2=" + b2); // 結果爲  -127
178     }

View Code

10.java中的常量

　　Java中的常量，常量就是一個固定不變的量（或者值）。例如 123,45,1.2，false等。
　　常見的分類
　　① 整數常量例如：123 ，250,666
　　② 小數常量例如：1.2,3.14
　　③ 字符串常量例如：」12345」
　　④ 字符常量例如： ‘2’,‘B’
　　⑤ 布爾常量例如：true ,false

11.java中的變量　

　　1.變量是什麼
　　很好理解，從小咱們學的數學，x=2,x就是一個變量

　　2.變量的語法

    /**
     * 語法格式： 數據類型 變量名；
     * 注意： 此處的數據類型能夠是Java中支持的全部的數據類型，包括本身定義的類型！
     */
    @Test
    public void test1() {
        //先聲明再賦值
        int x;
        x = 2;
        //聲明的時候同時賦值
        int y = 2;
        //能夠重複賦值
        y = 20;
        //使用變量
        int z = x + y;
        System.out.println("z=" + z);
    }

　　3.變量分類
　　1)成員變量
　　直接聲明在類中的變量；

　　2)局部變量
　　直接聲明在方法內部,好比main方法的形參或者大括號中

　　做用域範圍：
　　聲明在局部區域，例如方法裏面大括號的範圍內
　　局部變量必須放在使用的功能語句前面；

　　3)區別
　　a)局部變量在使用以前必須得有值，試想一下一個空變量盒子你用啥呢？
　　b)成員變量系統會分配默認值（默認值意義不大）
　　c)做用域範圍不一樣

　　4)問題
　　同一個做用域範圍以內能不可以有兩個名字同樣的變量，爲何？
　　

　　5)案例代碼

package com.wfd360.com;


import org.junit.Test;

public class Demo {
    //成員變量
    int age = 20;
    //成員變量系統會分配默認值（默認值意義不大），不賦值也可以使用
    int age2;

    @Test
    public void test2() {
        //局部變量
        int age = 28;
        String name = "無忌";
        //==============
        int age3;
        //局部變量在使用以前必須得有值,不然報錯
        //System.out.println("age3="+age3);
        // age2 爲成員變量不賦值也可使用
        System.out.println("age2=" + age2);
    }

    /**
     * 練習
     * 交換2個變量裏面的數據，例如 變量 a= 3;b=5; 交換後則變成：a=5,b=3;
     */
    @Test
    public void test3() {
        int a = 3;
        int b = 5;
        int c = a;
        a = b;
        b = c;
        System.out.println("a=" + a);
        System.out.println("b=" + b);

    }

    /**
     * 語法格式： 數據類型 變量名；
     * 注意： 此處的數據類型能夠是Java中支持的全部的數據類型，包括本身定義的類型！
     */
    @Test
    public void test1() {
        //先聲明再賦值
        int x;
        x = 2;
        //聲明的時候同時賦值
        int y = 2;
        //能夠重複賦值
        y = 20;
        //使用變量
        int z = x + y;
        System.out.println("z=" + z);
    }
}

View Code

12.java中的表達式

 1  /**
 2      * 表達式：
 3      * 由一系列的 常量  變量  運算符，括號()組成的一個算式，爲了按照必定的運算規則計算出結果值
 4      * 例如： 3+2-5
 5      */
 6     @Test
 7     public void test4() {
 8         int a = 3;
 9         int b = 2;
10         int c = 5;
11         int d = a + b - c;
12         System.out.println("d=" + d);
13     }