瘋狂Java講義第五版讀書筆記

文章目錄

• 瘋狂Java講義第五版讀書筆記
• • 第一章：Java語言概述與開發環境
  • • 1.1、Java程序運行機制
    • 1.2、Java第一個程序
    • 1.3、Java命名規范
    • • 1.3.1、包命名
      • 1.3.2、類命名、接口命名、抽象命名
      • 1.3.3、方法命名、變量命名
  • 第二章：面向對象
  • • 2.1、程序設計的三種結構
    • • 2.1.1、順序結構
      • 2.1.2、選擇結構
      • 2.1.3、循環結構
    • 2.2、面向對象的設計簡介
    • • 2.2.1、簡要描述：
      • 2.2.2、 類的簡單定義
      • 2.2.3、面向對象與面向過程
      • 2.2.4、面向對象三大基本特征
    • 2.3、面向對象特征
    • • 2.3.1、類與對象
      • 2.3.2、類的結構關系
  • 第三章：數據類型與運算符
  • • 3.1、注釋
    • • 3.1.1、單行注釋
      • 3.1.2、多行注釋
      • 3.1.3、文件注釋
    • 3.2、關鍵詞和標識符
    • • 3.2.1、分號
      • 3.2.2、花括號
      • 3.2.3、方括號
      • 3.2.4、圓括號
      • 3.2.5、空格
      • 3.2.6、圓點
      • 3.2.7、關鍵詞
    • 3.3、數據類型
    • • 3.3.1、Java語言說明
      • 3.3.2、數據類型分類
      • • 3.3.2.1、基本數據類型
        • 3.3.2.2、引用數據類型
    • 3.4、運算符
    • • • 3.4.1、算術運算符
        • 3.4.2、關系運算符
        • 3.4.3、按位運算符
        • 3.4.4、邏輯運算符
        • 3.4.5、賦值運算符
        • 3.4.6、條件運算符
  • 第四章：流程控制與數組
  • • 4.1、流程控制
    • • 4.1.1、順序結構
      • 4.1.2、分支結構
      • 4.1.3、循環結構
    • 4.2、數組
    • • 4.2.1、數組簡要描述
      • 4.2.2、數組的初始化
      • 4.2.3、foreach循環
      • 4.2.4、堆內存和棧內存
      • 4.2.5、操作數組的工具類——Arrays
      • • 4.2.5.1、打印數組
        • 4.2.5.2、數組排序
        • 4.2.5.3、在數組中查找指定元素并返回其下標
  • 第五章：面向對象
  • • 5.1、類的初步理解
    • • 5.1.1、類的定義
      • 5.1.2、類常見的基本格式
      • • 5.1.2.2、成員變量
        • 5.1.2.1、方法
        • 5.1.2.2、構造器
        • 5.1.2.3**補充** 參數傳遞問題
    • 5.2、類的特征
    • • 5.2.1、封裝
      • • 5.2.1.1、this關鍵詞
        • 5.2.1.2、簡要介紹
      • 5.2.2、繼承
      • • 5.2.2.1、簡要說明
        • 5.2.2.2、特點
      • 5.2.3、多態
      • • 5.2.3.1、前提
        • 5.2.3.2、示例
    • 5.3、重要類的闡述
    • • 5.3.1、抽象類
      • 5.3.2、內部類
      • 5.3.3、枚舉類
      • 5.3.4、包裝類
    • 5.4、lambda表達式
    • 5.5、修飾符的適用范圍介紹
  • 結語

第一章：Java語言概述與開發環境

1.1、Java程序運行機制

Java程序要經過先編譯、后解釋兩個步驟

Java執行的兩個步驟

Java 語言里負責解釋執行字節碼文件的是Java 虛擬機

