碼上歡樂
相關內容    簡體    繁體

惡補 Java 基礎

本文轉載自   查看原文   2021-11-12 13:48   119    java

JAVA概述：

Java是一種高級計算機語言，它是由SUN公司（已被Oracle公司收購）於1995年5月推出的一種可以編寫跨平台應用軟件、完全面向對象的程序設計語言。Java語言簡單易用、安全可靠、主要面向Internet編程，自問世以來，與之相關的技術和應用發展得非常快。在計算機、移動電話、家用電器等領域中，Java技術無處不在。

為了使軟件開發人員、服務提供商和設備生產商可以針對特定的市場進行開發，SUN公司將Java划分為三個技術平台，它們分別是JavaSE、JavaEE和JavaME。

Java SE（Java Platform Standard Edition）標准版，是為開發普通桌面和商務應用程序提供的解決方案。JavaSE是三個平台中最核心的部分，JavaEE和JavaME都是從JavaSE的基礎上發展而來的，JavaSE平台中包括了Java最核心的類庫，如集合、IO、數據庫連接以及網絡編程等。

Java EE(Java Platform Enterprise Edition) 企業版，是為開發企業級應用程序提供的解決方案。JavaEE可以被看作一個技術平台，該平台用於開發、裝配以及部署企業級應用程序，其中主要包括Servlet、JSP 、JavaBean 、JDBC、EJB、Web Service等技術。

Java ME(Java Platform Micro Edition) 小型版，是為開發電子消費產品和嵌入式設備提供的解決方案。JavaME主要用於小型數字電子設備上軟件程序的開發。例如，為家用電器增加智能化控制和聯網功能，為手機增加新的游戲和通訊錄管理功能。此外，Java ME提供了HTTP等高級Internet協議，使移動電話能以Client/Server方式直接訪問Internet的全部信息，提供最高效率的無線交流。

2、JDK與JRE

JDK(Java Development Kit)：Java的開發工具

  • JRE(Java runtime Environment)：Java程序的運行環境
    • JVM(Java Virtual Machine)：Java虛擬機

image-20211102153140371

Java中文網站：https://www.java.com/zh-CN/

3、Java程序運行機制

Java語言是一門編譯型語言也是一門解釋型語言

image-20211102154834983

5、Java關鍵字

image-20211102155056941

6、Java標識符

  • Java所有組成的部分都需要名字。類名、變量名以及方法名就稱為標識符 。

  • 所有的表示符都應該以字母(A-Z或者a-z)，美元符 $ 、或者下划線 _ 開始 。

  • 不能使用關鍵字作為變量名或方法名

  • 標識符對大小寫敏感

  • image-20211102155619268

7、什么是字節

  • 位（bit）：是計算機內部數據 存儲的最小單位，11001100是一個八位二進制數

  • 字節（byte）：是計算機中 數據處理 的基本單位 ，習慣上用大寫 B 來表示。

  • 1B （byte，字節）=8bit

  • 字符：是指計算機中使用的字母、數字、字和符號

    image-20211102160217818

8、Java數據類型

強類型語言

  • Java規定變量的使用要嚴格符合規定，所有的變量必須先定義后才能使用

Java的數據類型分為兩大類：

  • 基本數據類型

  • 引用數據類型

    image-20211102160727940

數據類型的默認值

image-20211102161303162

9、變量

什么是變量

  • Java是一種強類型語言，沒一個變量都需要聲明其類型

  • Java變量是程序中最基本的存儲單位，其要素包括變量名，變量類型和作用域

    image-20211102164339759

10、變量名的命名規范

image-20211102161042763

11、運算符

image-20211102164505673

12、包

  • 為了更好地組織類，Java提供了包機制，用於區別類名的命名空間
  • 語法格式為：

image-20211102161503163

其中：

image-20211102161535026

為了能使用某一個包的成員，我們可以導入包“import”

image-20211102161644035

13、JavaDoc

  • javadoc命令是用來生成自己的API文檔的
  • image-20211102161802721

