java基礎--------二維數組及面向對象（一）

第一部分 二維數組

二維數組的定義：元素是一維數組的數組。

格式：
數組類型 [] [] 數組名=new 數據類型[m][n];
數組類型[] []數組名= new 數據類型[m][];
數組類型[][]數組名=new 數據類型[][]{{...},{...},{...}};
數組類型[][]數組名={{...},{...},{...}};


二維數組的遍歷

	public static void main(String [] args){
//定義一個長度爲4的二維數組，其中每個元素即一維數組的長度不固定
		int [] [] arr={{1,2,3},{2,3},{3,4,5},{5,6,7,8}};
//外for循環循環的是二維數組的個數
		for(int x=0;x<arr.length;x++){
//內for循環的是二維數組中，每個一維數組的個數
			for(int y=0;y<arr[x].length;y++){
//判斷是否爲每個一維數組的最後一個元素
				if(y==arr[x].length-1){
					System.out.print(arr[x][y]);
				}else{
					System.out.print(arr[x][y]+", ");
				}				
			}
			System.out.println();
		}
	}

二維數組的求和

public static void main(String [] args){
//定義一個二維數組
	int [] [] arr={{1,2,3},{2,3},{3,4,5},{5,6,7,8}};
//定義一個變量sum，用來計算所有元素的和。
	int sum=0;
//內外循環嵌套遍歷數組求和
	for(int x=0;x<arr.length;x++){
//定義一個變量s，用來計算每個一維數組的和。
		int s=0;
		for(int y=0;y<arr[x].length;y++){
			sum+=arr[x][y];
			s+=arr[x][y];
						
		}
	System.out.println("數組中第"+(x+1)+"個一維數組的和爲"+s);			
	}
	System.out.println("數組所有元素的和爲"+sum);
}

應用二維數組輸出楊輝三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1

//分析楊輝三角可得，其實每一行楊輝三角都可以看做是一個一維數組。每行和每列的個數相等。並且arr[x][y]=arr[x-1][y-1]+arr[x-1][y]。
public static void main(String [] args){
//定義一個二維數組
	int [] [] arr=new int [7][7];
//先將每行每列的首個位置，及最後一個位置都輸出1；
	for(int x=0;x<arr.length;x++){
		arr[x][0]=1;
		arr[x][x]=1;
	}
//從第三行第二列開始計算數組中的值
	for(int x=2;x<arr.length;x++){
		for(int y=1;y<x;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<=x;y++){
			System.out.print(arr[x][y]+"\t");
		}
		System.out.println();
	}
}

第二部分 面向對象（一）

1、面向對象：面向對象是基於面向過程的編程思想，其特點是：
（1）：是一種更符合我們思考習慣的思想
（2）：把複雜的事情簡單化
（3）：讓我們從執行者變成了指揮者。
2、注意：如何讓我們的操作更符合面向對象思想呢？
（1）：有哪些類？
（2）：每個類有哪些成員
（3）：類與類的關係
3、類與對象的區別：

