超詳細Java學習知識點-不定更新

練氣期

一、了解

jvm就是Java虛擬機 通過這個進行編譯 可以實現跨平台

jre包括jvm和運行java的核心庫

jdk包含jre和開發工具：javac.exe 和 java.exe

二、開始helloword

關鍵字

常量:整數、字符串、小數、字符、布爾值、空

三、數據類型

計算機儲存單元：最小位信息單元 bit 最小的存儲單元 byte 1byte = 8bit

是強類型語言 不同的數據類型分配了不同的存儲空間 相比之下 js的數據類型是弱類型語言

Java數據類型 ：

 

內存：

變量申明的空間在內存中 ，程序的運行也是在內存中

long類型：

后面+L

float類型：

后面+F

四、標識符

就是命名規則！have  數字開頭、駝峰命名法 （小駝峰變量和方法、大的是類）、不能是關鍵字

五、類型轉換

自動類型轉換：由小到大

強制類型轉換：

比如：int a = (int)123.123

六、算數運算符

加減乘除余數

注意：兩個整數相除得到的整數 要得到小數必須有浮點數的參與

加操作會自動提升

七、賦值運算符

八、自增自減運算符

九、關系運算符

十、邏輯運算符

&  有false 則false

|  有true則true  

^ 有相同則false 有不同則true（異同）

！非

十一、短路運算符

 && || 和& | 基本相同 但是 有個短路的效果

十二、三元運算符

a>b?a:b

十三、數據輸入

Scanner（掃描器）

使用一共 三步：

導包：import java.util.Scanner

創建對象：Scanner sc = new Scanner(System.in)

接收數據：int x = sc.nextInt()

十四、流程控制

if（）| if（）else（）|  if   else if  else

switch（）{ case ：break  ，default  } 這個可以多判斷   case1: case2: case3:

for循環：水仙花數 ：每位的立方和等於原數

while  do……while

十五、 跳出控制語句

contiune 跳出本次循環體的內容

break 終止循環

十六、嵌套循環

十七、Random

產生一個隨機數

使用三步驟：

導包：import java.util Random

創建對象：Random  r = new Random()

獲取隨機數： int number = r.nextInt(10) //范圍【0.10）

十八、數組

存儲多個類型的數據

格式一：int arr[]

格式二： int[] arr

使用：int[] arr = new int[3]

十九、java內存分配

 

左邊的是棧內存，右邊的是堆內存

棧內存：存儲局部變量。用完就消失

堆內存：存儲new出來的內容（實體和對象）

 

二十、數據初始化之靜態初始化

int[] arr = new int[]{1,2,3}

 

 簡化版：int[ ] arr = {1,2,3}

--------------2021-11-7-----------------------

二十一、遍歷

簡單~~~~

二十二、方法

解釋：將具有獨有功能的代碼塊組織成為一個整體，使其具有特殊功能的代碼集。

步驟：先創建（方法定義）、再調用（手動執行）。

注意：方法是平級關系，不能嵌套；
　　　void 表示無返回值，可以省略return，也可以單獨的書寫return ，但是后面不能加數據，后面加數據就要去除void，寫上數據類型。

 二十三、帶返回值方法的定義和調用

public class demo1 {
    /**
     *  帶返回值方法的定義和調用
     *  定義格式:
     *      public static 數據類型 方法名(參數）{
     *          return 數據;
     *  }
     * 調用格式:
     *     數據類型 變量名 = 方法名(參數)
     * 
     * */
    public static void main(String[] args) {
        // 調用方法
        boolean flag =  isEvenNumber(10);
        System.out.println(flag);
    }
        //創建一個方法 判斷一個數是否偶數
    public static boolean isEvenNumber(int num) {
        if(num % 2 == 0) {
        return true;
        } else {
        return false;
        }
    }

}

二十四、方法重載

多個方法：1.同一個類中；
　　　　　2.相同的方法名；

　　　　　3.參數不同，類型不同，數量不同。

在調用的時候,java虛擬機會通過參數的不同來區分同名的方法。

eg:

