JavaSE從頭再來（一）

一、數組

case1 數組反轉

int[] array = {10,20,30,40,50};
        for (int min = 0,max = array.length-1;min < max; min++, max--){
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
           

case2 數組作為傳回參數

public static int[] result(int a, int b){
        int sum = a+b;
        int sub = a-b;
        int multi = a*b;
        int[] result = {sum,sub,multi};
        return result;
    }
           

作用：可以傳回多個參數

case3 數組的toString方法

System.out.println(Arrays.toString(arr));

二、面向對象

case1 成員變量的預設值

資料類型	預設值
基本類型	整數
浮點數	0.0
字元	‘\u0000’
布爾	false
引用類型	數組、類、接口	null

case2 對象的記憶體圖

1.一個對象，調用一個方法記憶體圖

通過上圖，我們可以了解，在棧記憶體中運作的方法，遵循"先進後出，後進先出"的原則。變量p指向堆記憶體中的空間，尋找方法資訊，去執行該方法。

但是，這裡依然有問題存在。建立多個對象時，如果每個對象内部都儲存一份方法資訊，這就非常浪費記憶體了，因為所有對象的方法資訊都是一樣的。

2. 兩個對象使用同一個方法的記憶體圖

對象調用方法時，根據對象中方法标記（位址值），去類中尋找方法資訊。這樣哪怕是多個對象，方法資訊隻儲存一份，節約記憶體空間。

3. 一個引用，作為參數傳遞到方法中記憶體圖

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-hLR6wXVo-1585570310959)(C:/Users/謝康立/AppData/Roaming/Typora/typora-user-images/image-20200327171145672.png)]

引用類型作為參數，傳遞的是位址值。

case3 成員變量和局部變量（定義位置的不同 ）

成員變量	局部變量
位置	類中，方法外	方法中或方法聲明上
作用範圍	類中	方法中
初始化值	有預設值	沒有預設值，必須定義指派才能使用
記憶體位置	堆記憶體	棧記憶體
生命周期	和對象共生死	和方法共生死

case4 封裝

面向對象程式設計語言是對客觀世界的模拟，客觀世界裡成員變量都是隐藏在對象内部的，外界無法直接操作和修改。封裝可以被認為是一個保護屏障，防止該類的代碼和資料被其他類随意通路。要通路該類的資料，必須通過指定的方式。适當的封裝可以讓代碼更容易了解與維護，也加強了代碼的安全性。 如：阻止使用者傳遞不合理的值

原則：将屬性隐藏起來，若需要通路某個屬性，提供公共方法對其通路

使用

private

關鍵字來修飾成員變量

用法：

private 資料類型 變量名

1. private是一個權限修飾符，代表最小權限。
2. 可以修飾成員變量和成員方法。
3. 被private修飾後的成員變量和成員方法，隻在本類中才能通路。

注意：基本類型的boolean值，Getter方法一定要寫出isXXX的形式

如：

public void isMale(){return male;}

this

代表所在類的目前對象的引用（位址值）

用法：

this.成員變量名

記住：方法被哪個對象調用，方法中的this就代表那個對象。即誰在調用，this就代表誰。

封裝優化——構造方法

當一個對象被建立時候，構造方法用來初始化該對象，給對象的成員變量賦初始值。

無論你與否自定義構造方法，所有的類都有構造方法，因為Java自動提供了一個無參數構造方法，一旦自己定義了構造方法，Java自動提供的預設無參數構造方法就會失效。

public class Student {
	private String name;
	private int age;
	// 無參數構造方法
	public Student() {}
	// 有參數構造方法
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
}
           

注意事項：

1. 如果你不提供構造方法，系統會給出無參數構造方法。
2. 如果你提供了構造方法，系統将不再提供無參數構造方法。
3. 構造方法是可以重載的，既可以定義參數，也可以不定義參數。

case5 JavaBean

JavaBean 是 Java語言編寫類的一種标準規範。符合 JavaBean 的類，要求類必須是具體的和公共的，并且具有無參數的構造方法，提供用來操作成員變量的 set 和 get 方法。

即為：

• 成員變量
• 構造方法
• 無參構造方法【必須】
• 有參構造方法【建議】
• 成員方法
• set 和 get 方法

以學生類為例的示範代碼：

