第一章Java的历史，环境搭建

Java 程序设计基础

张美娟   17710131197 （微信同步） 23 级 - 计科

5- 某某

老师 / 娟姐     18   - 》无代沟 - 》 E309

课堂要求：

1. 不允许迟到、旷课，请假 ( 导员 - 》假条 - 》发送给

班长 + 学委 )

2. 本门课程要求写笔记：电子版本，以 csdn 博客形

式记笔记

      纳入到平时成绩

      博客笔记：以网络形式进行存储，方便携带

查看

              以章节为一篇文章

              提高竞争力；

              变现 第一章： Java 的历史、环境搭建

             

3. 不允许玩手机、游戏、看电视剧、电影以及和学习

无关的事

      手机：统一放在电脑左边、右边、我这边

     

4. 课堂案例及时练习，遇见问题沟通

课下要求：

  1. 及时完成作业，发布到雨课堂

  2. 遇到问题及时问、我、同学之间都可以

Java 是一种计算机编程语言；除了 java 还有很多编

程语言： c 语言、 c++ 、 c# 、 python 等

不同的计算机编程语言语法不同；应用场景不同；

java 是一种后端开发编程语言 一、 Java 的历史

1. 1995 年， sun 公司推出的一款面向对象的编程语

言

2. jdk ： java 开发的必要工具 - 》 1996

97   jdk1.1

98   jdk1.2

...

04 年， jdk1.5; 更名为 jdk5.0

    推出了新特性：泛型、增强 for 等

     

      jdk6.0 二、 Java 语言的特点 【理解】

1. 简单性：相对 c 、 c++ 等

2. 开源性：开放源代码

3. 编程资源广泛性：很多大厂作为推手

      jdk7.0

      jdk8.0 （ jdk1.8 ） -> Lambda 表达式

(stream 流 )

      ...

      jdk18

      ...

     

     

2009 年， sun 被 oracle( 甲骨文 ) 公司收购。

java 的发展分为三个方向：【记住】

          JavaSE ： Java 语言核心基础

          JavaEE ：企业级开发

          JavaME ：通信         4. 跨平台性：可以在不同的操作系统上，执行 java

代码

5. 面向对象性：后续课程讲解

三、 Java 运行机制 【实际操作，记住】

1. Java 的执行机制：先编译后解释运行

2. 注意：实际运行的时候，运行的是 .class 文件

windows + MACOS + linux

(1) 先编译：将 java 代码通过编译器生成对应的

字节码文件 ( .class 结尾 )

  Java 的源文件：以 .java 文件

(2) 后运行：将 .class 文件 通过解释器，逐

行的解释并运行

.java 文件一次编译；可以被多次的运行 四、环境搭建

1. 安装 jdk ：安装文档步骤即可

2. 名词解释：

3. 配置 环境变量：

将 .exe 文件进行双击安装；

采用默认的路径，默认存储在 ：

C:\Program Files\Java

(1) JVM:Java 虚拟机，作用：屏蔽不同操作系统

之间的差异性

(2) JRE ： Java 运行环境， JRE = 解释器 +JVM

(3) JDK:Java 开发工具、 Java 开发工具包；

      JDK = JRE + 编译器 + 类库 + 工具 (1) java_home ： jdk 的根目录

    C:\Program

Files\Java\jdk1.8.0_131

     

(2) path ： jdk 的 bin 目录

    C:\Program

Files\Java\jdk1.8.0_131\bin

     

(3) classPath ：代表 告知 jvm 去哪找执行

的 .class 文件

    classPath=. ；代表在当前路径下查找需

要的文件

4. 测试环境是否配置成功 五、 Java 的第一个程序

1. 创建 Java 的源文件：以 .java 结尾

2. class ：类，代码容器

打开 Dos 命令窗口

(1) 在 搜索框中 输入 cmd ，点击回车即可

(2) 采用 系统键按住 + 同时再按 R ，输入

cmd ，回车即可

(3) 在 盘符对应的 输入框，输入 cmd ，回车即

可

Dos 命令窗口中输入：

    java -> 回车

    javac -> 回车