public class demo02 {
    public static void main(String[] args) {
        // 調用方法
        System.out.println(compare(10, 20));
        System.out.println(compare((byte)10,(byte)20));
        System.out.println(compare((short)10,(short)20));
        System.out.println(compare(10L, 20L));
    }
        //創建一個方法 判斷兩數相等
    public static boolean compare(int a,int b) {
        System.out.println("int");
        return a == b;
    }
    public static boolean compare(byte a,byte b) {
        System.out.println("byte");
        return a == b;
    }
    public static boolean compare(short a,short b) {
        System.out.println("short");
        return a == b;
    }
    public static boolean compare(long a,long b) {
        System.out.println("long");
        return a == b;
    }
}

二十五、方法參數傳遞（基本類型）

 eg：

public class demo03 {
    public static void main(String arg[]) {
        int number  = 100;
        System.out.println("調用change方法前：" + number);  // number = 100
        change(number);                                    // 棧內存中開辟了另一個方法 里面有個新的number
        System.out.println("調用change方法后：" + number);  // 這是main方法中的number，依然number = 100
    }
    public static void change(int number) { 
        number = 200;
    }
}

總結：對於基本數據類型的參數，形式參數的改變，不影響實際參數的值。

二十六、方法參數傳遞（引用類型）

eg：

public class demo03 {
    public static void main(String arg[]) {
        int[] arr  = {10,20,30};
        System.out.println("調用change方法前：" + arr[1]);  // arr[1] = 10
        change(arr);                                        // 直接改變了堆內存中arr對應的地址的arr[1]的值
        System.out.println("調用change方法后：" + arr[1]);  // 改變后 arr[1] = 200
    }
    public static void change(int[] arr) { 
        arr[1] = 200;
    }
}

二十七、數組遍歷

簡單~~~~直接悟通！

二十八、Debug（斷點調試用來調試程序）多用

二十九、導包鍵盤錄入

import java.util.Scanner;  //導入對應的包
// 快捷鍵 ALT+ENTER

public class demo04 {
    public static void main(String arg[]) {
        //鍵盤錄入一個數
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個數：");
        int number = sc.nextInt();
    }
}

 築基期

一、面向對象

對象：客觀存在的事物皆為對象（沒對象就new一個吧，同志們），比如：小紅的華為手機；

面向對象：關注對象，了解詳細信息，面對具體的對象操作；

類：類是對象的數據類型，是具有相同屬性和行為的一組對象的集合 ，比如：人；

　　屬性：對象特有的東西，比如：名字，年齡；

　　行為：對象的功能操作，比如：打球，跑步；

二、java中類的定義

類的重要性：是java程序的基本組成單位；

類的組成：屬性和行為；

　　屬性：在類中通過成員變量來體現（類中方法外的變量）；

　　行為：在類中通過成員方法來體現（和前面的方法相比去掉static關鍵詞即可）；

eg：

public class phone {
    // phone 的成員變量 就是屬性
    String brand;
    int price;
    
    //成員方法 
    public void call() {
        System.out.println("打電話");
    }
    public void sendMessages() {
        System.out.println("發短信");
    }
}

三、對象的使用

格式： 類名 對象名 = new 類名（）；

　　　Phone p = new Phone( )；

eg:

// 新建一個測試類 使用上面的 對象類
public class PhoneDemo {
    public static void main(String arg[]) {
        //創建對象
        phone p = new phone();
        
        //使用成員變量
        
        System.out.println(p.brand);
        System.out.println(p.price);
        
        p.brand = "小米";
        p.price = 2000;
        
        System.out.println(p.brand);
        System.out.println(p.price);
        //使用成員方法
        
        p.call();
        p.sendMessages();
    }
}

四、對象的內存圖（執行流程）

 

如果多次new，那么在堆內存中也會多出新的對象，相應不同的地址。

簡單易懂，我悟了。

五、成員變量和局部變量

 

 

 

 

 四大不同：

　　一位置不同：如圖；

　　二內存中位置不同：成員在堆內存，局部在棧內存；

