Java语言程序设计

第一章：Java环境搭建

Java 是一种计算机编程语言；除了 java 编程语言，还有很多的编程语言：c 、 c++ 、 c# 、 python 等

不同编程语言类比于不同国家语言；每个编程语言的语法不同；应用场景不同

Java 是一个用于后端开发的编程语言

一、Java历史

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

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

97     jdk1.1

98     jdk1.2

..

2004 年： jdk1.5 版本，更名为 jdk5.0

        添加新特性：泛型、增强的 for 等

        jdk6.0

        jdk7.0

         jdk8.0 -> 企业， lambda 表达式

(stream 流 )

       

        ...

        jdk18.0

        ....

2009 年： sun 被 oracle( 甲骨文 ) 收购了

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

    JavaSE ： Java 语言核心基础

    JavaEE ：企业级开发应用

    JavaME ：通信相关

二、 Java 语言的特点

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

2. 开源性 ( 开放源代码，编程人员写的程序 )

3. 资源广泛性：很多编程爱好者进行研究，大厂作

为推手

4. 跨平台性：可以在不同的操作系统运行

windows 、 linux 、 unix 、 macos 等

开发环境 windows /macos

部署环境： linux

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

三、 Java 运行机制

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

源码文件： .java 文件，开发人员进行编写

编译：将 .java 源文件通过编译器 生成对应的

字节码文件

    (.class 文件 )

运行：将 .class 文件 通过解释器 - 》逐行的翻译

并运行

2. 注意：实际运行时，运行 .class 文件； .java 只需

要编译一次， .class 文件可以被多次的运行 ( 一次

编译多次运行 )

注意：如果源代码更改，重新的编译，生成新的对

应的 .class

四、环境搭建

1. 名词解释：

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

之间差异

(2) JRE: Java 运行环境； JRE = 解释器 +JVM

(3) JDK ： Java 开发工具， JDK=JRE+ 编译器 + 工

具类 + 工具

2. 安装 JDK

点击 jdk 的安装文件，按照 步骤完成即可。

(1) jdk 不要重复安装，如果想卸载，需要通过控

制面板

(2) jdk 没有 提供操作界面，需要安装

notpad++ 文本编辑器进行编写代码

3. 配置环境变量

(1) java_home ： jdk 的根目录

    C:\Program

Files\Java\jdk1.8.0_131

     

(2) path ： java 的 bin 目录

    C:\Program

Files\Java\jdk1.8.0_131\bin

     

(3) classPath ： . ； 代表：告知 jvm 去哪找对应的执行.class 文件； . 代表在当前路径下查找

4. 测试 jdk 的安装是否成功

打开 Dos 命令窗口进行测试：

(1) 直接在 搜索框中输入 cmd 按回车：

(2) 直接 利用 先 系统键 + 同时 再按 R ，输入

cmd 即可

(3) 在 文件夹 的输入框中 输入 cmd ，回车即可

五、 Java 的第一个开发程序

1. java 的源文件以： .java 进行结尾

2. class ：类，代码容器

class 类名 {

  public static void main(String[]

args){

}

}

(1) main 函数：被称为 主函数，程序的入口，一

个类中最多只能有一个主函数

(2) System.out.println();// 控制台打印

输出信息

3. 编译和运行：

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

(2) 运行： java 类名

4. 细节：

(1) 一个源文件中可以定义多个类，每个类中都可

以定义一个 main 函数

(2) 一个源文件中多个类之间不允许重名

5. 公开类：

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

(2) 一个类被 public 修饰，则此类被称为公开

类、公共类

(3) 语法：

  public class 类名 {}

   

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

(5) 一个源文件中最多只能定义 一个公开类

六、 package( 包 )

1. 作用：类似于文件夹，方便进行分门别类进行管

理

2. 语法： package 包名；

3. 注意事项：

(1) package 语句必须位于源文件中第一行有效语

句

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

句

4. 带包的编译和运行

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

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

七、编码规范

1. 良好的标识符命名规范

(1) 硬性要求 [ 语法要求 - 开发 + 面试题目涉及 ]

1. java 中标识符只能以 数字、字母、 _ 、 $ 组

成，但是不能以数字开头

2. java 中标识符没有长度限制

3. java 中标识符严格区分大小写

4. 不能使用 java 中关键字、保留字 (goto 、

const) 、特殊符号命名 (true/false/null)

