【Java】Day1-基礎基礎

Part1

一.Java基礎介紹

• Java是一門後臺開發語言，使用的是大型Web系統開發，APP後臺服務器首選開發語言。
• Java語言特點：跨平臺，安全性高
• 特點：面向對象
• 編譯性解釋語言：編譯後會新建一個out文件

1.配置環境變量

JDK

JDK=Java Development Kit(Java開發工具)
提供了很多Java命令，像執行，編譯等，並且JDK內置了JRE(Java運行環境)，提供了豐富的類庫供我們調用去完成程序開發
Javac 編譯chengcheng.lass
java 執行

配置環境變量

基礎，跳過

編碼格式改變成UTF-8

JRE配置

選擇jdk環境裏面的jre以便於以後可以直接看到源代碼

2.編程準備

新建一個java project
新建一個package
新建一個class，第一個字母要大些

.HelloWorld示例

package test.lemmon;

public class HelloWorld {  //新建一個類
	
	/**主方法，程序執行的main，這裏是程序自動執行的
	 * @param args
	 */
	 
	// 公開的任何人都可以調用，靜態的，返回數據爲空，main函數名稱
	public static void main(String[] args){
		System.out.println("HelloWorld");		
	}
}

java文件設置

相比於py中一個文件可以存放多個類，java中也可以，但是：

• java文件中可以有多個類
• java文件中如果有一個public類，則這個public類必須和文件同名，且有且只有一個public類。也就是可以有其他私有類
• java中的類必須有一個main函數，類似於C中的main函數作爲程序運行的起點。
• 推薦是一個文件一個類，類名和文件名一致
• 類名使用駝峯命名

編譯和運行

• 1.javac工具把java程序編譯成class程序
• 2.java虛擬機把class程序執行

src目錄：存放源代碼

IDEA的快捷鍵

保存：Ctrl + S
刪除：Ctrl + D
撤回：Ctrl + Z
撤銷：Ctrl + Y(恢復上一步操作，與CTRL+Z作用相反)
提示：alt + /   
註釋：ctrl+/ ctrl+shift+/   command+ctrl+/
取消註釋：ctrl+/  ctrl+shift+ \
查找：ctrl+f   
搜索：ctrl+h
代碼行位置交換：alt+↓  alt+↑
下一行插入空行：Shift+Enter
代碼格式化：ctrl+shift+f	
批量編輯：shift+alt+a
顯示打開面板：alt+shift+w
搜文件名：Ctrl+shift+R
顯示類結構：Ctrl+O
顯示繼承結構：Ctrl+T
代碼格式化：Ctrl+Shift+F

3.分隔符

註釋

單行註釋

//
ctrl+/：增加註釋
ctrl+/：取消註釋

多行註釋

	/*
	 *
	 */
ctrl+shift+/：增加註釋
ctrl+shift+\：取消註釋
	 

二.開始編程

1.Java基本類型

[外鏈圖片轉存失敗(img-HLLgno2B-1566289224474)(DA8F2C45F37B453AADA2CDF6A947DF69)]

編譯性的語言

2.編碼規範

在命名文件的時候一般選擇小駝峯命名方式，在命名類的時候一般選擇大駝峯命名方式

3.引用數據類型

引用數據類型存儲的是一個變量的地址，類似於指針
涉及的數據類型是：

• 類
• 接口
• 枚舉

數組

• 一維數組

     //創建一維數組
        int[] arr1  = new int[4];
        int[] arr2 = {1,2,3,4};
    //這種可讀性高
        arr1[i]= i;
    

有new的意思是開闢內存，長度是4個。一個數組的類型在初始的時候必須被定義，但是數組的長度可以不確定

• 當不確定數組長度的時候

// 數據類型 數組名稱[] =null;(聲明)
 String[] name2 = null;

• 然後實例化數組

//賦予長度
name2 = new String[3];

//賦值
name2[1] = "Wendy";

• 二維數組

創建二維數組

	//創建二維數組
		int [][] ary1 = new int [4][4];
		int [][] ary2 = {{1,2},{2},{3,6},{4,7}};	

4.運算符分類

基本分類

算術運算符
[外鏈圖片轉存失敗(img-SIExohJG-1566289224476)(9886F28033F149D581F6E6CEAF1D1973)]

比較運算符
[外鏈圖片轉存失敗(img-QQr0hrZm-1566289224477)(678C1F72F77048CB88C8FA15F8CABA2C)]

