Java基礎(chǔ)語法
數(shù)組操作的2個異常
數(shù)組的索引超過范圍異常 (索引越界)
程序中訪問了不存在的索引, 每個數(shù)組的索引范圍從0開始,最大的索引=數(shù)組的長度-1
public static void main(String[] args) {
//定義存儲int類型的數(shù)組
int[] arr = {1,2,3,4,5};
//數(shù)組中存儲5個元素,長度是5個
System.out.println(arr.length);
//索引0-4
//訪問不存在的索引
System.out.println(arr[5]);
}
數(shù)組的空指針異常
當(dāng)數(shù)組的引用類型變量arr不保存數(shù)組的地址了,再操作數(shù)組,就出現(xiàn)空指針異常
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
System.out.println(arr);
arr = null; //數(shù)組 = 空 , 不再保存數(shù)組在內(nèi)存中的地址了
//不能操作數(shù)組的任何內(nèi)容
System.out.println(arr.length);
}
數(shù)組的內(nèi)存問題
兩個數(shù)組在內(nèi)存中的表現(xiàn)
每個數(shù)組,都會在內(nèi)存中,開辟空間存儲數(shù)據(jù), 內(nèi)存之間是相互獨立的,沒有關(guān)聯(lián)
一個數(shù)組就會占用一個內(nèi)存空間
public static void main(String[] args) {
//定義2個數(shù)組
int[] arr1 = new int[]{1,2,3,4,5};
int[] arr2 = new int[]{6,7,8,9,0};
//輸出數(shù)組,看到不同的地址
System.out.println(arr1);
System.out.println(arr2);
System.out.println(arr1[0]);
System.out.println(arr2[0]);
}
多個變量指向同一個內(nèi)存空間
public static void main(String[] args) {
//定義數(shù)組,存儲一些元素
int[] arr1 = {1,2,3,4};
System.out.println(arr1);
//將數(shù)組arr1的內(nèi)存地址,賦值到另一個變量
int[] arr2 = arr1;
System.out.println(arr2);
System.out.println(arr1[0]);
arr2[0] = 100;
System.out.println(arr1[0]);
}
數(shù)組的常見操作
數(shù)組的遍歷 (迭代)
所謂數(shù)組的遍歷,就是將數(shù)組中的每一個元素分別取出的過程.
數(shù)組的遍歷,是數(shù)組其他操作的一個最基礎(chǔ)的案例
循環(huán)遍歷取出數(shù)組的元素,循環(huán)的次數(shù)由長度決定
public static void main(String[] args) {
int[] arr = {2,4,6,8,10};
//循環(huán)遍歷數(shù)組,取出數(shù)組中的每個元素,依次取出
//數(shù)組的長度是5個,索引0-4 for(知道次數(shù)) while(不知道次數(shù))
for(int i = 0 ; i < arr.length ; i++) {
//利用循環(huán)中的變量i, 作為索引使用,取出數(shù)組的元素
System.out.println(arr[i]);
}
}
數(shù)組最值獲取
取出數(shù)組中的最大值,或者是最小值
實現(xiàn)核心思想 : 遍歷中進(jìn)行比較
/*
- 獲取數(shù)組的最大值
- 實現(xiàn)步驟 :
- 1.定義變量,保存數(shù)組0索引上的元素
- 2.遍歷數(shù)組,取出數(shù)組的每個元素
- 3.數(shù)組的元素和變量,進(jìn)行比較
- 如果數(shù)組的元素,大于變量
- 數(shù)組的元素,存儲在變量中
- 4.數(shù)組全部遍歷完成,變量保存的就是最大值
*/
public class ArrayDemo06 {
public static void main(String[] args) {
//創(chuàng)建數(shù)組
int[] arr = {1,5,10,2,6,9,0,7};
//定義變量,保存數(shù)組0索引上的元素
int max = arr[0];
//遍歷數(shù)組,取出數(shù)組的每個元素
for(int i = 1 ; i < arr.length ; i++) {
//數(shù)組的元素,和變量max比較
if(arr[i] > max) {
//賦值變量
max = arr[i];
}
}
//數(shù)組全部遍歷完成,變量保存的就是最大值
System.out.println("最大值是::"+max);
}
}
數(shù)組的倒序遍歷
public static void main(String[] args) {
int[] arr = {1,3,5,7,9};
//從數(shù)組的最大索引開始遍歷
for(int i = arr.length-1 ; i >= 0 ; i--) {
System.out.println(arr[i]);
}
}
數(shù)組拼接為字符串
任意數(shù)組 : int[] arr = {1,2,3,4,5,6,7}, 遍歷數(shù)組,取出元素,元素拼接為一個字符串
輸出的格式 [1,2,3,4,5,6,7]
/*
- 輸出的格式 [1,2,3,4,5,6,7]
- 數(shù)組遍歷,拼接成上面的格式
- 解決最后一個逗號問題 :
- 判斷循環(huán)變量 i , 如果i的值,到達(dá)了數(shù)組的最大索引
- 字符串拼接] ,而不是逗號
*/
public class ArrayDemo08 {
public static void main(String[] args) {
//創(chuàng)建數(shù)組
int[] arr = {1,2,3,4,5,6,7};
//遍歷,取出元素,字符串的拼接
String s = "[";
for(int i = 0 ; i < arr.length ;i++) {
//判斷i是不是最大索引,如果是拼接]
if(i == arr.length - 1) {
s = s + arr[i]+"]";
}else {
s = s + arr[i]+",";
}
}
System.out.println(s);
}
}
數(shù)組元素的查找
已知數(shù)組 : 在數(shù)組中查找一個元素是否存在
元素存在于數(shù)組中 : 返回元素所在的索引
元素不存在數(shù)組中 : 返回負(fù)數(shù)
實現(xiàn)功能的核心思想 :
/*
數(shù)組元素基本查找
-
已知數(shù)組 : 在數(shù)組中查找一個元素是否存在
元素存在于數(shù)組中 : 返回元素所在的索引
元素不存在數(shù)組中 : 返回負(fù)數(shù)
實現(xiàn)功能的核心思想 : 遍歷,進(jìn)行比較實現(xiàn)思想 :
1. 定義數(shù)組
2. 定義要查找的元素
3. 定義變量,保存查找后的結(jié)果 (數(shù)組的索引,或者是負(fù)數(shù))
4: 遍歷數(shù)組,取出每個元素,和要查找的元素對比
一旦找到,就不會在進(jìn)行比較了
*/
public class ArrayDemo09 {
public static void main(String[] args) {
//1. 定義數(shù)組
int[] arr = {1,5,6,7,2,3,8};
//2. 定義要查找的元素
int key = 1;
//3. 定義變量,保存查找后的結(jié)果 (數(shù)組的索引,或者是負(fù)數(shù))
int index = -1;
//4: 遍歷數(shù)組,取出每個元素,和要查找的元素對比
for(int i = 0 ; i < arr.length ; i++) {
//查找的元素 和 數(shù)組的元素相等,找到了
if(key == arr[i]) {
//數(shù)組的索引,賦值到變量index
index = i;
//不需要再計算了吧,結(jié)束循環(huán)
break;
}
}
if(index >= 0) {
System.out.println("元素找到了,在"+index+"這個索引");
}else{
System.out.println("抱歉,元素未找到");
}
}
}
數(shù)組翻轉(zhuǎn)
所謂數(shù)組翻轉(zhuǎn),就是數(shù)組中元素的位置發(fā)生了轉(zhuǎn)變 不等于倒序遍歷
原始數(shù)組 : {1,2,3,4,5}
翻轉(zhuǎn)數(shù)據(jù) : {5,4,3,2,1}
/*
- 數(shù)組的翻轉(zhuǎn)
- 數(shù)組最遠(yuǎn)端的元素?fù)Q位
- 實現(xiàn)思想 :
- 1. 定義2個變量
- 一個變量,保存數(shù)組的最小索引
- 一個變量,保存數(shù)組的最大索引
- 2: 當(dāng)最小索引,超過最大的索引,程序結(jié)束
- 3: 利用循環(huán)實現(xiàn)
- 4: 第三方變量的位置交換
*/
public class ArrayDemo11 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,0};
//一個變量,保存數(shù)組的最小索引
//一個變量,保存數(shù)組的最大索引
int min = 0;
int max = arr.length - 1;
for(; min <= max ;) {
//第三方變量交換位置
int temp = arr[max]; //臨時變量,保存數(shù)組的最大索引
//最小索引的元素,賦值到最大索引
arr[max] = arr[min];
//臨時變量的值,賦值到小索引上
arr[min] = temp;
//位置交換完畢,修改索引
min++;
max--;
}
//數(shù)組遍歷
for(int i = 0 ; i < arr.length ; i++) {
System.out.println(arr[i]);
}
}
}
以上程序小的優(yōu)化
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,0};
//一個變量,保存數(shù)組的最小索引
//一個變量,保存數(shù)組的最大索引
/* int min = 0;
int max = arr.length - 1;*/
for(int min = 0 , max = arr.length - 1; min <= max ;min++ ,max--) {
//第三方變量交換位置
int temp = arr[max]; //臨時變量,保存數(shù)組的最大索引
//最小索引的元素,賦值到最大索引
arr[max] = arr[min];
//臨時變量的值,賦值到小索引上
arr[min] = temp;
}
//數(shù)組遍歷
for(int i = 0 ; i < arr.length ; i++) {
System.out.println(arr[i]);
}
}</pre>
二維數(shù)組
一維數(shù)組 : 一個數(shù)組,存儲的是需要的數(shù)據(jù) int[] arr = {123}
-
二維數(shù)組 : 一個數(shù)組,存儲的元素,是另一個數(shù)組. 理解為數(shù)組中的數(shù)組
- 定義方式 :
數(shù)據(jù)類型[][] array = new 數(shù)據(jù)類型[3][2];
格式解析 : 定義了一個二維數(shù)組
[3] : 二維數(shù)組的長度, 這個二維數(shù)組里面存儲了3個一維數(shù)組
[2] : 每個一維數(shù)組的長度是2- 二維數(shù)組中,存儲的是一維數(shù)組的內(nèi)存地址
public static void main(String[] args) {
/*
* 二維數(shù)組的長度是3,存儲3個一維數(shù)組
* 每個一維數(shù)組,可以存儲2個元素
*/
int[][] array = new int[3][2];
System.out.println(array);// [[I@15db9742
//思考?
System.out.println(array[0]); // [I@6d06d69c
}
二維數(shù)組的內(nèi)存圖.jpg- 定義方式:
數(shù)據(jù)類型[][] array = new 數(shù)據(jù)類型[][]{}
創(chuàng)建數(shù)組直接賦值元素
public static void main(String[] args) {
int[][] array = new int[][] { {1,2},{3,4,5,6},{7,8,9} };
System.out.println(array);
//思考, 輸出5
System.out.println(array[1][2]);
//數(shù)組的越界異常
System.out.println(array[2][2]);
}- 定義方式:
數(shù)據(jù)類型[][] array = {};</pre>
public static void main(String[] args) {
int[][] array = { {1,2,3},{4,5},{6,7,8,9,0} };
System.out.println(array);
}
遍歷
二維數(shù)組的遍歷 : 和一維數(shù)組遍歷幾乎是一樣的
利用嵌套循環(huán),雙for, 外循環(huán),遍歷二維數(shù)組,內(nèi)循環(huán),遍歷一維數(shù)組
public static void main(String[] args) {
int[][] array = { {1,2,3},{4,5},{6,7,8,9,0} };
//外循環(huán),遍歷二維數(shù)組,取出里面的3個一維數(shù)組
for(int i = 0 ; i < array.length; i++) {
//System.out.println(array[i]);
//內(nèi)循環(huán),遍歷每個一維數(shù)組
for(int j = 0; j <array[i].length;j++ ) {
System.out.print(array[i][j]);
}
System.out.println();
}
}
方法
方法概念
方法(Method)稱為函數(shù)(Function)
方法 : 在程序中是一個可以完成某個功能的獨立代碼片段
某個功能 : 只要可以實現(xiàn)的都是功能 (求和)
獨立代碼 : 方法是在一個{} 實現(xiàn)的, 不同的方法之間是沒有聯(lián)系的
方法好處 : 可以將重復(fù)的代碼抽取出來,方便我們反復(fù)應(yīng)用.
方法定義
- 定義格式
修飾符 返回值類型 方法名(參數(shù)列表){
方法體,主體
return ;
}
* 修飾符 : 目前我們很多點沒有講解,現(xiàn)在就是固定用法 public static
* 返回值類型 : 本質(zhì)上是數(shù)據(jù)類型,方法是實現(xiàn)功能的代碼,功能實現(xiàn)完畢后應(yīng)該是有結(jié)果的,結(jié)果的數(shù)據(jù)類型
* 方法名 : 標(biāo)識符,自定義, 見名知意
* 參數(shù)列表 : 方法要實現(xiàn)的功能中,是否會有未知的數(shù)據(jù),就是參數(shù)列表
* 方法體 : 寫完成功能的代碼
方法定義的練習(xí)
-
要求 : 使用方法技術(shù),實現(xiàn)兩個整數(shù)的求和
/*
* 我們自己定義方法,實現(xiàn)需求 實現(xiàn)兩個整數(shù)的求和
* 2個分析 :
* 功能計算后的結(jié)果是什么,還是整數(shù) 返回值
* 功能計算中是否存在未知的數(shù)據(jù), 兩個整數(shù)就是未知的
* 寫在方法的參數(shù)列表, 定義2個整數(shù)類型變量
*/
public static int sum(int a, int b) {
// 方法體 : 寫完成功能的代碼
return a + b;
}
方法的調(diào)用
什么是方法的調(diào)用 : 就是讓我們寫好的方法執(zhí)行起來
如何調(diào)用方法 : call name 叫名字
傳遞方法的參數(shù), 接收方法的返回值結(jié)果
public static void main(String[] args) {
//調(diào)用寫的方法 sum, 明確方法中的2個未知數(shù)
int i = sum(5,6); // 11
System.out.println(i);
}
/*
* 我們自己定義方法,實現(xiàn)需求 實現(xiàn)兩個整數(shù)的求和
* 2個分析 :
* 功能計算后的結(jié)果是什么,還是整數(shù) 返回值
* 功能計算中是否存在未知的數(shù)據(jù), 兩個整數(shù)就是未知的
* 寫在方法的參數(shù)列表, 定義2個整數(shù)類型變量
*/
public static int sum(int a, int b) {
// 方法體 : 寫完成功能的代碼
return a + b;
}</pre>
方法調(diào)用的內(nèi)存圖
方法的運(yùn)行,是在方法棧運(yùn)行.
方法的壓棧和方法的彈棧,方法進(jìn)入內(nèi)存(棧)到達(dá)底部, 棧內(nèi)存特點是先進(jìn)去的后出來.
方法定義的注意事項 (匹配)
方法不能定義在另一個方法中,寫在類中
方法的定義沒有先后順序的
方法定義的返回值類型,必須和return后面的類型一致
調(diào)用方法傳遞參數(shù)也要一致
如果方法定義上,返回值是void, 你卻返回了值
方法定義的練習(xí)
- 定義方法 : 實現(xiàn)任意整數(shù)的乘法表
public static void main(String[] args) {
//調(diào)用打印乘法表的方法
printChengFaBiao(7);
}
/*
* 定義方法 : 實現(xiàn)任意整數(shù)的乘法表
* 分析:
* 返回值: 功能實現(xiàn)后,結(jié)果的數(shù)據(jù)類型, 沒有返回結(jié)果 void
* 方法參數(shù): 實現(xiàn)功能的未知數(shù), 任意整數(shù)
*
* 方法的返回值沒有,void 方法里面可以不寫 return
/
public static void printChengFaBiao(int num) {
//實現(xiàn)乘法表的功能
for(int i = 1 ; i <= num ; i++) {
for(int j = 1; j <= i ; j++) {
System.out.print(j+""+i+"="+j*i+"\t");
}
System.out.println();
}
}
- 定義方法 : 實現(xiàn)任意數(shù)字的高斯算法 1+2+3...+100
public static void main(String[] args) {
//調(diào)用打印乘法表的方法
//printChengFaBiao(7);
//調(diào)用高斯算法的方法
int sum = getSum(200);
System.out.println(sum);
}
/*- 定義方法 : 實現(xiàn)任意數(shù)字的高斯算法 1+2+3...+100
- 分析:
- 返回值: 功能實現(xiàn)后,結(jié)果的數(shù)據(jù)類型, 結(jié)果是求和的數(shù), 整數(shù)int
- 方法參數(shù): 實現(xiàn)功能的未知數(shù), 任意整數(shù)
/
public static int getSum(int num) {
//定義變量,保存求和的結(jié)果
int sum = 0;
for(int i = 1 ; i <= num ; i++) {
sum = sum + i;
}
//計算的結(jié)果,返回
return sum;
}
/ - 定義方法 : 實現(xiàn)任意整數(shù)的乘法表
- 分析:
- 返回值: 功能實現(xiàn)后,結(jié)果的數(shù)據(jù)類型, 沒有返回結(jié)果 void
- 方法參數(shù): 實現(xiàn)功能的未知數(shù), 任意整數(shù)
- 方法的返回值沒有,void 方法里面可以不寫 return
/
public static void printChengFaBiao(int num) {
//實現(xiàn)乘法表的功能
for(int i = 1 ; i <= num ; i++) {
for(int j = 1; j <= i ; j++) {
System.out.print(j+""+i+"="+j*i+"\t");
}
System.out.println();
}
}
方法調(diào)用上的總結(jié) (調(diào)用方式)
-
賦值調(diào)用
- 接收方法的返回值結(jié)果
-
輸出語句調(diào)用
- 直接將方法的調(diào)用,寫在輸出語句中
直接調(diào)用,不接收任何結(jié)果
如果方法返回值類型是 void , 不能接收返回值
public static void main(String[] args) {
//1: 賦值調(diào)用,方法必須有返回值
int i = sum(1,2);
System.out.println(i);
//2: 輸出語句調(diào)用,方法直接放在輸出語句
System.out.println( sum(7,8) );
//3: 直接調(diào)用,不接收任何結(jié)果
sum(1,5);
Scanner sc = new Scanner(System.in);
System.out.println( sc.nextInt() );
//System.out.println( print() );
}
public static void print() {
System.out.println("這是一個void方法");
}
public static int sum(int a, int b) {
return a + b;
}</pre>
方法的重載
方法的重載(overload) : 在同一個類中,允許方法名字是相同的,只要方法的參數(shù)列表不一致,這些方法就是重載現(xiàn)象.
方法的重載 : 和修飾符,返回值無關(guān)
參數(shù)列表不一致 :
包含參數(shù)的個數(shù)不同
參數(shù)的數(shù)據(jù)類型不同
參數(shù)的順序的不同
以上三個,只要有一個不同,就是重載
public static void main(String[] args) {
//function();
}
/*
* 寫方法,看其他的方法,是否與本方法重載
*/
public static void function() {
}
public static void function(int a) {
}
public static int function(double a) {
return 0;
}
void function(int a, int b) {
}
public static void function(double b,int a) {
}
public static void function(int a, double b) {
}
- 方法重載調(diào)用練習(xí)
public static void main(String[] args) {
function((byte)1);
function((short)1);
function(1L);
}
public static void function() {
System.out.println("這是無參數(shù)的方法");
}
public static void function(byte b) {
System.out.println("字節(jié)型參數(shù)的方法: "+b);
}
public static void function(short s) {
System.out.println("短整型參數(shù)的方法: "+s);
}
public static void function(int i) {
System.out.println("整型參數(shù)的方法: "+i);
}
public static void function(long l) {
System.out.println("長整型參數(shù)的方法: "+l);
}
-
方法重載練習(xí)
需求 : 方法定義實現(xiàn)乘法表
用戶如果傳遞參數(shù),就按照他傳遞參數(shù)輸出乘法表
用戶不傳遞參數(shù),輸出99的, 默認(rèn)
/*
- 需求 : 方法定義實現(xiàn)乘法表
用戶如果傳遞參數(shù),就按照他傳遞參數(shù)輸出乘法表
用戶不傳遞參數(shù),輸出99的, 默認(rèn)
本案例的存在的問題 : 代碼出現(xiàn)了重復(fù) (很大重復(fù))
進(jìn)行簡化,不能有這么大的重復(fù)
方法: 共性代碼的抽取
/
public class MethodDemo07 {
public static void main(String[] args) {
printChengFaBiao(5);
}
/寫有參數(shù)的方法,傳遞什么,輸出什么
/
public static void printChengFaBiao(int num) {
//實現(xiàn)乘法表的功能
for(int i = 1 ; i <= num ; i++) {
for(int j = 1; j <= i ; j++) {
System.out.print(j+""+i+"="+ji+"\t");
}
System.out.println();
}
}
/寫無參數(shù)的方法,實現(xiàn)輸出99乘法表
上面的方法,是帶有參數(shù)的方法,傳遞9,就是99乘法表
-
在本方法中,調(diào)用上面的方法,傳遞9
*/
public static void printChengFaBiao() {
printChengFaBiao(9);//實現(xiàn)乘法表的功能
/*- for(int i = 1 ; i <= 9 ; i++) { for(int j = 1; j <= i ; j++) {
- System.out.print(j+""+i+"="+ji+"\t"); } System.out.println(); }
*/
}
}
方法參數(shù)的傳遞效果
- 方法的參數(shù)是基本數(shù)據(jù)類型
public static void main(String[] args) {
//定義2個變量
int a = 1;
int b = 2;
//調(diào)用方法change,傳遞實際參數(shù)
change(a, b);
System.out.println(a); // a = 1
System.out.println(b); // b = 2
}
/*
* 定義方法,傳遞2個整數(shù)值
* 不返回
*/
public static void change(int a, int b) {
a = a + b;
b = b + a;
}</pre>
- 方法的參數(shù)是引用數(shù)據(jù)類型
public static void main(String[] args) {
int[] arr = {1,2,3};
System.out.println(arr[0]); // 1
//調(diào)用方法change,傳遞數(shù)組,傳遞到方法參數(shù)的也是內(nèi)存的地址
change(arr);
System.out.println(arr[0]); // 100
}
//change方法參數(shù),寫數(shù)組, 方法參數(shù)接收到的也是地址
public static void change(int[] arr) {
//修改數(shù)組中的元素值
arr[0] = 100;
}