注意： java 中允许使用汉字命名，但是不建议使

用，容易出现乱码  

(2) 建议要求【软性要求】

(1) 望文生义， Student / Worker

(2) 包名：全小写， package

demo.com.zmj;

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

             

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

写，其余单词首字母大写 ( 驼峰命名法 ) ，

ageAndName

(5) 常量：全大写； PI

2. 良好的编码格式

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

(2) 层级之间要有严格缩进，一个 Tab 键

3. 良好的注释习惯

注释：对代码的解释和说明

(1) // ：单行注释：只能写一行注释内容

(2) /*

多行注释：可以写 N 行注释内容

  */

注意：注释内容不参与编译

注意 2 ：单行注释不能嵌套多行注释；  但是多行注释可以嵌套单行注释

第二章：变量、数据类型、运算符、表 达式

一、变量

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

本单元

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

3. 语法：

(1) 先声明，再赋值：

  数据类型 变量名 ; // 声明

  变量名 = 值 ;   // 赋值

   

(2) 声明的同时并赋值：

  数据类型 变量名 = 值 ;

   

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

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

二、 java 中的数据类型分类

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

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

1KB= 1024B

1MB= 1024KB

1GB= 1024MB

1TB= 1024GB

..

10.24 号，称之为 程序猿节

(1) 整数类型 (4 种 )

  byte   1B   -128~127

  short   2B   -32768~32767

  int     4B  

-2147483648~2147483647

  long   8B   -922 京 ~922 京 -1

注意： long 的字面值后面需要加 L 或是 l( 建议大

写，区分数字 1)

(2) 小数类型 ( 浮点类型 -2 种 )

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

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

D/d ，或是不加

  注意： float 和 double 可以采用科学计数法进

行存储

(3) 字符类型 (1 种 )

  char 2B ，字面值形式如下：

   

  a. 单引号引起来的一个字符

      char c1 = 'A';

  b. 采用整数形式，整数范围 0~65535

      char c2 = 65;

      char c3 = 29233;

  c. 转义字符：

      '\n' ：换行

      '\t' ：水平跳格

      '\' ' ：单引号

      '\" ' ：双引号 (4) 布尔类型 (1 种 )

  boolean 字面值 true/false

      true ：代表关系成立

      false ：关系不成立

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

(1) 类、数组、接口等都称为对象类型

(2) 以字符串为例：

  a. 字符串： String

  b. 使用 双引号引起来的 一个或是多个字符

      String str = "hello"; 数据类型实际开发总结：

整数类型通常使用： int

小数类型： double

布尔类型：通常应用判断、循环结构中

字符类型：实际开发不常用

字符串：实际开发频繁使用

实际存储数据：根据项目业务

姓名 ： String name =" 韩晨夕 " ;  

年龄 : int age = 35;

成绩 ： double score = 99.5;

性别 ： String sex = " 男 ";

    char c = ' 男 ';

    int flag = 1; // 1- 男 0- 女

电话： String tel= "17710131197";

地址： String addr = " 天津市武清区 ";

身份证号 : String

id="37082819891012203x"

三、数据类型之间的转换

1. 自动类型提升

(1) 场景：小数据类型赋值给大数据类型 ( 存储的

数据范围衡量数据的大小 )

(2) 规则：

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

>double

   

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

2. 强制类型转换

(1) 场景：大数据类型赋值给小数据类型，需要强

制类型转化

(2) 语法：

  源数据类型 变量名 = 值 ;

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

四、表达式

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

子，通常有一个结果

2. 表达式的结果规则：

(1) 如果表达式中有 double 类型，结果为 double

(2) 表达式中没有 double 类型，有 float ，结果

为 float

(3) 表达式中没有 double/float ，有 long ，结

果为 long

(4) 其余结果为： int

五、运算符

1. 算术运算符

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

模 )

注意： + 的两种用法：

  a. 如果 + 两端都为数值类型，则为加法运算

  b. 如果 + 两端有一端为字符串类型，则为字

符串拼接

2. 赋值运算符

=   +=   -=   *=   /=

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.*;// 导入包中

所有 类

       

(2) 位置：定义在 package 语句的后面，所有类上

面

(3) 例如： import java.util.Scanner;

3. 步骤：

(1) 导入包：

  import java.util.Scanner;

  import java.util.*;

(2) 创建对象：

  Scanner sc = new

Scanner(System.in);