賦值運算符
[外鏈圖片轉存失敗(img-DjMf7r5N-1566289224477)(BC1FEDACB634410DA4DC0880D4B515AE)]

邏輯運算符
[外鏈圖片轉存失敗(img-Cxck8O3S-1566289224478)(8FA65C0E9D3040979304A45D8AF5F7BE)]

條件預算符

• A?B:C
• 如果A成立則執行B，否則執行C

運算順序

1. ++
2. 括號
3. /,%(從左到右)
4. +,-(從左到右)

三.循環

1.for循環

• 普通的for循環

public class forfor {
	public static void main(String[] args){
		for (int i=0;i<5;i++){
			//換行輸出
			System.out.println(i);
		}			
		for (int j=0;j<5;j++){
			//不換行輸出
			System.out.print(j);
		}
		
		//普通for循環
		int[] arr={10,20,30};
		for (int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
	}
}

• 增強for循環（jdk1.5）

public static void main(String[] args){
        String[][] name = {
                {"Ben","Tom","Jack","seven1"},
                {"Ben","Tom","Jack","seven2"},
                {"Ben","Tom","Jack","seven3"}
        };

        for (String[] i:name){
            for (String j:i){
                System.out.println(j);
            }
            System.out.println("--------------");
        }
        /**
        *for(數組類型[] i:數組名稱){
            
        }
        *把每次遍歷的數組存放到i中
        *蕾西與python中的for i in Arry:
        */
    }

2.while循環

• do…while

		do{
			b=b+a;
		}
		while(a>0);

• while

		while(a>0){
			b=b+a;
			
		}

3.continue和break

• 跳出本次循環(忽略本次循環)continue
• 跳出整個循環(結束整個循環)break

4.if語句

• if…else if

int sixAge = 20;
		int shadowAge = 20;
		if (sixAge > shadowAge) {
			System.out.println("1:six是shadow的大哥");
		}else if (sixAge < shadowAge) {
			System.out.println("2:shadow是six的大哥");
		}else if (sixAge == shadowAge) {
			System.out.println("3:six的年齡和shadow的一樣大");
		}

5.switch語句

switch(){
    case a:
    break;
    case b:
    break;
    
    default:
    break;
}

• 舉個例子

int day = 8;
		switch (day) {
		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;
		case 6:
			System.out.println("這是星期六");
			break;
		case 7:
			System.out.println("這是星期天");
			break;
		default:
			System.out.println("非法的值");
			break;
		}

這裏如果沒有break，就會繼續運行case

int day = 5;
		switch (day) {
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			System.out.println("這是工作日");
			break;
		case 6:
		case 7:
			System.out.println("這是週末，大家可以去浪了");
			break;
		default:
			System.out.println("非法的值");
			break;
		}

default用於執行其他非case裏面的場景

6.三段式

int sixAge = 22;
int shadowAge = 20;
String result = sixAge > shadowAge ? "six是shadow的大哥" : "six不是shadow的大哥";

類似於：if_else場景

if (sixAge > shadowAge) { // 如果條件滿足纔會進入這個分支，否則不會進入
			System.out.println("six是shadow的大哥");
		} else {
			System.out.println("six不是shadow的大哥");
		}

四.變量

局部變量&全局變量

局部變量：

• 1：必要要初始化
• 2：沒有修飾符

String name = "six";

全局變量：

• 1：可以不用初始化，不初始化就爲對應數據類型的默認值（缺省值null）
• 2: 有修飾符
• 3：但是注意當未空指針的時候訪問它的屬性或者方法回報錯NullPointerException

private static int aInt = 10;

五.函數定義

在java中，定義函數需要三個部分：修飾符，類方法，返回值

修飾符

• public
• private
• protected

類方法

• static

返回值類型

這裏就是java的基本數據類型

舉個例子

修改符  static 返回值類型  方法名(形參類型  形參名,形參類型  形參名..)
{
//函數在這裏
}

六.運算

和python不同的是，在java中字符串類型的比較使用的是equls，int類型的數據使用==比較。

Part 2

一.函數

1.函數的定義

