當前位置：首頁 > 编程语言 > java >内容正文

java

狂神说笔记——Java SE基础01

發布時間：2024/1/8 java 49 豆豆

生活随笔收集整理的這篇文章主要介紹了狂神说笔记——Java SE基础01 小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

計算機預科

1.打開CMD的方式

開始 + 系統 + 命令提示符。

Win + R 輸入 CMD 打開控制臺 (推薦使用)。

在任意文件夾下，按住Shift鍵 + 鼠標右鍵打開命令行窗口。

在資源管理器的地址欄前加上 CMD 路徑。

2.管理員身份運行方式

選擇以管理員方式運行。

3.常見的Dos命令

盤符切換

C:\Users\subei>D 'D' 不是內部或外部命令，也不是可運行的程序或批處理文件。C:\Users\subei>D:D:\>C:C:\Users\subei>F:F:\>

F:\>dir驅動器 F 中的卷是工作臺卷的序列號是 1714-20F6F:\ 的目錄2021/05/17 16:15 <DIR> BaiduNetdiskDownload 2021/05/15 19:50 <DIR> CloudMusic 2021/05/14 21:19 <DIR> Dev-Cpp 2021/05/14 16:56 <DIR> DTL8Folder 2021/05/14 22:35 <DIR> HBuilderX 2021/05/14 22:36 <DIR> java 2021/05/14 17:00 <DIR> MyDrivers 2021/05/14 22:47 <DIR> Notepad++ 2021/05/14 22:29 <DIR> Sublime Text 3 2021/05/14 18:56 <DIR> Typora 2021/05/17 17:53 <DIR> VCW 2021/05/14 21:25 <DIR> VS2017 2021/05/14 21:47 <DIR> Windows Kits0 個文件 0 字節13 個目錄 663,783,088,128 可用字節F:\>E:E:\>dir驅動器 E 中的卷是數據卷的序列號是 3F12-1129E:\ 的目錄2020/06/04 07:47 610,571,366 AI教程超級合輯.zip 2021/05/14 13:44 <DIR> java 2021/05/14 21:47 <DIR> NUT 2021/05/14 13:45 <DIR> Office Tool 2021/05/05 15:18 69,730,999 Office-Tool-with-runtime-v8.1.zip 2021/05/11 17:26 <DIR> 作業 2021/05/14 23:15 <DIR> 工具 2021/05/14 13:38 <DIR> 論文 2020/10/21 21:58 1,000,218 狂神說Java全棧學習路線.jpg3 個文件 681,302,583 字節6 個目錄 605,834,113,024 可用字節E:\>

切換目錄：cd change directory

E:\>cd /d d:d:\>cd /d d:\levend:\LEVEN>cd ..d:\>

返回上一級：cd …

清理屏幕： cls

退出終端：exit

查看電腦IP信息：ipconfig

打開計算機：calc

打開畫圖：mspaint

打開記事本：notepad

ping命令：ping 網址

文件操作

C:\Users\subei\Desktop>md testC:\Users\subei\Desktop>cd testC:\Users\subei\Desktop\test>cd>a.txtC:\Users\subei\Desktop\test>

刪除文件

C:\Users\subei\Desktop\test>del a.txtC:\Users\subei\Desktop\test>cd ..C:\Users\subei\Desktop>rd testC:\Users\subei\Desktop>

基礎

1.Java簡介

java的特性和優勢
- 簡單性
- 面向對象
- 可移植性
- 高性能
- 分布式
- 動態性
- 多線程
- 安全性
- 健壯性
Java的三大版本
- JavaSE：標準版（桌面程序，控制臺開發……）
- JavaME：嵌入式開發（手機、小家電……）
- JavaEE：E企業級開發（Web端、服務器開發……）
Java安裝與卸載開發環境
- 卸載JDK
  - 刪除Java安裝目錄；
  - 刪除JAVA_HOME；
  - 刪除path下關于java的目錄；
  - java -version驗證。
- 下載路徑：地址
- 安裝教程：傳送門
  - 官網下載JDK8(選擇JDK8,比較穩定)；
  - 安裝JDK，步驟如上傳送門。

2.Hello World

Hello World
隨便新建一個文件夾，存放代碼。
新建一個Java文件
文件后綴名為.java
Hello.java
注意：系統可能沒有文件的后綴名，需手動打開顯示文件后綴名。
編寫代碼
public class Hello {public static void main(String[] args) {System.out.println("Hello World!Java!");}}
編譯javac.java文件，會生成一個class文件！
運行class文件，java class文件。

可能會遇到的問題
每個單詞的大小不能出現問題，Java是大小寫敏感的；
盡量使用英文；
文件名和類名必須保證一致，并且首字母大寫；
符號使用的了中文。
Java運行機制
- 編譯型
- 解釋型
IDEA2020.2安裝
- 傳送門
Java中的注釋有三種：
- 單行注釋：只能注釋一行文字
- 多行注釋：可以注釋一段文字
- 文檔注釋