(3) 使用：

  int n = sc.nextInt();// 输入一个整数

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

一个小数

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

符串

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

入一个字符

第三章：分支结构

一、 if 分支结构

1. 基本 if 结构：

(1) 语法：

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

      // 语句

  }

(2) 执行原理：如果判断条件成立，则执行 {} 中的

语句

2. 基本 if 结构 2

(1) 语法：

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

      // 语句 1

  }else{

      // 语句 2

  }

(2) 执行原理：如果 if 条件成立，则执行语句 1 ，

否则执行语句 2

3. 多重的 if 结构

(1) 语法：

  if( 判断条件 1){

      // 语句 1

  }else if( 判断条件 2){

      // 语句 2

  }else if( 判断条件 3){

      // 语句 3

  }else{

      // 语句 n

  }

(2) 执行原理：从上往下依次判断，哪一个条件成

立，则执行对应 {} 中的语句

4. if 嵌套结构

(1) 语法：

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

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

          //

      }else if( 判断条件 ){

           

      }else{}

  }else {

       

  }

二、等值分支结构 (switch...case 结构 )

1. 语法：

switch( 表达式 ){

  case 值 1: 语句 1;break;

  case 值 2: 语句 2;break;

  case 值 3: 语句 3;break;

  ...

  default: 语句 n;break;

}

2. 执行原理：

首先获取 switch() 中表达式的结果，根据结果从上往下进行匹配case 后面的值，结果和哪一个

case 的值相等，则执行对应的后面的语句；如果都不相等，则执行default 后面的语句

3. 细节：

(1) 表达式的结果类型： byte 、 short 、 int 、char、 String

(2) break ：终止 switch 结构，防止 case 穿透

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

三、局部变量

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

2. 特点：

(1) 必须先赋值，再使用

报错：可能尚未初始化变量

(2) 作用范围：从定义位置开始，到定义它的代码

块结束

  报错信息为：找不到符号

(3) 在重合的作用范围内，不允许命名冲突

  报错信息为：已在方法 xxx 中定义了变量 xx

第四章：循环结构

一、理解：

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

段代码

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

循环变量的改变、循环体

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

二、 while 循环

1. 语法：

// 循环变量的初始化

while( 循环条件 ){

  // 循环体

  // 循环变量改变

}

2. 执行原理：

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

果循环条件满足 —— 结果为 true ，则执行循环体，然

后执行循环变量的改变，接着再次判断循环条件，

如果满足 ——true ，则再次执行循环体，同时循环变

量进行改变 ... 直到循环条件不满足 - 结果为

false ，则终止、跳出循环结构。

3. 循环特点：

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

(2) 如果程序写的不合适，可能会出现死循环

三、 do..while 循环

1. 语法：

// 循环变量的初始化