class School{//創建一個Shcool類
	//學校類的屬性有學校的名字，學校的辦學時間
	//學校名稱
	String name;
	//學校辦學時間
	int age;
	public void show(){
		System.out.println("我是黑馬學校");
	}
	public void display(){
		System.out.println("我是清華大學");
	}
	public void method(){
		System.out.println("我是北京大學");
	}
	public void func(){
		System.out.println("我是"+name+",辦學時間："+"
	}
}


class SchoolDemo{
	public static void main(String [] args){
		//創建一個學校的對象。格式爲：類名 對象名=new 類名（）;
		//調用：對象名.成員變量; 對象名.成員方法();
		School sch=new School();
		//用對象名分別調用類School的方法。
		sch.show();//輸出"我是黑馬學校";
		sch.display();//輸出"我是清華大學"
		sch.method();//輸出"我是北京大學"
	}
}

類是我們從現實世界中抽象出來的屬性和行爲，與之對應的專業稱呼就是成員變量和成員方法。成員變量對應的是屬性，比如人有名字，年齡；花有色彩，香味。而成員方法對應的行爲，比如人有睡覺，思考，吃飯等行爲；花有開發，結果等功能。實例，有時也稱爲對象，是我們將花類，或者人類，給創建的一個真實的存在。通過這個存在，我們就可以調用這個抽象出來的類的成員變量，和方法。


4、變量中成員變量和局部變量的區別：
（1）：在類中的位置不同
成員變量在一個類的類中，在類中的成員方法外。
局部變量在方法定義中，或者方法聲明上。
（2）：在內存中的位置不同
成員變量的內存開闢在堆內存中
局部變量在調用方法時在棧內存中。
（3）：生命週期不同
成員變量：隨着對象的創建而創建，隨着對象的消失而消失
局部變量：隨着方法的調用而產生，隨着方法的調用完畢而消失。
（4）：初始化值不同
成員變量有默認值。byte/short/int/long類型的默認值爲0；float/double類型的默認值爲0.0；char類型的默認值爲‘\u0000';boolean類型默認爲false;引用類型爲null。
局部變量必須有初始化值。

class Demo{
	String name;
	boolean b;
	int age;
	char ch;
	public void show(){
		System.out.println(name);//輸出爲null
		System.out.println(b);//輸出爲false
		System.out.println(age);//輸出爲0
		System.out.println(ch+"我愛黑馬");// 我愛黑馬（注意"我"字前有空格)
	}
}
class VarDemo{
	public static void main(String [] args){
		//創建對象
		Demo d=new Demo();
		//調用方法
		d.show();
	}
}

5、類作爲參數傳遞及匿名對象
匿名對象就是沒有名字的對象。比如在Demo d=new Demo()中的Demo類的實例對象名爲d;Demo類的匿名對象就是new Demo();

class Demo{
	String name;
	//帶參數的show方法，參數爲String類型
	public void show(String name){
		System.out.println(name);
	}
	//帶參數的show(),但是參數爲Demo類型
	public void show(Demo d){
		d.show();
	}
	//不帶參的show()方法。
	public void show(){
		System.out.println("我要學安卓");
	}
}


class ClassDemo{
	public static void main(String [] args){
		//這裏就是通過匿名對象調用方法。調用的是帶參show(),參數爲String類型
		new Demo().show("黑馬");
		//創建一個對象
		Demo d=new Demo();
		//通過匿名對象調用show,同時參數爲Demo類的對象。
		new Demo().show(d);
		
	}
}

輸出結果：
黑馬
我要學安卓
其實上面這串代碼中Demo類中有三個show()方法，但由於show()中的參數列表不同，因此方法重載。


6、封裝：
封裝的定義是隱藏實現細節，提供公共的訪問方式。像以前學過的方法，類都是封裝的體現。由private修飾的成員方法或者成員變量，也是封裝。因爲被private修飾的變量和方法只能在本類中被訪問。如果想在其他類中訪問這些變量或者方法，就要通過getxxx()/setxxx()。

class Phone{
	//將變量私有
	private String brand;
	private int size;
	public void setBrand(String brand){
	//哪個對象調用這個方法，該方法內部的this就錶帶那個對象。像下面的ph調用了這個方法。就是ph.brand="蘋果";
		this.brand=brand;
	}
	public String getBrand(){
		return brand;
	}
	public void setSize(int size){
		this.size=size;
	}
	public int getSize(){
		return size;
	}
}


class VarDemo{
	public static void main(String [] args){
		Phone ph=new Phone();
		ph.setBrand("蘋果");
		ph.setSize(3);
		System.out.println(ph.getBrand()+"********"+ph.getSize());
	}
}

7、構造方法
構造方法用於對對象的數據進行初始化。一般情況下，構造方法可以分爲兩種，一種是無參構造，一種是帶參構造。

class School{
	//私有成員變量
	private String name;
	private int age;
	//無參構造方法
	School(){}
	//帶參構造方法
	School(String name,int age){
		this.name=name;
		this.age=age;
	}
	public void show(){
		System.out.println(name+"******"+age);
	}
}


class SchoolDemo{
	public static void main(String [] args){
		//創建對象，並且在創建對象的同時，爲對象進行初始化。
		School sc=new School("黑馬",5);
		//調用方法
		sc.show();
	}
}

輸出結果爲：黑馬******5
構造方法的注意事項
A:如果我們沒寫構造方法，系統將提供一個默認的無參構造方法
B:如果我們給出了構造方法，系統將不再提供默認構造方法

如果這個時候，我們要使用無參構造方法，就必須自己給出。

8、static 關鍵字
(1)靜態的意思。可以修飾成員變量和成員方法。
(2)靜態的特點：
A:隨着類的加載而加載
B:優先於對象存在
C:被類的所有對象共享，這其實也是我們判斷該不該使用靜態的依據。
D:可以通過類名調用，既可以通過對象名調用，也可以通過類名調用，建議通過類名調用。
(3)靜態的內容在方法區的靜態區
(4)靜態的注意事項；
A:在靜態方法中沒有this對象
B:靜態只能訪問靜態
(5)靜態變量和成員變量的區別
A:所屬不同
靜態變量：屬於類，類變量
成員變量：屬於對象，對象變量，實例變量
B:內存位置不同
靜態變量：方法區的靜態區
成員變量：堆內存
C:生命週期不同
靜態變量：靜態變量是隨着類的加載而加載，隨着類的消失而消失
成員變量：成員變量是隨着對象的創建而存在，隨着對象的消失而消失
D:調用不同
靜態變量：可以通過對象名調用，也可以通過類名調用
成員變量：只能通過對象名調用

class Demo{
	static String name="andriod";
	String name1="黑馬";
	public void show(){
		System.out.println(name);//編譯報錯，非靜態方法不能訪問靜態變量。靜態只能訪問靜態，非靜態不能訪問靜態。
	}
}


class VarDemo{
	public static void main(String [] args){
		Demo d=new Demo();
		System.out.println(Demo.name);//輸出andriod
		System.out.println(d.name);//andriod
		System.out.println(d.name1);//黑馬
		System.out.println(Demo.name1);//編譯報錯
	}
}