/*** @author subeiLY* @create 2021-05-23 21:21*/ public class Hello {// 單行注釋/*多行注釋*//*** 文檔注釋* @param args*/public static void main(String[] args) {// 輸出一個Hello World!System.out.println("Hello World!");}/*** 有趣的代碼注釋 _(\_/)* ,((((^`\* (((( (6 \* ,((((( , \* ,,,_ ,((((( /"._ ,`,* ((((\\ ,... ,(((( / `-.-'* ))) ;' `"'"'""(((( (* ((( / ((( \* )) | |* (( | . ' |* )) \ _ ' `t ,.')* ( | y;- -,-""'"-.\ \/* ) / ./ ) / `\ \* |./ ( ( / /'* || \\ //'|* || \\ _//'||* || )) |_/ ||* \_\ |_/ ||* `'" \_\* `'"**/ }

3.標識符與關鍵字

標識符
- 所有的標識符都應該以字母(A-Z 或者 a-z)，美元符($)，或者下劃線(_)開始；
- 首字符之后可以是字母（A-Z 或者 a-z）美元符（$）、下劃線（）或數字的任何字符組合；
- 不能使用關鍵字作為變量名或方法名；
- 標識符是大小寫敏感的；
- 可以使用中文命名，但是一般不建議這樣去使用，也不建議使用拼音。

/*** @author subeiLY* @create 2021-05-24 18:36*/ public class Demo01 {public static void main(String[] args) {String Ahello = "subeiLY";String hello = "subeiLY";String $hello = "subeiLY";String _hello = "subeiLY";String _vvhh = "subeiLY";String 王者榮耀 = "subeiLY";} }

關鍵字

abstractbooleanbreakbytecase

catch	char	const	class	continue
default	do	double	else	extends
final	finally	float	for	goto
if	implements	import	instanceof	int
interface	long	native	new	package
private	protected	public	return	short
static	strictfp	super	switch	this
throw	throws	transient	try	void
volatile	while	synchronized

4.數據類型

強類型語言
- 要求變量的使用要嚴格符合規定，所有變量都必須先定義后才能使用。
弱類型語言
數據類型基本分類
- 基本類型
  - 數值類型
    - 整數類型
      - byte占1字節，范圍：-128 - 127
      - short占2字節，范圍： -2^15 - 2^15-1
      - int占4字節，范圍： -2^31 - 2^31 - 1
      - long占8字節，范圍： -2^63 - 2^63-1
    - 浮點類型
      - float占4字節
      - double占8字節
    - 字符類型：char占2字節
  - boolean類型：占1位其值只有tue和fase兩個。
- 引用類型
  - 類
  - 接口
  - 數組

/*** @author subeiLY* @create 2021-05-24 19:06*/ public class Demo02 {public static void main(String[] args) {// 八大基本數據類型// 整數int num1 = 10; // 最常用byte num2 = 20;short num3 = 30;long num4 = 40L; // Long類型要在數字后面加L// 小數：浮點數float num5 = 50.1F; // float類型要在數字后面加Fdouble num6 = 3.1415926534546246455;// 字符類型char name = 'A';// 字符串，String不是關鍵字，類String names = "subeiLY";// 布爾值boolean flag = true;boolean flag2 = false;} }

什么是字節
- 位（bit）：是計算機內部數據儲存的最小單位，11001100是一個八位二進制數。
- 字節（byte）：是計算機中數據處理的基本單位，習慣上用大寫B來表示，1B（byte字節）=8bit（位）。
- 字符：是指計算機中使用的字母、數字、字和符號。
  - 1bit表示1位
  - 1Byte表示一個字節1B=8b
  - 1024B=1KB
  - 1024KB=1M
  - 1024M=1G

數據類型擴展及面試題

/*** @author subeiLY* @create 2021-05-25 9:17*/ public class Demo03 {public static void main(String[] args) {// 整數拓展：進制二進制0b 十進制八進制0 十六進制0xint i=10;int i2 = 010; // 八進制0int i3 = 0x10; // 十六進制0xSystem.out.println(i); // 10System.out.println(i2); // 8System.out.println(i3); // 16System.out.println("-------------------------------------");//************************************************// 浮點數拓展// BigDecimal 數據工具類// float 有限離散舍入誤差大約接近但不等于// 最好完全使用浮點數進行比較float f = 0.1f; // 0.1double d = 1.0/10; // 0.1System.out.println(f==d); // falsefloat d1 = 2425444564215654564f;float d2 = d1 + 1;System.out.println(d1==d2); // trueSystem.out.println("-------------------------------------");//************************************************// 字符拓展char c1 = 'a';char c2 = '中';System.out.println(c1);System.out.println((int)c1); // 強制轉換System.out.println(c2);System.out.println((int)c2); // 強制轉換// 所有字符的本質還是數字// 編碼 Unicode 2字節 0 - 65536 Excelchar c3 = '\u0061';System.out.println(c3); // a// 轉義字符// \t 制表符// \n 換行// ......System.out.println("hello\tworld!");System.out.println("hello\nworld!");System.out.println("-------------------------------------");//String sa = new String("hello world");String sb = new String("hello world");System.out.println(sa==sb); // falseString sc = "hello world";String sd = "hello world";System.out.println(sc==sd); // true// 布爾值擴展boolean flag = true;if(flag==true){} // 新手if(flag){} // 老油條// 代碼要精簡易讀} }

5.類型轉換

由于Java是強類型語言，所以要進行有些運算的時候的，需要用到類型轉換。
低 ------------------------------------------------> 高 byte -> short -> char -> int -> long -> float -> double
運算中，不同類型的數據先轉化為同一類型，然后進行運算。

/*** @author subeiLY* @create 2021-05-25 9:45*/ public class Demo04 {public static void main(String[] args) {int i = 128;byte b = (byte)i; // 內存溢出double b1 = i;// 強制轉換 (類型)變量名高--低// 自動轉換低--高System.out.println(i);System.out.println(b);System.out.println(b1);/*注意點：1.不能對布爾類型轉換2.不能將對象類型轉換為不相干的類型3.在把高容量轉換到低容量時，強制轉換4.轉換的時候可能存在內存溢出，或者精度問題！*/System.out.println("++++++++++++++++++++++++++++++++++++");System.out.println((int)123.7);System.out.println((int)-45.89f);System.out.println("=======================");char a = 'a';int c = a+1;System.out.println(c); // 98System.out.println((char)c); // b} }

常見問題

/*** @author subeiLY* @create 2021-05-25 9:56*/ public class Demo05 {public static void main(String[] args) {// 操作比較大時，注意溢出// JDK7新特性，數字之間可以用下劃線分割int money = 10_0000_0000;System.out.println(money);int years = 20;int total = money*years; // -1474836480 計算時溢出System.out.println(total);long total2 = money*years;System.out.println(total2); // 默認是int，轉換之前已經存在問題了!!!long total3 = money*(long)years;System.out.println(total3); // 20000000000} }

6.變量與常量

變量：可以變化的量。
Java是一種強類型語言，每個變量都必須聲明其類型。
Java變量是程序中最基本的存儲單元，其要素包括變量名，變量類型和作用域。
每個變量都有類型，類型可以是基本類型，也可以是引用類型；
變量名必須是合法的標識符；
變量聲明是一條完整的語句，因此每一個聲明都必須以分號結束。

/*** @author subeiLY* @create 2021-05-25 10:46*/ public class Demo06 {static int allClicks = 0; // 類變量String str = "hello world"; // 實例變量public void method(){int i = 0; // 局部變量}public static void main(String[] args) {// int a,b,c;// int a=1,b=2,c=3;String name = "wahaha";char x = 'X';double pi = 3.14;} } /*** @author subeiLY* @create 2021-05-25 10:52*/ public class Demo07 {// 類變量 staticstatic double salary = 2500;// 屬性：變量// 實例變量:從屬于對象：實例變量：從屬于對象；如果不自行初始化，這個類型的默認值 0 0.0// 布爾值：默認是 faLse// 除了基本類型，其余的都是nullString name;int age;// main 方法public static void main(String[] args) {// 局部變量：必須聲明和初始化值int i = 10;System.out.println(i);// 變量類型變量名字 = new Demo08();Demo07 demo07 = new Demo07();System.out.println(demo07.age);System.out.println(demo07.name);// 類變量 staticSystem.out.println(salary);}// 其他方法public void add(int i){System.out.println(i);} }

常量（ Constant）：初始化（ initialize）后不能再改變值！不會變動的值；
所謂常量可以理解成一種特殊的變量，它的值被設定后，在程序運行過程中不允許被改變。
常量名一般使用大寫字符。

/*** @author subeiLY* @create 2021-05-25 14:45*/ public class Demo08 {// 修飾符，不存在先后順序static final double PI = 3.14;public static void main(String[] args) {System.out.println(PI);} }

變量的命名規范
- 所有變量、方法、類名：見名知意；
- 類成員變量：首字母小和駝峰原則：monthSalary；
- 局部變量：首字母小寫和駝峰原則；
- 常量：大寫字母和下劃線：MAX_VALUE；
- 類名：首字母大寫和駝峰原則：Man, GoodMan；
- 方法名：首字母小寫和駝峰原則：run()，runRun()。

7.基本運算符

Java語言支持如下運算符：

算術運算符：+，-，*，/，%，++，–
賦值運算符: =
關系運算符：>，≤，>=，<=，==，!=， instanceof
邏輯運算符：&&，‖，!
位運算符：&，|，A，~，>>，<<，>>>（了解！！！）
條件運算符: ？：
擴展賦值運算符：+=，-=，*=，/=

package github.demo01;/*** @author subeiLY* @create 2021-05-25 15:14*/ public class Demo01 {public static void main(String[] args) {// 二元運算符int a = 10;int b = 20;int c = 25;int d = 25;System.out.println(a+b);System.out.println(a-b);System.out.println(a*b);System.out.println(a/b);System.out.println(a/(double)b);} } package github.demo01;/*** @author subeiLY* @create 2021-05-25 16:03*/ public class Demo02 {public static void main(String[] args) {long a = 123123123123123L;int b = 123;short c = 10;byte d = 8;System.out.println(a+b+c+d);System.out.println(b+c+d);System.out.println(c+d);} } package github.demo01;/*** @author subeiLY* @create 2021-05-25 16:03*/ public class Demo02 {public static void main(String[] args) {long a = 123123123123123L;int b = 123;short c = 10;byte d = 8;System.out.println(a+b+c+d);System.out.println(b+c+d);System.out.println(c+d);System.out.println((double)c+d);} } package github.demo01;/*** @author subeiLY* @create 2021-05-25 18:03*/ public class Demo03 {public static void main(String[] args) {// 關系運算符返回的結果int a = 10;int b = 20;int c = 21;System.out.println(c%a); // c / a 的余數System.out.println(a>b);System.out.println(a<b);System.out.println(a==b);System.out.println(a!=b);} }

8.自增自減運算符、初識Math類

package github.demo01;/*** @author subeiLY* @create 2021-05-25 20:00*/ public class Demo04 {public static void main(String[] args) {// ++ -- 自增，自減一元運算符int a = 3;int b = a++; // 執行完這一行代碼后，先給b賦值，再自增System.out.println(a);int c = ++a; // 執行完這一行代碼前，先自增，再給c賦值System.out.println(a);System.out.println(b);System.out.println(c);// 冪運算 2^3double pow = Math.pow(2,3);System.out.println(pow);} }

9.邏輯運算符、位運算符

package github.demo01;/*** @author subeiLY* @create 2021-05-25 20:10*/ public class Demo05 {// 邏輯運算符public static void main(String[] args) {// 與(and) 或(or) 非(取反)boolean a = true;boolean b = false;System.out.println("a && b:" + (a && b)); // 邏輯與：兩個變量都為真，結果才為trueSystem.out.println("a || b:" + (a || b)); // 邏輯或：兩個變量有一個為真，則結果才為trueSystem.out.println("!(a && b):" + !(a && b)); // 取反：如果是真，則變為假；如果是假，則變為真// 短路運算int c = 5;boolean d = (c<4)&&(c++<4);System.out.println(d);System.out.println(c);} } package github.demo01;/*** @author subeiLY* @create 2021-05-26 9:11*/ public class Demo06 {public static void main(String[] args) {/*A = 0011 1100B = 0000 1101 ----------------------------------A&B = 0000 1100A|B = 0011 1101A^B = 0011 0001~B = 1111 00102*8 = 16<< *2>> /2*/System.out.println(2<<3);} }

10.三元運算符

package github.demo01;/*** @author subeiLY* @create 2021-05-26 9:39*/ public class Demo07 {public static void main(String[] args) {int a = 10;int b = 20;a += b; // a = a+ba -= b; // a = a-bSystem.out.println(a);// 字符串連接System.out.println(""+a+b);System.out.println(a+b+"");} } package github.demo01;/*** @author subeiLY* @create 2021-05-26 9:43*/ public class Demo08 {public static void main(String[] args) {// 三元運算符// x ？ y : z// 如果x==true,則結果為y，否則結果為zint score = 80;String type = score < 60 ? "不及格" : "及格";System.out.println(type);} }

11.包機制

為了更好地組織類，Java提供了包機制，用于區別類名的命名空間。
包語句的語法格式為：

package pkg1[.pkg2[.pkg3……]];

一般利用公司域名倒置作為包名；
為了能夠使用某一個包的成員，我們需要在Java程序中明確導入該包。使用" import"語句可完成此功能。

import package1[.package2……].(classname | *);

12.JavaDoc

javadoc命令是用來生成自己API文檔的。
參數信息
- @ author作者名
- @ version版本號
- @ since指明需要最早使用的jdk版本
- @ paran參數名
- @ return返回值情況
- @ throws異常拋出情況

package github.demo01;/*** @author subeiLY* @create 2021-05-26 10:20* @version 1.0* @since 1.8*/ public class Doc {String name;/*** @author * @param name* @return* @throws Exception*/public String test(String name) throws Exception{return name;} } javadoc -encoding UTF-8 -charset UTF-8 Doc.java

流程控制

1.用戶交互 Scanner

之前我們學的基本語法中我們并沒有實現程序和人的交互，但是Java給我們提供了這樣一個工具類，我們可以獲取用戶的輸入。 java. util. Scanner是Java5的新特征，我們可以通過Scanner類來獲取用戶的輸入。
基本語法
Scanner s = new Scanner(System.in);
通過 Scanner類的next()與 nextLine()方法獲取輸入的字符串，在讀取前我們一般需要使用 hasNext()與 hasNextLine()判斷是否還有輸入的數據。

package github.liuc;import java.util.Scanner;/*** @author subeiLY* @create 2021-05-26 10:42*/ public class Demo01 {public static void main(String[] args) {// 創建一個掃描器對象，用于接收鍵盤數據Scanner scanner = new Scanner(System.in);System.out.println("使用next方法接收:");// 判斷用戶有沒有輸入字符串if(scanner.hasNext()){String str = scanner.next();System.out.println("輸入的內容為:" + str);}// 凡是屬于IO流的類如果不關閉會一直占用資源scanner.close();} } package github.liuc;import java.util.Scanner;/*** @author subeiLY* @create 2021-05-26 10:48*/ public class Demo02 {public static void main(String[] args) {// 從鍵盤接收數據Scanner scanner = new Scanner(System.in);System.out.println("使用nextLine方式接收:");// 判斷是否還有輸入if(scanner.hasNextLine()){String str = scanner.nextLine();System.out.println("輸出的內容為:" + str);}scanner.close();} }

next()：
- 1、一定要讀取到有效字符后才可以結束輸入。
- 2、對輸入有效字符之前遇到的空白，next()方法會自動將其去掉。
- 3、只有輸入有效字符后才將其后面輸入的空白作為分隔符或者結束符。
- 4、next()不能得到帶有空格的字符串。
nextLine()：
- 1、以 Enter為結束符也就是說 nextLine()方法返回的是輸入回車之前的所有字符。
- 2、可以獲得空白。

package github.liuc;import java.util.Scanner;/*** @author subeiLY* @create 2021-05-26 10:58*/ public class Demo04 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);// 從鍵盤接收數據int i = 0;float f = 0.0f;System.out.println("請輸入整數:");// 如果……那么……if(scanner.hasNextInt()){i = scanner.nextInt();System.out.println("整數數據:" + i);}else{System.out.println("輸入的不是整數數據！");}System.out.println("請輸入小數:");// 如果……那么……if(scanner.hasNextFloat()){f = scanner.nextFloat();System.out.println("小數數據:" + f);}else{System.out.println("輸入的不是小數數據！");}scanner.close();} } package github.liuc;import java.util.Scanner;/*** @author subeiLY* @create 2021-05-26 14:17*/ public class Demo05 {public static void main(String[] args) {// 求輸入的數字的總和及平均數Scanner scanner = new Scanner(System.in);// 和double sum = 0;// 計算輸入了多少個數字int m = 0;// 通過循環判斷是否輸入，并統計求和while(scanner.hasNextDouble()){double x = scanner.nextDouble();System.out.println("你輸入了第" + m + "個數據，當前結果為sum=" + sum);m = m +1;sum = sum + x;}System.out.println(m + "個數的和為:" + sum);System.out.println(m + "個數的平均數是:" + (sum/m));scanner.close();} }

2.順序結構

JAVA的基本結構就是順序結構，除非特別指明，否則就按照順序一句一句執行。
順序結構是最簡單的算法結構。
語句與語句之間，框與框之間是按從上到下的順序進行的，它是由若干個依次執行的處理步驟組成的，它是任何一個算法都離不開的一種基本算法結構。

package github.struct;/*** @author subeiLY* @create 2021-05-26 14:27*/ public class SXDemo01 {public static void main(String[] args) {System.out.println("hello1");System.out.println("hello2");System.out.println("hello3");System.out.println("hello4");System.out.println("hello5");System.out.println("hello6");System.out.println("hello7");System.out.println("hello8");} }

3.選擇結構

if單選擇結構
- 我們很多時候需要去判斷一個東西是否可行，然后我們才去執行，這樣一個過程在程序中用if語句來表示。
if(布爾表達式){// 如果布爾表達式為true將執行的語句 } package github.struct;import java.util.Scanner;/*** @author subeiLY* @create 2021-05-26 14:30*/ public class IFDemo01 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("請輸入內容:");String s = scanner.nextLine();// equals：判斷字符串是否相等if(s.equals("Hello")){System.out.println(s);}System.out.println("End");scanner.close();} }
if雙選擇結構
if(布爾表達式){// 如果布爾表達式為true }else{// 如果布爾表達式值為false } package github.struct;import java.util.Scanner;/*** @author subeiLY* @create 2021-05-26 14:36*/ public class IFDemo02 {public static void main(String[] args) {// 考試分數大于60就是及格，小于60則為不及格Scanner scanner = new Scanner(System.in);System.out.println("請輸入成績:");int score = scanner.nextInt();if(score>60){System.out.println("及格");}else {System.out.println("不及格");}scanner.close();} }
if多選擇結構

if(布爾表達式1){// 如果布爾表達式1為true執行代碼 }else if(布爾表達式2){// 如果布爾表達式2為true執行代碼 }else if(布爾表達式3){// 如果布爾表達式3為true執行代碼 }else{// 如果以上布爾表達式值都不為true執行代碼 } package github.struct;import java.util.Scanner;/*** @author subeiLY* @create 2021-05-26 14:41*/ public class IFDemo03 {public static void main(String[] args) {// 考試分數大于60就是及格，小于60則為不及格Scanner scanner = new Scanner(System.in);System.out.println("請輸入成績:");int score = scanner.nextInt();if(score==100){System.out.println("恭喜滿分！");}else if(score<100 && score >=90){System.out.println("A級");}else if(score<90 && score >=80){System.out.println("B級");}else if(score<80 && score >=70){System.out.println("C級");}else if(score<70 && score >=60){System.out.println("D級");}else if(score<60 && score >=0){System.out.println("不及格");}else{System.out.println("成績不合法");}scanner.close();} }

嵌套的f結構
if(布爾表達式1){// 如果布爾表達式1為true執行代碼if(布爾表達式2){// 如果布爾表達式2為true執行代碼} }
switch多選擇結構
- 多選擇結構還有一個實現方式就是 switch case語句。
- switch case語句判斷一個變量與一系列值中某個值是否相等，每個值稱為一個分支。

package github.struct;import java.util.Scanner;/*** @author subeiLY* @create 2021-05-26 14:48*/ public class IFDemo04 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);//char grade = 'K';switch (grade){case 'A':System.out.println("優秀");break;case 'B':System.out.println("良好");break;case 'C':System.out.println("及格");break;case 'D':System.out.println("再接再厲");break;case 'E':System.out.println("掛科");break;default:System.out.println("成績錯誤！！！");}scanner.close();} }

4.循環結構

while循環
while(布爾表達式){// 循環內容 }
- 只要布爾表達式為true，循環就會一直執行下去。
- 我們大多數情況是會讓循環停止下來的，我們需要一個讓表達式失效的方式來結束循環。
- 少部分情況需要循環一直執行，比如服務器的請求響應監聽等。
- 循環條件一直為true就會造成無限循環【死循環】，我們正常的業務編程中應該盡量避免死循環。會影響程序性能或者造成程序卡死奔潰！
package github.struct;/*** @author subeiLY* @create 2021-05-26 15:06*/ public class WileDemo01 {public static void main(String[] args) {// 輸出1~100int i = 0;while(i<100){i++;System.out.println(i);}} } package github.struct;/*** @author subeiLY* @create 2021-05-26 15:07*/ public class WileDemo02 {public static void main(String[] args) {// 死循環while(true){// 等待客戶鏈接// 定時檢查}} } package github.struct;/*** @author subeiLY* @create 2021-05-26 15:09*/ public class WhileDemo03 {public static void main(String[] args) {// 計算1+2+3+...+100=？int i = 0;int sum = 0;while(i<=100){sum = sum + i;i++;}System.out.println(sum);} }
do……while循環
do{// 代碼語句 }while(布爾表達式);
- do……while循環和 while循環相似，不同的是，do…while循環至少會執行一次。
package github.struct;/*** @author subeiLY* @create 2021-05-26 15:15*/ public class DoWhileDemo01 {public static void main(String[] args) {// 計算1+2+3+...+100=？int i = 0;int sum = 0;do{sum = sum + i;i++;}while(i<=100);System.out.println(sum);} } package github.struct;/*** @author subeiLY* @create 2021-05-26 15:16*/ public class DoWhileDemo02 {public static void main(String[] args) {int a = 0;while(a<0){System.out.println(a);a++;}System.out.println("==================");do{System.out.println(a);a++;}while(a<0);} }

While和do- While的區別：
while先判斷后執行。 do……while是先執行后判斷！
Do……while總是保證循環體會被至少執行一次！這是他們的主要差別。

for循環
- for循環語句是支持迭代的一種通用結構，是最有效、最靈活的循環結構。
- for循環執行的次數是在執行前就確定的。語法格式如下：
for(初始化;布爾表達式;更新){// 代碼語句 } package github.struct;/*** @author subeiLY* @create 2021-05-26 15:19*/ public class ForDemo01 {public static void main(String[] args) {int a = 1; // 初始化條件while(a<=100){ // 條件判斷System.out.println(a); // 循環體a+=2; // 迭代}System.out.println("while循環結束!");// 初始化條件判斷迭代for(int i=1;i<=100;i++){System.out.println(i);}System.out.println("for循環結束!");} }
- 關于for循環有以下幾點說明：
  - 最先執行初始化步驟。可以聲明一種類型，但可初始化一個或多個循環控制變量，也可以是空語句。
  - 然后，檢測布爾表達式的值。如果為true，循環體被執行。如果為false，循環終止，開始執行循環體后面的語句。
  - 執行一次循環后，更新循環控制變量（迭代因子控制循環變量的增減）。
  - 再次檢測布爾表達式，執行上面的過程。

package github.struct;/*** @author subeiLY* @create 2021-05-26 15:25*/ public class ForDemo02 {public static void main(String[] args) {// 計算0到100之間的奇數和偶數的和int oddSum = 0;int evenSum = 0;for(int i = 0;i<=100;i++){if(i%2!=0){oddSum+=i;}else{evenSum+=i;}}System.out.println("奇數的和:" + oddSum);System.out.println("偶數的和:" + evenSum);} } package github.struct;/*** @author subeiLY* @create 2021-05-26 15:28*/ public class ForDemo03 {public static void main(String[] args) {// 用whiLe或for循環輸出1-1000之間能被5整除的數，并且每行輸出3個 // for (int i = 0; i < 1000; i++) { // if(i%5==0){ // System.out.print(i + "\t"); // } // if(i%(5*3)==0){ // 每行 // System.out.println(); // // System.out.print("\n"); // } // // /* // println : 輸出完會換行 // print : 輸出完不會換行 // */ // }int i = 0;while(i<1000){if(i%5==0){System.out.print(i + "\t");}if(i%(5*3)==0){ // 每行System.out.println();}i++;}} } package github.struct;/*** @author subeiLY* @create 2021-05-26 15:34*/ public class ForDemo04 {public static void main(String[] args) {// 打印9*9乘法表for(int i = 1;i <= 9;i++){for(int j = 1;j <= i;j++){System.out.print(i + "*" + j + "=" + i*j + "\t");}System.out.println();}} } package github.struct;/*** @author subeiLY* @create 2021-05-26 15:42*/ public class ForDemo05 {public static void main(String[] args) {int[] numbers = {10,20,30,40,50}; // 定義一個數組for(int i = 0;i<5;i++){System.out.println(numbers[i]);}System.out.println("========================");// 遍歷數組的元素for(int x:numbers){System.out.println(x);}} }

5.break& continue

break在任何循環語句的主體部分，均可用 break控制循環的流程。 break用于強行退出循環，不執行循環中剩余的語句。（ break語句也在 switch語句中使用）。
continue語句用在循環語句體中，用于終止某次循環過程，即跳過循環體中尚未執行的語句，接著進行下一次是否執行循環的判定。
關于goto關鍵字
- goto關鍵字很早就在程序設計語言中出現。盡管goto仍是Java的一個保留字，但并未在語言中得到正式使用；Java沒有goto。然而，在 breaki和 continue這兩個關鍵字的身上，我們仍然能看出一些goto的影子—帶標簽的 break和continue。
- “標簽”是指后面跟一個冒號的標識符，例如：label；
- 對Java來說唯一用到標簽的地方是在循環語句之前。而在循環之前設置標簽的唯一理由是：我們希望在其中嵌套另一個循環，由于 break和 continue關鍵字通常只中斷當前循環，但若隨同標簽使用，它們就會中斷到存在標簽的地方。

package github.struct;/*** @author subeiLY* @create 2021-05-26 15:47*/ public class BreakDemo01 {public static void main(String[] args) {int i = 0;while(i<100){i++;System.out.println(i);if(i==30){break;}}System.out.println("123");} } package github.struct;/*** @author subeiLY* @create 2021-05-26 15:49*/ public class ContinueDemo {public static void main(String[] args) {int i = 0;while(i<100){i++;if(i%10==0){System.out.println();continue;}System.out.println(i);}} } package github.struct;/*** @author subeiLY* @create 2021-05-26 15:55*/ public class LabelDemo {public static void main(String[] args) {// 打印101~150之間的所有質數// 質數是指在大的自然數中，除1和它本身以外不再有其他因數的自然數。int count = 0;outer:for(int i = 101;i<150;i++){for(int j = 2;j<i/2;j++){if(i%j==0){continue outer;}}System.out.print(i + " ");}} } package github.struct;/*** @author subeiLY* @create 2021-05-26 15:59*/ public class TestDemo01 {// 打印三角形public static void main(String[] args) {for(int i=1;i<=5;i++){for(int j = 5;j>=i;j--){System.out.print(" ");}for(int j = 1;j<=i;j++){System.out.print("*");}for(int j = 1;j<i;j++){System.out.print("*");}System.out.println();}} }/* 輸出效果：**************************/

方法

1.何謂方法

Java方法是語句的集合，它們在一起執行一個功能。
- 方法是解決一類問題的步驟的有序組合；
- 方法包含于類或對象中；
- 方法在程序中被創建，在其他地方被引用。
設計方法的原則：方法的本意是功能塊，就是實現某個功能的語句塊的集合。我們設計方法的時候，最好保持方法的原子性，就是一個方法只完成1個功能，這樣利于我們后期的擴展。

package github.method;/*** @author subeiLY* @create 2021-05-27 9:28*/ public class Demo01 {// main方法public static void main(String[] args) {int sum = add(1, 2);System.out.println(sum);}// 加法public static int add(int a,int b){return a+b;} }

2.方法的定義及調用

Java的方法類似于其它語言的函數，是一段用來完成特定功能的代碼片段，一般情況下，定義一個方法包含以下語法：
方法包含一個方法頭和一個方法體。下面是一個方法的所有部分：
- 修飾符：修飾符，這是可選的，告訴編譯器如何調用該方法。定義了該方法的訪問類型。
- 返回值類型：方法可能會返回值。 returnValueType是方法返回值的數據類型。有些方法執行所需的操作，但沒有返回值。在這種情況下， returnValueType是關鍵字void。
- 方法名：是方法的實際名稱。方法名和參數表共同構成方法簽名。
- 參數類型：參數像是一個占位符。當方法被調用時，傳遞值給參數。這個值被稱為實參或變量。參數列表是指方法的參數類型、順序和參數的個數。參數是可選的，方法可以不包含任何參數。
  - 形式參數：在方法被調用時用于接收外界輸入的數據。
  - 實參：調用方法時實際傳給方法的數據。
- 方法體：方法體包含具體的語句，定義該方法的功能。
修飾符返回值類型方法名(參數類型參數名){...方法體...return 返回值; }
調用方法：對象名.方法名（實參列表）
Java支持兩種調用方法的方式，根據方法是否返回值來選擇，當方法返回一個值的時候，方法調用通常被當做一個值。例如：

int larger = max(30,40);

如果方法返回值是void，方法調用一定是一條語句。

System.out.println("Hello,subeiLY!");

案例

package github.method;/*** @author subeiLY* @create 2021-05-27 9:46*/ public class Demo02 {public static void main(String[] args) {int max = max(10, 20);System.out.println(max);}// 比大小public static int max(int num1,int num2){int result = 0;if(num1==num2){System.out.println("num1==num2");return 0; // 終止方法}if(num1>num2){result = num1;} else {result = num2;}return result;} }

課后作業：值傳遞和引用傳遞

方法可以修改傳遞引用所對應的變量值，而不能修改傳遞值調用所對應的變量值，這句話相當重要，這是按值調用與引用調用的根本區別，以下為分析：
按值調用(call by value)表示方法接受的時調用者提供的值。

package github.method;/*** @author subeiLY* @create 2021-05-27 9:58*/ public class HomeWork01 {private static int x = 10;public static void updataeValue(int value){value = 3 * value;System.out.println("value的值:" + value);}public static void main(String[] args) {System.out.println("調用前的值:" + x);updataeValue(x);System.out.println("調用后的值:" + x);}}

分析：

1）value被初始化為x值的一個拷貝（也就是10）
2）value被乘以3后等于30，但注意此時x的值仍為10！
3）這個方法結束后，參數變量value不再使用，被回收。

**結論：**當傳遞方法參數類型為基本數據類型（數字以及布爾值）時，一個方法是不可能修改一個基本數據類型的參數。

按引用調用(call by reference)
按引用調用則表示方法接收的是調用者提供的變量地址(如果是C語言的話來說就是指針啦，當然java并沒有指針的概念)
當然java中除了基本數據類型還有引用數據類型，也就是對象引用，那么對于這種數據類型又是怎么樣的情況呢？我們還是一樣先來看一個例子：
先聲明一個User對象類型：

package github.method;/*** @author subeiLY* @create 2021-05-27 10:07*/ public class User {private String name;private int age;public User(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;} }

執行class

package github.method;/*** @author subeiLY* @create 2021-05-27 10:09*/ public class HomeWork02 {public static void updateUser(User student){student.setName("subeiLY");student.setAge(22);}public static void main(String[] args) {User user = new User("SUBEI",20);System.out.println("調用user前的值:" + user.getName() + "," + user.getAge());updateUser(user);System.out.println("調用user后的值:" + user.getName() + "," + user.getAge());} }

分析一下這個過程：

分析：

1）student變量被初始化為user值的拷貝，這里是一個對象的引用。
2）調用student變量的set方法作用在這個引用對象上，user和student同時引用的User對象內部值被修改。
3）方法結束后，student變量不再使用，被釋放，而user還是沒有變，依然指向User對象。

**結論：**顯然，User的值被改變了，但是這是將最開始所對應得值改變了，把User的本身屬性改變了，才會進行值得變化，雖然看似是按引用傳遞值，但是實際上是將值改變了。

到這里估計不少人都蒙逼了，下面我們通過一個反例來說明。

package github.method;/*** java中的按值調用* @author subeiLY* @create 2021-05-27 10:17*/ public class HomeWork03 {/*** 交換兩個對象* @param x* @param y*/public static void swap(User x,User y){User temp = x;x = y;y = temp;}public static void main(String[] args) {User user = new User("user", 26);User stu = new User("stu", 18);System.out.println("調用前user的值："+ user.getName()+","+user.getAge());System.out.println("調用前stu的值："+ stu.getName()+","+stu.getAge());swap(user, stu);System.out.println("調用后user的值："+ user.getName()+","+user.getAge());System.out.println("調用后stu的值："+ stu.getName()+","+stu.getAge());}}

通過程序，會發現user和stu的值并沒有發生變化，也就是方法并沒有改變存儲在變量user和stu中的對象引用。swap方法的參數x和y被初始化為兩個對象引用的拷貝，這個方法交換的是這兩個拷貝的值而已，最終，所做的事都是白費力氣罷了。在方法結束后x，y將被丟棄，而原來的變量user和stu仍然引用這個方法調用之前所引用的對象。

這個過程也充分說明了java程序設計語言對對象采用的不是引用調用，實際上是對象引用進行的是值傳遞，當然在這里我們可以簡單理解為這就是按值調用和引用調用的區別，而且必須明白即使java函數在傳遞引用數據類型時，也只是拷貝了引用的值罷了，之所以能修改引用數據是因為它們同時指向了一個對象，但這仍然是按值調用而不是引用調用。
總結
- 一個方法不能修改一個基本數據類型的參數（數值型和布爾型）。
- 一個方法可以修改一個引用所指向的對象狀態，但這仍然是按值調用而非引用調用。
- 上面兩種傳遞都進行了值拷貝的過程。

以上分析借鑒了zejian_的博文

3.方法重載

重載就是在一個類中，有相同的函數名稱，但形參不同的函數。
方法的重載的規則
- 方法名稱必須相同。
- 參數列表必須不同（個數不同、或類型不同、參數排列順序不同等）
  方法的返回類型可以相同也可以不相同。
- 僅僅返回類型不同不足以成為方法的重載。
實現理論：
- 方法名稱相同時，編譯器會根據調用方法的參數個數、參數類型等去逐個匹配，以選擇對應的方法，如果匹配失敗，則編譯器報錯。

package github.method;/*** @author subeiLY* @create 2021-05-27 9:46*/ public class Demo02 {public static void main(String[] args) {int max = max(10, 20);System.out.println(max);double max2 = max2(10.0, 20.0);System.out.println(max);}// 比大小public static int max(int num1,int num2){int result = 0;if(num1==num2){System.out.println("num1==num2");return 0; // 終止方法}if(num1>num2){result = num1;} else {result = num2;}return result;}// 比大小public static double max2(double num1,double num2){double result = 0;if(num1==num2){System.out.println("num1==num2");return 0; // 終止方法}if(num1>num2){result = num1;} else {result = num2;}return result;} } package github.method;/*** @author subeiLY* @create 2021-05-27 9:28*/ public class Demo01 {// main方法public static void main(String[] args) {int sum = add(1, 2);System.out.println(sum);int sum2 = add2(1, 2, 3);System.out.println(sum2);}// 加法public static int add(int a,int b){return a+b;}public static int add2(int a,int b,int c){return a+b+c;} }

4.命令行傳參

package github.method;/*** @author subeiLY* @create 2021-05-27 10:41*/ public class Demo03 {public static void main(String[] args) {// args.length 數組長度for(int i=0;i < args.length;i++){System.out.println("args[" + i + "]:" + args[i]);}} }

5.可變參數

JDK1.5開始，Java支持傳遞同類型的可變參數給一個方法。
在方法聲明中，在指定參數類型后加一個省略號（）。
一個方法中只能指定一個可變參數，它必須是方法的最后一個參數。任何普通的參數必須在它之前聲明。

package github.method;/*** @author subeiLY* @create 2021-05-27 10:53*/ public class Demo04 {public static void main(String[] args) {Demo04 demo04 = new Demo04();demo04.test(1,2,3,4,5);}public void test(int... i){System.out.println(i[0]);System.out.println(i[1]);System.out.println(i[2]);System.out.println(i[3]);System.out.println(i[4]);} } package github.method;/*** @author subeiLY* @create 2021-05-27 10:53*/ public class Demo04 {public static void main(String[] args) {// 調用可變參數的方法printMax(34,3,3,2,56.5);printMax(new double[]{1,2,3});}public static void printMax(double... numbers){if(numbers.length==0){System.out.println("沒有數據！");return;}double result = numbers[0];// 排序for(int i=1;i<numbers.length;i++){if(numbers[i] > result){result = numbers[i];}}System.out.println("The max Value is " + result);} }

6.遞歸

A方法調用B方法，我們很容易理解！
遞歸就是：A方法調用A方法！就是自己調用自己。
利用遞歸可以用簡單的程序來解決一些復雜的問題。它通常把一個大型復雜的問題層層轉化為一個與原問題相似的規模較小的問題來求解，遞歸策略只需少量的程序就可描述岀解題過程所需要的多次重復計算，大大地減少了程序的代碼量。遞歸的能力在于用有限的語句來定義對象的無限集合。
遞歸結構包括兩個部分：
- 遞歸頭：什么時候不調用自身方法。如果沒有頭，將陷入死循環；
- 遞歸體：什么時候需要調用自身方法。

package github.method;import java.util.Scanner;/*** @author subeiLY* @create 2021-05-27 12:02*/ public class Demo05 {// 5! 5*4*3*2*1public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("請輸入一個數:");int number = scanner.nextInt();int test = test(number);System.out.println(number + "的階乘:" + test);}public static int test(int n){if(n==1){return 1;}else{return n*test(n-1);}} }

寫一個計算器，要求實現加減乘除功能，井且能夠循環接收新的數據，通過用戶交互實現。

package github.method;import java.util.Scanner;/*** @author subeiLY* @create 2021-05-27 15:40*/ public class HomeWork04 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);double sum = 0;while(true){System.out.println("請輸入第一個整數:");double a = scanner.nextDouble();System.out.println("請輸入第二個整數:");double b = scanner.nextDouble();System.out.println("請輸入要運算的字符(+:表示加法,-:表示減法,*:表示乘法,/:表示除法)");String temp = scanner.next();switch (temp){case "+":sum = a + b;System.out.println("結果是:" + sum);continue;case "-":sum = a - b;System.out.println("結果是:" + sum);continue;case "*":sum = a * b;System.out.println("結果是:" + sum);continue;case "/":sum = a / b;System.out.println("結果是:" + sum);continue;default:System.out.println("請輸入正確的運算符號！！");}}} }

總結

以上是生活随笔為你收集整理的狂神说笔记——Java SE基础01的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。