do{

  // 循环体

  // 循环变量的改变

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

2. 执行原理：

先执行循环变量的初始化，然后执行循环体，接着

对循环变量进行改变，判断循环条件，满足 - 结果为

true ，则再次的执行循环体，对循环变量进行概

念，判断循环条件 .... 直到循环条件结果为

false ，结束、跳出循环结构。

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

四、 for 循环

1. 语法：

for( 循环变量的初始化 ; 循环条件 ; 循环变量的改

变 ){

  // 循环体

}

2. 执行原理：

3. 执行特点：

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

(2) for() 中的循环变量初始化可以定义在外面，

但是变量的作用范围扩大了

(3) for 中的判断条件如果为空语句，则默认结果

为 true

循环总结：

while 和 for ：循环特点相同 先判断，再执行

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

实际开发： for 循环比较常用

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

循环

for 循环：循环次数明确时，建议使用 for

五、循环控制语句 【开发 + 面试 + 考试重点】

1. break ：终止、结束当前循环结构；可以应用在swtich..case结构中，防止 case 穿透

2. continue ：中止、结束本次循环，从而进入下一次循环

六、循环的嵌套

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

2. 循环的次数：外层循环次数 * 内层循环次数

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

4. 利用循环结构打印图形：外层循环控制行数、内

层循环控制列数

第五章：函数

一、函数

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

名字进行反复的调用

2. 函数的使用流程：

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

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

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

   

(2) 函数的调用：通过名字进行反复的使用

3. 函数的定义位置：定义类以内，其他函数以外的

位置 ( 与 main 函数并列 )

二、函数的基本使用

1. 函数的定义：

public static void 函数名 (){

  // 函数的实现

}

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

(1) 函数的声明：

  public static void 函数名 ()

  注意：函数名 ，望文生义，采用驼峰命名法

形式命名

(2) 函数的实现： {}

2. 函数的调用：

(1) 通过函数名直接使用函数对应的功能

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

三、参数的使用

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

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

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

称为参数

2. 形式参数：

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

种约定，约定了调用者需要给函数传递什么数据

(2) 定义：

  public static void 函数名 ( 数据类型

变量名 , 数据类型 变量名 , 数据类型 变量名 3){

       

  }

(3) 使用：形参相当于 函数内部的局部变量

(4) 一个函数可以定义多个形参，称为形参列表

(0~n 个 )

3. 实际参数：

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

据

(2) 实参的作用：给形参赋值

(3) 注意：实参的个数、顺序、数据类型必须和形

参一致

定义一个函数 selectMax ，接收两个整数 m,n ，打印两个数据中的较大值；在main 函数中调用此函数

四、函数的返回值

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

者通过函数获取一些数据结果 ( 函数给调用者一

定的结果 )

2. 返回值的语法：

public static 函数返回值 函数名 ( 形参列表 )

{

  // 函数的实现、函数体

}

3. 函数的返回值分类：

(1) 返回值类型为： void ，代表函数没有返回

值，函数不需要给调用者任何结果返回

  public static void 函数名 ( 参数 ){}

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

代表函数有返回值，函数必须给调用者返回值对应

类型的数据

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

{

      return xxx;

  }

4. 函数返回值的处理：

(1) 第一种处理方式：定义同类型的变量接收返回

值

(2) 第二种处理方式：

5. return 的作用：

(1) 将函数返回值进行返回值给调用者

(2) 结束当前的函数

五、函数的执行机制

1. 理解：

程序以 Main 函数作为入口，进入 main 函数从上往下依次执行，如果遇到函数的调用，则优先执行被调用的函数内部代码，被调用函数执完毕之后，带着带着返回值返回到调用为止，继续后续代码内容

2. 函数的嵌套调用：被调用的函数内部，又调用了

其他的函数

六、递归调用

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

2. 注意：如果使用递归解决问题，必须给递归设置

一个出口，否则出现无穷递归，最终运行报错，

错误信息为：

java.lang.StackOverflowError( 栈溢出 )

3. 递归的思想：

(1) 递进：每一次推进，计算都比上一次变得简单，直至简单到无需继续推进，就能获得结果。也

叫到达出口。

(2) 回归：基于出口的结果，逐层向上回归，依次计算每一层的结果，直至回归到最顶层。

4. 案例：

package demo;

public class Test6{

public static void main(String[]

args){

int r =jieCheng(8);

System.out.println(r);

}

// 函数功能：计算 n 的阶乘

public static int jieCheng(int n)

{

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

// 设置一个出口，当 n=1 或是 0 ，

结果直接为 1

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

return n * jieCheng(n-1);

}

}

第六章：数组

一、理解

1. 数组：一次性的定义多个同类型的变量，可以存

储多个数据，而且可以对多个变量进行统一管理

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

3. 数组的使用：

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

  数据类型 [] 数组名 ; // 建议

  数据类型 数组名 [];

  数据类型 [] 数组名 ;

   

  int[] a;

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

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

   

  a = new int[4];

4. 细节：

(1) 数组下标：从 0 开始，依次为 0 、 1 、 2 、

3... 数组的长度 -1

(2) 访问数组时，采用数组名 + 下标，数组名 [ 下

标 ]

(3) 操作数组时，给定的下标不在合理范围内，编

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

java.lang.ArrayIndexOutOfBoundsExcept

ion:( 数组的下标越界 )

(4) // 对数组元素进行一一 ，称为数组的遍历

for(int i=0;i<5;i++){

System.out.println("i="+i+" 对应的元

素

  为： "+ages[i]);

}

(5) 获取数组的长度：数组名 .length

5. 数组的默认值：

整数类型： 0

小数类型： 0.0

布尔类型： false

字符类型：空字符

引用类型： null

6. 数组 不同定义方式：

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

  数据类型 [] 数组名 ;

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

   

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

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

   

(3) 显示初始化：

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

   

(4) 显示初始化：

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

二、数组的内存

1. 数组在内存中空间是连续的

2. 数组类型的变量，存储是数组内存在空间的首地

址

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

三、数组的扩容

1. 思想：

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

2 倍

(2) 将原数组的内容进行一一赋值到新的数组中

(3) 新地址覆盖旧地址

2. 扩容的实现：

(1) 第一种方式：

int[] a = {4,7,3}; // 数组的长度为

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

为： "+a.length);

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

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

");

}

System.out.println();

// 将数据 8 存储到 a 数组中，不够用，扩容

// 1. 创建一个更大长度的数组

int[] b = new

int[a.length*2];

// 2. 将原数组的内容一一赋值新数组

中

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

  // 新的数组中 = 原数组中内容

b[i] = a[i];

}

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