　　三生命周期不同：成員隨着對象的存在而存在，局部隨着方法的存在而存在；

　　四初始化不同：成員有默認的初始化值，局部沒有默認值並且必須先定義才能使用；

六、封裝

6.1、private關鍵字

是一個權限修飾符；

可以修飾成員變量和成員方法；

作用：保護成員不被別的類使用，只能 在本類中才能訪問；

　　   但是如果需要被其他類使用，提供兩個方法：

　　　　　get變量名（）方法，用於獲取成員變量的值；（方法用public 修飾）

　　　　　set變量名（）方法，用於設置成員變量的值；（方法用public 修飾）

6.2、this關鍵字

局部變量 賦值給 成員變量 但是局部變量和成員變量同名 就使用 this

public class phone {
    // phone 的成員變量 就是屬性
    String brand;
    int price;
    
    //成員方法 
    public void call() {
        System.out.println("打電話");
    }
    public void sendMessages() {
        System.out.println("發短信");
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;   // 為了讓局部變量 賦值給 成員變量 就使用 this
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
}

6.3、this的內存原理

 

就一句話，誰調用，this就是指的那個對象地址。

6.4、封裝

是面向對象的三大特征之一（封裝、繼承、多態）

 好處：可以控制成員變量的操作，提高安全性；

　　　 提高代碼的復用性；

七、構造方法

構造方法是一個特殊的方法；

作用：創建對象；

格式：

public class 類名{
        修飾符 類名（參數）{  // 修飾符一般public
            
        }
    }

功能：主要完成對象數據的初始化；

注意：如果類中沒有構造方法，那么就會系統默認創建一個無參構造方法；有構造方法，那么就不會提供默認的構造方法；

八、標准類制作

要求：

1、成員變量

　　使用private修飾；

2、構造方法

　　提供一個無參構造方法；

　　提供一個帶多個參數的構造方法；

3、成員方法

　　提供一個成員變量對應的setXxxx（）/getXxxx（）；

　　提供一個顯示對象信息的show（）；

4、創建對象並為其成員變量賦值的兩種方式

　　無參構造方法創建對象后使用setXxxx（）賦值；

　　使用帶參構造方法直接創建帶有屬性值得對象；

eg:

標准類

public class Student {
    // 成員變量
    private String name;
    private int age;
    
    // 構造方法
    public Student() {}  // 無參構造
    public Student(String name,int age) { // 有參構造
        this.name = name;
        this.age = age;
    }
    
    //    成員方法
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    
    // show 方法
    public void show() {
        System.out.println(name + "," + age);
    }
}

 測試類：

public class StudentDemo {