First.java class 类名 {

// main 函数：也称为主函数，程序的入口，

一个类中最                 // 多只能定义

一个 main 函数

public static void main(String[]

args){

System.out.println("Hello

World!!!");

// 控制台打印输出，并换行

}

}

3. 编译和运行

打开 Dos 命令窗口：

(1) 编译： javac 源文件名 .java

  注意：编译之后生成一个以 类名命名的

.class 文件

(2) 运行： java 类名

4. 细节： 5. 公开类：

六、包 (package)

(1) 一个源文件中可以定义多个类 , 但是每个类之间

不允许重名

(2) 每个类中都可以定义一个主函数

(3) 每个类都会生成对应的 .class 文件

(1) public ：公开的、公共的

(2) 被 public 修饰的类称为公开类、公共类

(3) 语法：

  public class 类名 {}

   

(4) 公开类的类名必须 和 源文件名保持一致

(5) 一个源文件中最多只能有一个 公开类 1. 作用：类似于文件夹，用于分门别类进行管理文

件；方便存储和维护

2. 语法：

package 包名；

package 包名 1. 包名 2. 包名 ; // 多级包结构

3. 注意事项：

(1) package 语句必须定义在源文件中第一行有

效语句

(2) 一个源文件中最多只能定义一行 package 语

句

4. 带包的编译和运行

(1) 编译： javac -d . 源文件名 .java

(2) 运行： java 包名 . 类名

        java 包名 1. 包名 2. 包名 3. 类名 七、编码规范

1. 标识符命名规范（语法要求）

2. 标识符的建议要求：

标识符：开发中 起名字的地方统称为标识符

(1) Java 中标识符只能以：数字、字母、下划线

(_) 、 $ 组成，但是不能以数字开头

(2) Java 中的标识符没有长度的限制

(3) Java 中的标识符严格区分大小写

(4) 不能使用 java 中关键字、保留字、特殊符号

(true\false\null) 进行命名

java 中标识符可以采用中文进行命名；但是不建

议，容易出现乱码 (1) 望文生义， Student/ User / Admin /

name

(2) 包名 全小写， demo ; demo.aa.zmj

(3) 类名：每个单词首字母大写， TestStudent

(4) 变量名、函数名、方法名：第一个单词首字母

小写，其余单词首字母大写，称为 驼峰命名法

(ageAndName)

(5) 常量：建议全大写， PI / A

3. 良好的 格式要求

(1) 建议每行写一句代码

(2) 层级之间有严格缩进，通常为 Tab

4. 良好的注释规范 注释：对代码解释和说明，可以提高代码的可读性

(1) // ：单行 注释 , 只能写一行注释，不能换

行

(2) /*

        多行 注释，可以写 多行内容

  */

   

  注意：单行注释中不能嵌套多行注释；

        多行注释可以嵌套单行注释

创建 源文件 TestStudent.java ，在源文件中定

义公开类，

在源文件中 package 语句， demo 包中：

打印输出 "good good study" // 代码加注释

      "day day up..."

       

编译 、运行         第二章：变量、数据类型、表达式、运

算符

一、变量

1. 概念：计算中一块内存空间，存储数据的基本单

元 / 单位

2. 变量的组成部分：数据类型、变量名字、数据

3. 语法：

(1) 先声明，再赋值：

  数据类型 变量名 ； // 变量的声明

  变量名 = 数据 ; // 赋值

   

(2) 声明的同时赋值：

  数据类型 变量名 = 数据 ;

   

(3) 同时定义多个同类型的变量：

  数据类型 变量名 1, 变量名 2, 变量 3= 值 , 变量

名 4; 二、 Java 中的数据类型

1. 基本数据类型 ( 原始数据类型、简单数据类型 )

注意： java 是一种强类型的语言，对应类型的数据必

须存储在对应类型的变量中

B(Byte-> 字节 ) 1B = 8b (bit, 位 )

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

10.24 被称为程序猿节

(1) 整数类型

  byte     1B     -128~127   short   2B     -32768~32767

  int     4B    

-2147483648~2147483647

  long     8B     -922 京 ~922 京 -1

   

  注意： long 字面值后面需要 加 L/l( 建议 L ，

区分数字 1)

(2) 小数类型

  float ： 4B, 单精度，字面值后面必须加 f/F

  double ： 8B ，双精度 , 字面值后面可以加 D/D,

也可以不加

注意： float 和 double 采用 科学计数法的形式

进行存储；

     

(3) 字符类型

a. char   2B

b. 字面值形式：

    i. 使用 单引号的形式直接赋值

      char c1='A';

      char c2 = ' 中 ';       char c3 = '3';

       

    ii 采用整数形式进行存储，范围 0~65535

      char c = 65; // A

      char c2 = 29233 ; // ' 爱 '

c. 转义字符：

    '\n' ：换行

    '\t' ：水平跳格， tab

    '\' ' ：单引号

    '\" ' ：双引号

    ...

       

(4) 布尔类型：

  boolean ：字面值， true/false

            true: 代表关系成立

            false ：代表关系不成立

            float(4B) 和 long(8B) 相比谁的存储数据范围

更大。

float ，因为 float 采用科学计数法的形式进行存

储

2. 对象数据类型 / 引用数据类型

(1) 类、数组、集合、接口等都属性对象类型

(2) 以字符串为例：

  a. 字面值：使用双引号 引起来 的一个或是

多个字符

   

  b. String str = " 中国 "; 三、类型转换

1. 自动类型提升

小结：

整数常用 int

小数常用 double

布尔类型：常用于 分支结构，循环结构 中的判断

字符串：经常用， String -> 开发重要

年龄： int

成绩： double

性别： ' 男 '/' 女 ' char " 男 " / " 女 "- 》

String

手机号： 17710131197 ->String

姓名：赵佳铭 -> String

身份号： 38999595959..x   -> String (1) 场景：将小数据类型 赋值给大数据类型 ( 存储

的数据类型范围越大 -> 大数据类型 )

       

(2) 自动类型提升规则：

  byte->short->int->long->float-

>double

   

  char -> int -> long -> float ->

double

2. 强制类型转换

(2) 场景：将大数据类型 赋值 给小数据类型，需

要使用强制类型转换

(2) 语法：

    源数据类型 变量名 = 值；

    大数据类型

   

    目标类型 变量名 = ( 目标类型 ) 变量名 ;

    小数据类型 四、表达式

1. 理解：表达式由变量、字面值、运算符组成式

子，通常有一个结果

2. 表达式结果规则：

五、运算符

(1) 表达式有 double ，结果 为 double

(2) 没有 double, 有 float ，结果为 float

(3) 没有 double/float ，有 long ，结果 为

long

(4) 其余全部为 int 类型

  byte 和 byte   byte 和 short short 和

short

  byte 和 int   short 和 int   int 和

int 1. 算术运算符

+ - *( 乘法 ) /( 除法 )   %( 取余数 / 取模 )

java 的 + 两种应用：

(1) 加法运算， + 两端都是 数值类型

(2) 字符串拼接： + 两端只要有一端为字符串，则

为字符串的拼接

2. 赋值运算符

=     +=     -=   *=     /=

int a = 2;

a+=1; // 结果上： a = a+1;

a*=5; // a=a*5; 3*5 = 15

a-=10 ; // a=a-10;

System.out.println("a="+a);// 3 3. 比较运算符 ( 关系运算符 )

>   ：大于

>=   ：大于等于

<   ：小于

<=   ：小于等于

==   ：等于

!=   ：不等于

注意：被关系运算符连接的表达式称为布尔表达

式，关系成立 -true ；关系不成立 -false ；结果类

型为布尔类型

4. 逻辑运算符：

&& ：逻辑与，并且，两端连接的必须都为布尔表达

式，两端同时为 true ，结果才为 true 。

   

|| ：逻辑或，或者，两端连接的必须都为布尔表达

式，只要有一端为 true ，结果就为 true

! ：逻辑非，在结果上进行取反 5. 一元运算符

++( 自增 )         --( 自减 )

开发应用如下：

a++ 或是 ++a ：让 a 变量自身加 1

a-- 或是 --a: 让 a 变量自身减 1

以下内容常用于开发面试或是考试：

int c=a++;// 先使用再加 1

int c=++a;// 先加 1 再使用

6. 三元运算符

(1) 语法：

  布尔表达式 ? 表达式 1: 表达式 2

(2) 原理：判断布尔表达式结果是否成立，成立 ——

true ，则执行表达式 1 ；否则执行表达式 2 六、扫描议 (Scanner)

1. 作用：实现人机交互

2. 使用步骤：

(1) 导包： import 包名 1. 包名 2. 类名 ;// 导入

某一个

        import 包名 1. 包名 2.* ； // 导入包

中所有类

       

  注意：定义在 pacakge 语句的后面，所有类的

上面；

        一个源文件中可以定义多行 import 语

句

  import java.util.Scanner;

(2) 创建 Scanner 对象：

  Scanner sc = new

Scanner(System.in);

   

(3) 使用：

  int n = sc.nextInt();// 输入一个整数 第三章：分支结构

一、 if 分支结构

1. if 的基本结构

  double s = sc.nextDouble();// 输入

一个小数

  String str = sc.next();// 输入一个

字符串

  char c = sc.next().charAt(0);// 输

入一个字符

(1) 语法：

  if( 判断条件 / 布尔表达式 ){

      // 语句

  }

(2) 执行原理：如果 if 后面 () 中的条件成立，结

果为 true ，则执行 {} 中的语句 2. if 的基本结构 2

(1) 语法：

  if( 判断条件 / 布尔表达式 ){

      // 语句 1

  }else{

      // 语句 2

  }

(2) 执行原理：如果 if() 中的条件成立，则执行

语句 1 ，否则执行语句 2

3. 多重的 if 结构 (1) 语法：

  if( 判断条件 ){

      // 语句 1

  }else if( 判断条件 ){

      // 语句 2

  }else if( 判断条件 ){

      // 语句 3

  }else if( 判断条件 ){

      // 语句 4

  }else{

      // 语句 n

  }

4. 嵌套的 if 结构 二、等值分支结构： switch...case

1. 语法：

(1) 语法：

  if( 判断条件 ){

      if( 判断条件 ){

          // 语句

      }else if( 判断条件 ){

           

      }

  }else{

       

  }

(2) 执行原理：先判断外层的 if 条件，再判断内层

的 if 条件 switch( 表达式 ){

  case 值 1: 语句 1;break;

  case 值 2: 语句 2;break;

  case 值 3: 语句 3;break;

  ...

  default: 语句 n;break;

}

执行原理：会根据 switch 中的表达式结果，从上往

下进行依次匹配 case 后面的值，哪一个匹配成功，

则执行 case 后面对应的语句，如果都匹配不成功，

则执行 default 后面的语句。

2. 细节： 三、局部变量

1. 概念：定义在函数 / 方法的内部的变量

2. 特点：

(1) switch 后面表达式的结果类型必须是

byte 、 short 、 int 、 char 、 String

(2) break ：终止、结束 switch..case 结构，防

止 case 穿透

(3) default 没有位置先后要求

(1) 先赋值，再使用

(2) 从定义位置开始，到定义它的代码块结束

(3) 在重合的作用范围内，不允许命名冲突 第四章：循环结构

一、循环的理解

1. 理解：通过某个条件，重复并且有规律的执行一

段代码

2. 循环的组成部分：循环变量的初始化、循环条

件、循环变量的改变、循环体

3. 循环分类： while 循环、 do...while 循环、 for 循

环

二、 while 循环

1. 语法：

// 循环变量的初始化

while( 循环条件 ){

  // 循环体 ( 重复执行的功能代码 )

  // 循环变量的改变

} 2. 执行原理：

3. 特点：

三、 do..while 循环

1. 语法：

先执行循环的初始化，接着判断循环条件，如果条

件满足 - 结果为 true ，执行 {} 中循环体，从而执行

循环变量改变，再次判断循环条件，如果满足 - 结果

为 true ，执行 {} 中循环体，从而执行循环变量的改

变，再次判断循环条件 ... 执行循环条件不满足，

结果为 false ，终止、结束整个循环结构，继续执

行后续代码 ....

(1) 先判断，再执行，执行次数 0~n 次

(2) 如果循环的控制不合理，可能出现死循环 2. 执行原理：

3. 特点：先执行，再判断，执行的次数为： 0~n 次

四、 for 循环【开发应用重点】

1. 语法：

// 循环变量的初始化

do{

  // 循环体

  // 循环变量的改变

}while( 循环条件 ); // 分号不能省略

先执行循环变量的初始化，接着执行循环体，同时

循环变量改变，然后判断循环条件，条件满足，则

再次执行循环体，循环变量的改变，再次的判断循

环条件 ... 直到循环条件不满足，结果为 false ，

终止、跳出循环结构 for( 循环变量的初始化 ; 循环条件 ; 循环变量的改

变 ){

  // 循环体

}

2. 执行原理：

3. 特点： 五、循环的控制语句

1. break ：终止、结束当前循环；可以应用在

switch..case 中，用于防止 case 穿透

(1) 先判断，再执行，执行的次数为 0~n 次

(2) 循环变量的初始化代码可以定义在 for 上面，

此时循环变量的作用范围扩大了，不建议

(3) 循环条件没有，则默认为 true

循环的总结：

while 循环和 for 循环特定：先判断，再执行

do..while 循环：先执行，再判断

后期开发：

while 循环：当循环次数不确定时，建议使用

while 循环

for 循环：当循环的次数明确时，建议使用 for 循环 2. continue ：中止、结束本次循环，从而进入下一

次循环

六、循环的嵌套

1. 理解：在循环结构中，定义完整的循环结构

2. 循环嵌套时，循环次数：外层循环次数 * 内层循

环次数

3. 循环控制语句应用循环嵌套中：

4. 利用循环打印图形：通常使用外层循环控制行，

内层循环控制列

break ：终止、结束本层循环

continue ：中止、结束本层的本次循环，从而进

入本层下一次循环 第五章：函数

一、理解

1. 函数：执行一段特定功能的代码，并且可以通过

名字被反复的调用

2. 函数的使用流程：

(1) 函数的定义：确定了函数的功能和函数名

      a. 函数的声明：确定函数名

  b. 函数的实现：确定函数功能

(2) 函数的调用：通过函数名进行反复的使用 3. 函数定义的位置：定义在类以内，其他函数以外

( 与 main 并列 )

二、函数的基本使用

1. 函数的定义：

2. 函数的调用：

public static void 函数名 (){

  // 函数体 ( 函数实现 )

}

函数的定义分为函数的声明 和函数的实现：

函数的声明： public static void 函数名 ()

        注意：函数名望文生义、驼峰命名

函数的实现： {}

(1) 可以通过函数名使用函数，被称为调用

(2) 语法：函数名 (); 三、参数的使用

1. 多数情况下，函数与调用者之间需要数据的交

互；调用者必须提供必要的数据，才能使函数完

成相应的功能，函数和调用者之间交互的数据被

称为参数

2. 形式参数：

3. 实际参数：

(1) 形式参数：简称形参，函数和调用者之间需要

交互数据约定，约定调用者需要传递哪种类型、几

个参数

(2) 语法： ( 数据类型 参数名 , 数据类型 参数名

2)

(3) 使用：将形参作为函数的局部变量进行使用即

可 四、函数的返回值

1. 理解：函数和调用者之间的一种数据交互，调用

者通过函数调用，函数需要给调用者返回的数据

2. 语法：

(1) 实际参数：简称实参，函数调用时，用户传递

给函数的具体数据

(2) 语法：函数名 ( 实参 );

(3) 作用：实际参数用于给形参赋值

(4) 注意：实际参数的个数、顺序、数据类型必须

和形参一致

public static 返回值类型 函数名 ( 参数 ){

  // 函数体 ( 函数功能 )

} 3. 函数返回值类型：

4. 函数返回值的处理：

5. return 的作用

五、函数执行的机制

(1) 返回值类型为 void ，代表无返回值，函数无

需给调用者返回任何数据结果

(2) 返回值类型为： 8 种基本数据、对象类型，代

表函数必须给调用者返回对应的数据；函数体中必

须 有 return xxx;

(1) 第一种处理方式：定义和返回值类型同类型的

变量接收

(2) 第二种处理方式：不处理

(1) 将返回值返回给调用者

(2) 结束当前函数 1. 理解：

2. 函数的嵌套调用：

六、递归调用

1. 理解：一个函数中调用自身

2. 注意：函数递归使用过程中，必须设置一个出

口，否则可能会出现无穷递归，运行过程中报错

信息为： java.lang.StackOverflowError （栈溢

出）

3. 递归的思想：

程序以 main 函数作为程序入口，进入 main 函数从

上往下依次执行，如果遇到函数调用，则优先执行

被调用函数内部的代码，函数执行完毕以后，带着

返回值返回到调用位置，再继续后续代码 .....

被调用的函数内部，又调用其他的函数 (1) 递进：每一次推进，计算都比上一次变得简

单，直至简单到无需继续推进，就能获得结果。也

叫到达出口。

(2) 回归：基于出口的结果，逐层向上回归，依次

计算每一层的结果，直至回归到最顶层。

4. 案例：

package demo;

public class Test8{

public static void main(String[]

args){   // 135642

int r = jieCheng(8);

System.out.println(r);

}

// 函数功能：计算 n 的阶乘 第六章：数组

一、理解：

public static int jieCheng(int n)

{

// 递归的出口

if(n==1 || n==0) return 1;

// n 的阶乘 = n* (n-1) 的阶乘

return n* jieCheng(n-1);

}

} 1. 数组：一组连续的存储空间，可以存储多个相同

类型的数据，而且可以统一管理

2. 数组的重要因素：数组的长度 和 数据类型

3. 数组的使用：

(1) 声明数组：确定数组的数据类型

  数据类型 [] 数组名 ;

  int[] a; // 建议

  int a[];

  int []a;

   

(2) 分配空间：确定数组的长度

  数组名 = new 数组类型 [ 长度 ];

  a = new int[5];

4. 数组的基本语法： (1) 数组的下标：从 0 开始，依次为 0 、 1 、

2..., 数组的长度 -1

(2) 数组的访问：通过数组名 + 下标，数组名 [ 下

标 ]

     

(3) 访问数组时指定的下标不在合法范围内，则编

译通过，运行报错，错误信息为：

java.lang.ArrayIndexOutOfBoundsExcept

ion( 数组的下标越界 )

(4) 对数组元素进行一一访问，遍历

  // 利用循环控制数组的下标

  for(int i=0;i< 数组的长度 ;i++){

      // 数组名 [i] 访问

  }

5. 数组的默认值 整型类型： 0

小数类型： 0.0

字符类型：空字符

布尔类型： false

引用类型： null

6. 数组的定义方式：

(1) 先声明，再分配空间：

  数据类型 [] 数组名；

  数组名 = new 数据类型 [ 长度 ];

   

(2) 声明的同时分配空间：

  数据类型 [] 数组名 = new 数据类型 [ 长

度 ];

   

(3) 显示初始化：

  数据类型 [] 数组名 = new 数据类型 []{ 值

1, 值 2, 值 3};

  注意：数组的长度由 {} 中数据的个数决定，

[] 中不能再指定数组的长度

   

(4) 显示初始化： 二、数组的内存

1. 数组：内存中空间是连续的 ( 方便管理 )

2. 数组类型变量存储的是数组在内存中首地址

3. 寻址方式：首地址 + 数据类型的字节数 * 下标

三、数组扩容

1. 思想：

2. 实现数组扩容：

  数据类型 [] 数组名 ={ 值 1, 值 2, 值 3};

  注意：初始化必须和声明一起完成，不能分开

(1) 创建一个更大空间的新数组，通常是数组的长

度 2 倍

(2) 将原数组中的元素一一赋值到新的数组中

(3) 新的地址覆盖旧的地址 第一种方式：

package demo;

public class Test5{

public static void main(String[]

args){

int[] a = {7,8,3,5,2};

// 原来数组的长度

System.out.println(" 数组的原长

度： "+a.length);

for(int i=0;i<a.length;i++){

System.out.print(a[i]+"

");

}

System.out.println();

// 将 新的数据 20 存储到 a 数组

中，不够用，需要扩容

// 1. 创建一个更大空间的新数组

int[] b = new

int[a.length*2];

// 2. 将原数组元素一一赋值到新数组

中 //   新 = 原 - 》 新 [0] = 原

[0] ， 新 [1] = 原 [1]

for(int i=0;i<a.length;i++){

// 新 = 原

b[i] = a[i];

}

// 3. 新的地址覆盖旧的地址

a = b;

a[5] = 20;

System.out.println(" 新数组的长

度： "+a.length);

for(int i=0;i<a.length;i++){

System.out.print(a[i]+"

");

}

}

} 第二种方式：

java.util.Arrays.copyOf( 原数组名 , 新数组

的长度 );

a=java.util.Arrays.copyOf(a,a.length*

2);

四、二维数组 [ 开发 + 面试 + 考试不重要，比赛时应

用 ]

1. 理解：类似于 excel 表格，由行和列组成

2. 行和列的下标都是从 0 开始，行也称为高纬，列

称为低维

数据类型 [][] 数组名 = new 数据类型 [ 行数 ][ 列

数 ];

3. 遍历二维数组，通过行和列进行访问 五、数组的排序

1. 排序：将数组中的元素按照一定规则进行存储

2. 排序方式： [ 从小到大 ]

int[][] a = new int[5][4];

a[1][2] = 9;

a[3][0] = 5;

// 遍历数组

// 外层循环控制行

for(int i=0;i<a.length;i++){

// 内层循环控制列

for(int j=0;j<a[i].length;j++){

System.out.print(a[i][j]+"

");

}

System.out.println();

} 第七章：面向对象

一、编程思想

(1) 冒泡排序方式：每次将相邻的两个数据进行一

一比较，将较大的数据进行往后移

  // 循环：控制比较轮数

for(int i=1;i<a.length;i++){

for(int j=0;j< a.length

i;j++) {

// 比较 a[j] 和 a[j+1]

if(a[j]>a[j+1]){

int temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

}

}

(2) java.util.Arrays.sort(a); 借助工具类

排序 1. 面向过程：

2. 面向对象：

二、对象

1. 理解：计算机中的对象：复杂的客观事物在 Java

程序中的一种表现形式 ( 一切皆对象 )

2. 对象的组成部分：

(1) 面向过程：将问题拆分为第一步、第二步、第

三步 ... 将问题解决

(2) 问题：解决较大业务时，相对麻烦

(1) 面向对象：将一些内容看成一个整体，作为一

个对象，利用对象与对象之间关系，解决问题

(2) 解决复杂业务相对容易 3. 类：

三、类的组成

1. 类名：望文生义，每个单词首字母大写

(1) 对象的属性：代表对象有什么特征，对应静态

数据部分

(2) 对象的方法：代表对象能做什么，对应动态的

行为和功能

(1) 类：计算机中用于区分不同类别对象，用于描

述该类对象具有哪些属性和哪些方法

(2) 类和对象的关系：

  类是对象的模板

  对象是类的实例

   

  注意：一个类可以创建多个对象 2. 类的定义：

class 类名 {

  // 1. 属性

  // 2. 方法

}

3. 属性：

(1) 属性：也被称为成员变量

(2) 语法：数据类型 变量名 ;

        数据类型 变量名 = 值 ;

(3) 位置：定义在类以内，方法以外

(4) 成员变量具有默认值：

  整数类型： 0

  小数类型： 0.0

  字符类型：空字符

  布尔类型： false

  对象类型： null

(5) 成员变量的作用范围：至少在本类中有效

(6) 命名冲突：在本类中不允许有同名成员变量，

但是成员变量可以和局部变量命名冲突，局部变量

优先使用 4. 方法：

(1) 方法：成员方法

(2) 位置：定义类以内，其他方法以外

(3) 语法：

  public static 返回值类型 函数名 ( 形参 )

{

      // 函数体

  }

  方法定义如下：

  public 返回值类型 方法名 ( 形参 ){

      // 方法体

  }

(4) 方法的定义：分为方法的声明和方法的实现

  声明：修饰符 返回值类型 方法名 ( 参数 ) 异

常 四、创建对象

1. 语法：类名 对象名 = new 类名 ();

2. 对象的使用：

五、方法的重载 (overload) 【开发 + 面试 + 考试重

点】

1. 理解：一个类中定义了多个同名，但是形参不同

的方法

2. 要求：

        注意：修饰符可以有 0~n

  实现： {}

对象名 . 属性名

对象名 . 方法名 ( 实参 );

(1) 方法名相同

(2) 形参列表不同 ( 参数的个数、顺序、数据类型 )

(3) 返回值类型、修饰符、异常没有要求 3. 使用：

六、构造方法

1. 构造方法：是一种特殊的方法，也称为构造器

2. 定义位置：定义在类以内，方法以外

3. 构造方法的要求：

4. 使用：

通过调用传递的实际参数，决定调用重载中的哪一

个方法

(1) 构造方法的方法名必须和类名一致

(2) 构造方法没有返回值类型 ( 连 void 都没有 )

(3) 语法：

  public 类名 ( 形参 ){}

(4) 构造方法允许重载（一个类中可以定义多个构

造方法：无参数的构造方法只能定义一个，可以定

义多个有参数的构造方法）

(5) 构造方法不允许手动调用 5. 作用：

6. 开发实际应用技巧：

七、 this 的应用

(1) 构造方法在创建对象时， jvm 根据传递的参数

决定使用哪一个构造方法完成对象的创建

(2) 如果一个类中没有定义任何的构造方法，则

jvm 默认提供一个公开的、无参数的构造方法

(3) 如果一个类中定义任何有参数的构造方法，则

jvm 不会再提供公开的无参数的构造方法

(1) 用于创建对象

(2) 利用构造方法，在创建对象时，给属性赋值

一个类中通常提供 2 个构造方法：

(1) 提供一个无参数的构造方法

(2) 提供一个有参数的构造方法，参数个数、顺

序、类型取决于属性 1. this.

(1) this 代表当前对象，用于调用本类的属性和

成员方法

(2) this. 属性名 - 》调用属性

  this. 成员方法名 ( 实参 ); -> 调用方法

(3) this. 通常可以省略，但是当成员变量和局部

变量命名冲突时，通常使用 this. 区分成员变量

2. this() ：

(1) this() ：必须用在构造方法中第一行有效语

句

(2) 作用：调用本类的其他构造方法 八、引用

1. 引用：对象类型的变量

java 是强类型的语言，对应类型的对象必须存储在

对应类型的引用中：

    类名 引用名 = new 类名 ();

      引用           对象

      引用类型         对象类型   - 》一

致 2. 引用存储的是对象在堆空间中首地址

3. 对象与对象之间是相互独立的，操作一个对象不

会影响其他的对象

4. 可以单独的声明引用：类名 引用名 ;

5. 同类型的引用之间可以相互赋值，传递的是对象

在堆空间中首地址

6. 可以使用 null 作为引用的初始化数据，但是以

null 调用属性或是方法，则编译通过，但是运行

报错，错误信息为：

java.lang.NullPointerException( 空指针异常 )

7. 引用的应用场景：

(1) 引用应用在形式参数上：对应类型的对象和引

用都可以作为实际参数进行传递

(2) 引用应用在返回值上：对应类型的对象和引用

都可以作为返回值进行返回 第八章：面向对象的三大特性 [ 封装、继

承、多态 ]

一、封装

1. 目前程序存在的问题：程序没有进行数据安全检

测，可能出现业务逻辑问题

2. private ：私有的，被 private 修饰的内容，只能

在本类中使用

3. 给私有化的属性提供公开的 get 和 set 方法 二、继承

1. 理解

(1) set 方法：为属性赋值

  public void set 属性名 ( 数据类型 变量

名 ){

      this. 属性名 = 变量名 ;

  }

  注意： () 中的数据类型取决于赋值对应的属性

类型

(2) get 方法：获取属性值

  public 返回值类型 get 属性名 (){

      return 属性名 ;

  }

  注意：返回值类型取决于 获取的属性类型

碳素笔   是一种   笔

水杯   是一种   容器

狗     是一种   动物

A     is-a     B (1) Java 中的继承：体现类之间 is-a 关系

  A is a   B 关系成立， A 和 B 之间具有继承

  子类     父类

  子类 继承 父类

      extends

(2) 子类通过继承关系，直接使用父类中的属性和

方法    

2. 继承体现了程序的复用性和扩展性

3. 方法的覆盖： [ 也被称为方法的重写 -override] (1) 理解：子类中定义了和父类中相同的方法

(2) 方法覆盖的要求：

  a. 子类中的方法名、形参列表、返回值类型

和父类相同

  b. 子类的访问修饰符和父类相同，或是比父

类更宽

(3) 使用：如果子类覆盖了父类中方法，则优先使

用子类覆盖后的方法

(4) 注意事项：

a. 如果子类定义了和父类方法名、形参列表相

同，但是返回值类型和父类不同的方法时，编译报

错

b. 如果子类定义了和父类方法名、返回值相同，

但是参数列表不同的方法时，编译通过，运行也通

过，构成了父类 + 子类中的方法重载

方法重载：方法名相同，形参列表不同 - 》

overload

4. Java 中继承特点： (1) 一个父类可以同时定义多个直接子类

    class Animal{}

    class Cat extends Animal{}

    class Dog extends Animal{}

(2) 一个子类只能有一个直接的父类，但是可以具

有多个间接的父类 ( 多级继承 ) ， java 中的类之间的

继承关系是：单继承

    class A{}

    class B extends A{}

    class C extends B{}

    // B 是 C 的直接父类， A 是 C 间接父类

5. java 中的访问修饰符

(1) 访问修饰符代表可以访问的权限

(2) java 中有 4 个访问修饰符：

  private ：私有的

  default ：默认的

  protected ：受保护的

  public ：公开的

(3) 访问权限如下：             本类   同包   不同包的子类

  其他

private     ok

default     ok     ok

protected   ok     ok       ok

public       ok     ok       ok    

  ok

(4) 4 个访问修饰符修饰内容的可继承性如下：

private ：被 private 修饰的属性和方法不允许被

继承

default ：被 default 修饰的属性和方法只能同包

子类继承

protected ： .... 同包 + 不同包的子类可以继承

public : ... 所有子类都可以继承

6. super 的应用： 三、多态

1. 理解：

(1) 第一种应用： super.

  a. super. ：应用在子类的方法中，访问父

类中的属性或是成员方法的

  b. super. 属性名

      super. 成员方法名 ( 实参 );

     

     

(2) 第二种应用： super()

a. 创建子类对象时， jvm 默认创建对应的父类对

象，默认使用父类中无参数的构造方法完成父类对

象的创建

b. super()/super( 实参 ) ：应用在子类构造方

法的第一行，代表调用父类构造方法，用于指示利

用哪一个构造方法完成父类对象的创建

c. 子类的构造方法中，如果没有使用

super()/super( 实参 ) ，则在子类的构造方法第

一行默认添加 super() (1) 父类型的引用存储不同子类型的对象

    父类类名 引用名 = new 子类类名 ();

        引用         对象

        父类型       子类型

(2) 以父类型的引用调用属性和方法时，只能调用

父类中定义的 -> 编译过程检测

(3) 运行过程， jvm 自动检测子类是否覆盖父类中

的方法，如果覆盖了，则优先调用子类覆盖后的方

法

2. 引用之间的转换： (1) 父类型的引用 赋值给 子类型的引用，需要强

制类型转换

      大类型         小类型

  a. 如果实际存储的对象类型和转换的类型一

致，编译通过，运行通过

  b. 如果实际存储的对象类型和转换的类型不

一致，编译通过，运行报错，错误信息为：

java.lang.ClassCastException( 类型转换异

常 )

   

(2) 子类型的引用 赋值给 父类型的引用，直接赋

值即可

(3) 如果没有继承关系的双方 , 不允许强制类型转

换，编译报错

3. 利用 instanceof 避免类型转换异常

(1) 语法：引用名 instanceof 类名

(2) 应用：判断引用中存储的实际对象类型是否兼

容于后面的类型，兼容 -true ；不兼容 -false( 兼

容，是不是后面的一种 )

4. 多态的应用场景： 第九章：三个修饰符

一、 abstract[ 抽象的 ]

1. 可以修饰类：

(1) 多态应用在形式参数上：本类型 + 所有子类型

的对象、引用都可以作为实际参数进行传递

(2) 多态应用在返回值上：本类型 + 所有子类型的

对象、引用都可以作为返回值进行返回

(1) 被 abstract 修饰的类称为抽象类

(2) 语法：

  abstract class 类名 {}

(3) 特点：抽象类可以声明引用，但是不能创建对

象

(4) 注意：抽象类中可以定义属性、成员方法、构

造方法 2. 可以修饰方法：

3. 抽象类可以定义子类：

二、 static [ 静态的 ]

1. 可以修饰属性：

(1) 被 asbtract 修饰的方法称为 抽象方法

(2) 语法：

  访问修饰符 abstract 返回值类型 方法名

( 形参 );

  注意：访问修饰符 和 asbtract 没有先后的

顺序

(3) 特点：抽象方法只有方法的声明部分，没有方

法的实现

(4) 注意：抽象方法只能定义在抽象类中

(1) 语法：

  class 类名 extends 抽象类类名 {}

  abstract class 类名 extends 抽象类

类名 {}

(2) 注意：如果子类不想定义为抽象类，则必须覆

盖抽象的父类中所有的抽象方法 (1) 被 static 修饰的属性称为静态属性、静态变

量、类变量

(2) 语法： static 数据类型 变量名 ;

        static 数据类型 变量名 = 值 ;

(3) 特点：静态属性基于类而存在，和创建多少对

象无关，所有的对象共享同一份

(4) 使用：

  a. 可以通过 对象名 . 静态属性名

  b. 可以直接通过 类名 . 静态属性名 - 》建议

2. 可以修饰方法 (1) 被 static 修饰的方法称为静态方法

(2) 语法：

  访问修饰符 static 返回值类型 方法名 ( 形

参 ){}

(3) 注意：访问修饰符 和 static 之间没有先后

顺序

(4) 使用：类名 . 静态方法名 ( 实参 );

(5) 静态方法中只能访问本类的静态成员

(6) 静态方法中不能使用 this/super 关键字

思考： System.out.println(); 实现原理？

    System : 类

    out : 静态属性 - 》 对象，被 static

    println: - 》方法

   

3. 可以修饰代码块 三、 final[ 最终的、最后的 ]

(1) 被 static 修饰的代码块 称为静态代码块

(2) 语法：

  class 类名 {

    static{}

  }

(3) 作用：在类加载的时候，按照和静态属性定义

的先后顺序完成静态属性的初始化工作

(4) 类加载：当 jvm 第一次使用一个类的时候，

通过 classpath 找到对应的 .class 文件，对文件

进行读取，读取该类的相关信息 ( 包、类、父类、属

性、方法、构造方法等 ) ，将读取到的信息保存到

jvm 内存中，一个类 类加载只进行一次。

(5) 类加载的时机 ( 什么叫第一次使用一个类 )

  a. 第一次访问该类的静态成员 ( 静态属性、

方法 )

  b. 第一次创建该类对象：

        先进行类加载，再完成对象的创建

  c. 子类类加载，会导致其父类先类加载   1. final 可以修饰变量 ( 局部变量、实例变量、静态

变量 )

2. final 可以修饰方法：被 final 修饰的方法能被子类

继承，但是不能被覆盖

3. final 可以修饰类：被 final 修饰的类不能被继承，

没有子类

第十章：接口

一、理解

(1) 被 final 修饰的变量作用范围内的常量

(2) 语法： final 数据类型 变量名 ;

        final 数据类型 变量名 = 值 ;

(3) 被 final 修饰的引用，存储的对象不允许改

变 1. 接口：是一种标准，接口的实现者和使用者都必

须遵循的约定。

2. 语法特点：

二、实现类

1. 实现类的语法：

(1) 接口的关键字： interface

(2) 接口的语法：

  interface 接口名 {}

(3) 接口不能创建对象，可以声明引用

(4) 接口中的属性都是公开的、静态的、常量 ( 默

认被 public 、 static 、 final 修饰 )

(5) 接口中没有构造方法

(6) 接口中的方法都是公开、抽象方法 ( 默认被

public 、 asbtract 修饰 )

class 类名 implements 接口名 {}

abtract class 类名 implements 接口名 {} 2. 实现类的注意：

三、接口的继承性

1. java 中的接口是多继承

2. 类和接口之间多实现关系

(1) 实现类不想成为抽象类，则需要覆盖接口中所

有的抽象方法

(2) 实现类覆盖接口中的方法时，访问权限必须是

public

(1) 一个接口可以同时继承多个接口

(2) 语法：

  interface 接口名 extends 父接口 1, 父

接口 2{} 3. 类实现多个接口的同时可以继承一个类：

四、接口多继承的影响

1. 由于接口的多继承性，让多态更加的多样性

2. 以接口类型的引用调用方法时，只能调用该接口

中声明的方法

(1) 一个类同时可以实现多个接口

(2) 语法：

  class 类名 implements 接口名 1, 接口名

2{}

(3) 注意：如果一个类实现多个接口，需要把所有

接口中抽象方法全部覆盖 ( 包括父接口中的 )

(1) 语法：

  class 类名 extends 父类 implements

  接口名 1, 接口名 2{}

(2) 注意：一个类实现多个接口的同时，允许继承

一个父类，但是必须继承在前，实现在后 五、高版本 Jdk 语法补充

1. JDK8.0 开始 ，接口中可以定义默认方法和静态

方法。

2. JDK9.0 开始，接口中可以定义私有方法。

(1) 默认方法：

default 返回值类型 方法名 ( 形参列表 ){ // 方

法实现 }

注意：带有方法实现的非静态方法必须加

default ；默认访问权限为 public

(2) 静态方法：

public static 返回值类型 方法名 ( 形参列表 )

｛ // 方法实现 ｝

注意：静态方法没有写访问修饰符，默认为 public

private 返回值类型 方法名 ( 形参列表 ){ // 方

法实现 } 六、接口的分类

1. 常量接口：接口中只有静态常量，没有定义任何

方法，应用不广泛

2. 标记接口：空接口，接口中没有定义任何的属性

和方法。

3. 普通接口：具有至少一个抽象方法的接口。

4. 函数式接口：接口中只有一个抽象方法，对静态

方法和默认 方法没有要求。 [ 用于 lambda 表达

式 ]

第十一章：内部类

interface IA{

  int n = 6;

}

interface IB{} 一、理解

1. 内部类：定义在一个类内部的类

2. 内部类编译之后会生成独立的 .class 文件，命名

规则为：

外部类类名 $ 内部类的类名 .class

3. 内部类的分类：成员内部类、静态内部类、局部

内部类、匿名内部类

4. 匿名内部类为例：

(1) 要求：继承一个父类或是实现一个接口

(2) 特点：匿名内部类定义和对象的创建一起完

成 , 基于一个匿名内部类只能创建该类的一个对象

案例：

package demo;

public class Test2{

public static void main(String[]

args){

// 匿名内部类

IA ia=new IA(){ public void m1(){

System.out.println("m1...");

}

public int m2(int a,int

b){

int sum = a+b;

return sum;

}

};

ia.m1();

System.out.println(ia.m2(8,7));

}

}

interface IA{

void m1();

int m2(int a,int b);

} 二、 Lambda 表达式

1. 理解：用于简化匿名内部类的实现过程，基于函

数式接口实现

2. 注意： lambda 只能应用在函数式接口上

3. 语法：

4. 注意事项：

接口名 引用 = ( 参数名 , 参数名 2)->{

  // 方法的实现部分

};

(1) 当 {} 中有且只有一行语句时， {} 可以省略

( 没有返回值的方法 )

(2) () 中的数据类型可以省略

(3) 如果方法带有返回值，当方法实现只有一行语

句，并且为 return 语句时，此时 {}+return 可以

一起省略