a = b;

System.out.println(" 扩容之后的长度为："+a.length);

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

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

");

}

(2) 第二种方式：借助工具类：

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

长度 );

四、二维数组

1. 二维数组：类似于 excel 表格，有行和列构成

2. 行标和列标都是从 0 开始，访问二维数组通过行和列进行访问：数组名[ 行下标 / 高纬 ][ 列下标 / 低

维 ]

3. 二维数组的定义：数据类型 [][] 数组名 = new 数据类型[ 行数 ][ 列数 ];

int[][] a= new int[4][3];// 4 行 3 列二维数组

五、数组的排序

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

储

2. 排序方式：从小到大

(1) 冒泡排序：每次将相邻的两个元素进行一一比

较，较大的值往后放

int[] a = {9,4,5,2,6,3,1,9};

/* 从小到大进行排序

  冒泡排序：每次将相邻的两个元素进

行一一比较，较大的值往后

    下标： 0   1   2 3

元素： 9   4   5 2

--------- 第一轮 ---------

---

a0~a1 4   9   5 2

a1~a2 4   5   9 2

a2~a3 4   5   2 9( 最大

值 )

    ---------- 第二轮 ---------

--

a0~a1 4   5   2 9

a1~a2 4   2   5 9

--------- 第三轮 ---------

--

a0~a1 2 4   5 9

*/

// 第 i=1 轮：使用 a[j] 代表第一个

比较项，相邻 的一项 a[j+1]

/*for(int j=0;j<3;j++){    

// x = 4 - i = a.length - i

// 使用 a[j] 和 a[j+1] 进

行比较

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

// 交换：借助第三遍历

int temp = a[j];

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

a[j+1] = temp;

}

}

// 第 i=2 抡：

for(int j=0;j<2;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;

}

}

// 第 i=3 抡

for(int j=0;j<1;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;

}

}*/

// 外层循环控制比较的轮数

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;

}

}

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

System.out.print(a[i]+"\t");

}

(2) 第二种：借助工具类

java.util.Arrays.sort( 数组名 );

第七章：面向对象

一、编程思想

1. 面向过程：

(1) 面向过程：将问题分为第一步、第二步、第三步... 直到问题解决

(2) 问题：解决小业务相对比较简单，但是面对复杂业务时，相对不好处理

2. 面向对象：

(1) 面向对象：将一些业务过程看成一个整体，利用对象之间关系，解决问题

(2) 好处：解决业务复杂问题时，相对简单

二、对象

1. 对象：计算机中的对象：复杂的客观事物在 Java程序中的一种表现形式

一切皆对象

2. 对象的组成部分：

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

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

3. 类：

(1) 计算机中，使用类进行区分不同类别对象，用于描述该类对象有哪些属性和哪些方法

(2) 类和对象的关系：

  类是对象的模板

  对象是类的实例

  注意：一个类可以创建多个对象

三、类的组成

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

2. 类的组成：

class 类名 {

  // 1. 属性

  // 2. 方法

}

3. 属性：

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

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

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

        数据类型 变量名 = 值 ;

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

  整数类型： 0

  小数类型： 0.0

  布尔类型： false

  字符类型：空字符

  对象类型： null

   

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

(6) 一个类中不允许成员变量命名相同，但是成员变量可以和局部变量命名冲突；局部变量在方法中被优先使用

4. 方法：

(1) 方法：也称为成员方法

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

(3) 语法：

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

      // 方法体

  }

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

  a. 方法的声明：

      修饰符 返回值类型 方法名 ( 形参 ) 异常

     

      注意：一个方法的修饰符可以有 0~n 个

  b. 方法的实现： {}

5. 创建对象：

(1) 类名 对象名 = new 类名 ();

(2) 使用：

  对象名 . 属性名

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

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