public class Student {
	//成員變量
	private String name;
	private int age;
	//構造方法
	public Student() {}
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	} 
    //成員方法
	publicvoid setName(String name) {
		this.name = name;
	} 
    public String getName() {
		return name;
	} 
    publicvoid setAge(int age) {
		this.age = age;
	} 
    publicint getAge() {
		return age;
	}
}
           

測試類：

public class TestStudent {
	public static void main(String[] args) {
	//無參構造使用
	Student s= new Student();
	s.setName("柳岩");
	s.setAge(18);
	System.out.println(s.getName()+"‐‐‐"+s.getAge());
	//帶參構造使用
	Student s2= new Student("趙麗穎",18);
	System.out.println(s2.getName()+"‐‐‐"+s2.getAge());
	}
}
           

三、常用API - 1

case 1 Random類

public int nextInt(int n)

：傳回一個僞随機數，範圍在 0 （包括）和 指定值 n （不包括）之間的

int 值。 [0，n-1]

構造方法：

Random r = new Random();

如果要擷取1-10，則

r.nextInt(10)+1

如果要擷取0-10，則

r.nextInt(10+1)

import java.util.Random;
public class Test01Random {
public static void main(String[] args) {
	int n = 50;
	// 建立對象
	Random r = new Random();
	// 擷取随機數:1~50
	int number = r.nextInt(n) + 1;
	// 輸出随機數
	System.out.println("number:" + number);
	}
}
           

case2 ArrayList類 (對象數組)

數組的長度是固定的，無法适應資料變化的需求。為了解決這個問題，Java提供了另一個容器

java.util.ArrayList

集合類,讓我們可以更便捷的存儲和操作對象資料。

java.util.ArrayList

是大小可變的數組的實作，存儲在内的資料稱為元素。此類提供一些方法來操作内部存儲的元素。 ArrayList 中可不斷添加元素，其大小也自動增長。

java.util.ArrayList<E>

<E>

，表示一種指定的資料類型，叫做泛型，取自Element（元素）的首字母。在出現E的地方，我們使用一種引用資料類型将其替換即可，表示我們将存儲哪種引用類型的元素

基本格式

注意：

• 對于ArrayList來說，直接列印的不是位址值，而是内容
• JDK1.7以後，右側泛型的尖括号之内可以留白，但是<>仍然要寫。簡化格式

成員方法：

增：

public boolean add(E e)

： 将指定的元素添加到此集合的尾部 ，E為元素的類型，傳回值為布爾類型，可以用來判斷是否成功

ArrayList<String> list = new ArrayList<>();
String s1 = "曹操";
String s2 = "劉備";
//add方法
list.add(s1);
list.add(s2);
           

指定增：

public boolean add(int index ,E e)

：将指定的元素插入此清單中的指定位置

删：

public E remove(int index)

：移除此集合中指定位置上的元素。傳回被删除的元素。

改：

public set(int index, E element)

：用指定元素替換清單中指定位置的元素

查：

public E get(int index)

：傳回此集合中指定位置上的元素。傳回擷取的元素。

長度：

public int size()

：傳回此集合中的元素數。周遊集合時，可以控制索引範圍，防止越界。

泛型隻能是引用類型，不能是基本類型！

存儲基本資料類型

ArrayList對象不能存儲基本類型，隻能存儲引用類型的資料。類似

<int>

不能寫，但是存儲基本資料類型對應的包裝類型是可以的。是以，想要存儲基本類型資料，

<>

中的資料類型，必須轉換後才能編寫，轉換寫法如下：

基本類型	基本類型包裝類
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

隻有 Integer 和 Character 需要特殊記憶，其他基本類型隻是首字母大寫即可

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
           

數值添加到集合 ：

生成6個1~33之間的随機整數,添加到集合

Random r = new Random();
ArrayList<Integer> list = new ArrayList<>();

for(int i = 0; i<6;i++){
    int n = r.nextInt(33)+1;
    list.add(n);
}

for (int i = 0; i < list.size(); i++) {
	System.out.println(list.get(i));
}
           

對象添加到集合 ：

自定義4個學生對象,添加到集合,并周遊

AarryList<Stu> list = new ArrayList<stu>();

Stu s1 = new Stu("張三",18);
Stu s2 = new Stu("李四",18);
Stu s3 = new Stu("王五",18);

list.add(s1);
list.add(s2);
list.add(s3);
for(int x = 0; x < list.size(); x++) {
	Student s = list.get(x);
	System.out.println(s.getName()+"‐‐‐"+s.getAge());
}
           