    public static void main(String[] args) {
        // 無參構造方法創建對象后用set賦值
        Student s1 = new Student();
        s1.setName("彭於晏");
        s1.setAge(18);
        s1.show();
        // 多個參數構造方法直接創建帶屬性值的對象
        Student s2= new Student("胡歌",20);
        s2.show();
    }

}

九、字符串

9.1、API

java api 就是jdk提供的各種功能的java類。eg：Scanner。

9.2 、String

在java.lang下，使用時是不用導包的。

String 代表字符串，java程序中所有的雙引號字符串，都是String對象。

特點：

　　字符串不可變，他們的值在創建后不能被更改；

　　雖然String值不可變，但是他們可以被共享；

　　字符串效果相當於字符數組（chart【】），但是底層原理是字節數組byte【】

題外話：jdk8及以前是字符串數組，jdk9級以后是字節數組。

9.3、String類的構造方法

對象特點：

　　每次new都有一個新地址；

　　以“ ”方式給出的字符串，只要字符的序列相同（順序和大小寫），無論在程序代碼中出現幾次，jvm都只會創建一個String對象，並在字符串池中維護。

9.4、字符串的比較

以前 使用 == 比較：

　　基本類型：比較的是數值是否相同；

　　引用類型：比較的是地址是否相同；

字符串想要比較數值是否相同：

　　一個新方法 equals（）

　　eg:(s1.equals(s2))

--------------2021-11-17-----------------------

十、StringBuilder

意義：如果對字符串進行拼接，每次拼接都會構建一個新的String對象，即耗時，也耗內存空間，Stringbuilder類就是來解決這問題。

區別：

　　String是不可變的；

　　StringBulider是可變的；

方法：

StringBuilder sb = new StringBuilder();
   //添加數據 返回的是對象本身
sb.append("hello");
   // 翻轉
sb.reverse();

StringBuilder和String的相互轉換：

StringBuilder sb= new StringBuilder();
// StringBuilder To String
String s = sb.toString();
// String To StringBuilder
String s = "hello"
StringBuilder sb =new StringBuilder(s)

十一、集合

意義：當我們存儲數據的時候會選擇數組，但是數組長度是固定的，不一定會滿足我們的需求，更適應不了變化的需求，這時候就有集合。

特點：存儲空間可變的數據模型。

ArrayList<E>:
            //可以調整大小的數據實現。
            // <E>是一種特殊的數據類型，泛型。
　　//怎么用？
    E替換我們所應用數據類型
    eg：ArrayList（String）

方法：添加add、刪除remove、修改set、獲取get、集合長度size

eg：
public static void main(String arg[]){
         ArrayList<String> array = new ArrayLisy<String>();
         // 添加 add
         array.add("hello");
         // 指定位置 插入元素
         array.add(1,javase);
　　　　　 // 刪除 可以通過索引刪除 
　　　　　 array.remove(1); 
　　　　　// 修改 
　　　　　array.set(1,"ashduj");
　　　　　// 獲得
　　　　　array.get(0);
　　　　　// 長度
　　　　　array.size();

}             

十二、來個學生管理系統來總結練手

學生類:

package com.learnjava.Student;
/**
 * 
 * 學生類
 *
 */
public class Student {
    // 學號 
    private String sid;
    // 姓名
    private String name;
    // 年齡
    private String age;
    // 居住地
    private String address;
    
    // 無參構造函數Student
    public Student() {
        
    }
    // 有參構造函數Student
    public Student(String sid,String name, String age,String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }
    public String getSid() {
        return sid;
    }
    public void setSid(String sid) {
        this.sid = sid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    
}

學生管理類：

package com.learnjava.Student;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;

/**
 * 
 * 學生管理系統
 *
 */

public class StudentManger {
    /*
     * 1.用輸出語句完成主界面的編寫;
     * 2.用Scanner實現鍵盤的輸入;
     * 3.用switch語句完成操作的選擇;
     * 4.用循環完成再次回到主界面;
     */

    public static void main(String[] args) {
        // 創建集合對象，用於存儲學生數據
        ArrayList<Student> array = new ArrayList<Student>();
        // 用循環完成再次回到主界面 無限循環
        while(true) {
        // 用輸出語句完成主界面的編寫;
        System.out.println("-----------歡迎來到學生管理系統-----------");
        System.out.println("1.添加學生");
        System.out.println("2.刪除學生");
        System.out.println("3.修改學生");
        System.out.println("4.查看所有學生");
        System.out.println("5.退出");
        System.out.println("請輸入你的選擇:");
        
        // 用Scanner實現鍵盤的輸入
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        
        // 用switch語句完成操作的選擇
        
        switch(line) {
        case "1":
//            System.out.println("添加學生");
            addStudent(array);
            break;
        case "2":
//            System.out.println("刪除學生");
            removeStudent(array);
            break;
        case "3":
//            System.out.println("修改學生");
            setStudent(array);
            break;
        case "4":
//            System.out.println("查看所有學生");
            findAllStudent(array);
            break;
        case "5":
            System.out.println("謝謝使用");
            System.exit(0); // jvm 虛擬機 退出
        }
        
        }
        
    }