1. 理解：一个类中可以定义多个同名的方法，但是参数列表不同

2. 要求：

(1) 方法名相同

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

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

3. 使用：根据调用时，传递的实际参数决定调用哪

一个方法

五、构造方法

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

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

3. 特点 ( 要求 )

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

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

(3) 语法：

  修饰符 类名 ( 形参 ){}

(4) 构造方法允许重载

  ( 一个类中可以定义多个构造方法，但是无参数的构造方法只能一个，可以同时定义多个有参数

的构造方法 )

(5) 构造方法不能手动调用，在创建对象时，被调用

4. 使用：

(1) 在创建对象时，根据传递的实际参数，决定具体调用哪一个构造方法完成对象的创建

(2) 如果一个类中没有提供任何的构造方法时，jvm默认提供一个公开的无参数的构造方法；当类

中提供了有参数的构造方法，则默认的构造方法不再提供( 可以自定义写出 )

5. 构造方法的作用：

(1) 用于创建对象

(2) 借助构造方法给属性赋值

6. 开发应用技巧：

实际开发一个类中通常提供两个构造方法：

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

(2) 一个有参数的构造方法 ( 参数取决于属性的个

数、类型、顺序 )

六、 this 的应用

1. this.

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

是方法

(2) this. 属性名

  this. 方法名 ( 实参 );

(3) this. 通常可以省略，但是当成员变量和局部变量命名冲突时，可以使用 this. 区分成员变

量  

2. this()

(1) this() 只能应用在构造方法中，调用本类其他构造方法

(2) this() 只能应用在构造方法中的第一行有效语句

七、引用

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

java 是一种强类型的语言，对应类型的数据需要

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

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

  // 引用         对象

  // 引用类型     对象的类型

注意：引用的类型必须和对象的类型一致

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

3. 每个对象在堆空间是相互独立，操作一个对象不会影响其他对象

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

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

象在堆空间中首地址

6. 可以利用 null 作为引用的初始化数据，代表空地址，但是如果使用存储null 引用调用属性或是方

法，编译通过，但是运行报错，错误信息为：

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

7. 引用的应用场景：

(1) 引用应用在形式参数上：该类型的对象和引用都可以作为实际参数进行传递

(2) 引用应用在返回值类型上：该类型的对象或是引用都可以作为返回值进行返回

第八章：面向对象的三大特性 ( 封装、继 承、多态 )

一、封装

1. 目前的程序无法保证数据的安全性、容易造成业

务数据的错误

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

本类中访问

3. 为私有化的属性提供公开的 get 和 set 方法：

（ 1 ） get 方法，获取私有化属性的值：

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

        return 属性名 ;

    }

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

        方法名： get+ 属性名首字母大写

(2) set 方法，为私有化属性赋值：

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

名 ){

      this. 属性名 = 变量名

  }

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

        方法名： set+ 属性名首字母大写

二、继承

碳素笔 是一种   笔

水杯   是一种 容器

狗     是一种 动物

A     is a   B

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

系

A- 子类   继承   B- 父类

      extends

1. 理解：

(1) 继承体现的是类之间的一种 “is-a” 关系。

      A   is a   B

      子类         父类

      子类   继承   父类

          extends

(2) 语法：

  class 子类类名 extends 父类类名 {}

(3) 通过继承关系，子类型可以直接使用父类中定

义的属性和方法

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

3. 方法的覆盖【也被称为方法的重写 - override 】

(1) 方法的覆盖：子类中定义和父类中相同的方法

(2) 方法的覆盖要求：

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

父类一致

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

宽

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

覆盖后的

(4) 注意：如果子类定义了和父类方法名、形参列

表相同，但是返回值类型不同的方法，则编译报错

(5) 如果子类定义了和父类方法名相同、形参列表

不同的方法，则编译通过，运行也 ok ，这构成了方

法的重载

4. Java 中继承特点：

(1) 一个父类可以有多个直接的子类

    class Animal{}

    class Dog extends Animal{}

    class Cat extends Animal{}

(2) 一个子类只能有一个直接的父类，但是可以有多个间接的父类( 多级继承 ) ， java 中的类之间是单

继承

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) 访问修饰符修饰内容的继承性：

  private 修饰的属性和方法，不能被继承

  default 修饰的属性和方法，同包子类允许

继承

  protected 修饰的属性和方法，同包 + 非同