列印集合方法

定義以指定格式列印集合的方法(ArrayList類型作為參數)，使用{}擴起集合，使用@分隔每個元素

格式：{元素@元素@元素}。

public static void printArrayList(ArrayList<String> list) {
	// 拼接左括号
	System.out.print("{");
	// 周遊集合
	for (int i = 0; i < list.size(); i++) {
	// 擷取元素
	String s = list.get(i);
	// 拼接@符号
	if (i != list.size() ‐ 1) {
		System.out.print(s + "@");
	} else {
	// 拼接右括号
		System.out.print(s + "}");
	}
}
           

擷取集合方法 :

定義擷取所有偶數元素集合的方法(ArrayList類型作為傳回值)

public static ArrayList<Integer> getArrayList(ArrayList<Integer> list){
    //建立小集合用來儲存偶數
    ArrayList<Integer> smallList = new ArrayList<>();
    //周遊list
    for(int i = 0;i<list.size();i++){
        Integer num = list.get(i);
        if(num%2==0)
            smallList.add(num);
    }
    return smallList;
}
           

case3 String類

類 String 中包括用于檢查各個字元串的方法，比如用于比較字元串，搜尋字元串，提取子字元串以及建立具有翻

譯為大寫或小寫的所有字元的字元串的副本

特點

1. 字元串不變：字元串的值在建立後不能被更改

   String s1 = "abc";
   s1 += "d";
   System.out.println(s1); // "abcd"
   // 記憶體中有"abc"，"abcd"兩個對象，s1從指向"abc"，改變指向，指向了"abcd"
              

2. 因為String對象是不可變的，是以它們可以被共享。

   String s1 = "abc";
   String s2 = "abc";
   記憶體中隻有一個"abc"對象被建立，同時被s1和s2共享。
              

3. "abc"

   等效于

   char[] data={ 'a' , 'b' , 'c' }

   。

   例如：
   String str = "abc";
   相當于：
   char data[] = {'a', 'b', 'c'};
   String str = new String(data);
   String底層是靠字元數組實作的
              

構造

// 無參構造
String str = new String（）；
// 通過字元數組構造
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);
// 通過位元組數組構造
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);
           

判斷方法

• public boolean equals (Object anObject)

  ：将此字元串與指定對象進行比較

• public boolean equalsIgnoreCase (String anotherString)

  ：忽略大小寫比較

// 建立字元串對象
String s1 = "hello";
String s2 = "hello";
String s3 = "HELLO";
// boolean equals(Object obj):比較字元串的内容是否相同
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
//boolean equalsIgnoreCase(String str):比較字元串的内容是否相同,忽略大小寫
System.out.println(s1.equalsIgnoreCase(s2)); // true
System.out.println(s1.equalsIgnoreCase(s3)); // true
           

擷取功能的方法

• public int length（）

  ：傳回字元串長度

• public String concat(String str)

  ：指定字元串連接配接到該字元串的末尾

• public char charAt(int index)

  ：傳回指定索引處的值

• public int indexOf(String str)

  ：傳回子字元串第一次出現在該字元串内的索引

• public String substring(int beginIndex)

  ：傳回一個子字元串，從索引處開始截取字元串到結尾

• public String substring (int beginIndex,int endIndex)

  ：傳回一個該索引區間的字元串，包含beginIndex，不含endIndex

String s = "helloworld";
//擷取長度
s.length();	//10
//将指定的字元串連接配接到該字元串的末尾 
s.concat("！！"); //helloworld!!
//擷取指定索引處的字元
s.charAt(0);	//h
//擷取str在字元串第一次出現的索引，沒有傳回-1
s.indexOf('l'); //2
s.indexOf("owo");	//4
s.indexOf("ok");	//-1
//從start開始截取字元串到末尾
s.substring(5);	//world
//從start到end截取字元串，含start不含end
s.substring(0,s.length());	//helloworld
s.substring(3,8);	//lowor
           

轉換功能的方法

• public char[] toCharArray()

  ：将字元串轉為新的字元數組

• public byte[] getBytes()

  ：使用預設字元集将String編碼為新的位元組數組

• public String replace(CharSequence target , CharSequence replacement)

  ：将與target比對的字元串使用replacement字元串替換，即後替前

