JavaSE篇-Day(6)學習筆記

Java語言基礎

二維數組概述和格式1的講解

/*
	二維數組：就是元素爲一維數組的一個數組。
	
	格式1：
		數據類型[][] 數組名 = new 數據類型[m][n];
		
		m:表示這個二維數組有多少個一維數組。
		n:表示每一個一維數組的元素有多少個。
		
	注意：
		A:以下格式也可以表示二維數組
			a:數據類型 數組名[][] = new 數據類型[m][n];
			b:數據類型[] 數組名[] = new 數據類型[m][n];
		B:注意下面定義的區別
			int x;
			int y;
			int x,y;
			
			int[] x;
			int[] y[];
			
			int[] x,y[];
*/
class Array2Demo {
	public static void main(String[] args) {
		 //定義一個二維數組
		 int[][] arr = new int[3][2];
		 //定義了一個二維數組arr
		 //這個二維數組有3個一維數組的元素
		 //每一個一維數組有2個元素
		 //輸出二維數組名稱
		 System.out.println(arr); //地址值	[[I@175078b
		 //輸出二維數組的第一個元素一維數組的名稱
		 System.out.println(arr[0]); //地址值	[I@42552c
		 System.out.println(arr[1]); //地址值	[I@e5bbd6
		 System.out.println(arr[2]); //地址值	[I@8ee016
		 //輸出二維數組的元素
		 System.out.println(arr[0][0]); //0
		 System.out.println(arr[0][1]); //0
	}
}

二維數組格式1的內存圖解

二維數組格式2的講解

/*
	格式2：
		數據類型[][] 數組名 = new 數據類型[m][];
		
		m:表示這個二維數組有多少個一維數組。
		列數沒有給出，可以動態的給。這一次是一個變化的列數。
*/
class Array2Demo2 {
	public static void main(String[] args) {
		//定義數組
		int[][] arr = new int[3][];
		
		System.out.println(arr);	//[[I@175078b
		System.out.println(arr[0]); //null
		System.out.println(arr[1]); //null
		System.out.println(arr[2]); //null
		
		//動態的爲每一個一維數組分配空間
		arr[0] = new int[2];
		arr[1] = new int[3];
		arr[2] = new int[1];
		
		System.out.println(arr[0]); //[I@42552c
		System.out.println(arr[1]); //[I@e5bbd6
		System.out.println(arr[2]); //[I@8ee016
		
		System.out.println(arr[0][0]); //0
		System.out.println(arr[0][1]); //0
		//ArrayIndexOutOfBoundsException
		//System.out.println(arr[0][2]); //錯誤
		
		arr[1][0] = 100;
		arr[1][2] = 200;
	}
}

二維數組格式2的內存圖解

二維數組格式3的講解

/*
	格式3：
		基本格式：
			數據類型[][] 數組名 = new 數據類型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
		簡化版格式：
			數據類型[][] 數組名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
			
		舉例：
			int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
			int[][] arr = {{1,2,3},{4,5},{6}};
*/
class Array2Demo3 {
	public static void main(String[] args) {
		//定義數組
		int[][] arr = {{1,2,3},{4,5},{6}};
		
		System.out.println(arr);
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		
		System.out.println(arr[0][0]); //1
		System.out.println(arr[1][0]); //4
		System.out.println(arr[2][0]); //6
		
		System.out.println(arr[0][1]); //2
		System.out.println(arr[1][1]); //5
		//越界
		System.out.println(arr[2][1]); //錯誤
	}
}

二維數組格式3的內存圖解

二維數組練習1遍歷

