Java基礎————語言基礎篇

	經過兩週Java語言的學習,對Java語言有了初步的認識,並且對於語言基礎有了一定的掌握,爲了加深對基礎知識的認識和理解,在此對前兩週的知識進行復盤。

一、基本命名規則。
【1】標識符的命名只能通過字母、數字、下劃線_ 以及美元符 $組成,且不能以數字開頭;
【2】不能以關鍵字或者保留字作爲標識符;
【3】對大小寫敏感。
其中又分爲:
1.**類***的命名規則(帕斯卡命名法):通常定義爲由具有含義的單詞組成,所有單詞的首字母大寫。 如:HelloWorld、 MyTest等等;
2.函數名、變量名***的命名規則(駝峯命名法):可大小寫混寫,首字符小寫,字間分隔符用字的首字母大寫。做到【見名知意】如: main、run、testMethod、getElementById等;
3.包名***的命名規則(域名倒置):全小寫、不以.開頭或結尾。如:com.qf.teach、com.qf.teach.bj 等;
4.常量***的命名規則:使用全部大寫字母,字與字之間用下劃線分隔。如:HELLO_WORLD 、 GET_ELEMENT_BY_ID等;
二、語言基礎。

【1】變量
定義:計算機內存中的一塊存儲空間,是存儲數據的基本單元。
組成:數據類型、變量名、值。
【2】數據類型
1.基本數據類型
在這裏插入圖片描述Java的基本數據類型一共有八種,其中所需要我們注意的是:
(1)、使用***long***關鍵字時,在給這個long類型的變量賦值之後需要在其值的後面追加***L

(2)、使用***float***關鍵字時,在給這個float類型的變量賦值之後需要在其值的後面追加***F

(3)、使用***double***關鍵字時,在給這個double類型的變量賦值之後可以在其值的後面加***D
;也可以不加,因爲計算機中小數的默認數據類型即爲double。
2、引用數據類型
(1)字符串String
任何" "之間的內容都是字符串,包括空格。例如:String str = “HelloWorld”;

(2)數組(本文後面介紹)

3、類型轉換
I. 自動類型轉換:兩種類型相互兼容,目標類型大於源類型。
II. 強制類型轉換:兩種類型相互兼容,目標類型小於源類型。
通過在源類型前面,加上 (目標類型) ,達到強制轉換的目的,但是,有可能失去精度 如:小數強轉爲整數,則失去精度,小數點之後的值,無法保留。
三、選擇結構與分支結構
在進行選擇和分支結構之前,首先我們要認識一個新的知識,那就是***局部變量***:局部變量顧名思義就是局部的變量,專業的講是定義在函數內部的變量,必須先賦值在使用。它的作用範圍是:從定義行開始,到所在的代碼塊結束。需要注意的是:多個變量,在重合的作用範圍內,不允許重名。
【1】選擇結構

1.	基本if選擇結構
語法:
	if(布爾表達式){
		代碼塊 //當表達式結果爲true,則執行該代碼塊
	}

例如:

int a = 5;
if(a == 5){
System.out.println("這是基本if選擇結構");
}
2.if else選擇結構
語法:
	if(布爾表達式){
		//代碼塊1 
	}else{
		//代碼塊2
	}

例如:

int a = 1;
int b = 2;
if(a > b){
System.out.println(a);
}else{
System.out.println(b);
}
3.	多重if選擇結構
語法:
	if(布爾表達式){
		代碼塊1
	}else if(布爾表達式){
		代碼塊2
	}else if(布爾表達式){
		代碼塊3
	}else{
		代碼塊4
	}

注意:相互排斥,當有一個條件爲true時,其他均不再執行,使用與區間判斷(區間條件,遵循從大到小或從小到大)。

例如:

public class TestIfElseN{
	
	public static void main (String[] args){
		
		Scanner sc = new Scanner(System.in);
			
		System.out.println("請選擇你的英雄");
		System.out.println("1.德瑪西亞之力 2.德瑪西亞皇子 3.光輝女郎 4.德邦總管");
		int i = sc.nextInt();
		
		if(i ==1){
			System.out.println("德瑪西亞之力");
		}else if(i == 2){
			System.out.println("德瑪西亞皇子");
		}else if(i == 3){
			System.out.println("光輝女郎");
		}else if(i == 4){
			System.out.println("德邦總管");
		}
		
	}
}
4.	嵌套if選擇結構
語法:
	if(外層布爾表達式){
		if(內層布爾表達式){
			內層代碼塊1
		}else{
			內層代碼塊2
		}
	}else{
		代碼塊2
	}