String s = "abcde";
//轉字元數組
char[] chs = s.toCharArray();
//轉位元組數組
byte[] bytes = s.getBytes();
//替換ab為AB
String str = s.replace("ab","AB");
           

分割功能的方法

public String[] split(String regex)

：将此字元串**按照給定的regex（規則）**拆分為字元串數組。

String s1 = "aa|bb|cc";
String s2 = "[email protected]@cc";
//分别根據不同的分割符分割
String[] s1s = s1.split("|");
String[] s2s = s2.split("@");
           

拼接字元串 :

定義一個方法，把數組{1，2，3}按照指定個格式拼接成一個字元串。

格式參照如下：【word1#word2#word3】。

public static String arrayToString(int[] arr) {
    String s = new String("[");
    // 周遊數組，并拼接字元串
    for (int x = 0; x < arr.length; x++) {
        if (x == arr.length-1){
            s = s.concat(arr[x] + "]");
        }else{
            s = s.concat(arr[x] + "#");
        }
    }
    return s;
 }
           

統計字元個數 ：

鍵盤錄入一個字元，統計字元串中大小寫字母及數字字元個數

public static void main(String[] args) {
    //鍵盤錄入一個字元串資料
    Scanner sc = new Scanner(System.in);
    System.out.println("請輸入一個字元串資料：");
    String s = sc.nextLine();
    //定義三個統計變量，初始化值都是0
    int bigCount = 0;
    int smallCount = 0;
    int numberCount = 0;
    //周遊字元串，得到每一個字元
    for (int x = 0; x < s.length(); x++) {
        char ch = s.charAt(x);
        //拿字元進行判斷
        if (ch >= 'A' && ch <= 'Z') {
            bigCount++;
        } else if (ch >= 'a' && ch <= 'z') {
            smallCount++;
        } else if (ch >= '0' && ch <= '9') {
            numberCount++;
        } else {
            System.out.println("該字元" + ch + "非法");
        }
    }
    //輸出結果
    System.out.println("大寫字元：" + bigCount + "個");
    System.out.println("小寫字元：" + smallCount + "個");
    System.out.println("數字字元：" + numberCount + "個");
}

           

case4 static關鍵字

關于

static

關鍵字的使用，它可以用來修飾的成員變量和成員方法，被修飾的成員是屬于類的，而不是單單是屬于某個對象的。也就是說，既然屬于類，就可以不靠建立對象來調用了。

靜态變量（類變量）

當

static

修飾成員變量時，該變量稱為類變量。該類的每個對象都共享同一個類變量的值。任何對象都可以更改該類變量的值，但也可以在不建立該類的對象的情況下對類變量進行操作。

格式：

static 資料類型 變量名

例子：現在想為每一位新來報到的同學編學号（sid），從第一名同學開始，sid為1，以此類推。學号必須是唯一的，連續的，并且與班級的人數相符，這樣以便知道，要配置設定給下一名新同學的學号是多少。這樣我們就需要一個變量，與單獨的每一個學生對象無關，而是與整個班級同學數量有關，即為實作同一個教室，自動配置設定sid的功能

public class Student {
	private String name;
	private int age;
	// 學生的id
	private int sid;
	// 類變量，記錄學生數量，配置設定學号
	public static int numberOfStudent = 0;
	public Student(String name, int age){
		this.name = name;
		this.age = age;
		// 通過 numberOfStudent 給學生配置設定學号
		this.sid = ++numberOfStudent;
	} 
    // 列印屬性值
	public void show() {
		System.out.println("Student : name=" + name + ", age=" + age + ", sid=" + sid );
	}
}
           

靜态方法（類方法）

當

static

修飾成員方法時，該方法稱為類方法 。靜态方法在聲明中有 static ，建議使用類名來調用，而不需要建立類的對象。

定義格式：

修飾符 static 傳回值類型 方法名 (參數清單){
// 執行語句
}
           

調用格式

被static修飾的成員可以并且建議通過類名直接通路。雖然也可以通過對象名通路靜态成員，原因即多個對象均屬于一個類，共享使用同一個靜态成員，但是不建議，會出現警告資訊。

即：

通路類變量：類名.類變量名；

調用靜态方法：類名.靜态方法名(參數)；

public static void main(String[] args) {
	// 通路類變量
	System.out.println(Student.numberOfStudent);
	// 調用靜态方法
	Student.showNum();
}

           

靜态方法和成員方法的差別

