疯狂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