環境
并非所有的計算機都可以開發java程式，java程式的開發與運行需要專門的環境，
因為java語言的程式是運行在java所專有的系統中，
-
要運行java程式我們需要在作業系統（windows，MACOS，Linux）安裝jre（Java Runtime Environment，簡稱JRE），
-
要編譯（開發）java程式，我們就需要安裝JDK（Java Development Kit），
jre和JDK都是一個軟體，jre這個軟體可以運行java編譯后的程式，JDK中包含了JRE，JDK中不止有JRE還有java程式的編譯軟體，我們作為java程式員，只要安裝JDK即可，
[1]安裝JDK
關鍵的步驟:
安裝完成之后，會在安裝的目錄中產生一個檔案夾：
java目錄中有一個JDK和JRE，查看JDK的目錄下的內容：
[2]配置環境變數
我們要使用 java -version 查看當前的JDK的版本，
打開命令視窗：
①在運行中輸入CMD，回車，
②按鍵盤上的win鍵+R鍵，
所有的命令視窗默認都是在C盤，
我們需要連接幾個簡單dos命令，
-
盤符切換 : 進入任何和一個盤符， 都是使用
盤符名稱:比如 :D : -
進入某一個目錄： cd 目錄名稱
我們要執行java命令，就要進入jdk的bin目錄，
因為命令本身也是一段程式，所有要運行這個命令，必須能找到這個命令，所以我們要進入JDK的bin目錄才能執行java的命令，
我們不可能每次執行java程式都要進入這個bin目錄，所以要配置環境變數，環境變數的作用就是讓作業系統可以在任何位置都能找到java的命令，
配置環境變數開始：
新建用戶變數或者系統變數
修改PATH變數
新建編輯環境變數
測驗運行環境和編譯環境的版本：
java語言的介紹
-
java語言是所有的面向物件語言的帶頭大哥，
-
java語言是目前位置跨平臺做的最好的一門語言，
java語言的運行
第一個java程式：
在任何位置創建一個記事本檔案，后綴修改為.java
我這里的命名是Hello.java
在其中撰寫如下內容：
public class Hello{
public static void main(String []args){
System.out.println("Hello Java!");
}
}
保存檔案之后，在檔案所在的目錄進行編譯，使用命令 javac 檔案名，運行位元組碼檔案 : java Hello
第一個java程式的幾個問題：
-
源檔案的后綴必須是.java
-
源檔案的名字最好是英文，所有的單詞的首字母最好大寫，
-
程式中的類名和檔案名必須完全一致
-
java語言是嚴格區分大小寫的，所以該大寫的字母一定要大寫，
-
所有的標點符號必須是英文狀態輸入，
-
每一句程式結束了必須使用“;”結尾，
java程式的運行程序
java程式三步走：
①撰寫源程式， 所謂源程式就是我們撰寫的.java檔案，里面的內容是程式員看得懂，
②編譯遠程， 使用 javac命令將源程式編譯成位元組碼檔案(.class檔案)，java程式是運行在JVM上的，JVM只認識位元組碼檔案，
③執行java位元組碼檔案， 使用java 命令執行java位元組碼檔案，
JVM
JVM本身是一個軟體，在jre中就有JVM，
這臺電腦使用的JVM是：
java語言一個非常重要的特性就是跨平臺，
所謂跨平臺，就是我們在任何一個作業系統中將java源程式編譯成位元組碼檔案，然后這個位元組碼檔案可以在任何其他的作業系統中正常運行，
java語言如何跨平臺：
java語言跨平臺就是通過JVM實作，java程式是運行在JVM上的，和作業系統本身是沒關系，JVM就像一個花盆，java程式就好像花盆中的一顆植物，這棵植物只關心花盆，不關心花盆在哪里，
不同的作業系統上有不同的JVM，這個寫JVM對java程式的解釋是一樣的，
所以Oracle為每一個不同的作業系統都提供了專門的JVM，我們現在所說的JVM只是一個規范（標準），
目前市面上最流行的JVM就是HotSpot，就是全是的java的解釋器就只有HotSpot，這就是它規范的原因，
開發工具
java程式的開發工具：
常見的開發工具：記事本、eclipse（免費的）、IDEA（可以試用一個月）、NetBeans........
java語法語法基礎
Hello程式的說明
我們的第一個java程式：
public class Hello {
public static void main(String[] args) {
System.out.println("Hello Java!");
}
}
java程式的最小阻止單元是"類" (class)，
在java檔案中（.java結尾）撰寫java類，
在Hello.java檔案中的寫法：
public class Hello 是固定寫法，這里Hello稱之為類名，類名必須和檔案名完全一致，public和class 是固定的關鍵字，類中的程式要寫在一對{}
上面類中的:
public static void main(String[] args) {
System.out.println("Hello Java!");
}
稱之為主函式，主函式的簽名： public static void main(String[] args) 固定寫法！！！，
主函式中要執行的程式要寫在一對{}中， 我們目前寫的就是在控制臺輸出“Hello Java”，
基本結構：
類和主函式之間，主函式和要執行的程式之間都是有縮進的，這個縮進是一個制表符，任何一個結構的開始的{ 都是在陳述句的后面，結束的"}"都是在下面的，
資料型別
為什么要有資料型別？
我們認知周邊的事物就是分類識別，同樣計算機要處理資料，也是分類處理資料，所有就有了資料型別，
java中的資料型別：
java中的8中基本資料型別：
-
byte 位元組型， 在記憶體中占8個bit， 表示范圍是 -128 ~127
-
shrot 短整型， 在內中占2個位元組，16個bit， -32768 ~ 32767
-
int 整形， 在記憶體中占4個位元組， 32個bit，-2147483648 ~ 2147483647
-
long 長整型，在記憶體中占8個位元組，64個bit，-9223372036854775808 ~ 9223372036854775806
-
float 浮點型，在記憶體中占4個位元組，32個bit，1.4E-45 ~ 3.4028235E38
-
double雙精度型，在記憶體中占8個位元組，64個bit，4.9E-324 ~ 1.7976931348623157E308
-
char字符型，表示"一個"字符，在記憶體中占2個位元組，16個bit， 0~ 65535
-
boolean布爾型，表示true或者false，在記憶體中理論上占一個bit位， 在java中boolean的值只有true和false，
特殊的參考型別：String 表示字串，多個字符：“Hello”，
變數
變數是存盤資料的最小單元，
java語言是強資料型別別，申明變數的時候必須注名變數要存盤的資料型別，申請之后，變數的型別不能隨意改變，
申請變數的語法：
資料型別 變數名；
給變數賦值依然是使用賦值運算子=:
變數名 = 變數的值 ;
//申請的同時賦值
資料型別 變數名 = 變數的值；
使用變數的時候，直接使用變數的名稱即可，
案例：
public class Demo1 {
public static void main(String [] args){
// 申請變數
int age;
// 給變數賦值(不同資料型別，賦值方式不一樣)
age = 18; // 整形直接寫數字即可，
// 申請的同時賦值
double score = 86.9; // double型別的直接寫數字即可，
// 使用變數輸出這兩個變數值
System.out.println(age);
System.out.println(score);
}
}
不同型別的變數的賦值方式：
// 不同型別的變數的賦值方式
// byte型別， 數字，注意范圍不要超過byte的范圍
byte b = 127;
// short，數字，主要范圍不要超過short范圍
short s = 32000;
// int型別 數字，主要范圍不要超過int范圍
int i = 65432656;
// long型別，數字，注意如果數字超過了int的范圍，則需要使用"L/l"表示當前數字是長整型
long l = 2111111111111110L;
// 字符型 單個字符，必須使用單引號包裹
char ch = '男';
// 浮點型 如果賦值是小數，必須有后綴"F/f"，
float f = 12.0F;
// 雙精度型 數字，直接寫， 可以在后面使用"D/d"，
double d = 12.5;
// boolean型別， 在java中boolean只有true或者false，
boolean flag = true;
?
// 非基本型別的String 型別的名字是String，賦值要使用雙引號
String name = "旗木卡卡西";
命名規則和規范
類名，變數名的命名規則：（絕對不能觸犯）
-
不能以數字開頭
-
不能有特殊符號
-
不能是java的關鍵字或者保留字符，
類名，變數名的命名規范：
-
所有類名 單詞的首字母必須大寫 Demo
- 所有的變數名 第一個單詞全部小寫，其余單詞的首字母必須大寫 firsrName
-
如果是縮寫，類名則全部大寫，變數名則全部小寫
-
言簡意賅，
-
盡量使用英文單詞，如果是拼音，不允許使用拼音和英文的混合，千萬不要使用拼音縮寫，更不要使用中文，
資料型別轉換
所謂資料型別轉換，就是各種不同的資料型別之間的轉換，
問題：不同的資料型別在記憶體中的所占的bit位是不一樣的，那么數字 10 在記憶體中占多少bit位？
理論上數字10只需要4個bit位（1010），但是數字10有不同的型別：
byte b = 10;
short s = 10;
int i = 10;
long l = 10;
float f = 10;
double d = 10;
上面的定義在記憶體中的情況：
任何一個型別在無論數值多大，在記憶體中占的位置大小是固定的，
我們將任何一個byte型別的資料直接賦值給int型別，是否行得通？
byte x = ???; int i = x;
其實就是任何小的型別到大的型別都是自動轉換的，
還有一個特殊的情況就是： char可以自動轉換為int，
看圖記憶：
幾個問題：
給長整型賦值：
當我們寫任何整形數字的時候，如果沒有任何修飾（后綴）， 這個數字默認是int型別，
如果是將這個數字賦值給byte或者short，則默認會轉換為對應的型別，當然范圍必須在對應的型別的范圍內，
byte x = 10; short s = 100;
但是如果將整形數字賦值給長整型變數，這個數字則默認就是整形的，如果超過了整形的范圍，就會報錯，必須使用"L"標明是長整型，
long l = 21111111110L;
給float賦值：
float f = 12.5;
所有的小數在默認情況下都是double，所以當給float的變數賦值小數的時候，必須使用"F"后綴，
小的型別到大的型別是自動轉換的，那么大型別能否轉換小型別，
計算機認為將int轉換為short的時候，空間放不下，可能會丟失資料，我們知道不會丟失，所以我們可以強制轉換，
語法：[目標型別就是我們要轉換成的型別，源資料就是原始的資料]
目標型別 變數名 = （目標型別）源資料，
int x = 10;
// 強制型別轉換
short s2 = (short)x;
上面的案例中是沒有資料丟失的，
double d = 12.5; // 強制型別轉換 int a = (int)d; System.out.println(a);
上面的強制型別轉換會導致小數部分直接被丟棄，
基本型別和字串之間的轉換
任何型別轉換為字串 都可以使用 : xxxx + ""
字串轉換為其他型別：
[1]字串轉換為整形
前提是字串必須是整數形式的字串，比如： "128","369"，
操作語法：
String age = "20"; // 使用Integer.parseInt(str) 將字串轉換為數字 int age_ = Integer.parseInt(age); System.out.println(age_);
如果字串格式不爭取，則會報錯：
[2]轉換為Float或者Double或者Short或者byte或者......
String str = "10"; byte b1 = Byte.parseByte(str); short s3 = Short.parseShort(str); long ll = Long.parseLong(str); float f1 = Float.parseFloat(str); double d1 = Double.parseDouble(str); // 取出字串中的某一個字符， 其中0就索引， char ch = str.charAt(0); String bstr = "false"; boolean flag = Boolean.parseBoolean(bstr);
陳述句
控制臺的輸出陳述句，純粹的為了方便我們學習，在實際作業中，幾乎沒啥用，
固定的語法：
System.out.print();// 輸出不換行 System.out.println();// 輸出且換行
// 直接輸出一個字串，并且換行
System.out.println("今天天氣不太好！");
System.out.println("的確不太好");
// 輸出字串，但是不換行
System.out.print("這是第一行，");
System.out.print("還是第一行");
System.out.println();// 輸出一個空的換行
// 可以輸出任何型別的資料
System.out.println('帥');
System.out.println(15);
System.out.println(15L);
System.out.println(12.5);
System.out.println(true);
// 可以在（）中使用“+”連接任何型別和字串
System.out.println("小明的名字是:" + "小明");
System.out.println("小明的成績是：" + 89);
// 如果是兩個數字，”+“可能會出現數學運算
System.out.println(5+6);
// 任何變數都不需要雙引號，可以直接輸出或者使用"+"連接
String name = "旗木卡卡西";
int age = 28;
System.out.println(name + "的年齡是" + age);
int x = 3;int y = 4;
int temp = x ;
x = y;
y = temp;
System.out.println("x = " + x);
System.out.println("y = " + y);
在輸出陳述句中還有一些特殊的符號
在字串中可以使用\n 表示換行， 可以使用\t表示一個制表符，可以使用\\ 表示一個\
看案例：
// \n表示換行
System.out.println("你好！\n 今天天氣不錯!");
System.out.println("張三\t李四\t王五");
System.out.println("我的程式在C:\\code下");
// 輸出一個成績表
System.out.println("姓名 語文 數學 英語");
System.out.println("張三 80 89 85");
System.out.println("張三豐 80 89 85");
System.out.println("卡卡西 80 89 85");
System.out.println("-------------------");
System.out.println("姓名\t語文\t數學\t英語");
System.out.println("張三\t80\t89\t85");
System.out.println("張三豐\t80\t89\t85");
System.out.println("卡卡西\t80\t89\t85");
java基礎語法
運算子
[1]算數運算子
+，-，*，/，% ，++,--
和之前學習的JS中的使用完全一致，
但是在強資料型別的語言中，一個運算式的最終的結果取決于這個運算式中型別最大的運算元，
案例：
int x = 5,y = 2;
double z = x / y;
System.out.println("z = " + z);// 2.0
得到的z是2.0而不是2.5， 就是因為x和y都是int型別，所以結果會強制轉換為int型別，
案例：
int a = 5;
double b = 20.0 / 5;
應用問題：總共有168條資料，計劃每頁放20條資料，請計算總共需要多少頁？
//總共有168條資料，計劃每頁放20條資料，請計算總共需要多少頁？
int total = 168;
int size = 20;
//int maxPageNum = total % size == 0 ? total / size:(total / size + 1);
int maxPageNum = (int)Math.ceil(total * 1.0 / size);//ceil() 方法執行的是向上取整計算，它回傳的是大于或等于函式引數，并且與之最接近的整數，
System.out.println("最大頁碼是：" + maxPageNum);
總結：
下面的情況： 后面的運算式中有double型別的操作，前面的變數是int型別，無法接收，
int m = 10 + 2 / 5 * ( 1.2 * 5);
解決方案：
①將對應的double型別的運算元強制轉換為int
int m = 10 + 2 / 5 * ( (int)1.2 * 5);
②將整個運算式的結果強制轉換為int
int m = (int)(10 + 2 / 5 * ( 1.2 * 5));
[2]關系運算子
>,>=,<,<=,==,!=
java中沒有 ===和 !==
任何一個運算式中如果出現了比較運算子，則整個運算式的結果肯定是一個布林值，
[3]邏輯運算子
!,&&,||
***問題：&和&&有什么區別？
&&和|| 有短路作用， 在java中&和| 也可以做邏輯運算，但是沒有短路作用，
案例：
int x = 3,y = 4;
boolean flag = x > 3 && (y = 5) > 4;
System.out.println(flag);
System.out.println("x = " + x);
System.out.println("y = " + y);
當我們使用"&&"的時候，最終的結果中flag = false，x = 3，y = 4，
當我們將“&&”修改為“&”的時候，flag = false， x = 3, y = 5;
[4]賦值運算子
=，+=，-=，*=，/=，%=
[5]三目運算
當運算式1的結果為true的時候，整個運算式的結果是運算式2的結果否則是運算式3的結果
運算式1?運算式2：運算式3；
應用：找出兩個數中較大的一個數，
int m = 5,n = 7; int max = m > n ? m : n; System.out.println(max);
流程控制
分支流程
[1]if系列
if(運算式){if陳述句；}
if(運算式){if陳述句}else{else陳述句}
if(運算式){if陳述句}else if(運算式){elseif陳述句}....[else]
上面的分支陳述句的語法中所有的運算式都必須是布爾型別的，
在JS中if(運算式)會自動轉換布林值，但是在java中不行的，
[2]switch
switch(運算式){
case value1:
statement1;
break;// 可選
case value2:
statement2:
break;
.....
default:
statement;
}
在JDK1.7之前switch中的運算式只能是int或者char型別或者列舉，不能是任何其他型別，
在JDK1.7之后，新增了String，
回圈流程
[1]while(){}
要注意的是：（）中的運算式必須是布林值，
java中的while往往使用來做不知道回圈次數的回圈，或者死回圈，
問題：錄入學身的成績，并且計算平均分，
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int score = 0;
int sum = 0;
int count = 1;
while(true){
System.out.println("請錄入第"+count+"位同學的成績(輸入-1表示結束):");
score = sc.nextInt();
if(score == -1){
break;
}
sum += score;
count++;
}
System.out.println("總共錄入了"+count+"位同學的成績，平均分為："+(sum / count));
}
[2]do{}while()；
運算式也必須是布林值，和while的區別就是肯定至少會執行一次，
[3]for(;;){}
for(;;){}
for(運算式1;運算式2;運算式3){
回圈陳述句
}
第一次進入for回圈的時候，首先執行運算式1，在判斷運算式2，如果是true執行回圈陳述句，如果是false就退出回圈，
當回圈陳述句執行結束之后，執行運算式3,繼續判斷表示2的結果，根據結果進入下次回圈或者退出回圈，
for(int i = 0;i< 10;i++){
System.out.println(i);
}
[4]break和continue
break：跳出整個回圈，
continue：結束本次回圈，繼續下次回圈，
控制臺輸入
我們可以使用System.out.print()在控制臺輸出任何內容，
我們也可以使用System.in.read()在控制臺錄入任何內容，
java提供了一個專門的類，Scanner，這個Scanner可以從控制臺錄入任何基本資料型別，
用法：
// ①引入Scanner包
import java.util.Scanner;
public class Demo{
public static void main(String[] args) {
// ②創建一個Scanner物件
Scanner sc = new Scanner(System.in);
// ③錄入資料
// 錄入一個字串
System.out.println("請輸入您的姓名：");
String name = sc.next();// 讀取字串
System.out.println("請輸入您的年齡：");
int age = sc.nextInt();// 讀取控制臺的整形數字
System.out.println("姓名:"+name+"\n年齡："+age);
}
}
注意的事情：
[1]sc.next() 按照 空字符 截斷字串
如果輸入內容如下：
旗木 卡卡西
只能讀取到旗木 而 卡卡西 會進入下一個API的呼叫（可能會報錯），
如果一行的輸入中一定是有空格的，則可以使用sc.nextLine();
[2]讀取控制臺的數字 :
-
sc.nextInt()
-
sc.nextDouble()
-
sc.nextFloat()
當使用這些API的時候，輸入的格式必須正確，否則就會報例外：
變數作用域
所謂變數的作用域就是這個變數從申明到結束，（這個變數可以使用的位置）
java 中變數的作用域就是從變數的申明開始，到離這個變數最近的結束的“｝”結束，
public class Demo6 {
// 成員變數，作用域是在整個類中，
static String name = "這是一個成員變數";
public static void main(String[] args) {
// 區域變數 在main方法中使用
int x = 10;
if (x > 5){
// 區域變數，只能在if陳述句塊中使用，
int z = 100;
}
// 變數a和y 都只能在for回圈中使用
// a在整個回圈中都可以使用，
// y 每次回圈都會創建一個新的，
for(int a = 0;a > 10; a --){
int y = 1000;
System.out.println("0");
}
// 如果要在main方法中使用成員變數，則成員變數必須使用static修飾，
System.out.println(name);
}
}
雙層回圈
問題1：在控制臺輸出矩形
public class Demo7 {
public static void main(String[] args) {
/**
* *****
* *****
* *****
* *****
* *****
*/
for(int i = 0;i < 5 ; i ++) { // 控制行
for(int j = 0;j < 5;j ++) { // 每行顯示的個數
System.out.print("*");
}
System.out.println();// 換行
}
// for(int i = 0;i < 5 ; i ++) {
// System.out.print("*");
// System.out.print("*");
// System.out.print("*");
// System.out.print("*");
// System.out.println("*");
// }
// for(int i = 0;i < 5 ; i ++) {
// System.out.println("******");
// }
// System.out.println("******");
// System.out.println("******");
// System.out.println("******");
// System.out.println("******");
}
}
問題2: 在控制臺輸出一個正三角形
/**
* 雙層回圈
* *
* **
* ***
* ****
* *****
*/
public class Demo8 {
public static void main(String[] args) {
for (int i = 0;i < 5;i ++){// 5行
// 當j < i + 1的時候，隨著行的變數 i + 1 正好是 1~5的變化
for(int j = 0;j < i + 1 ;j ++){ // 控制每行的個數
System.out.print("*");
}
System.out.println();// 換行
}
}
}
問題3： 輸出如下的圖形
* ** *** **** *****
public class Demo9 {
public static void main(String[] args) {
for (int i = 0;i < 5;i ++){// 5行
// 一進來，每一行就開始了，
// 先輸出空格 空格的個數的變化是 4,3,2,1,0
for(int j = 0;j < 5 - i - 1 ;j ++){ // 控制每行的個數
System.out.print(" ");
}
// 然后輸出* 個數變化 1,2,3,4,5
// 當j < i + 1的時候，隨著行的變數 i + 1 正好是 1~5的變化
for(int j = 0;j < i + 1 ;j ++){ // 控制每行的個數
System.out.print("*");
}
System.out.println();// 換行
}
}
}
問題4：輸入如下的圖形
* *** ***** ******* *********
解決方案1：
public class Demo10 {
public static void main(String[] args) {
for (int i = 0;i < 5;i ++){// 5行
// 一進來，每一行就開始了，
// 先輸出空格 空格的個數的變化是 4,3,2,1,0
for(int j = 0;j < 5 - i - 1 ;j ++){ // 控制每行的個數
System.out.print(" ");
}
// 然后輸出* 個數變化 1,2,3,4,5
// 當j < i + 1的時候，隨著行的變數 i + 1 正好是 1~5的變化
for(int j = 0;j < i + 1 ;j ++){ // 控制每行的個數
System.out.print("*");
}
// 每一行增加的*的個數變化是 0,1,2,3,4
for(int j = 0;j < i;j ++){ // 控制每行的個數
System.out.print("*");
}
System.out.println();// 換行
}
}
}
解決方案2：
public class Demo11 {
public static void main(String[] args) {
for (int i = 0;i < 5;i ++){// 5行
// 輸出空格 4,3,2,1,0
for(int j = 0 ; j < 5 - i -1; j ++){
System.out.print(" ");
}
// 輸出* 1,3,5,7,9
for(int j = 0;j < 2 * i +1;j++){
System.out.print("*");
}
System.out.println();// 換行
}
}
}
演算法問題1：
1,1,2,3,5,8,13,21,34.......回圈計算第56位是多少？
/**
* 已知 斐波拉契數列（兔子數列）的第一位和第二位都是1，請計算第56位是多少？
*/
public class Demo12 {
public static void main(String[] args) {
long a =1,b = 1;
for(int x = 3; x <= 56;x ++){
// 計算下一個數
long m = a + b;
System.out.println("第"+x+"位是"+m);
// b賦值給a，m賦值給b
a = b;
b = m;
}
}
}
陣列
變數就是在記憶體中開辟一個空間，存盤一個資料，然后給這個空間起一個別名，他們和在一起就是一個變數，
陣列就是在記憶體開辟一組連續的空間，這組連續的空間的格式是一致的，給這組連續的空間一起起一個別名，給每個空間給上編號，他們和在一起就是一個陣列，
陣列的幾個特點：
-
在記憶體中是連續的空間，每個空間都有對應的索引，索引都是從0開始的，
-
一個陣列中的資料型別都是一致的，
-
陣列一旦初始化，長度是不能改變的，
陣列的初始化和簡單使用
[1]陣列的申明和初始化
在java中陣列使用 []申明,語法
[]在陣列名的前面或者后面都可以，但是一般寫在陣列名的前面 ， 陣列名的命名要求和變數名的命名要求完全一致，
案例：
// 申明陣列 int [] scores; String [] names;
陣列的初始化：語法
方式1：
陣列名 = new 資料型別[length]; // 這里的length必須存在，是整形
方式2：
陣列名 = new 資料型別[]{"卡卡西","佐助","鳴人"} // 直接給陣列元素賦值的情況下，千萬不要寫length
方式3:
// 申明陣列的同時初始化
資料型別 [] 陣列名 = {25,68,98,54,56} // 直接使用{}給陣列賦值，但是這種方式只能使用在申明的同時就初始化的情況，
案例：
// 初始化
scores = new int [5]; // scores中的5個元素的默認值都是0
names = new String[]{"卡卡西","佐助","小丸子"};// 不要寫長度
// 申明陣列的同時初始化
double [] ds = {12.5,12.3,12.6};
當我們使用方式1創建了一個陣列的時候，這個陣列是有默認值的，
String [] names = new String[10]; // 這個陣列的默認值是 null，
各種不同的資料型別的陣列的默認值是：
-
byte [] 默認值 0
-
short [] 默認值 0
-
int [] 默認值 0
-
long[] 默認值 0L
-
float [] 默認值 0.0F
-
double [] 默認值 0.0D
-
char [] 默認值
\u000其實就是一個空字符 -
boolean [] 默認值是 false，
-
其他型別 陣列 默認值全部是 null，
[2]陣列的使用
tips：在java中陣列元素的索引只能是int型別，
獲取指定索引的元素：
String name = 陣列名[index];
給指定索引的元素賦值:
陣列名[index ] = "哈哈";
獲取陣列的元素個數
int length = 陣列名.length;
tips:在java中任何使用我們使用的陣列的索引超過了陣列元素的索引界限時，都會拋出例外，
案例：
public class Demo14 {
public static void main(String[] args) {
// 申明陣列
int [] scores;
String [] names;
// 初始化
scores = new int [5]; // scores中的5個元素的默認值都是0
names = new String[]{"卡卡西","佐助","小丸子"};// 不要寫長度
// 申明陣列的同時初始化
double [] ds = {12.5,12.3,12.6};
// 陣列的簡單使用
String [] ns = new String[5];
ns[0] = "大圣";
ns[1] = "二師兄";
ns[2] = "小丸子";
ns[3] = "喬峰";
ns[4] = "虛竹";
// 獲取陣列的中某一個元素
String name = ns[1];
System.out.println("name-1:"+name);
System.out.println("------------------");
for (int i = 0;i < ns.length; i ++){
System.out.println(ns[i]);
}
}
}
冒泡排序
排序是所有演算法中最為重要的，在筆試中非常的常見，
筆試題：對如下的陣列進行從大到小的排序
int[] arr = {56,86,25,47,98,25,35};
所謂排序是說在程式執行結束之后，記憶體中的陣列修改為如下的樣式
int[] arr = {98,86,56,47,35,25,25};
import java.util.Arrays;
?
/**
* 冒泡
*/
public class Demo2 {
public static void main(String[] args) {
int[] arr = {56,86,25,47,98,25,35};
for(int i = 0; i < arr.length - 1;i ++){// 執行多少輪
for (int j = 0;j < arr.length - 1 - i;j ++){// 內部回圈的次數是 逐個遞減
// 比較j和j+1兩個元素的大小
if(arr[j] < arr[j + 1]){
// 交換兩個元素的位置
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
斷點除錯
找bug：如果程式報錯了，根據錯誤提示可以查找問題所在，如果程式沒有報錯，就必須猜測問題所在， 斷點除錯查找問題，bug不是語法錯誤，
寫好程式，在需要除錯的位置添加斷點：
加好斷點之后，右鍵debug啟動，啟動之后，程式會暫停在添加斷點的位
本文來自博客園，作者：{瀟瀟消消氣}，轉載請注明原文鏈接：{https://www.cnblogs.com/xiaoxiaodeboke/}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/429243.html
標籤：Java
上一篇：3-面向物件(2)
下一篇：SpringBoot自動裝配