public void method(){
    System.out.print("這是成員方法");
}
public static methodStatic(){
    System.out.print("這是靜态方法");
}
           

一旦使用static修飾從成員方法，就成為了靜态方法

靜态方法不屬于對象，而是屬于類的

成員方法必須先建立對象，再能使用

//成員方法需要建立對象，通過對象調用
MyClass obj = new MyClass();
obj.method();
//靜态方法可以直接通過類名調用
MyClass.methodStatic();
           

成員方法	靜态方法
修飾	void xxx();	static void xxx();
調用方式	對象.方法	類.方法
通路步驟	先建立對象後調用	直接調用

成員變量、成員方法、靜态變量和靜态方法

public class MyClass(){
    int num;  //成員變量
    static int numStatic;  //靜态變量
    
    //成員方法
    public void method(){
        System.out.println("這是一個成員方法：");
        //成員方法可以通路成員變量
        System.out.println(num);
        //成員方法可以通路靜态變量
        System.out.println(numStatic);
    }
    
    //靜态方法
    public static void methodStatic(){
    	System.out.println("這是一個靜态方法：");
        //成員方法可以通路靜态變量
        System.out.println(numStatic);
    }
}
           

靜态不能通路非靜态

• 在記憶體中是【先】有的靜态内容，【後】有的非靜态内容
• “先人不知道後人，但是後人肯定知道先人”

靜态方法中不能使用this

• this代表目前對象，但是靜态對應的不是對象

**原理圖解 **

static 修飾的内容：

• 是随着類的加載而加載的，且隻加載一次。
• 存儲于一塊固定的記憶體區域（靜态區），是以，可以直接被類名調用。
• 它優先于對象存在，是以，可以被所有對象共享。

靜态代碼塊

定義在成員位置，使用static修飾的代碼塊{ }。

• 位置：類中方法外。
• 執行：随着類的加載而執行且執行一次，優先于main方法和構造方法的執行。

用途：給類變量進行初始化指派

public class Game {
	public static int number;
	public static ArrayList<String> list;
	
    static {
	// 給類變量指派
	number = 2;
	list = new ArrayList<String>();
	// 添加元素到集合中
	list.add("張三");
	list.add("李四");
	}
}
           

static 關鍵字，可以修飾變量、方法和代碼塊。在使用的過程中，其主要目的還是想在不建立對象的情況下，去調用方法 。

case5 Arrays工具類

java.util.Arrays

此類包含用來操作數組的各種方法，比如排序和搜尋等。其所有方法均為靜态方法，調用起來非常簡單。

操作數組

• public static String toString(int[] a)

  ：傳回指定數組内容的字元串表示形式，即為數組轉字元串

public static void main(String[] args) {
// 定義int 數組
int[] arr = {2,34,35,4,657,8,69,9};
// 列印數組,輸出位址值
System.out.println(arr); // [[email protected]
// 數組内容轉為字元串
String s = Arrays.toString(arr);
// 列印字元串,輸出内容
System.out.println(s); // [2, 34, 35, 4, 657, 8, 69, 9]
}
           

• public static void sort(int[] a)

  ：對指定的 int 型數組按數字升序進行排序，在原數組上操作

public static void main(String[] args) {
// 定義int 數組
	int[] arr = {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
	System.out.println("排序前:"+ Arrays.toString(arr)); 
	// 升序排序
	Arrays.sort(arr);
	System.out.println("排序後:"+ Arrays.toString(arr));// 排序後:[2, 4, 5, 6, 7, 11, 24, 35, 46,48]
}
           

case6 Math工具類

java.lang.Math

類包含用于執行基本數學運算的方法，如初等指數、對數、平方根和三角函數

最常用的方法

方法	描述
floor()	取整，傳回小于目标數的最大整數
ceil()	取整，傳回大于目标數的最小整數
round()	四舍五入取整
sqrt()	計算平方根
cbrt()	計算立方根
exp()	傳回歐拉數 e 的n次幂
pow(底數，次方)	計算乘方
log()	計算自然對數
abs()	計算絕對值
max(x,y)	計算最大值
min(x,y)	計算最小值
random()	傳回一個僞随機數，[0.0 , 1.0)

圓周率

Math.PI

，在Math類的源碼中，我們可以看到，它自定義的圓周率 PI =3.14159265358979323846.以後的計算如果需要用到PI，盡量用已經定義好的圓周率，非常精确