/*
	需求：二維數組遍歷
	
	外循環控制的是二維數組的長度，其實就是一維數組的個數。
	內循環控制的是一維數組的長度。
*/
class Array2Test {
	public static void main(String[] args) {
		//定義一個二維數組
		int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
		
		//請問誰代表{1,2,3}
		//arr[0]就是第一個數組
		//arr[0] = {1,2,3};
		for(int x=0; x<arr[0].length; x++) {
			System.out.println(arr[0][x]);
		}
		System.out.println("--------------");
		
		for(int x=0; x<arr[1].length; x++) {
			System.out.println(arr[1][x]);
		}
		System.out.println("--------------");
		
		for(int x=0; x<arr[2].length; x++) {
			System.out.println(arr[2][x]);
		}
		System.out.println("--------------");
		
		//用循環改進
		for(int x=0; x<3; x++) {
			for(int y=0; y<arr[x].length; y++) {
				System.out.print(arr[x][y]+" ");
			}
			System.out.println();
		}
		System.out.println("--------------");
		
		//這個時候，注意了，3是我們根據上面的代碼得出來的
		//但是，它不能針對任何的數組都可以這樣
		//所以，我們應該想辦法改進
		//其實，外面的這個循環的長度就是二維數組的長度
		
		for(int x=0; x<arr.length; x++) {
			for(int y=0; y<arr[x].length; y++) {
				System.out.print(arr[x][y]+" ");
			}
			System.out.println();
		}
		System.out.println("--------------");
		
		//用方法改進
		//調用方法
		printArray2(arr);
		System.out.println("--------------");
		
		//我們再來一個列數是變化的
		int[][] arr2 = {{1,2,3},{4,5},{6}};
		printArray2(arr2);
	}
	
	/*
		需求：遍歷二維數組
		兩個明確：
			返回值類型：void
			參數列表：int[][] arr
	*/
	public static void printArray2(int[][] arr) {
		for(int x=0; x<arr.length; x++) {
			for(int y=0; y<arr[x].length; y++) {
				System.out.print(arr[x][y]+" ");
			}
			System.out.println();
		}
	}
}

二維數組練習2求和

/*
	公司年銷售額求和
	某公司按照季度和月份統計的數據如下：單位(萬元)
	第一季度：22,66,44
	第二季度：77,33,88
	第三季度：25,45,65
	第四季度：11,66,99
	
	分析：
		A:把題目的數據用二維數組來表示
			int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
		B:如何求和呢?
			求和其實就是獲取到每一個元素，然後累加即可。
		C:定義一個求和變量sum，初始化值是0。
		D:通過遍歷就可以得到每一個二維數組的元素。
		E:把元素累加即可。
		F:最後輸出sum，就是結果。
*/
class Array2Test2 {
	public static void main(String[] args) {
		//把題目的數據用二維數組來表示
		int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
		
		//定義一個求和變量sum，初始化值是0。
		int sum = 0;
		
		//通過遍歷就可以得到每一個二維數組的元素。
		for(int x=0; x<arr.length; x++) {
			for(int y=0; y<arr[x].length; y++) {
				//把元素累加即可。
				sum += arr[x][y];
			}
		}
		
		//最後輸出sum，就是結果。
		System.out.println("一年的銷售額爲："+sum+"萬元");
	}
}

二維數組練習3楊輝三角

/*

	需求：打印楊輝三角形(行數可以鍵盤錄入)
	
	1
	1 1	
	1 2 1
	1 3 3 1
	1 4 6 4 1 
	1 5 10 10 5 1

	分析：看這種圖像的規律
		A:任何一行的第一列和最後一列都是1
		B:從第三行開始，每一個數據是它上一行的前一列和它上一行的本列之和。
	
	步驟：
		A:首先定義一個二維數組。行數如果是n，我們把列數也先定義爲n。
		  這個n的數據來自於鍵盤錄入。
		B:給這個二維數組任何一行的第一列和最後一列賦值爲1
		C:按照規律給其他元素賦值
			從第三行開始，每一個數據是它上一行的前一列和它上一行的本列之和。
		D:遍歷這個二維數組。
*/
import java.util.Scanner;

