day01_Java基礎

一、今日課程內容

• 1- Java語言概述（了解）
• 2- Java環境搭建（操作）
• 3- Java的入門案例（熟悉）
• 4- Java的基礎語法（掌握）
• 5- 鍵盤錄入操作（熟悉）
• 6- 流程控制（掌握）

二、Java語言概述（了解）

1、Java語言概述

? 計算機高級語言按照程序執行方式分為解釋型語言和編譯型語言兩種。之前我們學的Python就屬于解釋型語言，Java等屬于編譯型語言。

? 解釋型語言是指使用專門的解釋器對源程序逐行解釋成特定平臺的機器碼并立即執行的語言。

? 編譯型語言是指使用專門的編譯器，針對特定平臺（操作系統）將某種高級語言源代碼一次性“翻譯”成可被該平臺硬件執行的機器碼（機器指令和操作數），并包裝成該平臺所能識別的可執行性程序的格式，這個轉換過程成為編譯。

? Sun公司(Stanford University NetWork): 美國的斯坦福大學)在1995年推出的高級編程語言.

? Java之父: 詹姆斯·高斯林(James Gosling)

? sun公司在2009年被Oracle公司收購了

**
**

2、為什么要學習Java語言

• 使用非常廣泛, 相對簡單易學
• 能夠看得懂大數據框架的源碼, 因為大數據中很多框架都是基于Java語言開發的
• 為后續Flink課程打基礎

3、Java平臺版本說明

• J2SE：標準版，也就是其他兩個版本的基礎，在JDK1.5的時候，正式更名為 JavaSE
• J2ME：小型版，一般是用于研發嵌入式程序，已經被android替代了，在JDK1.5更為為 JavaME
• J2EE：企業版，一般開發企業級互聯網程序，在JDK1.5的時候正式更為為 JavaEE（SpringBoot、SpringCloud、MyBatis。。。）

4、Java特點

• 1- 開源：JAVA源代碼是開放的
• 2- 跨平臺：
  • 用Java編寫的程序，可以在不同的操作系統上運行
  • 原理：由JVM保證Java程序的跨平臺性，但是JVM本生并不能跨平臺
• 3- 多線程
• 4- 面向對象：繼承 多態 接口

三、Java環境搭建（操作）

1、JDK和JRE的概述

• JDK：Java開發工具包(Java Development Kit), 包含開發工具 和 JRE.

  • 常用的開發工具: javac, java

• JRE：Java運行時環境(Java Runtime Environment), 包含運行Java程序時所需的核心類庫和 JVM.

  • 核心類庫: java.lang, java.util, java.io

• JVM：Java虛擬機(Java Virtual Machine)

  • 作用: 用來保證Java程序跨平臺性的, 但是JVM本身并不能跨平臺.

  

JRE與JDK區別圖解

2、JDK的下載和安裝

• 1- 下載JDK:

  • Oracle官網地址: www.oracle.com
  • 直接下載JDK地址: https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html

• 2- 執行安裝操作

  • 2.1 傻瓜式安裝即可, 一步一步下一步即可安裝成功
  • 2.2 安裝路徑:
    • 不要安裝到C盤, 不要用中文空格
  • 2.3 目錄說明
    • bin: 存放的是編譯器和工具
    • db: 存數數據
    • include: 編譯本地方法.
    • jre: Java運行時文件
    • lib: 存放類庫文件
    • src.zip: 存放源代碼的.

• 3- JDK卸載: 可直接在控制面板中卸載即可

• 4- 配置環境變量:

  

配置后, 一路點擊確定退出即可

• 5- 測試操作:
  • 方式一: 在DOS窗口中輸入"javac 或者 java", 能看到對應的指令即可.
  • 方式二: 在DOS窗口中輸入"java -version", 可以看到當前配置的JDK的版本

3、IDEA的安裝

? IDEA 全稱 IntelliJ IDEA，是Java編程語言開發的集成環境。IntelliJ在業界被公認為最好的java開發工具，尤其在智能代碼助手、代碼自動提示、重構、J2EE支持、各類版本工具(git、svn等)、JUnit、CVS整合、代碼分析、 創新的GUI設計等方面的功能可以說是超常的。

? IDEA是JetBrains公司的產品，這家公司總部位于捷克共和國的首都布拉格，開發人員以嚴謹著稱的東歐程序員為主。它的旗艦版本還支持HTML，CSS，PHP，MySQL，Python等。免費版只支持Python等少數語言。

總結: IDEA這個軟件是用Java語言開發的, 所以想使用IDEA, 你電腦上必須安裝JRE.

jetbrains公司官網地址: www.jetbrains.com

IDEA下載地址: www.jetbrains.com/idea/download/other.html

安裝步驟:

4、IDEA的啟動

• 1- 不導入任何配置, 選擇Do not import settings, 然后選擇OK.
  

• 2- 設置用戶界面主題, 可以根據自己的喜好進行設置, 然后選擇Next: Default plugins

• 3- 這個界面是告訴我們, 當前的IDEA可以開發哪些程序, 默認這些模塊都是選中的, 如果明確知道不需要使用某些模塊, 可以通過Disable All禁用掉此模塊. 這里我們不需要禁用, 直接選擇Next: Featured plugins即可.
  

• 4- 這個界面是JetBrains公司提供給我們的可選擇性安裝的5個小插件, 我們可以根據需求進行選擇, 這里建議安裝最后一個插件IDE Features Trainer, 它可以幫助我們快速使用IDEA. 然后選擇Start using IntelliJ IDEA即可.
  