包子类继承

  public 修饰的属性和方法，所有子类都可以

继承

6. super 的应用：

(1) 第一种用法： super.

  a. super. 引用在子类的方法中，代表访问

父类中属性或是成员方法

   

  b. super. 属性名

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

     

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

  a. 创建子类对象时， jvm 默认创建一个父类对象，而且默认使用父类中无参数的构造方法完成

父类对象的创建

  b. super()/super( 实参 ): 应用在子类的构造方法的第一行有效语句中，代表创建子类对象

时，告知 jvm 完成父类对象创建时采用哪一个构造方法完成对象的创建

  c. 如果子类的构造方法第一行没有指定

super()/super( 实参 ) ，则默认添加 super()

三、多态

1. 理解：

(1) 多态：父类型的引用存储不同子类型的对象

        父类类名 引用名 = new 子类类名

();

            引用           对象

          父类型         子类型

(2) 使用父类型的引用调用属性或是方法，只能调

用父类中定义的属性和方法

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

覆盖后的方法

2. 引用之间的转换：

(1) 父类型的引用赋值给子类型的引用，需要强制

类型转换

      大类型     小类型

  a. 子类类名 引用名 = ( 子类类名 ) 父类型

的引用名 ;

  b. 强制类型转换的结果：

      i. 实际存储的对象类型和要转换类型一

致，编译 + 运行通过

      ii. 实际存储的对象类型和要转换的类型

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

java.lang.ClassCastException( 类型转换异

常 )

     

(2) 子类型的引用 赋值给父类型的引用，无需强

转，直接赋值，体现多态

(3) 没有继承关系双方，不允许相互赋值，强制类

型转换也不允许

3. instanceof 避免类型转换异常：

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

(2) 执行：判断引用中存储的实际对象类型是否兼容于后面的类型( 是否为后面类型的一种 ) ，兼容 -

true ，不兼容 -false

(3) 作用：可以在程序设计中避免类型转换异常

直接使用案例中的 Animal 、 Dog 、 Cat 类即可，

在 main 函数中完成以下功能：

