Java基礎語法
數(shù)據(jù)類型
注意 : Java語言是強制類型語言. 任何的數(shù)據(jù),都是進行嚴格分類的
方便管理數(shù)據(jù),Java語言將數(shù)據(jù)分成了兩大類別.
-
基本數(shù)據(jù)類型 (四類八種)
-
整型
-
字節(jié)型 (關鍵字 byte)
字節(jié)型在內存中,占用1個字節(jié)(8個二進制位)
字節(jié)型的數(shù)據(jù)的取值范圍 -128 ~ 127
-
短整型(關鍵字 short)
短整型在內存中,占用2個字節(jié)(16個二進制位)
短整型的數(shù)據(jù)的取值范圍 -32768 ~ 32767
-
整型(關鍵字 int) Java的默認類型
整型在內存中,占用4個字節(jié)(32個二進制位)
整型的數(shù)據(jù)的取值范圍 -2147483648~ 2147483647
-
長整型(關鍵字 long)
長整型在內存中,占用8個字節(jié)(64個二進制位)
長整型的數(shù)據(jù)的取值范圍 -9223372036854775808~ 9223372036854775807
-
-
浮點
-
單精度(關鍵字 float)
單精度浮點在內存中,占用4個字節(jié)
單精度浮點的數(shù)據(jù)的取值范圍 1.4E-45~ 3.4028235E38
-
雙精度(關鍵字 double)Java的默認類型
雙精度浮點在內存中,占用8個字節(jié)
雙精度浮點的數(shù)據(jù)的取值范圍 4.9E-324~ 1.7976931348623157E308
-
-
字符 (關鍵字 char)
- 類型每次只能存儲1個字符
- 字符型在內存中,占用2個字節(jié) (和short一致)
-
布爾 (關鍵字 boolean)
- 布爾類型只有true和false
- 內存中占1個字節(jié)
-
-
引用數(shù)據(jù)類型 (5種)
- 數(shù)組 (英語 Array)
- 類 (英語 class 也是關鍵字)
- 接口 (英語 interface 也是關鍵字)
- 枚舉 (英語 enum 也是關鍵字)
- 注解 (英語 Annotation)
變量
變量 : 常量是固定不變化, 變量的數(shù)據(jù)是可以隨時改變的, 變量方便進行運算
變量的定義三要素 :
- 明確數(shù)據(jù)類型
- 變量的名字
- 變量的值
變量定義的格式 :
數(shù)據(jù)類型 變量名字 = 值
public static void main(String[] args) {
/*
* 定義出所有的基本數(shù)據(jù)類型變量
* 4類8種
* 定義格式:
* 數(shù)據(jù)類型 變量名字 = 值
*/
//定義字節(jié)型,關鍵字 byte
byte b = 100;
System.out.println(b);
//定義短整型,關鍵字 short
short s = 10000;
System.out.println(s);
//定義整型,關鍵字 int 最常用的類型
int i = 999999;
System.out.println(i);
//定義長整型,關鍵字 long
//注意 : Java語言,任何整數(shù)默認都是int類型
//將整數(shù)變成long類型, 數(shù)字后面寫字母L (不分大小寫,建議大寫)
long l = 1234567890123L;
System.out.println(l);
//定義浮點數(shù)據(jù),單精度 關鍵字float
//Java中浮點數(shù)據(jù),默認是double
//浮點數(shù)變成float類型,數(shù)字后面寫字母F (不分大小寫,建議大寫)
float f = 3.14F;
System.out.println(f);
//定義浮點數(shù)據(jù),雙精度 關鍵字 double
double d = 3.14;
System.out.println(d);
//定義字符類型, 關鍵字char
char c = '去';
System.out.println(c);
//定義布爾類型,關鍵字 boolean
boolean bool = true;
System.out.println(bool);
}
變量定義的注意事項
-
變量定義,但是沒有賦值,不能使用
public static void main(String[] args) { int i ; System.out.println(i); }
-
可以先定義變量,再賦值
public static void main(String[] args) { int i ; i = 1; System.out.println(i); } -
在同一個大括號內,變量名不能相同
public static void main(String[] args) { int i ; i = 1; System.out.println(i); int i = 2; System.out.printl(i); } 作用范圍,變量只能作用在定義的一對大括號內有效,出去大括號無效
變量定義格式補充
先聲明變量,后賦值
public static void main(String[] args) {
int a;
a = 1;
//一次定義多個變量名字
int b,c,d,e;
//分別進行賦值
b=1;
c=2;
d=3;
e=4;
//比較惡心
int f = 1, m=2, n,g;
n=1;
g=2;
}
數(shù)據(jù)類型轉換 (有點難)
Java語言是強制類型語言,要求在數(shù)據(jù)進行運算的時候,必須保證類型的一致性.
如果數(shù)據(jù)在運算的時候,類型不一致,發(fā)生類型轉換現(xiàn)象.
所有的基本數(shù)據(jù)類型中,只有布爾類型不參與轉換
自動類型轉換
-
轉換原則 : 數(shù)據(jù)類型取值范圍小的會自動提升為取值范圍大的類型
-
byte -> short -> int -> long -> float -> double
public static void main(String[] args) { /* * 字節(jié)byte和整型int 求和 * byte取值范圍小的類型,int取值范圍大 * 求和的時候,發(fā)生類型的轉換!! */ byte b = 1; int i = 2; int j = b + i; // b+1 類型轉換 b轉成int System.out.println(j); } -
byte和short的計算,默認轉成int
public static void main(String[] args) { //求和計算 //1 == Java默認int //1.1 == Java默認double //1 自動轉換double 補: 1.0 double d = 1+1.1; //計算后的最終的類型結果是 double System.out.println(d); d = 1+0.0; System.out.println(d); /* * 求和計算,認真思考 */ byte b = 1; short s = 1; //b+s不能運算,數(shù)據(jù)類型不同,類型的轉換,計算結果的數(shù)據(jù)類型int //Java規(guī)定 : byte short 進行運算,都會自動轉成int!! int k = b+s; System.out.println(k); } -
char類型計算的時候,查詢ASCII編碼表,取出整數(shù)進行計算 (轉成int類型)
public static void main(String[] args) { //char 字符類型,內存中占用2個字節(jié) char c = 'a'; System.out.println(c); //char字符類型,也可以進行計算 //字符char類型計算的時候,轉成int類型 //會到ASCII編碼表中查詢數(shù)字出來 System.out.println(c+1);// 98 }
-
字符編碼表.jpg
-
char類型是否存在取值范圍
在內存中,和short占用2個字節(jié) 0-65535
強制類型轉換
強制 : 程序人員手動的參與轉換
強制類型轉換 : 取值范圍大的類型,轉成取值范圍小的類型
盡量少做,出現(xiàn)數(shù)據(jù)精度丟失問題.
-
浮點數(shù),轉成整數(shù)
- 1.5 轉成整數(shù) 結果是1,小數(shù)部分直接丟棄
-
轉換的公式 :
被轉換后的類型 變量名字 = (被轉換后的類型)要轉換的數(shù)據(jù);public static void main(String[] args) { //浮點數(shù)據(jù),轉成整數(shù) double d = 1.5; //d取值范圍大的類型,轉成int類型 (丟失精度) //被轉換后的類型 變量名字 = (被轉換后的類型)要轉換的數(shù)據(jù); int i = (int)d; System.out.println(i); } -
整數(shù)之間的類型轉換
public static void main(String[] args) { byte b = 1; int i = 2; /* * b 1個字節(jié) * i 4個字節(jié) * b+i 的結果還是4個字節(jié) * * 4個字節(jié)的結果,復制到1個字節(jié)的c中 * b + i 的結果,強制的轉成byte類型 * * 被轉換后的類型 變量名字 = (被轉換后的類型)要轉換的數(shù)據(jù); */ byte c = (byte) (b + i); System.out.println(c); short s = 1 ; /* * s + 1 int類型,和short類不能計算 * s 提升為int類型,求和后變成int * 賦值回變量s ,需要類型的強制轉換 * s + 1的結果,強制轉換為short */ s = (short) (s + 1); System.out.println(s); }public static void main(String[] args) { /* * 1 是int類型 * int類型, 賦值到byte了呢 * * javac 編譯器 : .java文件,編譯為可以執(zhí)行的class文件 * 編譯的時候,檢測1是否超過byte的范圍 * 沒有超過byte范圍, javac幫你將int類型的1,轉成byte類型 */ byte b = 1; System.out.println(b); byte b2 = (byte)300; //超過byte范圍的300,強制轉byte類型 System.out.println(b2); } 計算中,常量是已經確定計算結果,(固定不變)
-
變量,在計算中,不確定結果,運行完畢才可知
short s1 = 1; short s2 = 1; /* * s1 + s2 == > 變成int */ short s3 = (short) (s1 + s2); System.out.println(s3); /* * s4 = 1+1 是正確的 * 變量計算和常量計算的區(qū)別 * s1 + s2 是變量, 編譯的時候javac, 編譯器不確定的值是什么 * 求和的結果按照int計算 * * 1 + 1是常量,固定不變 javac編譯,可以確定計算的結果 * 判斷出結果沒有超過short范圍,不會報錯 */ short s4 = 1 + 1; System.out.println(s4);
運算符
運算符在程序中作用是數(shù)據(jù)之間進行運算.運算符分類
算數(shù)運算符
-
+ - * / %- % 取模, 計算的結果要余數(shù)
賦值運算符
= 符號右邊的數(shù)據(jù),賦值到左邊的變量
-
+= -= *= /= %= 不能分開
public static void main(String[] args) { int i = 1; /* * i+1的結果,再賦值變量i */ i = i + 1; System.out.println(i); /* * += 賦值運算符 * j+=1; 本質上理解為 j = j+1 */ int j = 1; j+=1; // 等價于 j = j + 1 System.out.println(j); /* * += 另一個問題 * s += 2; 等價于s = s + 2 * += 是一個符號,運算是一次完成 (javac自動的進行強制轉換) */ short s = 1; s += 2; System.out.println(s); } -
++ 和 --
public static void main(String[] args) { //++ 符號,含義是變量自增1 -- 變量自減1 int i = 1; i++; System.out.println(i); /* * ++或者--符號,可以出現(xiàn)在變量的前面或者是后面 */ ++i; System.out.println(i); /* * ++在前在后的區(qū)別 */ int m = 1; //++在后面,后運算 //先將m的值,賦值變量n, m自己在增1 int n = m++; System.out.println(m); //2 System.out.println(n); //1 //++在前面,先運算 //m自己先增1, 增1后的結果,賦值到n n = ++m; System.out.println(m);//3 System.out.println(n);//3 }-
++ 和--的結論:
- 變量只有自己的時候 ++ 寫在前還是后沒有區(qū)別,自己都會增1
- 變量和其他變量做運算
- 寫后面,是先將自己的值賦給其他變量,自己在增1
- 寫前面,先自己增1,增1后賦值另一個變量
-
++ 和--的結論:
比較運算符
比較運算符,是數(shù)據(jù)之間做比較的,特點:比較運算符的執(zhí)行結果只能是布爾類型
比較運算符的運算結果,要么是true,要么是false,不會出現(xiàn)其他的結果
- == 等等于 比較符號兩邊的數(shù)據(jù)是否相等,如果相等,計算結果是true
- != 不等于 比較符號兩邊的數(shù)據(jù)是否不相等,如果不等待,結算結果是true
-
>大于號比較符號左邊的數(shù)是否大于右邊的數(shù),如果大于結果是true -
<小于號結果略 -
>=大于等于 <=小于等于結果略
邏輯運算符
邏輯的運算符,計算結果也是布爾類型,要么是true,要么是false
- & 邏輯與 &符號的兩邊 一邊結果是false,整體運算結果是false,兩邊都是true,結果是true
- | 邏輯或 |符號的兩邊 一邊結果是true,整體的運算結果是true,兩邊都是false,結果是false
- ! 邏輯非 ! 取反 true取反變false, false取反變true
- && 雙與 提高運算效率,和單符號的計算結果無區(qū)別
- 高效處理 : 左邊是false,右邊不計算
- || 雙或 提高運算效率,和單符號的計算結果無區(qū)別
- 高效處理 : 左邊是true,右邊不計算
public static void main(String[] args) {
//&符號的兩邊 一邊結果是false,整體運算結果是false
System.out.println(2==2 & 2==1);
//System.out.println(false & true );
//|符號的兩邊 一邊結果是true,整體的運算結果是true
System.out.println( 1==1 | 2==3);
//! 取反 true取反變false, false取反變true
System.out.println( !false );
int i = 1;
int j = 1;
System.out.println( i==2 && ++j==2);
System.out.println(j);
System.out.println(i==1 || j==3);
}
位運算符
位運算,數(shù)字的二進制位的運算
運算之前,先將數(shù)字轉成二進制后,才能計算
-
& | ^ << >> >>>
- 計算過程中,二進制0表示false,1表示true
- 計算結果,和邏輯運算符一致
- ^ (異或)相同結果是false,不相同結果是true
- <<左移動 >>右移動 數(shù)字的二進制進行位置移動
-
>>>無符號右移動
public static void main(String[] args) { System.out.println( 6 & 7 ); System.out.println(6 | 7); // ^異或 計算結果,相同為false,不同為true System.out.println( 6 ^ 7); //2 向右移動1位 相當于原數(shù)字/2 System.out.println(2 >> 1); //2左移動2位 相當于原數(shù)字*2*2 System.out.println( 2 << 2); //無論數(shù)據(jù)的最高位是1還是0,移動后全部補0 System.out.println(-1 >>> 2); }
三元運算符
三元又稱為三目運算
-
運算符格式 :
布爾表達式?結果1:結果2public static void main(String[] args) { //布爾表達式?結果1:結果2 //布爾表達式 : 怎么寫都可以,運算結果是true,false即可 //三元運算符的計算結果 : 布爾表達式結果是true,執(zhí)行結果1,否則執(zhí)行結果2 int i = 2==2?100:200; System.out.println(i); System.out.println(1==2?"等于":"不等于"); //System.out.println(1==1?5:1.0); }
字符串數(shù)據(jù)的+計算
字符串和+一起計算, +變成連接作用,失去的求和的含義
計算的結果都是字符串類型.
public static void main(String[] args) {
//"5" 是字符串類型 ,5是int類型
//不計算,遇到字符串, + 變成連接作用
//計算的結果的類型,是字符串
System.out.println("5" + 5);
System.out.println(1+2+"3");
System.out.println(true+"1");
}
Scanner 鍵盤輸入作用
在Java基礎階段 SE技術平臺中,是有意義
Scanner是Java中,已經做好的一個類,拿來使用即可
注意 : 使用已經做好的類Scanner,我們自己創(chuàng)建類,類名不能是Scanner
//1: 導入該類所在的包
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
//2: 創(chuàng)建Scanner類的對象
Scanner sc = new Scanner(System.in);
//3: 創(chuàng)建好的對象,調用方法,實現(xiàn)鍵盤的輸入 (整數(shù),字符串)
int i = sc.nextInt();//接收鍵盤輸入,整數(shù)
System.out.println(i+1);
}
}
Sacnner接收字符串類型
public static void main(String[] args) {
//Scanner鍵盤輸入字符串
Scanner sc = new Scanner(System.in);
//接收字符串, Scanner類中方法 next()
//String s = sc.next(); //字符串中有空格,空格后面不接收
//接收字符串,Scanner類中方法 nextLine()
String s = sc.nextLine(); //接收一行
System.out.println(s+123);
}
Scanner反復接收數(shù)據(jù)的問題
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//輸入int
int i = sc.nextInt(); // 123 回車
System.out.println(i);
//輸入字符串
String s = sc.nextLine();
System.out.println(s);
}
流程控制語句
現(xiàn)在階段,寫的所有程序,都稱為順序解構.程序只能從上向下依次執(zhí)行.
實現(xiàn)更加復雜的功能,使用流程控制語句
判斷語句 if ,選擇語句 switch ,循環(huán)語句 for while do while
if判斷語句
只有一個關鍵字 if (如果)
格式 :
if(條件的判斷){
if語句的執(zhí)行體
}
條件的判斷 : 這里的結果必須是布爾類型
if的語句體 : 如果條件判斷的結果是true,執(zhí)行該語句體,判斷的結果是false,什么也不做
- if的語句實現(xiàn)
public static void main(String[] args) {
int i = 1;
//if的判斷語句
if( i > 0) {
System.out.println("執(zhí)行了大括號里面程序");
System.out.println("if的條件判斷是true");
}
}
if語句注意事項
if語句是可以省略大括號的 : 0基礎,新手,大括號一定要寫
如果不寫大括號, if判斷語句只能控制距離他最近的一行程序!!
public static void main(String[] args) {
int i = 1 ;
if( i == 1)
System.out.println("你好");
System.out.println("我好");
}
if語句: (判斷條件) 有一個寫法,希望你用, 建議在判斷里面,常量寫在變量的前面.
public static void main(String[] args) {
//定義布爾類型的變量
boolean bool = false;
//System.out.println(false == false);
if(false == bool) {
System.out.println("if的判斷條件是true");
}
}
if...else語句
if是如果,else是否則. 如果怎么樣,就怎么樣. else語句是不能單獨出現(xiàn),只能跟隨if出現(xiàn)
語句格式 :
if(條件判斷){
if語句的執(zhí)行體
}else{
else語句的執(zhí)行體
}
- 執(zhí)行流程 :
- 程序先執(zhí)行if中的條件判斷語句,如果判斷語句是true,那么就執(zhí)行if的語句體
- 如果if中的條件判斷結果是false,那么就會執(zhí)行else的語句體
- if語句和else語句,永遠不會同時執(zhí)行,不會都不執(zhí)行
- if和else每天雞犬相聞,但是老死不相往來
- 適合于多個條件的判斷
if...else if...else if...else
多分支語法格式:
if(條件判斷){
} else if(條件判斷){
} else if(條件判斷){
} else {
}
適合與多條件的判斷,但是 if else過多,會導致程序的閱讀性下降
優(yōu)勢 : 高效的優(yōu)勢,只要有一個if的條件判斷結果是true,整體的語句結構就結束了
public static void main(String[] args) {
int i = 99;
//if else if的多分支
if(i < 100) {
System.out.println("第一個if的條件是true");
}else if(i > 100){
System.out.println("第二個if的條件是true");
}else if (i == 100) {
System.out.println("第三個if的條件是true");
}else {
System.out.println("所有的條件都是false");
}
}
多分支語句的練習
需求 : 請你輸入你的考試成績,對成績進行等級劃分
90-100 : 優(yōu)
80-89 : 良
70-79 : 中
60-69 : 差
<60 : 不及格
switch選擇語句
程序也是進行選擇的, switch語句中包含的關鍵字比較多
switch case default break
switch語句的格式 :
switch (變量){
case 常量1 :
要執(zhí)行的語句1;
break;
case 常量2 :
要執(zhí)行的語句2;
break;
case 常量3 :
要執(zhí)行的語句3;
break;
default:
要執(zhí)行的語句;
break;
}
-
語句流程詳細解釋
- switch中的變量,和case后面的常量,進行比較 (是否相同)
- 如果和 常量1相等,執(zhí)行 : 語句1, 執(zhí)行break,整體switch結束
- 如果和 常量2相等,執(zhí)行 : 語句2, 執(zhí)行break,整體switch結束
- switch中的變量,和任何一個case后面的常量都不相等,執(zhí)行default后面的語句, 執(zhí)行break,整體switch結束
-
switch語句中的變量的數(shù)據(jù)類型有限制
- byte short int char (JDK1.0-1.4)
- 添加數(shù)據(jù)類型 enum 枚舉 (JDK1.5)
- 添加數(shù)據(jù)類型字符串 (JDK1.7)
- 使用的是JDK1.8 (支持的類型 byte short int char 枚舉 字符串)
public static void main(String[] args) { int i = 5; switch (i) { case 1: System.out.println("case1"); break; case 2: System.out.println("case2"); break; case 3: System.out.println("case3"); break; default: System.out.println("所有case都不相等"); break; } }
選擇語句的練習
需求 : 根據(jù)輸入的月份,判斷是哪個季節(jié)
春季 : 3,4,5 夏季 : 6,7,8 秋季 : 9 ,10 ,11 冬季 12 , 1, 2
采用if和switch分別完成
if(month < 1 || month > 12) {
System.out.println("輸入的月份不存在");
}
//季節(jié)判斷 春季 : 3,4,5
else if(month >=3 && month <=5) {
System.out.println("春季");
}
//季節(jié)判斷 夏季 : 6,7,8
else if (month >= 6 && month <=8 ) {
System.out.println("夏季");
}
//季節(jié)判斷 秋季 : 9 ,10 ,11
else if (month >= 9 && month <= 11) {
System.out.println("秋季");
}
//季節(jié)判斷 冬季 12 , 1, 2
else {
System.out.println("冬季");
}
case穿透特性
在switch的語句中,不寫break,出現(xiàn)case的穿透性
switch (變量){
case 常量1 :
要執(zhí)行的語句1;
// break;
case 常量2 :
要執(zhí)行的語句2;
// break;
case 常量3 :
要執(zhí)行的語句3;
// break;
default:
要執(zhí)行的語句;
// break;
}
case穿透.jpg
case穿透特性實現(xiàn)季節(jié)判斷
public static void main(String[] args) {
//鍵盤輸入,接收月份
Scanner sc = new Scanner(System.in);
int month = sc.nextInt(); // 4
//利用case穿透特性
switch(month) {
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;
case 1:
case 2:
case 12:
System.out.println("冬季");
break;
default:
System.out.println("月份不存在");
}
}
循環(huán)語句
循環(huán) : 程序中的語句(代碼)多次的反復的執(zhí)行
使用的頻率非常的高
輸出10次 "HelloWorld"
System.out.println("HelloWorld"); 語句復制10次,不行
while循環(huán)
語法格式 :
while(布爾類型的表達式){
//while的循環(huán)體
}
- while循環(huán)的執(zhí)行流程
- 執(zhí)行布爾表達式,如果是true
- 執(zhí)行循環(huán)體中的程序
- 再次執(zhí)行布爾表達式,如果還是true
- 再次執(zhí)行循環(huán)體中的程序
- 再次執(zhí)行布爾表達式,如果是false
- while循環(huán)就結束了
- 結論: 只要while中的布爾表達式結果是true,就執(zhí)行循環(huán)體,直到布爾類型為false,循環(huán)結束
public static void main(String[] args) {
int i = 1;
while(i < 10) {
System.out.println("while的循環(huán)體 "+i);
//變量i 發(fā)生變化 ++
i++;
}
//打印10次HelloWorld
//j變化到10的時候,循環(huán)結束
int j = 0;
while(j < 10) {
System.out.println("HelloWorld");
j++;
}
}
while循環(huán)練習
-
輸出10以內的所有偶數(shù)
public static void main(String[] args) { //定義變量,默認值是0, 變化到10 int i = 0; while(i <= 10) { //判斷是不是偶數(shù) if(i % 2 == 0) { System.out.println(i + "是偶數(shù)"); } i++; } }public static void main(String[] args) { //定義變量,默認值是0, 變化到10 int i = 0; //變量i在循環(huán)的時候,每次+2行不? 不需要判斷了 while(i <= 10) { System.out.println(i + "是偶數(shù)"); //i=i+2; i+=2; } }
for循環(huán)
語法格式 :
for (初始化變量 ; 條件 ; 增量){
//for的循環(huán)主體
}
-
循環(huán)的三個部分解釋
- 初始化變量 : 定義變量 數(shù)據(jù)類型 變量名 = 值
- 條件 : 條件必須是布爾類型結果 true 或者 false
- 增量 : 循環(huán)變量的變化
- 條件 : 控制循環(huán)是否執(zhí)行,條件是true,循環(huán),條件是false結束循環(huán)
public static void main(String[] args) { for(int i = 0 ; i < 5 ; i++) { System.out.println("這里是for循環(huán)的循環(huán)體 "+i); } } -
for循環(huán)的執(zhí)行流程
- 執(zhí)行初始化的變量. (只會執(zhí)行一次)
- 執(zhí)行條件的判斷 (判斷條件是false,循環(huán)直接結束), 判斷條件是true
- 進入到for的循環(huán)體執(zhí)行
- 執(zhí)行變量的自增
- 執(zhí)行條件的判斷 (判斷條件是false,循環(huán)直接結束), 判斷條件是true
- 執(zhí)行循環(huán)體
- 執(zhí)行變量的自增
- 執(zhí)行條件的判斷 (判斷條件是false,循環(huán)直接結束)
for循環(huán)實現(xiàn)練習
-
for循環(huán)實現(xiàn)0-10之間的偶數(shù)
public static void main(String[] args) { //利用for循環(huán)中的變量 for(int i = 0 ; i <= 10 ;i+=2) { System.out.println(i +"是偶數(shù)"); } } -
for實現(xiàn)求和計算 1 + 2 + 3 +......+ 100 = 5050 (高斯算法)
public static void main(String[] args) { //定義變量int類型,保存求和后的結果 int sum = 0; //進行1-100之間的循環(huán) for(int i = 1 ; i <= 100 ;i++) { //求和計算, sum變量保存求和后的結果 sum = sum + i; } System.out.println(sum); }
do...while
格式 :
do{
//循環(huán)主體
}while(條件判斷);
- 循環(huán)執(zhí)行流程
- 判斷while中的循環(huán)條件
- 如果條件是true,執(zhí)行循環(huán)體
- 如果條件是false,結束循環(huán)
-
注意: do ... while 無條件先執(zhí)行一次循環(huán)體
break和continue
-
break : 終止 作用就是終止循環(huán), 在循環(huán)中遇到break,循環(huán)就結束,只能在循環(huán)中或者switch出現(xiàn)
public static void main(String[] args) { int i = 0; while(true) { i++; //判斷變量的值,如果=10,執(zhí)行break終止循環(huán) if(i == 10) { break; } } for( ; ;) { break; } } -
continue : 終止本次循環(huán),開始下一次循環(huán)
public static void main(String[] args) { for(int i = 0 ; i <=10 ;i++) { //判斷,如果變量是偶數(shù),執(zhí)行下一次循環(huán) if(i % 2 == 0) { continue; } System.out.println(i); } }
嵌套循環(huán)
引出 : 上體育課遲到20分鐘,處罰
操場跑圈 : 跑5圈, 再跑5圈, 再跑5圈, 再跑5圈
跑了4組,每組跑了5圈, 一共跑了多少圈 20 組數(shù)*每組圈數(shù)
理解 : 第一組5圈...... 我的第一次循環(huán) 5圈 我的第二次循環(huán) 5圈 (圍繞操場循環(huán)了5次)
一次大的循環(huán),包含5次小的循環(huán) : 程序 嵌套循環(huán), 總的循環(huán)次數(shù) = 大循環(huán)次數(shù)*小循環(huán)次數(shù)
嵌套for
兩個for循環(huán)在一起,形成嵌套形式, 雙循環(huán)
一個for是另一個for的循環(huán)體
格式 :
for(初始化變量 ; 條件 ; 增量){ //外循環(huán)
for(初始化變量 ; 條件 ; 增量){ //內循環(huán)
}
}
//內循環(huán)是外鍵循環(huán)的循環(huán)體
public static void main(String[] args) {
//外循環(huán),循環(huán)5次
for(int i = 0 ; i < 5 ;i++) {
//內循環(huán),循環(huán)3次
for(int j = 0; j < 3 ; j++) {
System.out.println("內循環(huán)");
}
System.out.println("外循環(huán)");
}
}
forfor循環(huán)的執(zhí)行流程.JPG
嵌套for循環(huán)練習
-
外循環(huán)一次,內循環(huán)多次
- 結論 : 外循環(huán)控制行數(shù) ,內循環(huán)控制每行的個數(shù)
public static void main(String[] args) { //外循環(huán)5次 for(int i = 0 ; i < 5 ;i++) { //內循環(huán)5次 for(int j = 0 ; j < 5 ;j++) { //內循環(huán)輸出星號 System.out.print("*"); } //外循環(huán)輸出空的換行 System.out.println(); } } -
尖向下的直角三角形
public static void main(String[] args) { // 有幾個行 5行 外循環(huán)5次 for(int i = 0 ; i < 5; i++) { /* * 每個行有幾個星號 第一行是5個,逐行遞減 * 變量j 0 1 2 3 4 * * 外循環(huán)第一行的時候,內循環(huán)5個 * 外循環(huán)第二行的時候,內循環(huán)4個 * j變化 : 每次執(zhí)行內循環(huán)的時候,變量j的初始化都+1 * * 外循環(huán)的i 變量 0 1 2 3 4 */ for(int j = i ; j < 5 ;j++) { System.out.print("*"); } System.out.println(); } } -
尖向上的直角三角形
public static void main(String[] args) { // 有幾個行 5行 外循環(huán)5次 for(int i = 0 ; i < 5 ;i++) { /* * 內循環(huán) : 循環(huán)次數(shù)不固定 每行遞增效果 * 第一行 : 內循環(huán)1次 * 第二行 : 內循環(huán)2次 * 內循環(huán)的變量 j * * 第一行 : 內循環(huán)1次 j<1 * 第二行 : 內循環(huán)1次 j<2 * 內 : 變量j每次都從0開始,但是條件在改變 */ for(int j = 0 ; j <= i ;j++) { System.out.print("*"); } System.out.println(); } } -
乘法表
public static void main(String[] args) { //i 1-9 for(int i = 1 ; i <= 9 ;i++) { // 第一次循環(huán)1 ,第二次循環(huán) 1 2 for(int j = 1; j<=i ;j++) { /* * 替換為乘法計算即可 */ System.out.print(j+"*"+i+"="+j*i+"\t"); } System.out.println(); } }