class Array2Test3 {
	public static void main(String[] args) {
		//創建鍵盤錄入對象
		Scanner sc = new Scanner(System.in);
		
		//這個n的數據來自於鍵盤錄入。
		System.out.println("請輸入一個數據：");
		int n = sc.nextInt();
		
		//定義二維數組
		int[][] arr = new int[n][n];
		
		//給這個二維數組任何一行的第一列和最後一列賦值爲1
		for(int x=0; x<arr.length; x++) {
			arr[x][0] = 1; //任何一行第1列
			arr[x][x] = 1; //任何一行的最後1列
		}
		
		//按照規律給其他元素賦值
		//從第三行開始，每一個數據是它上一行的前一列和它上一行的本列之和。
		for(int x=2; x<arr.length; x++) {
			//這裏如果y<=x是有個小問題的，就是最後一列的問題
			//所以這裏要減去1
			//並且y也應該從1開始，因爲第一列也是有值了
			for(int y=1; y<=x-1; y++) {
				//每一個數據是它上一行的前一列和它上一行的本列之和。
				arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
			}
		}
		
		//遍歷這個二維數組。
		/*
		for(int x=0; x<arr.length; x++) {
			for(int y=0; y<arr[x].length; y++) {
				System.out.print(arr[x][y]+"\t");
			}
			System.out.println();
		}
		*/
		//這個時候，要注意了，內循環的變化必須和曾經講過的九九乘法表類似
		for(int x=0; x<arr.length; x++) {
			for(int y=0; y<=x; y++) {
				System.out.print(arr[x][y]+"\t");
			}
			System.out.println();
		}
	}
}

思考題1Java中的參數傳遞問題及圖解

/*
	思考題1：看程序寫結果，然後分析爲什麼是這個樣子的。並畫圖講解。最後總結Java中參數傳遞規律。
	
	Java中的參數傳遞問題：
		基本類型：形式參數的改變對實際參數沒有影響。
		引用類型：形式參數的改變直接影響實際參數。
*/
class ArgsDemo {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		System.out.println("a:"+a+",b:"+b); //a:10,b:20
		change(a,b);
		System.out.println("a:"+a+",b:"+b); //???	a:10,b:20

		int[] arr = {1,2,3,4,5}; 
		change(arr);
		System.out.println(arr[1]); //???	4
	}

	public static void change(int a,int b) { //a=10,b=20
		System.out.println("a:"+a+",b:"+b); //a:10,b:20
		a = b;	//a=20
		b = a + b; //b=40
		System.out.println("a:"+a+",b:"+b); //a:20,b:40
	}

	public static void change(int[] arr) { //arr={1,2,3,4,5};
		for(int x=0; x<arr.length; x++) {
			if(arr[x]%2==0) {
				arr[x]*=2;
			}
		}
		//arr={1,4,3,8,5};
	}
}

思考題2加密問題的分析和代碼實現