JVM的作用很容易理解，就像有兩支不同的筆，但需要把同一個筆帽套在兩支不同的筆上，只有為這兩支筆分別提供一個轉換器，這個轉換器向上的接口相同，用于適應同一個筆帽；向下的接口不同，用于適應兩支不同的筆。在這個類比中，可以近似地理解兩支不同的筆就是不同的操作系統，而同一個筆帽就是Java字節碼程序，轉換器角色則對應JVM。類似地，也可以認為JVM分為向上和向下兩個部分，所有平臺上的JVM向上提供給Java字節碼程序的接口完全相同，但向下適應不同平臺的接口則互不相同。

jdk1.5版本以后不用去設置環境變量

1.2、Java第一個程序

public class Study {public static void main(String[] args) {System.out.println("hello world");} }

1.3、Java命名規范

1.3.1、包命名

常采用頂級域名作為前綴，例如com，net，org，edu，gov，cn，io等，隨后緊跟公司/組織/個人名稱以及功能模塊名稱。下面是一些包命名示例：

package org.springframework.boot.autoconfigure.cloud package org.springframework.boot.util package org.hibernate.action package org.hibernate.cfg package com.alibaba.druid package com.alibaba.druid.filter package com.alibaba.nacos.client.config package com.ramostear.blog.web

1.3.2、類命名、接口命名、抽象命名

類(Class)通常采用名詞進行命名，且首字母大寫，如果一個類名包含兩個以上名詞，建議使用駝峰命名(CamelCase)法書寫類名,每個名詞首字母也應該大寫。

public class UserDTO{ } class EmployeeService{ } class StudentDAO{ } class OrderItemEntity{ } public class UserServiceImpl{ } public class OrderItemController{ } public abstract class AbstractRepository<T>{ }

1.3.3、方法命名、變量命名

public User getOne(){} private String nickName; private String mobileNumber; private Long id; private Long orderItemId;

第二章：面向對象

Java中萬物皆為對象

2.1、程序設計的三種結構

不管是哪種結構，只有一個入口點a和一個出口點b

2.1.1、順序結構

雖然Java是面向對象的編程語言，但Java的方法類似于結構化程序設計的函數，因此方法中代碼的執行也是順序結構。

2.1.2、選擇結構

2.1.3、循環結構

即先判斷后執行，所以被稱為當型循環

因為是“直到條件為假時結束循環”，是先執行后判斷，所以被稱為直到型循環

2.2、面向對象的設計簡介

2.2.1、簡要描述：

? 面向對象是一種更優秀的程序設計方法，它的基本思想是使用類、對象、繼承、封裝、消息等基本概念進行程序設計，采用面向對象方式開發的軟件系統，其最小的程序單元是類，這些類可以生成系統中的多個對象，而這些對象則直接映像成客觀世界的各種事物。

2.2.2、 類的簡單定義

? 面向對象的軟件系統由多個類組成，類代表了客觀世界中具有某種特征的一類事物，這類事物往往有一些內部的狀態數據，面向對象的語言不僅使用類來封裝一類事物的內部狀態數據，而且類會提供操作這些狀態數據的方法，還會為這類事物的行為特征提供相應的實現，這種實現也是方法。

等式：成員變量（狀態數據）+方法（行為）=類定義

2.2.3、面向對象與面向過程

情景：豬八戒吃西瓜
在面向過程的程序世界里，一切以函數為中心，函數最大，因此這件事情會用如下語句來表達：

吃（豬八戒，西瓜）；

在面向對象的程序世界里，一切以對象為中心，對象最大，因此件事情會用如下語句來表達：

豬八戒.吃（西瓜）

面向對象更容易理解

2.2.4、面向對象三大基本特征

封裝（Encapsulation）、繼承（Inheritance）和多態（Polymorphism）

除此之外，抽象也是面向對象的重要部分，抽象就是忽略一個主題中與當前目標無關的那些方面，以便更充分地注意與當前目標有關的方面。

2.3、面向對象特征

2.3.1、類與對象

具有相同或相似性質的一組對象的抽象就是類，類是對一類事物的描述，是抽象的、概念上的定義；對象是實際存在的該類事物的個體，因而也稱為實例（instance）。

對象的抽象化是類，類的具體化就是對象

可以把類理解成某種概念、定義，它規定了某類對象所共同具有的數據和行為特征。