14、Scanner對象

  • Java提供了一個工具類，可以獲取用戶的輸入

  • 基本語法

    image-20211102162009346

image-20211102162032274

  • next（）：

      1. 一定要讀取到有效字符后才可以結束輸入
      1. 在遇到有效字符之前遇到的空白，next()會將其去掉
      2. 在有效字符之后識別到空格之后，next（）會將空格作為分隔符或結束符
      3. next不能得到帶有空格的字符串

  • nextLine（）：

    1. 以Enter（回車鍵）為結束符也就是說 nextLine（）方法返回的是輸入回車之前的所有字符
    2. 可以獲取到空白字符串

15、流程控制語句

  • if

    image-20211102163125513

  • if else

  • switch

    image-20211102163148986

  • which循環（先判斷，后執行）

  • do ...which循環（先執行，后判斷，至少執行一次）

    image-20211102163328568

  • for循環

    image-20211102163457768

  • 增強版for循環

    • 主要用於數組【返回沒有下標】或集合

    image-20211102163526938

  • break

    • 可以控制循環流程，用於強行退出循環

  • continue

    • 用於終止某次循環，然后繼續執行下一次循環

16、Java方法

1. 什么是Java方法

  • Java方法是語句的集合，他們在一起執行一個功能

    • 方法是解決一類問題的步驟的有序組合
    • 方法包含在類或對象中
    • 方法在程序中被創建

  • 一個方法最好只完成一個功能，這樣有利於后期的擴展

2.方法的定義

  • 方法包含一個方法頭和一個方法體

image-20211102165817278

  • ​
    • 修飾符：這是可選的，告訴編譯器如何調用該方法
    • 返回值類型：方法可能會返回值，有返回值就定義返回值，沒有就用 void
    • 方法名： 方法的實際名稱
    • 參數類型：方法像是一個占位符，當被調用時，傳遞值給參數，這個值就被稱為實參或者變量。參數列表是指方法的參數類型。順序和參數個數，參數是可選的，方法可以不包含任何參數
      • 形式參數： 在方法被調用時用於接收外界輸入的數據
      • 實參：調用方法是實際傳給方法的數據
    • 方法體：方法體，包含具體的語句，定義該方法的功能

3、方法的重載

  • 1、什么的重載？
    • 重載就是在一個類中，有相同的函數名，但形參不一樣
  • 規則：
    • 方法名必須相同
    • 參數列表必須不同（個數不同或類型不同、參數排序順序不同等）
    • 方法返回的；誒新可以相同，也可以不相同
    • 僅僅返回類型不同，不足以成為方法的重載

image-20211102174710545

17、方法調用

  • 調用方法：對象名.方法名（實參列表）

  • Java有兩種調用方法的方式，是根據是否有返回值來選擇的

    • 當有返回值是

    • image-20211102175206037

    • 返回值為 void 時

      • 執行的是一條語句

      image-20211102175404742

18、可變參數

  • 在方法聲明中，在指定參數類型后面加上一個省略號（...）

  • 一個方法只能指定一個可變參數，他必須是方法的最后一個參數。其他普通方法都要在它前面聲明。

    image-20211102180211252

19、遞歸

什么是遞歸？

  • ​ A方法調用B方法，我們容易理解
  • ​ 遞歸就是：A方法調用A方法，自己調用自己
  • image-20211102180527389

image-20211102180459038

20、數組的定義

1.什么是數組？

  • 數組是相同類型的有序集合
  • 每個數據稱為數組的元素，每一個元素可以通過一個下標來訪問他，下標索引從 0 開始。

2.數組聲明創建

  • 首先必須聲明數組變量，才能在程序中使用數組
  • 語法：

image-20211102181605420

  • Java語言中使用new操作符來創建數組

  • 語法：

    image-20211102181709251

獲取數組長度：

image-20211102181749883

3、數組的特點

image-20211102182038902

4、圖解數組

image-20211102182206901