    public static int add(int a,int b){
        return a+b;
    }

• 修飾符：public，protected，private，默認修飾符，從左往右權限逐漸降低。

訪問權限	類	包	子類	其他包
public	v	v	v	v
protected	v	v	v	x
default	v	v	x	x
private	v	x	x	x

2.函數參數的不定項

多餘輸入參數不定的場景，這裏需要一個多參數的輸入值。

• 給定一個容器([] args)用於存儲所有的參數，然後使用for循環把參數取出來。

public static int plus(int[] args){
        int sum = 0;
        for (int i=0;i<args.length;i++){
            sum += args[i];
        }
        return sum;
    }

• 另一種表示
• 這是JDK1.5的新特性可變參數

/**使用方法:
* public static 返回值類型 方法名稱 {數組類型...參數名稱}
*/

public static int plus(int...args){
        int sum = 0;
        for (int i=0;i<args.length;i++){
            sum += args[i];
        }
        return sum;
    }

3.函數的static

static靜態函數，也就是類函數，當這個類沒有被加載出來也可以調用的全局函數，參考例子1。

• 例子1

public class Test {
    public static void main(String[] args) {
		int result = plus(1, 2);
		int result2 = Test.plus(1, 2);
		System.out.println(result);
		System.out.println(result2);
    }

    public static int plus(int a, int b) {
        return a + b;
    }
}

• 但是，當沒有加上static的時候，這個方法就是對象方法，需要實例這個類纔可以使用

/**創建對象語法：
* 類名  對象名  = new 類名();
*/

public class Test {
    public static void main(String[] args) {
        Test tester = new Test();//創建一個對象
        System.out.println(tester.plus(11, 2));
    }
    
    public int plus(int a, int b) {
        return a + b;
    }
}

二.類與對象

類和對象是java的基礎，

1.創建一個類

java本身就是以類爲基礎創建的

public class newMember {

    // 手機號
    public String phone;
    // 密碼
    public String password;
    // 註冊名
    public String regName;
    // 餘額
    public double amount;

    // 1：註冊
    public void register(String mobilePhone, String pwd) {
        if (mobilePhone.length() == 11 && pwd.length() == 6) {
            System.out.println("註冊成功");
        } else {
            System.out.println("信息有誤");
        }
    }

    // 2：登錄
    public void login(String mobilePhone, String pwd) {
        if (mobilePhone.length() == 11 && pwd.length() == 6) {
            System.out.println("登錄成功");
        } else {
            System.out.println("賬號或者密碼錯誤");
        }
    }
}

2.對象的使用

這裏假設已經擁有一個已知的Member類，實例化一個對象叫shadow

// 類名稱 對象名稱 = new 類名稱();
Member shadow = new Member();

• 或者是：

// 類名稱 對象名稱 = null; 
Member shadow = null;
// 對象名稱 = new 類名稱(); //實例化對象
shadow = new Member();

• 調用對象

public class newTester {
    public static void main(String[] args) {
        newMember shadow = new newMember();
        shadow.phone="13754000125";
        shadow.password ="123456";
        shadow.login(shadow.phone,shadow.password);
    }
}

3.構造函數

構造函數是存在於類中一個和類名相同的函數，在創建對象並初始化的時候會自動調用這個函數。

• python

    def __init__(self,uid):
        self.uid = uid
        self.date = GetTime()

• java

 public newMember(){
        System.out.println("這是個無參數的構造函數");
    }

• 然後需要輸入參數時,需要使用this方法對輸入的參數實例化

    public newMember(String phone) {
        this.phone = phone;
    }

三.內存地址（疑惑）

1.棧內存

理論比較複雜，通俗說的話棧內存是已經確定好大小的

• 同一個字符串，不同命名但是位置是相同的

String str1 = "hello";//字面值--》字符串池
System.out.println(System.identityHashCode(str1));//1531448569

String str0 = "hi";//字面值--》字符串池
System.out.println(System.identityHashCode(str0));//1867083167

String str2 = "hello";
System.out.println(System.identityHashCode(str2));//1531448569

2.堆內存

堆內存是針對對象來分配的,每次new的時候都會創建一個新的內存空間

String str3 = new String("hello");//通過new創建的--》堆內存
System.out.println(System.identityHashCode(str3));//284720968

String str4 = new String("hello");
System.out.println(System.identityHashCode(str4));//189568618

四.包裝類

把基本數據類型封裝成一個類，可以調用數據類型的方法進行數據處理。

Integer

• Integer.MAX_VALUE
• Integer.MIN_VALUE
  獲取最大長度；獲取最小長度
• Integer.parseInt(str)
  將字符串轉爲整型

int i = Integer.parseInt(str);
		System.out.println(i);

獲取類型

public static String getType(Object test) {
		return test.getClass().getName();
	}

五.面向對象三大特徵

1.封裝

• public和protect和private
  在之前創建了一個Member類，擁有姓名手機這些屬性

public class Member {
    public String phone;
    public String password;
    public String regName;
    public double amount;

}

但是這樣的話屬性是可以直接使用的