2.3.2、類的結構關系

一般→特殊關系

這種關系就是典型的繼承關系，Java語言使用extends關鍵字來表示這種繼承關系，Java的子類是一種特殊
的父類。因此，這種一般→特殊的關系其實是一種“is a”關系。

整體→部分結構關系

也被稱為組裝結構，這是典型的組合關系，Java語言通過在一個類里保存另一個對象的引用來實現這種組合關系。因此，這種整體→部分結構關系其實是一種“has a”關系。

第三章：數據類型與運算符

3.1、注釋

程序注釋是源代碼的一個重要部分，對于一份規范的程序源代碼而言，注釋應該占到源代碼的1/3以上。

3.1.1、單行注釋

//public class Study { // public static void main(String[] args) { // System.out.println("hello world"); // } //}

3.1.2、多行注釋

/* public class Study {public static void main(String[] args) {System.out.println("hello world");} }*/

3.1.3、文件注釋

/*** @author * @date 2022/5/12 10:24*/

3.2、關鍵詞和標識符

3.2.1、分號

Java語言里對語句的分隔不是使用回車來完成的，Java語言采用分號（;）作為語句的分隔

Java語句可以跨越多行書寫，但一個字符串、變量名不能跨越多行

3.2.2、花括號

花括號的作用就是定義一個代碼塊，花括號的作用就是定義一個代碼塊，類定義部分必須放在一個代碼塊里，方法體部分也必須放在一個代碼塊里。除此之外，條件語句中的條件執行體和循環語句中的循環體通常也放在代碼塊里

3.2.3、方括號

方括號的主要作用是用于訪問數組元素，方括號通常緊跟數組變量名，而方括號里指定訪問的數組元素的索引

3.2.4、圓括號

圓括號是一個功能非常豐富的分隔符：定義方法時必須使用圓括號來包含所有的形參聲明，調用方法時也必須使用圓括號來傳入實參值；不僅如此，圓括號還可以將表達式中某個部分括成一個整體，保證這個部分優先計算；除此之外，圓括號還可以作為強制類型轉換的運算符。

3.2.5、空格

Java語言中的空格包含空格符（Space）、制表符（Tab）和回車（Enter）等

3.2.6、圓點

圓點（.）通常用作類/對象和它的成員（包括成員變量、方法和內部類）之間的分隔符，表明調用某個類或某個實例的指定成員

3.2.7、關鍵詞

Java一共包含51個關鍵字

在上面的51個關鍵字中，enum是從Java 5新增的關鍵字，用于定義一個枚舉。而goto和const這兩個關鍵字也被稱為保留字（reserved word），保留字的意思是，Java現在還未使用這兩個關鍵字，但可能在未來的Java版本中使用這兩個關鍵字；不僅如此，Java還提供了三個特殊的直接量（literal）：true、false和null；Java語言的標識符也不能使用這三個特殊的直接量。從Java 10開始引入的var并不是關鍵字，它相當于一個可變的類型名（后面會述），因此var依然可作為標識符。

3.3、數據類型

3.3.1、Java語言說明

Java語言是強類型（strongly typed）語言，強類型包含兩方面的含義：

① 所有的變量必須先聲明、后使用；

② 指定類型的變量只能接受類型與之匹配的值

注：變量定義——（修飾符）變量類型 變量名，可以有初始值也可無

var可以動態進行定義局部變量，局部變量要有初始值

編程的本質：是對內存中數據的訪問和修改。程序所用的數據都會保存在內存中，程序員需要一種機制來訪問或修改內存中數據。這種機制就是變量，每個變量都代表了某一小塊內存，而且變量是有名字的，程序對變量賦值，實際上就是把數據裝入該變量所代表的內存區的過程；程序讀取變量的值，實際上就是從該變量所代表的內存區取值的過程。形象地理解：變量相當于一個有名稱的容器，該容器用于裝各種不同類型的數據。

3.3.2、數據類型分類

3.3.2.1、基本數據類型