5、數組的創建

  • 靜態創建

    image-20211102182339037

  • 動態創建

image-20211102182409605

6、數組的邊界

  • 數組下標的合法區間：[ 0，length-1 ],如果業界就會報錯：
  • image-20211102182640492

7、小結

  • 數組是相同數據類型的有序集合
  • 數組也是對象，數組元素相當於對象的成員變量
  • 數組的長度是確定的，不可變的，如果越界，就會報錯

21、多維數組

  • 多維數組可以看做是數組的數組，比如二維數組就是特殊的一維數組，其中，二維數組中的每一個元素都是一維數組

定義：

image-20211102183234594

22、Arrays類

  • 數組的工具類java.util.Arrays
  • Arrays類中的方法都是static修飾的靜態方法，在使用的時候可以直接使用類名進行調用

常用功能：

image-20211102183617747

23、冒泡排序

image-20211102183657268

24、面向對象（OOP）

  • 在面向之前，先了解一下面向過程

1、面向過程思想：

  • 步驟清晰簡單，第一步做什么，第二步做什么，由上到下
  • 面向過程適合處理一些較為簡單的問題

2、面向對象思想：

  • 物以類聚，分類的思維模式，思考問題首先會解決問題需要那些分類，然后對這些分類進行單獨思考。最后才對某個分類下的細節進行面向過程的思索。
  • 面向對象適合處理復雜的問題，適合處理需要多人協作的問題。

3、什么是面向對象：

  • 面向對象編程（OOP）

  • 本質：以類的方式組織代碼，以對象的組織（封裝）數據。

4、三大特性

  • 封裝
  • 繼承
  • 多態

25、加強方法

方法的定義：

修飾符 返回值類型 方法名（參數。。。）{
        方法體
    return 返回值;
}
  • 返回值要和返回值類型相同
  • return 結束方法，返回一個結果
  • 方法名：要注意規范，要做到見明知意
  • 參數定義：（參數類型 參數名，。。。）
  • 異常拋出

break和return的區別

break：跳出switch，結束循環

return 結束方法，返回一個結果

方法調用：

非靜態方法：

//    非靜態方法
    public void student(){
        System.out.println("學生很開心");
    }
    
=======================================

//        非靜態方法調用
//        調用需要實例化 new這個Java_09_FangFa3類
        Java_09_FangFa3 fa3 = new Java_09_FangFa3();
        fa3.student();

靜態方法：

//    靜態方法
    public static void student1(){
        System.out.println("大數據牛！！！");
    }
    
=========================================

//        靜態方法調用
//        類.方法名
        Java_09_FangFa3.student1();

形參和實參

//                        形參
    public static int min(int a ,int b){
        return a+b;
    }

image-20211109000111284

值傳遞和引用傳遞

this關鍵字

26、創建與初始化對象

使用new關鍵字創建對象

  • 使用new關鍵字創建的時候，除了分配內存空間之外，還會給 創建好的對象進行默認的初始化以及 對 構造器的調用。

  • 類中的構造器也可以稱為構造方法，是在創建對象的時候必須調用的，並且構造器有以下特點

    • 必須和類的名字相同
    • 必須沒有返回類型，也不能寫void

無參構造：

public class Person {
//    一個類即使什么都不寫，他也會存在一個方法
    String name;

//    無參構造器
//    實例化初始值
//    1、使用new關鍵字必須要有構造器，new的本質就是調用構造器
    public Person() {
    }

有參構造：

public class Person {
//    一個類即使什么都不寫，他也會存在一個方法
    String name;

//    有參構造
//    一旦有了有參構造，就必須要有無參構造
    public Person(String name) {
        this.name = name;
    }
 }
  • 一旦有參構造生成了，無參構造就會失效

調用：

//        構造器的使用
        Person person = new Person("xioahe");
        System.out.println(person.name);

內存分析：

Pet類

public class Pet {
    String name;
    int age ;

//    默認就有無參構造
    public Pet() {
    }