int a = 5;
int b = 10;
if(a == 5){
	if(b == 10){
	System.out.println("yes");
	}else{
	System.out.println("no");
	}
}else{
System.out.println("nonono");
}

【2】分支結構

語法:

switch(變量|表達式){ //byte short int char String
	case 1:
		邏輯代碼1;
		break;

	case 2:
		邏輯代碼2;
		break;

	default:
		邏輯代碼3;
		break;
}

注意:switch的case被選中後,不會主動退出這個結構,需手工追加break,跳出整個switch。

int  w = 5;
switch(w){
	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;	
	default:
		System.out.println("哈撒給");
		break;
		}
	}
}

四、循環結構

1、通過某個條件,使一段代碼周而復始的執行

2、循環的組成部分:
I. 初始部分:循環用以判斷的變量
II. 循環條件:決定是否繼續循環的依據
III. 循環操作:單次執行的邏輯代碼或任務(一次循環要做的事情)
IV. 迭代部分:控制循環條件改變的增量

3.循環的種類

【1】while循環
	I.	語法:
			while(布爾表達式){
			
			}
	II.	特點:首次即有入口條件,先判斷、再執行;適用於循環次數明確的情況。

例:

int i =0 ;
int sum = 0;
while (i<=100){
sum += i ;
i++;
}
【2】do while循環:
	I.	語法:
			do{

			}while(布爾表達式);
	
	II.	特點:首次沒有入口條件,先執行、再判斷;適用於循環次數不明確的情況。

例:

int i =1 ;
int sum = 0;
do{
	if(i %2 != 0){
	sum += i;
}
	i++;
}while(i<=100);
【3】for循環:
	I.	語法:
			for(  1.初始部分 ;  2.循環條件 ;  4.迭代部分){
				3.循環操作
			}

	II.	特點:首次即有入口條件,先判斷、再執行;適用於循環次數明確的情況。

例:

int j=1;
for(int i = 1 ; i <= 5 ; i++){
	j = j*i;
}
【4】嵌套循環:
	I.	概念:在一個完整的循環當中,嵌套另一個完整的循環結構。

	II.	經驗:
		1).	圖形:外層控制行數、內層控制列數。
		2).	其他:外層控制循環次數、內層控制單次循環操作。

例:

for(int m = 1 ; m <= 9; m++){
	for(int w = 1 ; w <= 12 ; w ++ ){
		for(int b = 1 ; b <= 72 ; b++){
			if((m+w+b==36)&&(4*m+3*w+b/2==36)){
				System.out.println(m+"\n"+w+"\n"+b);
			}
		}
	}
}

4.流程控制語句:
I. break:中止、跳出switch、以及所有的循環結構。

II. continue:結束本次,進入下一次循環。

五、函數

  1. 概念:實現特定功能的一段代碼,可反覆使用。
  2. 函數的定義:
    public static void 函數名稱(){
    //函數的主體(功能代碼)
    }
  3. 定義的位置:定義在類的內部,與main函數並列。多數情況下,定義在main函數的下面。
  4. 函數的調用:函數名();
  5. 函數的執行順序:函數調用時,優先執行函數內部代碼,結束後,返回到函數調用處,繼續向下執行。
  6. 形式參數、實際參數:
    I. 定義語法:
    public static void 函數名稱 ( 形式參數 ) { //局部變量的聲明
    }
    II. 調用語法:
    函數名稱( 實際參數 ); //爲形式參數賦值
  7. 補充:
    I. == 比較的是地址,不是內容。所以當比較字符串時,==不夠準確。
    II. 比較字符串時,應使用 s1.equals(s2) ,可準確的比較字符串內容。
    III. 當比較兩個字符串不相同時,可使用 !s1.equals(s2)。 !(邏輯運算符:非)代表“不是”。
  8. 返回值與返回值類型:
    I. 定義返回值類型:基本數據類型、引用數據類型、void
    II. return value; //函數可以返回一個結果,類型必須與函數定義的返回值類型一致。
    III. 一個函數只能有一個返回值,如果函數中包含分支,需要保證所有的分支都有正確的返回值。
    IV. return的兩種用法:
    1). return value; //表示結束當前函數,並伴有返回值,返回到函數調用處。(有具體的返回值類型)
    2). return; //表示結束當前函數,直接會返回到函數調用處。(返回值類型是void)