 public static void main(String[] args){
        Member june = new Member();
        june.phone = "1388888";
        System.out.println(june.phone);
    }

所以需要對屬性的權限進行設置，換成private，在通過對外的函數來修改屬性，這裏增加setPhone和getPhone方法

public class Member {

    private String phone;
    private String password;
    private String regName;
    private double amount;

    public void setPhone(String phone){
	 	if (phone.length()==11) {
	 		this.phone = phone;
	 	}
	 	else
	 	    System.out.println("設置失敗");
    }

    public String getPhone(){
        return phone;
    }
}

這樣設置之後Tester就不可以直接對phone屬性操作

public static void main(String[] args){
        Member june = new Member();
        june.setPhone("13838000238");
        System.out.println(june.getPhone());

    }

封裝總結

• 將對象內部的屬性封裝起來，只提供操作對象屬性的公共方法
• 通過公開方法訪問數據,可以從方法里加入邏輯控制,避免不合理的訪問可進行數據檢查,保證數據完整性,防止不希望的交互和非法的訪問便於後期修改,提高代碼的可維護性封裝的實現
• 主要表現：
• 1:屬性私有化:隱藏對象的屬性和實現細節,不允許外部直接訪問
• 2:使用公開的方法操作和訪問屬性

2.繼承

使用extends繼承，用於繼承父類的方法。

public class Borrower extends Member {}

重寫

子類可以重新定義父類的方法，重寫是子類對父類的允許訪問的方法的實現過程進行重新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！

3.多態

當使用多態方式調用方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去調用子類的同名方法。

多態的好處：

• 可以使程序有良好的擴展，並可以對所有類的對象進行通用處理

多態的實現方式：

• 方式一：重寫：
• 方式二：接口
• 方式三：抽象類和抽象方法

重載

可以在同一個類中存在多個函數，函數名稱相同但參數列表不同。這就是函數的重載（overlording）。這是類的多態性表現之一。

• 特徵：
• 函數名和返回值類型完全一致。
• 參數的數量不同、或數量相同而類型和次序不同，以方便JVM區分到底調用哪個函數。

六.String類型

1.方法

• startsWith & endWith :判斷是否以指定字符串開頭或結尾

String str = "Hello World";
System.out.println(str.startsWith("H"));
System.out.println(str.endsWith("B"));

• substring：字符串截取
• 2:end 以及 2：5

String str2 = str.substring(2);
System.out.println(str2);
String str3 = str.substring(2, 5);
System.out.println(str3);

• split：字符串拆分

 String str4 = "He:llo:Wor:ld";
        String[] arry = str4.split(":");
        for (String i: arry) {
            System.out.println(i);
        }
        System.out.println(str4);

• indexOf：lastIndexOf： contains：字符串查找

 String str5 = "Hello World";
        //index:返回找到字符的首個位置，沒有找到返回-1
        System.out.println(str5.indexOf("l"));
        //用於判斷字符串中是否包含這個字符
        System.out.println(str5.contains("World"));
        //lastIndexOf() 方法可返回一個指定的字符串值最後出現的位置
        System.out.println(str5.lastIndexOf("l"));

• 字符串比較 equals : equalsIgnoreCase

    String str6 = "Hello World";
        String str7 = "hello world";
        //equals 用於判斷兩個字符串是否相同，區分大小寫
        System.out.println(str6.equals(str7));
        //equalsIgnoreCase 用於判斷兩個字符串是否相同，不區分大小寫
        System.out.println(str6.equalsIgnoreCase(str7));

• 字符串拼接 concat

      String str8 = "Hello";
        System.out.println(str8.concat("World"));

• 判空 isEmpty