    // 定義一個方法,添加學生方法
    public static void addStudent(ArrayList<Student> array) {

        // 鍵盤錄入學生對象需要的數據,顯示提示信息，提示輸入何種信息；
        String sid;
        Scanner sc =new Scanner(System.in);
        while(true) {
            System.out.println("請輸入學生學號：");
             sid = sc.nextLine();
            
            boolean flag  = isUsed(array, sid);
            if(flag) {
                System.out.println("學號被使用，請重新輸入");
            }else {
                break;
            }
        }
        
        System.out.println("請輸入學生姓名：");
        String name = sc.nextLine();
        System.out.println("請輸入學生年齡：");
        String age = sc.nextLine();
        System.out.println("請輸入學生居住地：");
        String address = sc.nextLine();
        
        // 創建學生對象，把輸入的內容賦值給學生對象的成員變量
        Student s = new Student();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        s.setAddress(address);
        
        // 將學生對象添加到集合中；
        array.add(s);
        
    }

    // 定義一個方法，判斷學號是否被使用
    public static boolean isUsed(ArrayList<Student> array ,String sid) {
        // 如果與集合中某個學生學號相同，則返回true，否則返回false；
        boolean flag = false;
        for(int i = 0; i < array.size();i++) {
            Student s = array.get(i);
            if(s.getSid().equals(sid)) {
                flag = true;
            }else {
                flag =false;
            }
        }
        return flag;
    }
    // 定義一個方法,用於查詢學生信息
    public static void findAllStudent(ArrayList<Student> array) {
        // 判讀集合中是否有數據，從而提示,不顯示表格
        if(array.size() == 0) {
            System.out.println("無數據,請添加數據!");
            return;
        }
        //顯示表頭
        System.out.println("學號\t\t\t姓名\t\t年齡\t\t居住地");
        
        // 遍歷集合 顯示學生信息 年齡顯示 “歲”
        
        for(int i = 0 ; i < array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getSid()+"\t\t"+s.getName()+"\t\t"+s.getAge()+"\t\t"+s.getAddress());
        }
    }

    // 定義一個方法,用於刪除學生信息
    public static void removeStudent(ArrayList<Student> array) {
        // 鍵盤錄入要刪除學生的學號，顯示提示信息
        Scanner sc = new Scanner(System.in);
        
        System.out.println("請輸入你要刪除學生的學號：");
        
        String sid = sc.nextLine();
        int index = -1;
        //遍歷集合 刪除對應學生對象
        for(int i = 0 ; i < array.size() ; i++) {
            Student s = array.get(i);
            if(s.getSid().equals(sid)) {
                index = i;
                break;
            }
        }
        if(index == -1) {
            System.out.println("為找到相關信息，請重新輸入！");
        }else {
            array.remove(index);
            System.out.println("刪除學生成功！");
        }
        
    }
    
    // 定義一個方法,用於修改學生信息
    public static void setStudent(ArrayList<Student> array) {
        // 鍵盤錄入要修改的學生的學號，顯示提示信息
        Scanner sc = new Scanner(System.in);
        
        System.out.println("請輸入你要修改學生信息的學號：");
        String sid = sc.nextLine();
        int index = -1;
        for(int i = 0; i < array.size();i++) {
            Student student = array.get(i);
            if(student.getSid().equals(sid)) {
                index = i;
                break;
            }
        }
        if(index == -1) {
            System.out.println("為找到相關信息！請重新輸入！");
            return;
        }
        //鍵盤輸入要修改的內容
        System.out.println("請輸入學生的新名字：");
        String name = sc.nextLine();
        System.out.println("請輸入學生的新年齡：");
        String age = sc.nextLine();
        System.out.println("請輸入學生的新地址：");
        String address = sc.nextLine();
        
        // 創建學生對象
        Student  s = new Student();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        s.setAddress(address);
        
        // 遍歷集合修改對應信息
        
        array.set(index, s);
        System.out.println("修改學生成功！");
    }
}

修煉完成！ 內力大增！

十三、繼承

格式：public class 子類名 extends 父類名{ }；

父類：被稱為基類、超類；

子類：被稱為派生類；

話不多說直接敲代碼：

package com.learnjava.jicheng;
/*
 * 父類
 */
public class Fu {
    public void show() {
        System.out.println("show方法被調用!");
    }
}



package com.learnjava.jicheng;
/*
 * 子類繼承父類
 */
public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被調用");
    }
}