/*
	某個公司採用公用電話傳遞數據信息，數據是小於8位的整數，爲了確保安全，
	在傳遞過程中需要加密，加密規則如下：
		首先將數據倒序，然後將每位數字都加上5，再用和除以10的餘數代替該數字，
		最後將第一位和最後一位數字交換。 請任意給定一個小於8位的整數，
		然後，把加密後的結果在控制檯打印出來。 
		
	題目要求：
		A:數據是小於8位的整數
			定義一個int類型的數據
			int number = 123456;
		B:加密規則
			a:首先將數據倒序
				結果 654321
			b:然後將每位數字都加上5，再用和除以10的餘數代替該數字
				結果 109876
			c:最後將第一位和最後一位數字交換
				結果 609871
		C:把加密後的結果輸出在控制檯
		
		通過簡單的分析，我們知道如果我們有辦法把這個數據變成數組就好了。
		不是直接寫成這個樣子的：
			int[] arr = {1,2,3,4,5,6};
			
		如何把數據轉成數組呢?
			A:定義一個數據
				int number = 123456;
			B:定義一個數組,這個時候問題就來了，數組的長度是多少呢?
				int[] arr = new int[8]; //不可能超過8
				在賦值的時候，我用一個變量記錄索引的變化。
				定義一個索引值是0
				int index = 0;
			C:獲取每一個數據
				int ge = number%10
				int shi = number/10%10
				int bai = number/10/10%10
				
				arr[index] = ge;
				index++;
				arr[index] = shi;
				index++;
				arr[index] = bai;
				...
*/
class JiaMiDemo {
	public static void main(String[] args) {
		//定義一個數據
		int number = 123456;
		
		//定義一個數組
		int[] arr = new int[8];
		
		//把數據中每一位上的數據獲取到後存儲到數組中
		/*
		int index = 0;
		arr[index] = number%10; //arr[0]=6;
		index++;
		arr[index] = number/10%10; //arr[1]=5;
		index++;
		arr[index] = mumber/10/10%10; //arr[2]=4;
		*/
		
		//通過觀察這個代碼，我們發現應該是可以通過循環改進的
		int index = 0;
		
		while(number > 0) { //number=123456,number=12345,number=1234,number=123,number=12,number=1,number=0
			arr[index] = number%10; //arr[0]=6,arr[1]=5,arr[2]=4,arr[3]=3,arr[4]=2,arr[5]=1
			index++;//index=1,index=2,index=3,index=4,index=5,index=6
			number/=10;//number=12345,number=1234,number=123,number=12,number=1,number=0
		}
		
		//然後將每位數字都加上5，再用和除以10的餘數代替該數字
		for(int x=0; x<index; x++) {
			arr[x] += 5;
			arr[x] %= 10;
		}
		
		//最後將第一位和最後一位數字交換
		int temp = arr[0];
		arr[0] = arr[index-1];
		arr[index-1] = temp;
		
		//輸出數據
		for(int x=0; x<index; x++) {
			System.out.print(arr[x]);
		}
		System.out.println();
	}
}

思考2加密問題的代碼改進

package stephencurry;
import java.util.*;
import java.math.*;
import java.io.*;
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
      //這個n的數據來自於鍵盤錄入。
         int num=123456;
         int []a=new int[10];
         int cnt=0;
         while(num>0) {
        	 a[cnt]=num%10;
        	 cnt++;
        	 num/=10;
         }
         for(int i=0;i<cnt;i++) {
        	 a[i]+=5;
        	 a[i]%=10;
         }
         int temp=a[cnt-1];
         a[cnt-1]=a[0];
         a[0]=temp;
         for(int i=0; i<cnt; i++) {
 			System.out.print(a[i]);
 		}
 		System.out.println();
	}
}

面向對象

面向對象的基本思想引入

1:面向對象思想
    面向對象是基於面向過程的編程思想。
    
    面向過程：強調的是每一個功能的步驟
    面向對象：強調的是對象，然後由對象去調用功能
    
2:面向對象的思想特點
    A:是一種更符合我們思想習慣的思想
    B:可以將複雜的事情簡單化
    C:將我們從執行者變成了指揮者
        
    舉例：
        買電腦：
            面向過程：我的瞭解電腦--瞭解我自己的需求--找對應的參數信息--去中關村買電腦--討價還價--買回電腦
            面向對象：我知道我要買電腦 -- 班長去給我買 -- 班長就買回來了
        洗衣服：
            面向過程：把衣服脫下--找一個盆--放點洗衣粉--加點水--把衣服扔進去--搓一搓--清洗衣服--擰乾--晾起來
            面向對象：把衣服脫下--打開全自動洗衣機--扔進去--一鍵即可--晾起來
        吃飯：
            面向過程：去超市買菜--摘菜--洗菜--切菜--炒菜--盛起來--吃
            面向對象：上飯店吃飯，你--服務員(點菜)--廚師(做菜)--服務員(端菜)--吃
            
            家常事物，買洗衣機和去飯店太不划算了，所以，找個對象。
            但是，你不跟我好好學習，你將來4000，你對象8000。
            