基本數據類型的表數范圍由小到大為

byte→short→char→int→long→float→double

char代表字符型，實際上字符型也是一種整數類型，相當于無符號整數類型

1、大轉小要強制類型轉換，類型前面加（需要的轉換的類型)，可能會引起溢出，從而造成數據丟失，也稱為縮小，但轉換小轉大可以直接進行轉換

2、如果希望把基本數據類型轉為字符串類型，可以把基本類型的值和一個空字符串進行連接

3、在通常情況下，字符串不能直接轉換為基本類型，但通過基本類型對應的包裝類則可以實現把字符串轉換成基本類型

public class Study {public static void main(String[] args) {String a="55";int s = Integer.parseInt(a);System.out.println(s);} }

4、boolean不能進行轉換，boolean主要用于流程的控制，通常運用int和double數據類型

Java規范并沒有強制指定boolean類型的變量所占用的內存空間。雖然boolean類型的變量或值只要1位即可保存，但由于大部分計算機在分配內存時允許分配的最小內存單元是字節（8位），因此bit大部分時候實際上占用8位。

3.3.2.2、引用數據類型

引用類型包括類、接口和數組類型，還有一種特殊的null類型。所謂引用數據類型就是對一個對象的引用，對象包括實例和數組兩種。

3.4、運算符

3.4.1、算術運算符

運算符含義

+	求和
-	相減
*	乘積
/	商
%	求余數（求模）
++	自加一
–	自減一

3.4.2、關系運算符

運算符含義

>	大于
>=	大于等于
<	小于
<=	小于等于
==	等于
!=	不等于

3.4.3、按位運算符

此處省略一萬字

3.4.4、邏輯運算符

運算符含義結果

&	邏輯與（可以翻譯成并且）	兩邊都是true，結果才是true
│	邏輯或（可以翻譯成或者）	有一邊是true，結果就是true
!	邏輯非（取反）	!true = false、!false = true
&&	短路與	兩邊都是true，結果才是true
││	短路或	有一邊是true，結果就是true

3.4.5、賦值運算符

運算符含義

=	賦值
+=	加等（原先的基礎上加上/追加這個數）
-=	減等（同理）
*=	乘等（同理）
/=	除等（同理）
%=	模等（同理）

3.4.6、條件運算符

布爾表達式 ? 表達式1 : 表達式2

判斷表達式是否成立，true則選擇表達式1，false則選擇表達式2

第四章：流程控制與數組

4.1、流程控制

4.1.1、順序結構

程序從上到下逐行地執行，中間沒有任何判斷和跳轉

4.1.2、分支結構

if語句

使用布爾表達式或布爾值作為分支條件來進行分支控制，放在if之后括號里的只能是一個邏輯表達式，即這個表達式的返回值只能是true或false

**注意：**使用if…else語句時，一定要先處理包含范圍更小的情況

switch語句

用多個整型值進行匹配，后面的控制表達式的數據類型只能是byte、short、char、int四種整數類型，枚舉類型和java.lang.String類型

4.1.3、循環結構

while循環

do while循環

for循環

此處省略5000字

4.2、數組

4.2.1、數組簡要描述

數組也是一種數據類型，它本身是一種引用類型。

int[]就是一種數據類型，與int類型、String類型類似，一樣可以使用該類型來定義變量，也可以使用該類型進行類型轉換等。使用int[]類型來定義變量、進行類型轉換時與使用其他普通類型沒有任何區別。int[]類型是一種引用類型，創建int[]類型的對象也就是創建數組，需要使用創建數組的語法

4.2.2、數組的初始化

//靜態初始化和動態初始化 int [] arrayName={22,33,33,22}; int[] array = new int[5];

4.2.3、foreach循環

for(數據類型 自定義一個變量：變量){System.out.println(自定義一個變量); }

4.2.4、堆內存和棧內存