        String str9 = "";
        System.out.println(str9.isEmpty());

• 替換 replace replaceFirst replaceAll

String str13 = "Hello World";
        //replace：替換這個字符串中的所有l成k
        System.out.println(str13.replace("l","k"));
        //replaceFirst：替換此字符串匹配給定的正則表達式的第一個子字符串，只換一個
        System.out.println(str13.replaceFirst("l","k"));
        //replaceAll：替換此字符串所有匹配給定的正則表達式的子字符串。
        System.out.println(str13.replaceAll("l","k"));

• valueOf：字符串描述

//返回給定參數的原生 Number 對象值;參數可以是原生數據類型, String等
        Integer a =Integer.valueOf(9);
        Double b = Double.valueOf(5);
        Float c = Float.valueOf("80");

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

Part 3

一.容器類

1.可變數組ArrayList

java已經封裝好的類，但是這樣的話並且通過<>括號設定這個數組的類型，也稱爲泛型

• 創建Array對象

import java.util.ArrayList;
ArrayList <String> arylist = new ArrayList();

• 添加數據 list.add(…);
• 但是添加其他類型的數據會報錯

        arylist.add("Hello");
        arylist.add("Six");
        arylist.add("Five");
        arylist.add("Four");
        arylist.add("Three");

• 取出數據 list.get(index);

        String name = arylist.get(0);
		System.out.println(name);

• 移除數據：remove(…)

arylist.remove(1);
System.out.println(arylist.get(1));

• 獲取list集合的大小：size()

int size = arylist.size();
System.out.println(size);

• isEmpty(…),判空函數

boolean flag = arylist.isEmpty();
System.out.println(flag);

• contains(…),判斷是否包含某數據

System.out.println(arylist.contains("Happy"));

• set(…)，修改某個位置上的數據

        arylist.set(1, "Tom");
        System.out.println(arylist.get(1));

• 增強for循環

ArrayList<String> names = new ArrayList();
		names.add("Shadow");
		names.add("Six");
		names.add("Edsion");
		names.add("Edsion");

for (String name : names) {
			System.out.println(name);
		}

• 迭代器
• 當有下一個元素的時候就自動獲取下一個元素

for (Iterator iterator = names.iterator(); iterator.hasNext();) {
			String name = (String) iterator.next();//獲得下一個元素
			System.out.println(name);
		}

另一種寫法

while(iterator.hasNext()){
			String string = (String) iterator.next();
			System.out.println(string);
		}

2.HashSet

java已經封裝好的類，特點：

• 數據排列是無序的
• 數據不可以重複

        HashSet<String> haset = new HashSet<String>();

• 添加數據

        haset.add("Shadow");
        haset.add("six");
        haset.add("six");
        haset.add("Edsion");
        System.out.println(haset);
        //[Edsion, six, Shadow]

• size() 獲取集合的大小
• 移除數據：remove(…)
• contains(…),判斷是否包含某數據
• clear(), 將集合裏的所有數據清空

        haset.clear();
     	System.out.println(haset.size());

• toArray(),將集合轉化成爲對應數據類型的數組

//獲取haset裏面的元素形成一個數組
Object[] objects = haset.toArray();
		for (Object object : objects) {
		//把數組裏面的數據取出，轉換成對應的字符串
			String str = (String) object;
			System.out.println(str);
		}

3.HashMap

以鍵值對的形式來保存數據，鍵不可以重複，類似於字典

HashMap<String, String> haMap = new HashMap<>();

• 存放數 據put(…,…)

hamap.put("regName", "Shadow");
hamap.put("Hello", "World");
hamap.put("age", "20");
hamap.put("gender", "男");
System.out.println(hamap);
//{Hello=World, regName=Shadow}

• 取數據 get(…)

String name = hamap.get("regName");
System.out.println(name);
//Shadow

• 移除：remove(…)

hamap.remove("age");
System.out.println(hamap.get("age"));
//null

• 獲取所有的鍵：keySet(…)
• 使用此方法可以獲所有鍵值對的集合，set類型
• hashset是set的一個子類，所以會擁有set集合的所有方法

Set<String> set = hamap.keySet();
		for (String key : set) {
			System.out.println(key);
		}

• 獲取或有的值：values(…)
• 和key不同的是value可以的話重複的，但是key是唯一的

Collection<String> values = hamap.values();
		for (String value : values) {
			System.out.println(value);
		}

• size()
• containsKey(…)
• containsValue(…)
• 遍歷

//獲得map的所有的key 的集合（固定api，獲取所有的key的集合）
		Set<String> keySet = map.keySet();
		//遍歷這個key的集合，把所有的值都遍歷出來
		for (String key : keySet) {
			System.out.println(key + "-->" + map.get(key));
		}

//藉助Entry模塊
        for (Map.Entry entry : hamap.entrySet()) {
            System.out.println(entry.getKey()+":"+entry.getValue());

        }