3:把大象裝進冰箱
    面向過程：
        動作有哪些呢?
            A:打開冰箱門
            B:裝進大象
            C:關閉冰箱門
            
        代碼體現；
            class Demo {
                public static void main(String[] args) {
                    /*
                    System.out.println("打開冰箱門");
                    //打開冰箱門的東西，我現在僅僅是爲了演示，就寫了一個輸出語句
                    //其實，它可能需要做很多操作。
                    //這個時候代碼就比較多一些了
                    //假設我要多次打開冰箱門，
                    //代碼一多，每次都寫一遍，麻煩不
                    //我們就應該用方法改進
                    
                    System.out.println("裝進大象");
                    System.out.println("關閉冰箱門");
                    */
                    
                    //寫了方法以後，調用就改變了
                    open();
                    in();
                    close();
                }
                
                public static void open() {
                    System.out.println("打開冰箱門");
                }
                
                public static void in() {
                    System.out.println("裝進大象");
                }
                
                public static void close() {
                    System.out.println("關閉冰箱門");
                }
            }
    
    面向對象：
        我們怎麼才能更符合面向對象思想呢?
            A:有哪些類呢?
            B:每個類有哪些東西呢?
            C:類與類直接的關係是什麼呢?
            
        把大象裝進冰箱的分析? (如何分析有哪些類呢?UML。名詞提取法。)
            A:有哪些類呢?
                大象
                冰箱
                Demo
            B:每個類有哪些東西呢?
                大象：
                    進去
                冰箱：
                    開門
                    關門
                Demo:
                    main方法
            C:類與類直接的關係是什麼呢?
                Demo中使用大象和冰箱類的功能。
                
        代碼體現：
            class 大象 {
                public static void in() {
                    System.out.println("裝進大象");
                }
            }
            
            class 冰箱 {
                public static void open() {
                    System.out.println("打開冰箱門");
                }
                
                public static void close() {
                    System.out.println("關閉冰箱門");
                }
            }
            
            class Demo {
                public static void main(String[] args) {
                    冰箱調用開門
                    大象調用進去
                    冰箱調用關門
                }
            }
            
4:開發，設計，特徵
面向對象開發
    就是不斷的創建對象，使用對象，指揮對象做事情。
    
面向對象設計
    其實就是在管理和維護對象之間的關係。

面向對象特徵
    封裝(encapsulation)
    繼承(inheritance)
    多態(polymorphism)

類與對象的概述

現實世界中是如何描述一個事物的呢?
	舉例：學生
			姓名,年齡,性別...
			學習,吃飯,睡覺
			
	屬性：該事物的描述信息
	行爲：該事物能夠做什麼
	
我們學習編程語言，是爲了模擬現實世界的事物的。
而我們學習的編程語言Java中最基本的單位是：類。
所以，我們就應該把事物通過類來體現出來：
由此，我們就得到了現實世界事物和類的對應關係：

事物：						類：	
	屬性						成員變量
	行爲						成員方法
	
	
類：是一組相關的屬性和行爲的集合。是一個抽象的概念。
對象：是該類事物的具體表現形式。具體存在的個體。

舉例：
	學生：類
	班長：對象

類的定義：學生類

/*
	事物：
		屬性	事物的信息描述
		行爲	事物的功能
	
	類：
		成員變量	事物的屬性
		成員方法	事物的行爲
		
	定義一個類，其實就是定義該類的成員變量和成員方法。
	
	案例：我們來完成一個學生類的定義。
	
	學生事物：
		屬性：姓名，年齡，地址...
		行爲：學習，吃飯，睡覺...
		
	把事物要轉換爲對應的類：
	
	學生類：
		成員變量：姓名，年齡，地址...
		成員方法：學習，吃飯，睡覺...
		
	成員變量：和以前變量的定義是一樣的格式，但是位置不同，在類中方法外。
	成員方法：和以前的方法定義是一樣的格式，但是今天把static先去掉。
	
	首先我們應該定義一個類，然後完成類的成員。
*/
//這是我的學生類
class Student {
	//定義變量
	//姓名
	String name;
	//年齡
	int age;
	//地址
	String address;
	