    public void shout(){
        System.out.println(this.name+ "叫了一聲");
    }
}

程序入口：

Pet dog = new Pet();
dog.age=3;
dog.name="wangcai";
dog.shout();

// cat沒有賦值
Pet cat = new Pet();

image-20211109122352949

小結

  • 1、類和對象
    • 類是一個模板：抽象的概念
    • 對象是一個具體的實例
  • 2、方法：定義、調用
  • 3、對象的引用
    • 引用類型 ：基本類型有八個
    • 對象是通過引用來操作的：棧-->堆
  • 4、屬性 ：字段 成員變量
    • ​ 默認初始化
      • 數字 ：0 0.0
      • char ：u0000
      • boolean：false
      • 引用：null
    • 修飾符 屬性類型 屬性名 =屬性值；
  • 5、對象的創建和使用
    • 必須使用new 關鍵字創造對象，構造器 Person xiaohe = new Person();
    • 對象的屬性 xiaohe.name
    • 對象的方法 xiaohe.add();
  • 6、類
    • 靜態的屬性 --> 屬性
    • 動態的行為 -->方法

27、OOP三大特性

1、封裝

概念：

  • 該露的露，該藏的藏
    • 我們設計程序要追求“高內聚，低耦合”。高內聚就是類的內部數據操作細節自己完成，不允許外部干涉；低耦合：緊緊暴露少量的方法給外部使用；
  • 封裝數據（數據的隱藏）
    • 通常，應盡早直接訪問一個對象中數據的實際表示，而通過操作接口來實現訪問，這稱為信息影藏
  • 屬性私有，get/set

優點：

  • 提高程序安全性
  • 影藏代碼細節
  • 統一接口
  • 程序可維護性增加

2、繼承

  • 關鍵字：extends
  • 子類會繼承父類，子類就會擁有父類的所有方法
  • Java中類只有單繼承，沒有多繼承
  • 在Java類中，所有的類都會繼承 object類

父類

public class Person {

}

子類

//                    繼承關鍵字
public class Student extends Person {
    
}
//                    繼承關鍵字
public class Teacher  extends  Person{


}

super關鍵字 VS this關鍵字

super：

  • super必須在繼承關系下才能使用
  • super調用父類的構造方法必須放在構造方法的第一行
  • super只能出現在子類的方法或者構造方法中
  • super和this不能同時調用構造方法（this調用構造方法也必須放在構造方法的第一行）

不同：

  • 1、代表對象不同

    • this 代表本類這個對象
    • super 代表父類的對象

  • 2、使用前提不同

    • this沒有繼承也可以使用
    • super：只能在繼承的條件下使用

  • 構造方法調用不同

    • this（）；調用的是本類的方法
    • super（）；調用的是父類的方法

父類

//這是一個人 類
public class Person {
    protected String name = "lisi";

    public Person() {
        System.out.println("person無參執行了");
    }

    //私有的東西無法被繼承
    public void print(){
        System.out.println("Java是一門好語言1！");
    }


}

子類

//這是一個學生類
//    子類會繼承父類，就會擁有父類的所有方法
//    在Java類中，所有的類，都會默認繼承Object類
//                    繼承關鍵字
public class Student extends Person {
        private String name = "myhes";

    public Student() {
        //隱藏代碼，調用了父類的無參構造，必須放在子類構造器·第一行
        super();
        System.out.println("student無參執行了");
    }

    public void print1(){
            System.out.println("Java是一門好語言2！");
        }

        public void test(String name){
            System.out.println(name);//xiaohe       程序輸入的name
            System.out.println(this.name);//myhes   獲取本類中的name
            System.out.println(super.name);//lisi   獲取父類的name

        }


        public void test1(){
            this.print1();  //this指向本類方法
            super.print();  //super指向父類方法
        }

}

方法重寫