package com.learnjava.jicheng;
/*
 *測試類
 */
public class testDemo {
    public static void main(String[] arg) {
        // 創建對象 ，調用方法
        Fu f = new Fu();
        f.show();
        Zi z = new Zi();
        z.method();
        z.show();
    }
}

總結：子類繼承有父類的內容，也有自己的內容。

好處：提高了代碼的復用性（多個類相同的內容可以放在同一個類中）；

　　　提高代碼維護性（只用修改一處就行了）；

壞處：讓類與類之間產生了關系，增加了耦合性，當父類變化后子類不得不變化，削弱了子類的獨立性。

什么時候使用繼承？

答：當兩個類，滿足A是B的一種，或者B是A的一種，就可以用。

十四、繼承中變量的訪問特點

變量查找：

　　① 子類局部變量找；

　　② 子類成員變量找；

　　③ 子類成員變量找；

　　④ 沒有就報錯；

十五、super

 super 關鍵詞的用法和this關鍵詞的用法相似

　　~ this：代表本類對象的引用；

　　~ super ：代表父類存儲空間的標識（可以理解為父類對象的引用）；

除了成員變量還可以訪問：this(…)/super(…)訪問構造方法，this.成員方法（…）/super.成員方法（…）訪問成員方法。

十六、繼承中構造方法的訪問特點

注意：一般子類構造方法中都有一個看不見的super（），指向的是父類的無參構造方法；

　　　　若父類沒有無參構造方法，那么就super（xxx）調用有參構造方法；

推薦父類自己給出無參構造方法；

十七、繼承中成員方法的訪問特點

先在子類成員范圍中找；

再到父類成員范圍中找；

沒有就報錯；

十八、super的內存圖

 

十九、方法重寫

概述：子類中出現了和父類中一模一樣的方法聲明。

應用：子類需要父類的功能，而功能主體子類有自己特有內容是，可以重寫父類中的方法，這樣，及沿襲了父類的功能，又定義了子類特有的內容。

eg：

package com.learnjava.overwrite;
/**
 * 
 * 舊手機
 *
 */
public class Phone {
    public void call(String name) {
        System.out.println("給"+ name + "打電話");
    }
    
}


package com.learnjava.overwrite;
/***
 * 
 *     新手機
 *
 */
public class newPhone extends Phone {
    @Override
    public void call(String name) {
        System.out.println("開啟視頻功能");
        super.call(name);
    }
}




package com.learnjava.overwrite;
/***
 * 
 * 測試類
 *
 */
public class PhoneDemo {
    public static void main(String[] arg) {
        // 創建對象 調用方法
        Phone p = new Phone();
        p.call("周傑倫");
        System.out.println("-----------");
        
        newPhone np = new newPhone();
        np.call("林俊傑");
    }

}

學習到一個注解：Override 檢查重寫方法的方法聲明的正確性。

注意事項：

　　父類的私有方法不能重寫（子類沒法繼承）（就是 private聲明的方法）；

　　子類方法訪問權限不能更低（public >  默認 > 私有）；

二十、Java中繼承的注意事項

· Java 中類只支持單繼承，不支持多繼承；

· Java 中類支持多層繼承；

--------------2021-11-19-----------------------

二十一、修飾符

權限修飾符（私有、默認、保護、公共）

 

final修飾符（最終態）

變量是基本類型：數值不變

變量是引用類型：地址不變，但是地址中的內容可以改變

static（靜態）

描述：被修飾的類的對象進行共享；

調用：可以通過對象調用，也可以通過類名調用（推薦類名）；

訪問特點：非靜態的成員方法能訪問 非靜態/靜態的成員變量和成員方法；但是靜態的成員方法只能訪問靜態的；

二十二、多態

概述：同一個對象，在不同時刻表現出來的不同形態。

--------------2021-11-22-----------------------

 金丹期

暫無此階段修為

 元嬰期

 暫無此階段修為

 化神期

 暫無此階段修為

 大乘期

 暫無此階段修為

 

 每日更新中…………