當一個方法執行時，每個方法都會建立自己的內存棧，在這個方法內定義的變量將會逐個放入這塊棧內存里，隨著方法的執行結束，這個方法的內存棧也將自然銷毀。因此，所有在方法中定義的局部變量都是放在棧內存中的；在程序中創建一個對象時，這個對象將被保存到運行時數據區中，以便反復利用（因為對象的創建成本通常較大），這個運行時數據區就是堆內存。堆內存中的對象不會隨方法的結束而銷毀，即使方法結束后，這個對象還可能被另一個引用變量所引用（在方法的參數傳遞時很常見），則這個對象依然不會被銷毀。只有當一個對象沒有任何引用變量引用它時，系統的垃圾回收器才會在合適的時候回收它。

4.2.5、操作數組的工具類——Arrays

給數組賦值：通過 fill 方法。
對數組排序：通過 sort 方法,按升序。
比較數組：通過 equals 方法比較數組中元素值是否相等

4.2.5.1、打印數組

public static void main(String[] args) {int [] array={11,2,5,9,3,4};System.out.println(array);System.out.println(Arrays.toString(array));}

4.2.5.2、數組排序

public static void main(String[] args) {int [] array={11,2,5,9,3,4};System.out.println(Arrays.toString(array));Arrays.sort(array);System.out.println(Arrays.toString(array));}

4.2.5.3、在數組中查找指定元素并返回其下標

public class Test_02 {public static void main(String[] args) {int [] array={11,2,5,9,3,4};System.out.println(Arrays.binarySearch(array,5));} }

第五章：面向對象

5.1、類的初步理解

5.1.1、類的定義

類是面向對象的重要內容，類當成一種自定義類型，可以使用類來定義變量，這種類型的變量統稱為引用變量。也就是說，所有類是引用類型。

5.1.2、類常見的基本格式

類中總體包含三種成員：構造器，成員變量，方法

三種成員總體概括：成員變量用于定義該類或該類的實例所包含的狀態數據，方法則用于定義該類或該類的實例的行為特征或者功能實現。構造器用于構造該類的實例，Java語言通過new關鍵字來調用構造器，從而返回該類的實例。

構造器是一個類創建對象的根本途徑，如果一個類沒有構造器，這個類通常無法創建實例。如果程序沒有構造器，系統將會提供。

5.1.2.2、成員變量

成員變量被分為類變量和實例變量兩種，定義成員變量時沒有static修飾的就是實例變量，有static修飾的就是類變量。其中類變量從該類的準備階段起開始存在，直到系統完全銷毀這個類，類變量的作用域與這個類的生存范圍相同；而實例變量則從該類的實例被創建起開始存在，直到系統完全銷毀這個實例，實例變量的作用域與對應實例的生存范圍相同。

5.1.2.1、方法

在前面幾個章節中我們經常使用到 System.out.println()，那么它是什么呢？
println() 是一個方法。
System 是系統類。
out 是標準輸出對象。

這句話的用法是調用系統類 System 中的標準輸出對象 out 中的方法 println()。

靜態方法和非靜態方法

靜態方法是有static修飾的，可以直接通過類來進行對方法的調用，通常把static修飾的成員變量和方法也稱為類變量、類方法。

非靜態方法是沒有static修飾的，調用方法的時候必須要進行創建對象，擁有一個實例，通常把不使用static修飾的成員變量和方法也稱為實例變量、實例方法。

static相當于一個標志，有static修飾的成員屬于類本身，沒有static修飾的成員屬于該類的實例

5.1.2.2、構造器

構造器名必須要和類名相同，形參列表和方法是一樣的

5.1.2.3補充 參數傳遞問題

Java中只有值傳遞

了解引用傳遞

class Student{int id;String name; public void paly(){ ...... } } =========== public void showStudent(Student student){System.out.println(student.id);System.out.println(student.name); }

這時可以把Student看成一個數據類型，但是準確來說是一個類，student代表Student類的一個變量，這樣就能訪問student中的數據了，一個方法的形式參數是一個類的類型(引用類型),這里其實需要的是該類的對象。

引用傳遞的實質是對其所引用的對象進行操作，而所引用的是同一個對象，所以說還是相當于一個值的傳遞