• 5- 因為IDEA的旗艦版是收費的, 這里我們選擇Evaluate for free(免費試用30天)
  

四、Java入門案例（熟悉）

1、創建項目和模塊

或者:

如果有以下界面, 可以參考:

第一次進入項目, 會彈出以下內容:

2、編寫代碼

• 1- 在src源代碼包下創建自定義包 com.itheima.demo01
  
  

• 2- 在com.itheima.demo01包下創建HelloWorld類.
  
  

• 3- 編寫代碼

package com.itheima.day01;public class HelloWorld {/*main方法，程序的入口快捷鍵：輸入main，等有下拉框的提升，然后按回車即可*/public static void main(String[] args) {// 快捷鍵：輸入sout，等有下拉框的提升，然后按回車即可System.out.println("Hello Java");}
}

• 4- 運行代碼: 然后在代碼編輯區右鍵, 選擇Run HelloWorld.main(), 執行程序即可.

目錄說明:

3、IDEA常見的快捷鍵

五、（重要）Java基礎語法（掌握）

1、注釋

注釋常見分類為三種：分別是單行注釋、多行注釋、文檔注釋

//單行注釋/*多行注釋多行注釋
*//**文檔注釋文檔注釋
*/文檔注釋的作用: 對代碼進行解釋用的，例如方法的作用是什么，需要傳遞什么樣的參數

package com.itheima.day01;public class HelloWorld {/*main方法，程序的入口快捷鍵：輸入main，等有下拉框的提升，然后按回車即可*/public static void main(String[] args) {// 快捷鍵：輸入sout，等有下拉框的提升，然后按回車即可System.out.println("Hello Java");// 單行注釋System.out.println("單行注釋代碼");/*多行注釋注釋1注釋2....*/System.out.println(myAdd(1, 2));}/*** 實現對兩個數據相加的操作* @param num1 數字1* @param num2 數字2* @return 求和的結果*/public static int myAdd(int num1, int num2){return num1+num2;}
}

2、分隔符

Java 語言里的分號(😉 花括號（{}）、方括號（[]）、圓括號（()）、 圓點（.）都具有特殊的分割作用，被統稱為分隔符。

• 分號（;） 是Java語言分隔語句的，每個 Java 語句都是使用分號作為結尾。

• 花括號（{}）作用是定義了一個代碼塊，一個代碼塊指的是”{” 和 “}” 所包含的代碼片段，代碼塊邏輯上是一個整體，花括號是成對出現的。

• 方括號（[]）作用是用于訪問數組元素，方括號通常跟著數組變量名；

• 圓括號（()) 功能較多，定義方法使用圓括號來包含參數聲明；調用方法傳遞實參值；圓括號可以作為強制類型轉換運算符等；

• 圓點（.）作用類/對象和它的成員（包含成員變量、方法和內部類）之間的分隔符，表明調用某個類或某個實例的指定成員。

3、Java關鍵詞

就是被Java語言賦予了特殊含義的單詞

特點:

?關鍵字是由純英文字母組成的, 而且全部都是小寫的.
?常用的開發工具(Notepad++, IDEA)針對于關鍵字都會高亮顯示.

常見的關鍵詞:

? public: 公共的權限, 目前先了解即可.

? class: 表示在創建一個類.

? static: 表示靜態的意思.

? void: 表示方法的返回值類型.

其他關鍵詞:

4、標識符

標識符就是用來給類、接口、方法、變量、包等起名字的規則

命名規則:

1.標識符只能包含52個英文字母(區分大小寫)、0 ~ 9數字 、$（美元符號）和_（下劃線）。  
2.標識符不能以數字開頭。
3.標識符不能和Java中的關鍵字重名。
4.最好做到見名知意.例如: name表示姓名, age表示年齡.

命名規范:

1.類, 接口的命名規范: 每個單詞的首字母都大寫, 其他字母全部小寫(大駝峰命名法)例如: HelloWorld, VariableDemo.
2.變量, 方法的命名規范: 從第二個單詞開始, 每個單詞的首字母都大寫, 其他字母全部小寫(小駝峰命名法).例如: zhangSanAge, studentName
3.常量(指的是: 自定義常量)的命名規范: 所有字母都大寫, 單詞之間用_(下劃線)隔開.例如: MAX_VALUE, MIN_VALUE, PI   注意: 目前先了解即可, 面向對象部分詳細解釋.
4.包的命名規范: 所有字母全部小寫, 多級包之間用.(點符號)隔開, 一般是公司的域名反寫.例如: cn.itcast、com.itheima

5、變量

在程序的執行過程中，其值可以在某個范圍內發生改變的量就叫變量

Java中要求一個變量每次只能保存一個數據，而且必須要明確保存數據的數據類型

格式:

方式一: 聲明變量并賦值
數據類型 變量名 = 初始化值;//示例: 聲明(定義)一個int類型的變量, 變量名叫a, 初始化值為: 10
int a = 10;方式二: 先聲明, 后賦值
數據類型 變量名;
變量名 = 初始化值;//示例
//1. 聲明(定義)一個int類型的變量, 變量名叫a
int a;						
//2. 把數字10賦值給變量a	  
a = 10;						

示例:

package com.itheima.day01;public class HelloWorld {/*main方法，程序的入口快捷鍵：輸入main，等有下拉框的提升，然后按回車即可*/public static void main(String[] args) {// 變量的定義String eatFood;String statue = "今天沒有上火";if(statue=="今天上火了"){eatFood = "吃清淡的";}else{eatFood = "吃海底撈火鍋";}System.out.println(eatFood);}
}

6、數據類型說明

Java是一種強類型語言, 針對于每一個數據都給出了明確的數據類型

• 基本數據類型(簡稱: 基本類型)

? byte, short, char, int, long, float, double, boolean

• 引用數據類型(簡稱: 引用類型)

? String, 數組, 類, 接口

圖解:

基本類型占用字節大小以及取值范圍:

注意事項:

1.變量未賦值，不能使用.
2.變量只在它所屬的范圍內有效.
3.一行上可以定義多個變量，但是不建議.
4.char類型的注意事項4.1- 值只能用單引號包起來4.2- 值的內容只能有一個字符

package cn.itcast.base;public class ArgDemo {public static void main(String[] args) {// 1-變量的定義方式一：聲明變量并且賦值int argA = 10;System.out.println(argA);// 2-變量的定義方式二：先聲明變量，再賦值double argB;if(argA>=10){argB = 10.1;}else{argB = 9.0;}System.out.println(argB);//        1.變量未賦值，不能使用.
//        int c;
//        System.out.println(c);//        2.變量只在它所屬的范圍內有效.if(argA>=10){int d = 2;System.out.println(d);}//        System.out.println(d);//        3.一行上可以定義多個變量，但是不建議.int e=10,f=11;System.out.println(e);System.out.println(f);}
}

7、數據類型轉換

? 不同類型的數據之間可能會進行運算，而這些數據取值范圍不同，存儲方式不同，直接進行運算可能會造成數據損失，所以需要將一種類型轉換成另外一種類型再進行運算。

注: Java程序中要求參與計算的數據，必須保證數據類型的一致性，如果數據類型不一致將發生類型轉換。

類型轉換主要有二類: 自動（隱式）類型轉換 和 強制（顯式）類型轉換

7.1 自動(隱式)類型轉換

指的是小類型轉大類型，會自動提升為大類型，運算結果是大類型.

大白話翻譯: 將取值范圍小的類型自動提升為取值范圍大的類型

例如:

1.定義兩個int類型的變量a和b, 分別賦值為10, 20.
int a=10,b=20;2.通過輸出語句打印變量a和b的和.
System.out.println(a+" "+b);3.定義int類型的變量c, 接收變量a和b的和. 
int c=a+b;4.打印變量c的值.
System.out.println(c);5.定義兩個變量aa和bb, 一個是int類型的數據, 另一個是byte類型的數據.
int aa=1;
byte bb=2;6.定義變量cc接收 變量aa和bb的和。分別設置變量cc的數據類型為byte類型和int類型, 觀察結果并打印.
int cc1 = aa+bb;
System.out.println(cc1);byte cc2 = aa+bb;
System.out.println(cc2);

演示案例:

public class Demo02_類型轉換 {// 演示 類型轉換:  自動(隱式)類型轉換   強制類型轉換public static void main(String[] args) {// 自動(隱式)類型轉換byte a = 10;short b = 15;char c = 20;int d = 13;long e = 50L;float f = 3.5F;double g = 5.5;int v1 = a + b;int v2 = a + c;int v3 = b + c;int v4 = a + d;int v5 = b + d;long v6 = c + e;long v7 = d + e;float v8 = e + f;double v9 = e + g;double v10 = f + g;System.out.println(v1);System.out.println(v2);System.out.println(v3);System.out.println(v4);System.out.println(v5);System.out.println(v6);System.out.println(v7);System.out.println(v8);System.out.println(v9);System.out.println(v10);}
}

轉換規則:

1.范圍小的類型向范圍大的類型提升，byte、short、char 運算時直接提升為int 。
2.boolean類型的數據只有true和false這兩個, 所以boolean類型的數據不參與類型轉換.即: byte、short、char --> int --> long --> float --> double

7.2 強制(顯式)類型轉換

指的是手動將大類型轉換成小類型，運算結果是小類型.

大白話翻譯: 將取值范圍大的類型強制轉換成取值范圍小的類型.

注意: 在進行大類型轉換為小類型的時候, 可能出現數據丟失, 甚至直接報錯(可能超過了小類型的范圍大小)

格式:

數據類型 變量名 = （數據類型）要被轉換的數據值；

示例: 嘗試把小數1.5賦值給int類型的變量a, 并打印結果.

public class NarrowConversion{private static String main(String[] args) {int iValue =232;//強制把一個 int 類型的值轉換成 byte 類型的值byte bValue=(byte)iValue;// 將輸出-23System.out.println(bValue);double dValue=3.98;// 強制把一個 double 類型的值轉換成 int 類型的值int tol = (int)dValue;// 將輸出 3System.out.println(tol);}
}

案例演示:

package com.itheima;public class Demo02_類型轉換 {// 演示 類型轉換:  自動(隱式)類型轉換   強制類型轉換public static void main(String[] args) {byte a = 10;short b = 15;char c = 20;int d = 13;long e = 50L;float f = 3.5F;double g = 5.5;// 強制類型轉換byte q1 = (byte)(a + d);System.out.println(q1);short q2 = (short) (a + b);System.out.println(q2);long q3 = (long) (e + f);System.out.println(q3);byte q4 = (byte) (e +a);System.out.println(q4);}
}注意: 將小數強轉成整數的時候，會直接將小數位數全部丟棄

8、了解ASCII碼表

https://www.zhihu.com/tardis/bd/art/388458283?source_id=1001

觀察下述代碼, 打印結果是多少呢?

public static void main(String[] args) {//字符類型變量char c = 'a';int i = 1;//字符類型和int類型計算System.out.println(c+i);
}

在計算機的內部都是二進制的0, 1數據，如何讓計算機可以直接識別人類文字呢？

于是就產生出了編碼表的概念。

• 編碼表：就是將人類的文字和一個十進制數進行對應起來組成一張表格。 ‘a’ -> 97 char:0-65535

• 存儲字符時：需要查找ASCII碼表,找到字符對應的數字,將數字轉換為二進制數存放到計算機中

• 使用字符時：將對應的二進制數轉換為十進制 找到ASCII表中對應的字符 顯示出來

• 將所有的英文字母，數字，符號都和十進制進行了對應，因此產生了世界上第一張編碼表ASCII碼表.

• ASCII（American Standard Code for Information Interchange 美國標準信息交換碼）, 規則如下:

字符	數值
‘0’	48
‘9’	57
A	65
Z	90
a	97
z	122

注意：

在char類型和int類型計算的過程中，char類型的字符先查詢編碼表，得到97，再和1求和，結果為98。

char類型提升為了int類型。char類型內存2個字節，int類型內存4個字節。

package com.itheima;public class Test03_ASCII碼 {public static void main(String[] args) {// 注意 ASCII碼 主要針對char類型的數據char c1 = 'A';System.out.println(c1 + 10); // 75  說明  'A' = 65char c2 = 'a';System.out.println(c2 + 10); // 107 說明 'a' = 97char c3 = 'b';System.out.println(c3 + 10); // 108 說明 'b' = 98char c4 = '0';System.out.println(c4 + 10); // 58 說明 '0' = 48// 注意: 其實看到的這些數值 對應的就是ASCII碼表中對應字符的十進制的表示內容}
}

9、運算符

9.1 分類

• 算術運算符

+, -, *, /, %, ++, --

• 賦值運算符

 =, +=, -=, *=, /=, %=

• 比較(關系)運算符

==, !=, >, >=, <, <=

• 邏輯運算符

&&, ||, !

• 三元(三目)運算符

注意: Java中的運算符絕大多數和Python中的運算符用法都一樣, 只有個別運算符的用法不同, 我們主要是學習這些用法不同運算符.

package com.itheima;public class Test04_運算符 {public static void main(String[] args) {System.out.println("演示一: 算術運算符  ++ --");// 1. 構建一個int類型的變量int a = 10;System.out.println(a++); //  10System.out.println(a); //    11int b = 10;System.out.println(++b); // 11System.out.println(b); //  11/*說明: ++  -- 是用于對數據進行 +1 或者 -1的操作在使用的時候, 都可以在變量的前面和后面設置: a++ 或者  ++a區別:a++: 先讓 a 參與運算, 運算后執行 +1操作++a: 先執行a +1的操作, 然后基于+1后結果參與運算*/System.out.println("演示二: 邏輯運算符 && ||  ! ");// 格式://      boolean flag =  條件1  [&&  ||] 條件2  [&&  ||] 條件3 ...//      !條件1      用于取反操作int c = 10;int d = 15;int e = 25;boolean flag = c > d && c > e;  // 當兩個條件都不成立的時候, 結果為FalseSystem.out.println(flag);flag = c < d && c > e;System.out.println(flag); // 當其中一個條件不成立的時候, 結果為falseflag = c < d && c < e;System.out.println(flag); // 當所有的條件都成立的時候, 返回trueflag = c > d || c > e;  // 當兩個條件都不成立的時候, 結果為FalseSystem.out.println(flag);flag = c < d || c > e;System.out.println(flag); // 當其中一個條件成立的時候, 結果為 trueflag = c < d || c < e;System.out.println(flag); // 當所有的條件都成立的時候, 返回trueflag = !(c < d);System.out.println(flag);flag = c < d && e < d || c < e;System.out.println(flag);/*&&:  并且   只有當所有的條件都成立的時候, 才會返回true, 否則均為false||:  或者   只有當所有的條件都不成立的時候, 才會返回false, 否則均為true!: 非  取反操作*/System.out.println("演示三: 三元運算符 ");// 需求: 當  d > e的時候, 返回 "d比e大" 否則 返回 "d比e小"// python:  'd比e大' if d < e else 'd比e小'// java 三元表達式格式:  條件 ? true: falseString s = d > e ? "d比e大" : "d比e小";System.out.println(s);if (d > e){System.out.println("d比e大");}else {System.out.println("d比e小");}}
}

package cn.itcast.base;public class OperatorDemo {public static void main(String[] args) {/*++ --這兩個可以放在變量的前面，也可以放在后面，但是兩種計算順序不同++: 對變量值加一--: 對變量值減一如果將運算符放在變量的后面，是先賦值，再計算。int b = a++;先將a的值賦值給b，因此b的值是10，再對變量a做加一的操作，因此a變成了11int d = ++c;先對c做加一的操作，c變成了11，再將c的值賦值給d，因此d的值也是11*/int a = 10;int b = a++;System.out.println(a);System.out.println(b);int c = 10;int d = ++c;System.out.println(c);System.out.println(d);/*邏輯運算符演示&& || ！&&：表達式中全部為true的時候，結果才是true；只要有一個是false，結果就是false||: 表達式中只要有一個是true，結果就是true*/int e = 10;int f = 11;int g = 12;int h = 13;boolean flag1 = f>e && g>h;System.out.println(flag1);boolean flag2 = f>e && h>g;System.out.println(flag2);boolean flag3 = e>f && h++>g;System.out.println(flag3);System.out.println(h);System.out.println("------------------------------------------");boolean flag4 = e>f || h>g;System.out.println(flag4);boolean flag5 = e>f || g>h;System.out.println(flag5);boolean flag6 = f>e || g++>h;System.out.println(flag6);System.out.println(g);boolean flag7 = e>f || g++>h;System.out.println(flag7);System.out.println(g);boolean flag8 = e>f;System.out.println(flag8);System.out.println(!flag8);/*三元（三目）運算符boolean類型的表達式 ? true條件下執行的表達式 : false條件下執行的表達式*/String result = !(e>f) ? "e大于f" : "e小于f";System.out.println(result);}
}

9.2 算術運算符

自增自減運算符

解釋:

++ 運算，變量自己增長1。反之，-- 運算，變量自己減少1，用法與++ 一致, 此處以++舉例.

• 獨立運算：
  • 變量在獨立運算時，前++和后++沒有區別 。
  • 變量前++ ：例如 ++i 。
  • 變量后++ ：例如 i++ 。
• 混合運算：
  • 和其他變量放在一起，前++和后++就產生了不同。
  • 變量前++ ：變量a自己加1，將加1后的結果賦值給b，也就是說a先計算。a和b的結果都是2。

public static void main(String[] args) {int a = 1;int b = ++a;System.out.println(a);//計算結果是2System.out.println(b);//計算結果是2
}變量后++ ：變量a先把自己的值1，賦值給變量b，此時變量b的值就是1，變量a自己再加1。a的結果是2，b的結果是1。
public static void main(String[] args) {int a = 1;int b = a++;System.out.println(a);//計算結果是2System.out.println(b);//計算結果是1
}

package com.itheima;public class Demo04_運算符 {// 演示運算符public static void main(String[] args) {//1. 算術運算符:  ++  --int a = 10;//a++;  // 等于:  a = a + 1 /  a += 1// System.out.println(a); // 11// System.out.println(a++); // 11// System.out.println(a); // 12// System.out.println(++a); // 13/*a++:  先使用 a參與運算, 運算后, 然后對a + 1++a; 先對 a進行 + 1 操作, +1 后, 再參與運算*///int i1 = 10 + a++;int i2 = 10 + ++a;//System.out.println(i1); // 20System.out.println(i2); // 21// 說明  -- 與之類似, 只不過是 -1 操作System.out.println(a--); //  11System.out.println(--a); // 9}
}

9.3 賦值運算符

Java和Python中的賦值運算符用法一致, 只不過默認包含有強制類型轉換, 具體如下:

下面的程序有問題嗎？

public static void main(String[] args){short s = 1;s+=1;System.out.println(s);
}

分析： s += 1 邏輯上看作是s = s + 1 計算結果被提升為int類型，再向short類型賦值時發生錯誤，因為不能將取值范圍大的類型賦值到取值范圍小的類型。但是，s=s+1進行兩次運算，+= 是一個運算符，只運算一次，并帶有強制轉換的特點，也就是說s += 1 就是s = (short)(s + 1)，因此程序沒有問題編譯通過，運行結果是2.

// 2- 賦值運算符  (底層帶有強制轉換)
short b = 5;
b = (short) (b + 1);
System.out.println(b);b +=1; // ==  b = (short) (b + 1);
System.out.println(b);

9.4 關系運算符

? Java中的關系運算符和Python中的關系運算符用法一致，這里不做過多的介紹了

9.5 邏輯運算符

? 邏輯運算符是用來判斷并且, 或者, 除非等邏輯關系的符號.

? 該符號兩端一般連接值為布爾類型的關系表達式.

符號	作用	說明
&&	短路與	并且的意思. 有false則整體為false, 都為true, 則整體為true,有短路效應.
||	短路或	或者的意思, 有true則整體為true, 都為false, 則整體為false,有短路效應.
!	邏輯非	取反的意思, 以前為true, 取反后為false, 以前為false, 取反后為true

案例演示:

public class OperatorDemo03 {public static void main(String[] args) {//1. 定義兩個int類型的變量a和b, 初始化值分別為: 2, 5int a = 2, b = 5;//2. 演示邏輯與(&)/* System.out.println((a++ > 2) & (b++ < 7)); //兩個表達式都會執行.System.out.println(a);System.out.println(b);*/System.out.println("------------------");//3. 演示短路與(&&)System.out.println((a++ > 2) && (b++ < 7)); //左邊表達式結果為false, 右邊不執行.System.out.println(a);System.out.println(b);}
}

演示:

int d = 100;
int e = 200;
// &&  兩邊的條件 如果都成立, 返回true 如果有任意條件不成立, 都會返回false
boolean tmp1 = d >= 100 && e > 200;
// || 兩邊的條件, 如果都不成立, 返回false, 只要有任意一方成立, 均返回true
boolean tmp2 = d > 100 || e > 200;
// ! 取反操作
boolean tmp3 = !(d > 100);System.out.println(tmp1);
System.out.println(tmp2);
System.out.println(tmp3);注意:  && || 都可以支持并聯寫多個條件 同樣也可以混合使用例如:  條件1 && 條件2 && 條件3 && ....條件1 || 條件2 || 條件3 || ....條件1 && 條件2 || 條件3 || .... !條件1 && 條件2 || 條件3...

9.6 三元運算符

格式

三元運算符也叫三目運算符，即由三部分組成，格式如下：

關系表達式? 表達式1：表達式2；

先執行關系表達式, 看其結果是true還是false.
1.如果是true, 則執行表達式1
2.如果是false, 則執行表達式2

需求

• 1 定義兩個int類型的變量a. b, 初始化值分別為10, 20

• 2 通過三元運算符, 獲取變量a和b的最大值.

• 3 將結果(最大值)打印到控制臺上.

public class OperatorDemo04 {public static void main(String[] args) {//1. 定義兩個int類型的變量a. b, 初始化值分別為10, 20int a = 10, b = 20;//2. 通過三元運算符, 獲取變量a和b的最大值.int max = a < b ? b : a;//3. 將結果(最大值)打印到控制臺上.System.out.println(max);}
}

package com.itheima.day01;public class 運算符 {public static void main(String[] args) {// 算術運算符int a = 10;// ++/--放在變量后面的情況，先進行賦值操作，再進行加1或者減1的操作// ++/--放在變量前面的情況，先進行加1或者減1的操作，再進行賦值操作
//        int b = a++;
//        int b = ++a;int b = --a;System.out.println(a);System.out.println(b);// 邏輯運行算/*&&：與。左右兩邊全部都成立的時候，最終結果才是true；否則就是false||：或。左右兩邊只要有任意一個成立，那么最終的結果就是true!：非。取反的操作。*/System.out.println(5>6 && 7<8); // falseSystem.out.println(5<6 && 7<8); // trueSystem.out.println(5>6 || 7<8); // trueSystem.out.println(5>6 || 7>8); // falseSystem.out.println(!(5>6)); // trueSystem.out.println(!(5>6 || 7>8)); // true// 三元運算符：是對簡單的if判斷語句進行了簡化int age = 100;String result = age>=18?"成年了，可以打游戲":"未成年，回去寫作業吧";System.out.println(result);String result2 = age>=18?(age>=90?"別打游戲了，心臟不好":"可以玩點刺激的"):"未成年，回去寫作業吧";System.out.println(result2);}
}

六、鍵盤錄入（熟悉）

類似于Python中的input(),raw_input(), Java中也是支持鍵盤錄入的.

1、使用步驟

• 1 導包。包就是文件夾.

注意:
a) Scanner類是java.util包下的類, 使用之前必須要先導包.
b) 導包的語句是定義在類的上面的, 格式如下:  import java.util.Scanner;

• 2 創建Scanner類的對象, 格式為:

//暫時先理解為固定格式, 也就是必須這么寫.
Scanner sc = new Scanner(System.in);

• 3 通過Scanner類的nextInt()方法接收用戶錄入的數據.

int a = sc.nextInt();

2、Scanner入門案例

需求

1 提示用戶錄入他/她的年齡.

2 通過鍵盤錄入功能, 接收用戶錄入的年齡.

3 將用戶錄入的數據(年齡)打印到控制臺上.

package com.itheima.day01;import java.util.Scanner;public class 鍵盤錄入 {public static void main(String[] args) {// 1- 創建Scanner實例對象// Java中創建類的實例對象需要用new關鍵字Scanner sc = new Scanner(System.in);// 2- 輸出提示信息System.out.println("請輸入您的年齡：");// 3- 獲取用戶輸入int inputAge = sc.nextInt();// Java里面可以直接對字符串與數字進行拼接操作。但是不能同時輸出多個變量System.out.println("您輸入的年齡是："+inputAge);}
}

七、（重要）流程控制（掌握）

? 和Python中一樣, Java中也是有分支結構和循環結構的, 它們的用法都一樣, 只是寫法稍有不同, 接下來, 我們來研究下Java中分支結構和循環結構的格式.

?

1、if語句

如果我們想某些代碼是在滿足條件的情況下, 才能被執行, 此時就需要用到選擇結構了, 選擇結構也叫分支結構, 主要分為以下兩種:

• if語句, 主要用于范圍的判斷
• switch case語句, 主要用于固定值的判斷.

if語句格式:

單分支格式:
if(判斷條件){// 滿足條件的內容
}雙分支:
if(判斷條件){// 滿足條件的內容
} else {// 不滿足條件的內容
}多分支
if(判斷條件){// 滿足條件的內容
} else if (判斷條件) {// 滿足條件的內容
} else if (判斷條件) {// 滿足條件的內容
} else {// 不滿足條件的內容
}多分支
if(判斷條件){// 滿足條件的內容
} else if (判斷條件) {// 滿足條件的內容
}

相關的案例:

package com.itheima.day01;import java.util.Scanner;public class IF多分支 {public static void main(String[] args) {// 1- 創建鍵盤錄入的實例對象Scanner sc = new Scanner(System.in);// 2- 提示用戶輸入考試分數System.out.println("請輸入您的考試得分：");// 3- 獲取用戶輸入的內容double inputScore = sc.nextDouble();System.out.println("用戶的考試得分是："+inputScore);// 4- 判斷用戶的考試級別// 如下的代碼邏輯有問題
//        if(inputScore>=60){
//            System.out.println("及格");
//        }else if(inputScore>=70){
//            System.out.println("良好");
//        }else if(inputScore>=90){
//            System.out.println("優秀");
//        }else{
//            System.out.println("沒有及格");
//        }if(inputScore>=90){System.out.println("優秀");}else if(inputScore>=70){System.out.println("良好");}else if(inputScore>=60){System.out.println("及格");}else{System.out.println("沒有及格");}}
}

2、switch語句

switch語句, 一般是用于做固定值判斷的。適合值是離散。

格式:

switch(表達式) {  case 值1: 	語句體1;break;case 值2:語句體2;break;case 值3:語句體3;break;...    //根據需求, 可以寫多組case.default:	語句體n;break;
}

示例:

1 一年有12個月, 分屬于春夏秋冬4個季節, 鍵盤錄入一個月份, 請用程序實現判斷該月份屬于哪個季節, 并輸出。

2 具體標準如下:

1 輸入： 1、2、12 輸出：冬季2 輸入： 3、4、5 輸出：春季3 輸入： 6、7、8 輸出：夏季4 輸入： 9、10、11 輸出：秋季輸入：其它數字 輸出：數字有誤

代碼實現:

package com.itheima;import java.util.Scanner;public class Test02_switch {public static void main(String[] args) {//1. 創建鍵盤錄入的對象Scanner scanner = new Scanner(System.in);//2. 獲取教案錄入的月份信息(1~12)// ln  是用于換行的//System.out.println("請輸入一個月份, 判斷屬于哪個季節(1~12):");System.out.print("請輸入一個月份, 判斷屬于哪個季節(1~12): ");int month = scanner.nextInt();// 3. 根據輸入的月份信息, 進行判斷switch (month){case 12:System.out.println("冬季");break;case 1:System.out.println("冬季");break;case 2:System.out.println("冬季");break;case 3:System.out.println("春季");break;case 4:System.out.println("春季");break;case 5:System.out.println("春季");break;case 6:System.out.println("夏季");break;case 7:System.out.println("夏季");break;case 8:System.out.println("夏季");break;case 9:System.out.println("秋季");break;case 10:System.out.println("秋季");break;case 11:System.out.println("秋季");break;default:System.out.println("您輸入的數字有誤, 請重新輸入...");break;}}
}

注意:

? 在switch語句中，如果case的后面不寫break，將出現case穿透現象，也就是不會在判斷下一個case的值，直接向后運行，直到遇到break，或者整體switch結束。

所以以上代碼可以優化為:

package com.itheima;import java.util.Scanner;public class Test03_switch {public static void main(String[] args) {//1. 創建鍵盤錄入的對象Scanner scanner = new Scanner(System.in);//2. 獲取教案錄入的月份信息(1~12)// ln  是用于換行的//System.out.println("請輸入一個月份, 判斷屬于哪個季節(1~12):");System.out.print("請輸入一個月份, 判斷屬于哪個季節(1~12): ");int month = scanner.nextInt();// 3. 根據輸入的月份信息, 進行判斷switch (month){case 12:case 1:case 2:System.out.println("冬季");break;case 3:case 4:case 5:System.out.println("春季");break;case 6:case 7:case 8:System.out.println("夏季");break;case 9:case 10:case 11:System.out.println("秋季");break;default:System.out.println("您輸入的數字有誤, 請重新輸入...");break;}}
}

3、for循環

? for循環是我們在實際開發中應用到的最多的循環, 它一般適用于循環次數固定的情況.

格式:

for(初始化條件1; 判斷條件2; 控制條件3) {//循環體;
}

說明:

1 初始化條件: 用來記錄 循環的初始狀態的. 即: 從哪開始循環.

2 判斷條件: 用來決定循環是否繼續執行的, 條件成立, 則循環繼續執行, 條件不成立, 整個循環就結束了.

3 控制條件: 用來控制初始化條件變化的, 一般是每循環一次, 初始化條件+1.

4 循環體: 需要用來重復做的事情(代碼).

案例1:

1 通過for循環, 打印1~5之間的數字.

2 通過for循環, 打印5~1之間的數字.

package com.itheima;public class Test04_for {public static void main(String[] args) {// 需求: 通過 for循環, 打印 1~5之間的數字for(int i = 1; i <=5; i++){System.out.println(i);}System.out.println("------------------");// 需求2: 通過for循環, 打印 5~1之間的數字for(int i = 5; i >=1 ; i--){System.out.println(i);}}
}

案例二: 求偶數和

求1-100之間的偶數和，并把求和結果打印到控制臺上

package cn.itcast.base;public class ForDemo {public static void main(String[] args) {// 通過for循環, 打印1~5之間的數字.for(int i=1;i<=5;++i){System.out.println(i);}// 通過for循環, 打印5~1之間的數字.for(int i=5;i>=1;i--){System.out.println(i);}// 求1-100之間的偶數和，并把求和結果打印到控制臺上/*1-打印1-100之間的數字2-篩選出偶數3-求偶數的和4-打印最終的結果*/// 偶數的中間臨時聚合結果int sum = 0;for(int i=1;i<=100;i++){if(i%2==0){// sum = sum + i;sum += i;}}System.out.println(sum);}
}

4、while循環

? while循環也是我們在實際開發中應用到的比較多的循環, 它一般適用于循環次數不固定的情況.

格式:

初始化條件1;
while(判斷條件2) {//循環體3;//控制條件4;
}

案例：在控制臺打印10次HelloWorld.

// 需求1: 在控制臺打印10次HelloWorld
int i = 1;
while(i<=10){System.out.println("Hello World");i++;
}

案例: 求和

獲取1~100之間所有偶數和, 并將結果打印到控制臺上.

// 需求2: 求和 獲取 1~100之間所有偶數和 并將結果打印到控制臺上
int j = 1;
int sum = 0;
while( j <= 100) {if(j % 2 == 0){sum += j;}j++;
}System.out.println("偶數之和為:"+ sum);

5、死循環

? 所謂的死循環指的是永不會結束的循環, 也就是循環的判斷條件永遠為true。在Java中, 死循環的寫法格式常用有以下2種:

• for(;😉 { }
• while(true){ }：推薦使用

public class DeadLoop {public static void main(String[] args) {for(;;) {System.out.println("Hello World!");}while(true) {System.out.println("Hello World!");}}
}

package com.itheima.day01;import java.util.Scanner;public class 死循環結合switch案例 {public static void main(String[] args) {// 1- 創建Scanner實例對象Scanner sc = new Scanner(System.in);while(true){// 2- 提示用戶輸入System.out.println("請輸入月份：");// 3- 獲取用戶輸入的月份int inputMonth = sc.nextInt();System.out.println("用戶輸入的月份是："+inputMonth);// 4- 判斷月份屬于哪個季節switch (inputMonth){// case后面必須要有空格case 1:case 2:case 12:System.out.println("冬季");break;case 3:case 4:case 5:System.out.println("春季");break;case 6:case 7:case 8:System.out.println("夏季");break;case 9:case 10:case 11:System.out.println("秋季");break;default:System.out.println("您輸入的月份有誤");break;}}}
}

6、循環跳轉

? 有些時候, 我們想提前終止循環的執行, 或者跳過循環的某一次執行, 例如: 打印1~10之間, 所有不是3倍數的數字, 或者采用死循環讓用戶不斷的錄入他/她的賬號和密碼, 直到用戶錄入正確, 再終止循環. 這些都要用到循環控制跳轉知識點.

break: 是用來終止整個循環, 循環不再繼續執行.
continue: 用來結束本次循環, 進行下一次循環的, 循環還會繼續執行.

例如:

package cn.itcast.base;public class BreakAndContinueDemo {public static void main(String[] args) {// 打印1-10的數字，如果遇到3的倍數，就進行特殊處理/*break: 用來結束整個循環（for/while）continue：用來結束當前循環（for/while），進入到下個循環中*/for(int i=1;i<=10;i++){if(i%3==0){System.out.println("3的倍數"+i);
//                break;continue;}System.out.println(i);}}
}

演示:

package com.itheima;public class Test06_break和continue {public static void main(String[] args) {// 演示 for循環的break和continue// 需求: 通過 for循環, 打印 1~5之間的數字for(int i = 1; i <=5; i++){System.out.println(i);// 當i等于3的時候, 跳出整個循環if(i == 3){break;}System.out.println(i);}System.out.println("------------------");// 需求2: 通過for循環, 打印 5~1之間的數字for(int i = 5; i >=1 ; i--){// 當 i等于3的時候, 跳出本次循環if(i == 3) {continue;}System.out.println(i);}// 演示在while循環中:// 需求1: 在控制臺打印10次HelloWorldint i = 1;while(i<=10){System.out.println(i);// 當i等于3的時候, 跳出整個循環if(i == 3){break;}i++;}System.out.println("------------------");// 需求1: 在控制臺打印10次HelloWorldint j = 1;while(j<=10){// 當 i等于3的時候, 跳出本次循環if(j == 3) {j++;continue;}System.out.println(j);j++;}}
}

7、循環嵌套

所謂的循環嵌套指的是循環結構中還包裹著循環結構, 外邊的循環結構叫外循環, 里邊的循環結構叫內循環.

for循環和while循環，可以任意組合。工作中，一般推薦就2層循環。如果你的代碼的循環嵌套層數>3層，一定要重新思考你的實現思路。

循環嵌套用的最多的就是for循環的嵌套, 具體格式如下:

for(初始化條件; 判斷條件; 控制條件) {		//外循環for(初始化條件; 判斷條件; 控制條件) {		//內循環//循環體;}
}

八、作業

1、需求：打印99乘法表，格式如下。嘗試實現正著的、while嵌套實現

1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
1*4=4	2*4=8	3*4=12	4*4=16	
1*3=3	2*3=6	3*3=9	
1*2=2	2*2=4	
1*1=1

package com.itheima.day01;public class 倒著的99乘法表 {public static void main(String[] args) {for (int line = 1; line <= 9 ; line++) {// 外層循環控制層數for (int j = 1; j <= 10-line; j++) {// 內層循環控制每行的內容System.out.print(j + "*" + (10-line) + "=" + (j*(10-line)) + "\t");}// 輸出一個回車換行System.out.println();}}
}

2、打印如下圖形

  ****
*********

package com.itheima.day01;import java.util.Scanner;public class 打印菱形 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("請輸入要打印的層數：");int lineCount = sc.nextInt();// 先打印上半部分for(int line=1;line<=lineCount;line++){// 外層循環控制行號for (int i = 1; i <= lineCount-line; i++) {// 負責打印每行的空格System.out.print(" ");}for (int i = 1; i <= 2*line-1; i++) {// 負責打印每行的星星System.out.print("*");}// 打印每行的回車換行System.out.println();}// 先打印下半部分for(int line=lineCount-1;line>=1;line--){// 外層循環控制行號for (int i = 1; i <= lineCount-line; i++) {// 負責打印每行的空格System.out.print(" ");}for (int i = 1; i <= 2*line-1; i++) {// 負責打印每行的星星System.out.print("*");}// 打印每行的回車換行System.out.println();}}
}