惡補 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虛擬機

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

3、Java程式運行機制

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

5、Java關鍵字

6、Java識別符號

Java所有組成的部分都需要名字，類名、變數名以及方法名就稱為識別符號，
所有的表示符都應該以字母(A-Z或者a-z)，美元符 $ 、或者下劃線 _ 開始，
不能使用關鍵字作為變數名或方法名
識別符號對大小寫敏感

7、什么是位元組

位（bit）：是計算機內部資料 存盤的最小單位，11001100是一個八位二進制數
位元組（byte）：是計算機中 資料處理 的基本單位，習慣上用大寫 B 來表示，
1B （byte，位元組）=8bit
字符：是指計算機中使用的字母、數字、字和符號

8、Java資料型別

強型別語言

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

Java的資料型別分為兩大類：

基本資料型別
參考資料型別

資料型別的默認值

9、變數

什么是變數

Java是一種強型別語言，沒一個變數都需要宣告其型別
Java變數是程式中最基本的存盤單位，其要素包括變數名，變數型別和作用域

10、變數名的命名規范

11、運算子

12、包

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

其中：

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

13、JavaDoc

javadoc命令是用來生成自己的API檔案的

14、Scanner物件

Java提供了一個工具類，可以獲取用戶的輸入
基本語法

next（）：
- 1. 一定要讀取到有效字符后才可以結束輸入
- 1. 在遇到有效字符之前遇到的空白，next()會將其去掉
  2. 在有效字符之后識別到空格之后，next（）會將空格作為分隔符或結束符
  3. next不能得到帶有空格的字串
nextLine（）：
1. 以Enter（回車鍵）為結束符也就是說 nextLine（）方法回傳的是輸入回車之前的所有字符
2. 可以獲取到空白字串

15、流程控制陳述句

if
if else
switch
which回圈（先判斷，后執行）
do ...which回圈（先執行，后判斷，至少執行一次）
for回圈
增強版for回圈
- 主要用于陣列【回傳沒有下標】或集合
break
- 可以控制回圈流程，用于強行退出回圈
continue
- 用于終止某次回圈，然后繼續執行下一次回圈

16、Java方法

1. 什么是Java方法

Java方法是陳述句的集合，他們在一起執行一個功能
- 方法是解決一類問題的步驟的有序組合
- 方法包含在類或物件中
- 方法在程式中被創建
一個方法最好只完成一個功能，這樣有利于后期的擴展

2.方法的定義

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

?
- 修飾符：這是可選的，告訴編譯器如何呼叫該方法
- 回傳值型別：方法可能會回傳值，有回傳值就定義回傳值，沒有就用 void
- 方法名：方法的實際名稱
- 引數型別：方法像是一個占位符，當被呼叫時，傳遞值給引數，這個值就被稱為實參或者變數，引數串列是指方法的引數型別，順序和引數個數，引數是可選的，方法可以不包含任何引數
  - 形式引數：在方法被呼叫時用于接收外界輸入的資料
  - 實參：呼叫方法是實際傳給方法的資料
- 方法體：方法體，包含具體的陳述句，定義該方法的功能

3、方法的多載

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

17、方法呼叫

呼叫方法：物件名.方法名（實參串列）
Java有兩種呼叫方法的方式，是根據是否有回傳值來選擇的
- 當有回傳值是
- 回傳值為 void 時
  - 執行的是一條陳述句

18、可變引數

在方法宣告中，在指定引數型別后面加上一個省略號（...）
一個方法只能指定一個可變引數，他必須是方法的最后一個引數，其他普通方法都要在它前面宣告，

19、遞回

什么是遞回？

? A方法呼叫B方法，我們容易理解
? 遞回就是：A方法呼叫A方法，自己呼叫自己

20、陣列的定義

1.什么是陣列？

陣列是相同型別的有序集合
每個資料稱為陣列的元素，每一個元素可以通過一個下標來訪問他，下標索引從 0 開始，

2.陣列宣告創建

首先必須宣告陣列變數，才能在程式中使用陣列
語法：

Java語言中使用new運算子來創建陣列
語法：

獲取陣列長度：

3、陣列的特點

4、圖解陣列

5、陣列的創建

靜態創建
動態創建

6、陣列的邊界

陣列下標的合法區間：[ 0，length-1 ],如果業界就會報錯：

7、小結

陣列是相同資料型別的有序集合
陣列也是物件，陣列元素相當于物件的成員變數
陣列的長度是確定的，不可變的，如果越界，就會報錯

21、多維陣列

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

定義：

22、Arrays類

陣列的工具類java.util.Arrays
Arrays類中的方法都是static修飾的靜態方法，在使用的時候可以直接使用類名進行呼叫

常用功能：

23、冒泡排序

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;
    }

值傳遞和參考傳遞

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();

小結

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();

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 關鍵字來創建物件
抽象方法，只有方法的宣告，沒有方法的實作，它使用子類來實作的（約束）

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）

什么是例外

例外分類：

例外的體系結構

Java例外層級關系：

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可以不要
        
    }

}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/356235.html

標籤：Java

上一篇：Pentaho資料集成回圈計數變數

下一篇：使用位運算驗證一個數是否為奇數？

惡補 Java 基礎