例:
無參構造:
在這裏插入圖片描述
有參構造:
在這裏插入圖片描述
return的兩種用法:
在這裏插入圖片描述

  1. 總結:
    I. 注意:一個類中可以定義多個函數,函數之間屬於並列關係,不可嵌套。
    II. 經驗:一個函數只做一件事。
    III. 好處:
    減少代碼冗餘。
    提高複用性。
    提高可讀性。
    提高可維護性。
    方便分工合作。

  2. 遞歸:
    I. 實際再發中,遞歸可以解決一些具有既定規律的問題。
    II. 當需要解決的問題可以拆分成若干個小問題,大問題、小問題的解決方法相同,有特定的規律,函數自己調用自己。
    III. 設置有效的出口條件,避免無窮遞歸。

遞歸案例:

// 求5的階乘
public class DiGui {
	public static void main(String[] args) {
		
		System.out.println(sum(5));
		
	}
	public static int sum(int n){
		if(n==1){
			return 1;
				
		}else{
	return n*sum(n-1);
	    }
	}
}

六、數組

  1. 概念:
    一組連續的存儲空間,存儲多個相同數據類型的值。
  2. 數組的創建:
    數據類型[] 數組名 = new 數據類型[長度]; // int [] a = new int[5];
  3. 數組的組成概述:
    I. 數組中的每個“格子”稱爲“數組的元素”。
    II. 對元素的訪問分爲:“賦值”、“取值”。
    III. 訪問元素時,需要通過“下標”(從0開始,依次+1,自動生成)
    IV. 訪問的語法:數組名[下標]; //存:a[0] = 10; 取:a[0]
    V. 下標的範圍:0 ~ 數組的長度-1 ,如果不在有效下標內,產生java.util.ArrayIndexOutOfBoundsException:錯誤下標
  4. 數組的“擴容”:
    I. 創建數組時,必須顯示指定長度,並在創建之後不可更改長度。
    II. 擴容的思路:
    1). 創建長度大於原數組的新數組。
    2). 將原數組中的數據依次複製到新數組當中。
    III. 數組的複製:
    1). 循環將原數組中的所有元素數據逐一賦值給新數組。
public class ArrayCopy {

	public static void main(String[] args) {
		
		//定義一個初始數組
		int[] arr = new int[5]; 
		
		//給初始數組賦值
		arr[0]=11;
		arr[1]=22;
		arr[2]=33;
		arr[3]=44;
		arr[4]=55;
		//對初始數組進行遍歷
		for(int i = 0; i <arr.length; i++){
			System.out.print(arr[i]+"\t");
		}
		System.out.println();
		//定義一個新的數組
		int[] newArr = new int[arr.length*2];
		
		// 將初始數組元素複製到新的數組中
		for(int i = 0 ; i<arr.length ; i++){
			newArr[i]=arr[i];
		}
		//遍歷新的數組
		for(int i = 0 ; i<newArr.length ; i++){
			System.out.print(newArr[i]+"\t");
		}
		
	}	
		
}

在這裏插入圖片描述
2). System.arraycopy(原數組 , 原數組起始位置 , 新數組 , 新數組起始位置 , 長度);

public class ArrayCopy2 {
	
	public static void main(String[] args) {

	//定義一個數組並賦值
		int[] arr=new int[3];
		arr[0]=10;
		arr[1]=20;
		arr[2]=30;
		//遍歷原數組
		System.out.println("原數組爲:");
		for(int i = 0 ;i <arr.length;i++){
				
			System.out.print(arr[i]+"\t");
		}
		System.out.println();
	//定義一個新的數組
		int[] newArr=new int[5];
		System.arraycopy(arr, 0, newArr, 0, arr.length);
	//遍歷新的數組
		System.out.println("新的數組爲:");
		for(int i = 0 ; i < newArr.length ; i++){
			System.out.print(newArr[i]+"\t");
		}
	}
	
}

在這裏插入圖片描述
3). 數組類型的變量 = java.util.Arrays.copyOf(原數組 , 新長度); //根據長度創建新數組,並將原數組中的元素賦值到新數組中

import java.util.Arrays;