public static void main(String[]

arsg){

  Animal a = null;

  /*

  利用 Scanner 输入一个整数 n ， n 是偶数

则存储 Dog,

  否则存储 Cat

  */

   

  /*

  判断：如果 a 中存储的是 Cat ，打印输

出 " 我是猫 " ，

      否则打印输出 " 我不是猫 "

4. 多态的应用：

(1) 多态应用在形式参数上：本类型 + 所有的子类型对象、引用都可以作为实际参数进行传递

(2) 多态应用在返回值上：本类型 + 所有子类型的对象、引用都可以作为返回值进行返回

第九章：三个修饰符

一、 abstract[ 抽象的 ]

1. abstract 可以修饰类：

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

(2) 语法：

  abstract class 类名 {}

(3) 特点：抽象类只能声明引用，不能创建对象

(4) 抽象类中可以定义属性和成员方法、构造方法

2. asbtract 可以修饰方法：

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

(2) 语法：

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

( 形参 );

  注意：访问修饰符和 abstract 没有先后顺序

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

现

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

3. 抽象可以定义子类

(1) 语法： class 类名 extends 抽象类类名 {}

(2) 特点：子类不想成为抽象类，则必须覆盖父类

中所有的抽象方法

二、 static[ 静态的 ]

1. 可以修饰属性：

(1) 被 static 修饰的属性称为静态属性、静态变

量、类变量

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

        static 数据类型 变量名 = 值 ;

(3) 特点：静态变量基于类存在，被所有对象共

享，和创建对象的多少无关

(4) 使用：

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

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

议

2. 可以修饰方法：

(1) 被 static 修饰的方法称为静态方法

(2) 语法：

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

参 ){}

(3) 使用：直接通过 类名 . 静态方法名 ( 实参 );

(4) 注意：静态方法中只能访问本类的静态成员，

不能直接访问本类的非静态成员

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

3. 可以代码块

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

(2) 位置：定义在类以内，方法以外，被 static

修饰的 {}

(3) 语法：

      class 类名 {

          static{}

      }

(4) 作用：在类加载的时候，静态代码块按照和属

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

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

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

进行读取 , 读取该类的包名、类名、父类、属性、构

造方法等信息，并将读取的信息保存到 jvm 内存

中，一个类进行一次类加载。

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

类 ) ：

  a. 第一次访问该类的静态成员

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

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

  c. 子类类加载，先导致其父类类加载  

三、 final[ 最终的、最后的 ]

1. final 可以修饰变量：

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

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

(3) 特点：只允许一次赋值，不允许修改

(4) 注意：引用一旦被 final 修饰，代表引用中存

储的对象不能更换

2. final 可以修饰方法：允许子类继承，但是不允许

覆盖

3. final 可以修饰类：被 final 修饰的类不允许被继

承，没有子类，例如： System 、 Math

第十章：接口

一、接口

1. 接口：是一种标准，接口的实现者和使用者都必须遵循的约定。

2. 接口的语法： 

(1) 接口的关键字： interface

(2) 语法：

    interface 接口名 {}

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

(4) 接口中不能定义构造方法

(5) 接口中所有属性为公开、静态、常量 ( 默认被

public static final 修饰 )

(6) 接口中所有方法位公开抽象方法 ( 默认被

public asbtract 修饰 )

二、接口的实现类

1. 语法：

class 类名 implements 接口名 {}

2. 注意：

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

所有的方法

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

public

3. 使用：

接口名 引用名 = new 实现类类名 ();

// 父类型       子类型

// 接口         实现类   - 》 体现多态

三、接口的继承性

1. 接口与接口之间是多继承

interface 接口名 1 extends 接口名 2, 接口名3{}

注意： Java 中的接口与接口是是多继承，一个接口同时可以继承多个父接口；

注意 2 ：如果实现类不想成为抽象类，需要覆盖所有接口中抽象方法( 包括接口的父接口 )

2. 接口和类之间为多实现

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

(2) 语法：

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

abstract class 类名 implements 接口名

1, 接口名 {}

(3) 注意：如果实现类不想成为抽象类，需要覆盖

所有接口中抽象方法

3. 一个类可以继承一个父类型的同时实现多个接口

(1) 语法：

  class 类名 extends 父类名

implements 接口 1, 接口名 2{}

(2) 注意：必须是继承在前，实现在后

四、接口的影响

1. 由于接口与之间的的多继承性和接口与类之间的

多实现性，让多态的应用更加多样性

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

该接口中定义的相关内容

五、 JDK 高版本接口语法补充

1. jdk8.0+

(1) 提供了默认方法：

  a. default 返回值类型 方法名 ( 形参 ){}

  b. 默认方法可以有方法的实现部分

  c. 默认方法的访问权限默认为 public

  d. 默认方法是允许被覆盖，覆盖时候，

      访问权限必须是 public

(2) 提供的静态方法：

  a. static 返回值类型 方法名 ( 形参 ){}

  b. 静态方法可以有方法的声明部分

  c. 静态方法的访问权限默认为 public

  d. 使用：接口名 . 静态方法名 ( 实参 );

2. jdk9.0+

(1) 提供了私有方法：

(2) 语法：

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

(3) 接口中的私有方法也是可以带有方法的实现部

分

六、接口的分类

1. 常量接口：接口中只有静态常量，没有定义任何方法，应用不广泛

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

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

4. 函数式接口：接口中只有一个抽象方法，对静态方法和默认 方法没有要求。[ 开发重点 ]

第十一章：内部类

一、理解

1. 定义在一个类内部的类称为内部类

2. 语法：

class 类名 {

  class 类名 {}

}

3. 内部类编译之后生成独立的 .class 文件，文件命名为：外部类类名$ 内部类的类名 .class

4. 内部类分类：成员内部类、静态内部类、局部内部类、匿名内部类

5. 匿名内

(1) 匿名内部类类继承一个类或是实现一个接口

(2) 匿名内部类只能创建该类的一个对象，而且类

的定义和对象的创建一起完成

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 sum = 0;

for(int i=1;i<=a;i++)

{

sum += i;

}

return sum;

}

};

ia.m1();

int r=ia.m2(45);

System.out.println("r="+r);

}

}

interface IA{

void m1();

int m2(int a);

}

二、 Lambda 表达式

1. Lambda 表达式：应用在函数式接口上，用于简

化程序代码

2. Lambda 表达式只能应用在函数式接口上 ( 接口中

有且只有一个抽象方法 )

3. 语法：

接口名 引用名 = ( 数据类型 参数名 ) ->{

    // 方法的实现

};

4. 应用的细节：

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

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

(3) 当 {} 中有且只有一行 return 语句时， {} 和

return 可以一起省略