方法參數傳遞的實質：傳入方法的是實際參數值的復制品，不管方法中對這個復制品如何操作，實際參數值本身不會受到任何影響

你有一把鑰匙，當你的朋友想要去你家的時候，如果你直接把你的鑰匙給他了，這就是引用傳遞。這種情況下，如果他對這把鑰匙做了什么事情，比如他在鑰匙上刻下了自己名字，那么這把鑰匙還給你的時候，你自己的鑰匙上也會多出他刻的名字。你有一把鑰匙，當你的朋友想要去你家的時候，你復刻了一把新鑰匙給他，自己的還在自己手里，這就是值傳遞。這種情況下，他對這把鑰匙做什么都不會影響你手里的這把鑰匙。。

5.2、類的特征

5.2.1、封裝

5.2.1.1、this關鍵詞

1、區別成員變量和局部變量

public class Student{ private String name; public void setName(String name){ //this.name表示類中的屬性name this.name = name;} }

2、this在類中表示當前類將來創建出的對象

public class Student{private String name;public Student(){System.out.println("this = "+this);}public static void main(String[] args){Student s = new Student();System.out.println("s = "+s);} }

5.2.1.2、簡要介紹

該露的露，該藏的藏

我們程序設計要追求“高內聚，低耦合”。高內聚就是類的內部數據操作細節自己完成，不允許外
部干涉；低耦合：僅暴露少量的方法給外部使用。

把變量通過private關鍵詞進行修飾，然后經過get和set方法進行外部訪問

//set負責給屬性賦值 //get負責返回屬性的值 public class Student{private String name;public void setName(String name){this.name = name;}public String getName(){return this.name;}} public class Test{public static void main(String[] args){Student s = new Student();s.setName("tom");System.out.println(s.getName());

5.2.2、繼承

5.2.2.1、簡要說明

Java的繼承通過extends關鍵字來實現，實現繼承的類被稱為子類，被繼承的類被稱為父類，有的也稱其為基類、超類。父類和子類的關系，是一種一般和特殊的關系。例如水果和蘋果的關系，蘋果繼承了水果，蘋果是水果的子類，則蘋果是一種特殊的水果。

5.2.2.2、特點

1、繼承的本質在于抽象。類是對對象的抽象，繼承是對某一批類的抽象。
2、為了提高代碼的復用性。
extands的意思是“擴展”。子類是父類的擴展。

JAVA中類只有單繼承，沒有多繼承！ 接口可以多繼承！

5.2.3、多態

5.2.3.1、前提

1.要有繼承關系

2.子類要重寫父類的方法

3.父類引用指向子類

5.2.3.2、示例

//父類 public class Test_01 {int num = 30;public void eat(){System.out.println("動物吃飯");}public static void sleep(){System.out.println("動物在睡覺");}public void run(){System.out.println("動物在奔跑");} } //子類 public class Test_02 extends Test_01{int num=50;public void catchMouse(){System.out.println("貓抓老鼠");} } //Demo public class Demo {public static void main(String[] args) {Test_01 t1 = new Test_02();t1.eat();t1.run();System.out.println(t1.num);Test_02 t2 = (Test_02) t1;t2.catchMouse();} }

編譯看左，運行看，成員變量編譯運行均看左

5.3、重要類的闡述

5.3.1、抽象類

5.3.2、內部類

5.3.3、枚舉類

5.3.4、包裝類

5.4、lambda表達式

5.5、修飾符的適用范圍介紹

后面有些東西還沒有寫完，但是也不想寫了，就先這樣，因為要敲代碼，后續有時間再來更新，沒有時間就算了，后面還有集合，IO流等知識，目前自己正看到IO流這里，時間寶貴，多敲代碼，少寫東西，浪費時間，敲著敲著不會的地方回去看就好了

結語

Java書籍推薦

鏈接：https://www.123pan.com/s/l5iA-Wlnwd

總結

以上是生活随笔為你收集整理的疯狂Java讲义第五版读书笔记的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。