	//定義方法
	//學習的方法
	public void study() {
		System.out.println("學生愛學習");
	}
	
	//吃飯的方法
	public void eat() {
		System.out.println("學習餓了,要吃飯");
	}
	
	//睡覺的方法
	public void sleep() {
		System.out.println("學習累了,要睡覺");
	}
}

學生類的使用

/*
	在一個java文件中寫兩個類：一個基本的類，一個測試類。
	注意：文件名稱和測試類名稱一致。
	
	如何使用呢?
		創建對象使用。
		
	如何創建對象呢?
		格式：類名 對象名 = new 類名();
		
	如何使用成員變量呢?
		對象名.變量名
	如何使用成員方法呢?
		對象名.方法名(...)
*/
//這是學生類
class Student {
	//姓名
	String name; //null
	//年齡
	int age; //0
	//地址
	String address; //null
	
	//學習
	public void study() {
		System.out.println("學生愛學習");
	}
	
	//吃飯
	public void eat() {
		System.out.println("學習餓了，要吃飯");
	}
	
	//睡覺
	public void sleep() {
		System.out.println("學習累了，要睡覺");
	}
}

//這是學生測試類
class StudentDemo {
	public static void main(String[] args) {
		//類名 對象名 = new 類名();
		Student s = new Student();
		
		//輸出成員變量值
		//System.out.println(s.name);
		//System.out.println(s.age);
		//System.out.println(s.address);
		//改進寫法
		System.out.println(s.name+"---"+s.age+"---"+s.address);
		
		
		//給成員變量賦值
		s.name = "林青霞";
		s.age = 27;
		s.address = "北京";
		//賦值後的輸出
		System.out.println(s.name+"---"+s.age+"---"+s.address);
		
		//調用方法
		s.study();
		s.eat();
		s.sleep();
	}
}

類的定義：手機類

/*
	手機事物：
		屬性：品牌，價格，顏色...
		行爲：打電話，發短信，玩遊戲...
		
	手機類：
		成員變量：品牌，價格，顏色
		成員方法：打電話，發短信，玩遊戲
*/
class Phone {
	//品牌
	String brand;
	//價格
	int price;
	//顏色
	String color;
	
	//打電話的方法
	public void call(String name) {
		System.out.println("給"+name+"打電話");
	}
	
	//發短信的方法
	public void sendMessage() {
		System.out.println("羣發短信");
	}
	
	//玩遊戲的方法
	public void playGame() {
		System.out.println("玩遊戲");
	}
}

手機類的使用

/*
	手機類的測試
*/
class Phone {
	//品牌
	String brand;
	//價格
	int price;
	//顏色
	String color;
	
	//打電話的方法
	public void call(String name) {
		System.out.println("給"+name+"打電話");
	}
	
	//發短信的方法
	public void sendMessage() {
		System.out.println("羣發短信");
	}
	
	//玩遊戲的方法
	public void playGame() {
		System.out.println("玩遊戲");
	}
}

class PhoneDemo {
	public static void main(String[] args) {
		//創建手機對象
		//類名 對象名 = new 類名();
		Phone p = new Phone();
		
		//直接輸出成員變量值
		System.out.println(p.brand+"---"+p.price+"---"+p.color);
		
		//給成員變量賦值
		p.brand = "諾基亞";
		p.price = 100;
		p.color = "灰色";
		//再次輸出
		System.out.println(p.brand+"---"+p.price+"---"+p.color);
		
		//調用方法
		p.call("林青霞");
		p.sendMessage();
		p.playGame();
	}
}

一個對象的內存圖

兩個對象的內存圖

三個對象的內存圖