public class ArrayCopy3 {
	public static void main(String[] args) {
		//定義一個數組並賦值
		int[] arr=new int[3];
		arr[0]=10;
		arr[1]=20;
		arr[2]=30;
		//遍歷原數組
		System.out.println("原數組爲:");
		for(int i = 0 ;i <arr.length;i++){
				
			System.out.print(arr[i]+"\t");
		}
		System.out.println();
		
		//定義一個新的數組
		int[] newArr=Arrays.copyOf(arr, 10);
		//遍歷新的數組
		System.out.println("新的數組爲:");
		for(int i = 0 ; i < newArr.length ; i++){
			System.out.print(newArr[i]+"\t");
		}
	}
}

在這裏插入圖片描述

  1. 地址的替換:
    I. 基本數據類型的變量存儲的是值
    II. 引用數據類型的變量存儲的是地址
    III. nums = newNums; //將新數組的地址,賦值給nums變量,進而在後續操作nums時,則操作長度更大的新數組。
  2. 數組類型的參數:
    I. 基本數據類型的傳遞,是“值”的傳遞,一方改變,不會影響另一方
    II. 引用數據類型的傳遞,是“地址”的傳遞,一方改變,會影響另一方
  3. 可變長參數:
    I. 概念:可接收多個同類型實參,個數不限,使用方式與數組相同。
    II. 語法:數據類型… 形參名 //必須定義在形參列表的最後,且只能有一個,支持0~N個參數。
    int… = int[] String… = String[] char… = char[] double… = double[]
    method(xxx , xxx[] , xxx… ); //可變長參數,是對數組的一種便利寫法的補充(80%的場景用數組,20%的場景用可變長參數)
  4. 排序:
    I. 冒泡排序:
    1). 相鄰的兩個值比較大小,互換位置。
    2). 記憶:外層 length - 1 ;內層 length -1 - i
    補充:嵌套循環約定俗稱的變量命名,一重循環 i;二重循環j;三重循環k;
public class MaoPao {
	public static void main(String[] args) {
		
		int[] arr = {22,12,33,99,67,44,2};
		
		for(int i = 0 ; i <arr.length ; i++){
			for(int j = 0 ; j < arr.length-1 ; j++){
				if(arr[j] > arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		for(int i = 0 ; i <arr.length ; i++){
			System.out.print(arr[i]+"\t");
		}
	}
	
}

II. 選擇排序:
1). 固定值與其他值比較大小,互換位置。
2). 記憶:外層 length - 1 ;同時外層i作爲固定值,內層的j = i+1作爲其他值的起始

public class Choice {
	
	public static void main(String[] args) {
		
		int[] arr={99,88,77,66,55,44};
		
		for(int i = 0 ; i <arr.length-1 ; i++){
			
			for(int j =i+1 ; j<arr.length ; j++){
				if(arr[i] > arr[j]){
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		System.out.println("排序後的數組爲:");
		for(int k = 0 ; k < arr.length ; k++){
			System.out.print( arr[k] + "\t");
		}
		
	}
}
  1. 二維數組:
    I. 概念:一維數組中的一維數組,數組中的元素,還是數組。
    II. 語法:數據類型[][] 數組名= new 數據類型[高維][低維];
    III. 注意:高維數組中的每一個元素,保存了低維數組的地址。訪問array[0]等價於在訪問0x0000A111(“二維數組的內存分配圖”)。
    二維數組經典案例之楊輝三角
public class YH {

	public static void main(String[] args) {
//1	
//11		
//121		
//1331		
//14641
		int rows = 5;
		int[][] arr = new int[rows][];
		
		//創建不同長度的二維數組
		for(int i = 0 ; i<arr.length ; i++){
			arr[i]=new int[i+1];
		}
		//完成初始的賦值
		for(int i = 0 ;i <arr.length ;i++){
			arr[i][0] = 1;
			arr[i][i] = 1;
		}
		//判斷計算
		for(int i = 2 ; i < arr.length ; i++){
			for(int j = 1 ; j < i ; j++){
				//當前位置的值 = 上一行的同列 + 上一行的前一個列
				arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
			}
		}
		
		for(int i = 0 ; i < arr.length ; i++){
			for(int j = rows - 1 ; j > i ; j--){//滿足4次
				System.out.print("\t");
			}
		
			for(int j = 0 ; j < arr[i].length ; j++){
				System.out.print( "\t"+ arr[i][j] +"\t");
			}
			System.out.println();
		}
	}
}

在這裏插入圖片描述

以上便是在兩週的Java語言學習中所學到的知識內容,由於是第一次學習Java ,不足之處請各位及時提出,好讓我明白自己的不足,提升自己的知識層面。最後、感謝您的查看。筆芯

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章