  • 重寫需要有繼承關系，子類重寫父類的方法！
  • 方法名必須相同
  • 修飾符：范圍可以擴大，但不能縮小： public > protected > default >private
  • 拋出的異常：范圍，可以被縮小，但不能擴大

一句話：子類的方法和父類的方法必須一致：方法體不同

為什么要重寫：

  • 父類的功能，不滿足於子類的需求

父類

public class A {
    public  void add(){
        System.out.println("A>>>B");
    }


}

子類

public class B extends A{

//    靜態方法和非靜態方法區別很大
    // 靜態：方法的調用只和A，B，定義的類型有關

    //非靜態： 非靜態的方法才叫重寫，

//    Override 重寫
    @Override  //注解：有功能的注解
    public void add() {
        System.out.println("大數據");
    }
}

啟動

//        重寫
        B b = new B();
        b.add();

//        父類的引用指向了子類
        A a = new B();//子重寫了父類的方法
        a.add();

image-20211109160947609

3、多態

概念：

  • 一個方法可以根據發送對象的不同而采用多種不同的方式
  • 一個對象的實際類型是確定的，但是可以指向的類型可以有很多
    • 指向的類型可以有：父類：有關系的類
多態存在的條件：
  • 有繼承關系
  • 子類重寫父類的方法
  • 父類引用指向子類對象
注意：

多態是方法的多態，屬性沒有多態

Person父類

//多態
public class Person {

    public void sun(){
        System.out.println("這是一個加法");
    }



}

student子類

 public class Student extends Person{
	@Override
    public void sun() {
        System.out.println("增強加法");
    }


    public void jian(){
        System.out.println("這是一個減法");
    }

}

程序類

//        多態
//        子類能調用的方法都是自己的和父類的
        Student student1 = new Student();

//        指向父類
//        父類型，可以指向子類，不能調用子類獨有的方法
        Person student2 = new Student();
//        爺爺
        Object student3 = new Student();

//        方法重寫時，父類調用的方法也走子類的方放

        student1.jian();
        ((Student) student2).jian();



    }

instanceof（類型轉換）

//        instanceof

//        Object > Person >Student
//        Object > String
//        存在繼承關系才true
        Object obj = new Student();
        System.out.println(obj instanceof Student);//true
        System.out.println(obj instanceof Person);//true
        System.out.println(obj instanceof Object);//true
        System.out.println(obj instanceof String);//false

28、static 關鍵字

Student類

public class Student  {

    private static int age;//靜態變量
    private double score; //非靜態變量

//    非靜態方法
    public void run(){

    }

//    靜態方法   ,靜態屬性和靜態屬性 類一起加載的，所以能直接調用
    public static void add(){

    }

    public static void main(String[] args) {
//        Student s1 = new Student();
//
//        System.out.println(s1.score); //通過對象訪問

//        age  //靜態變量可以直接調用

//        Student.age  // 類變量

        Student s2 = new Student();
        s2.run();// 通過對象訪問非靜態方法

        add();// 靜態方法可以直接調用

    }

Person類

//靜態代碼塊
public class Person {
    {   // 匿名代碼塊,在構造器之前
        System.out.println("這是一個匿名代碼塊");
    }

    static { //靜態 代碼塊   ，只執行一次
        System.out.println("這是一個靜態代碼塊");
    }

    public Person(){
        System.out.println("構造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("============================");
        Person person2 = new Person();
    }

//結果
    /*
這是一個靜態代碼塊
        這是一個匿名代碼塊
    構造方法
============================
    這是一個匿名代碼塊
            構造方法

     */
小結：
  • 靜態屬性、靜態方法，可以直接在類中直接調用（因為靜態屬性是和類生成時一起加載的，所以能直接調用)
  • 而，非靜態的屬性、方法，則需要通過對象來調用
  • 靜態代碼塊只執行一次

29、abstract 抽象類

  • abstract 修飾符也可以修飾類
  • 抽象類中可以寫普通方法，單抽象方法必須卸載抽象類中
  • 抽象類不能使用new 關鍵字來創建對象
  • 抽象方法，只有方法的聲明，沒有方法的實現，它使用子類來實現的（約束）

image-20211112112048743

30、接口

普通類：只有具體實現

抽象類：具體實現和規范（抽象方法）都有！

接口：只有規范，自己不能夠寫方法

  • 聲明類的關鍵字是class，聲明接口的關鍵字是interface

  • 接口就是規范，定義的是一組規則，實現了現實世界中 “ 如果你是，那么必須能。。。”的思想

  • 接口本質是契約，就像我們人間的法律一樣，制定了就必須要去遵守

  • 接口是OO的精髓，是對對象的抽象

  • 接口不能被實例化，因為接口中沒有構造方法

  • implements 實現可以多接口

  • 方法默認被 public abstract 修飾（抽象）

  • 屬性默認被 public static final 修飾（常量）

  • 實現類中，必須要重寫接口的方法

接口一

//接口關鍵字 interface
public interface UserService {

//    public void run(){
//
//    }
    //接口中所有的定義都是抽象的  使用的是public abstract 修飾
//    public abstract void run();
   void add(String name);
   void delete(String name);
   void update(String name);
   void query(String name);

}

接口二

public interface TimeService {
    void time();
}

實現類

//這是一個接口實現類
//    類通過 implements 接口              JAVA是單繼承的，但是可以通過接口實現多繼承
public class UserServiceImpl implements UserService,TimeService {

//實現了接口的類，就需要重寫接口中的方法
    @Override
    public void add(String name) {
        System.out.println("今天星期五");
    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void time() {

    }
}

31、內部類

什么是內部類

  • 內部類就是在一個類的內部在定義一個類，比如在A類中在定義一個B類，那么B相對於A 來說就稱為內部類,而A類相對於B類來說就稱為外部類

  • 1、成員內部類

  • 2、靜態內部類

  • 3、局部內部類

  • 4、匿名內部類

成員內部類

public class Outer {
    private int age = 18;
    public void run(){
        System.out.println("這是外部類");
    }


//    內部類
    public class add{
        public void add(){
            System.out.println("這是一個內部類");
            //        內部類可以獲得外部類的私有屬性/方法
        public void e1(){
            System.out.println(age);
        }
        }
    }
}

靜態內部類

   //    靜態內部類
   public static class add{
        public void add(){
            System.out.println("這是一個靜態內部類");
        }

局部內部類

//    局部內部類
// 在方法里面再寫一個類
    public void run1(){
        class Inner{
            
        }
    }

匿名內部類

public class Test {
    public static void main(String[] args) {
//        沒有名字實例化類，不用將實例保存到變量中
//        匿名內部類
        new Outer().run();
    }
}

32、異常（Exception）

什么是異常

image-20211112124504810

異常分類：

image-20211112124631640

異常的體系結構

image-20211112124732724

Java異常層級關系：

image-20211112124742219

image-20211112124810028

image-20211112124851228

33、異常處理機制

處理方法

  • 拋出異常（ throw 、 throws）
  • 捕獲異常（try 、catch 、 finally）
  • 拋出異常就是不處理異常，捕獲異常就是要處理異常

異常處理五個關鍵字：

  • try 、catch 、 finally 、 throw 、 throws

    捕獲異常

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
//     捕獲異常
//        如果要捕獲多個異常  ： 要按照異常層級關系 從小到大
        try {  //監控異常區域
            System.out.println(a/b);
        } catch (Exception e) { //catch 捕獲異常
            System.out.println("程序出錯"); //捕獲異常后執行代碼塊
        }finally { //處理善后工作
            System.out.println("finally");
        }
//        finally可以不要
        
    }

}


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 惡補Java Swing線程刷新UI機制（由淺到深的參考大佬博文） 惡補各種知識（網絡篇） java基礎 java基礎 Java基礎 Java基礎 關於Java基礎 Java - 基礎 java基礎——Scanner的基礎和進階 Android開發Java基礎之Java語言基礎(1)
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM