一、
if
分支结构
1. if
的基本结构
(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
结构
(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.
语法：
switch(
表达式
){
case
值
1:
语句
1;break;
case
值
2:
语句
2;break;
case
值
3:
语句
3;break;
...
default:
语句
n;break;
}
执行原理：会根据
switch
中的表达式结果，从上往
下进行依次匹配
case
后面的值，哪一个匹配成功，
则执行
case
后面对应的语句，如果都匹配不成功，
则执行
default
后面的语句。
2.
细节
(1) switch
后面表达式的结果类型必须是
byte
、
short
、
int
、
char
、
String
(2) break
：终止、结束
switch..case
结构，防
止
case
穿透
(3) default
没有位置先后要求
三、局部变量
1.
概念：定义在函数
/
方法的内部的变量
2.
特点：
(1)
先赋值，再使用
(2)
从定义位置开始，到定义它的代码块结束
(3)
在重合的作用范围内，不允许命名冲突
第四章：循环结构
一、循环的理解
1.
理解：通过某个条件，重复并且有规律的执行一
段代码
2.
循环的组成部分：循环变量的初始化、循环条
件、循环变量的改变、循环体
3.
循环分类：
while
循环、
do...while
循环、
for
循
环
二、
while
循环
1.
语法：
//
循环变量的初始化
while(
循环条件
){
//
循环体
(
重复执行的功能代码
)
//
循环变量的改变
}
2.
执行原理：
3.
特点：
三、
do..while
循环
1.
语法：
先执行循环的初始化，接着判断循环条件，如果条
件满足
-
结果为
true
，执行
{}
中循环体，从而执行
循环变量改变，再次判断循环条件，如果满足
-
结果
为
true
，执行
{}
中循环体，从而执行循环变量的改
变，再次判断循环条件
...
执行循环条件不满足，
结果为
false
，终止、结束整个循环结构，继续执
行后续代码
....
2.
执行原理：
3.
特点：
三、
do..while
循环
1.
语法：
先执行循环的初始化，接着判断循环条件，如果条
件满足
-
结果为
true
，执行
{}
中循环体，从而执行
循环变量改变，再次判断循环条件，如果满足
-
结果
为
true
，执行
{}
中循环体，从而执行循环变量的改
变，再次判断循环条件
...
执行循环条件不满足，
结果为
false
，终止、结束整个循环结构，继续执
行后续代码
....
2.
执行原理：
3.
特点：
三、
do..while
循环
1.
语法：
先执行循环的初始化，接着判断循环条件，如果条
件满足
-
结果为
true
，执行
{}
中循环体，从而执行
循环变量改变，再次判断循环条件，如果满足
-
结果
为
true
，执行
{}
中循环体，从而执行循环变量的改
变，再次判断循环条件
...
执行循环条件不满足，
结果为
false
，终止、结束整个循环结构，继续执
行后续代码
....
四、
for
循环【开发应用重点】
1.
语法：
四、
for
循环【开发应用重点】
1.
语法：
(1)
先判断，再执行，执行的次数为
0~n
次
(2)
循环变量的初始化代码可以定义在
for
上面，
此时循环变量的作用范围扩大了，不建议
(3)
循环条件没有，则默认为
true
循环的总结：
while
循环和
for
循环特定：先判断，再执行
do..while
循环：先执行，再判断
后期开发：
while
循环：当循环次数不确定时，建议使用
while
循环
for
循环：当循环的次数明确时，建议使用
for
循环
五、循环的控制语句
1. break
：终止、结束当前循环；可以应用在
switch..case
中，用于防止
case
穿透
2. continue
：中止、结束本次循环，从而进入下一
次循环
六、循环的嵌套
1.
理解：在循环结构中，定义完整的循环结构
2.
循环嵌套时，循环次数：外层循环次数
*
内层循
环次数
3.
循环控制语句应用循环嵌套中：
2. continue
：中止、结束本次循环，从而进入下一
次循环
六、循环的嵌套
1.
理解：在循环结构中，定义完整的循环结构
2.
循环嵌套时，循环次数：外层循环次数
*
内层循
环次数
3.
循环控制语句应用循环嵌套中：
第五章：函数
一、理解
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.
形式参数：
3.
实际参数：
(1)
形式参数：简称形参，函数和调用者之间需要
交互数据约定，约定调用者需要传递哪种类型、几
个参数
(2)
语法：
(
数据类型 参数名
,
数据类型 参数名
2)
(3)
使用：将形参作为函数的局部变量进行使用即
可
(1)
实际参数：简称实参，函数调用时，用户传递
给函数的具体数据
(2)
语法：函数名
(
实参
);
(3)
作用：实际参数用于给形参赋值
(4)
注意：实际参数的个数、顺序、数据类型必须
和形参一致
四、函数的返回值
1.
理解：函数和调用者之间的一种数据交互，调用
者通过函数调用，函数需要给调用者返回的数据
2.
语法
public static
返回值类型 函数名
(
参数
){
//
函数体
(
函数功能
)
}
3.
函数返回值类型：
4.
函数返回值的处理：
5. return
的作用
五、函数执行的机制
(1)
返回值类型为
void
，代表无返回值，函数无
需给调用者返回任何数据结果
(2)
返回值类型为：
8
种基本数据、对象类型，代
表函数必须给调用者返回对应的数据；函数体中必
须 有
return xxx;
(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.
数组类型变量存储的是数组在内存中首地址
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);
第二种方式：
java.util.Arrays.copyOf(
原数组名
,
新数组
的长度
);
a=java.util.Arrays.copyOf(a,a.length*
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.
排序：将数组中的元素按照一定规则进行存储
2.
排序方式：
[
从小到大
]
(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)
解决复杂业务相对容易
(1)
对象的属性：代表对象有什么特征，对应静态
数据部分
(2)
对象的方法：代表对象能做什么，对应动态的
行为和功能
(1)
类：计算机中用于区分不同类别对象，用于描
述该类对象具有哪些属性和哪些方法
(2)
类和对象的关系：
类是对象的模板
对象是类的实例
注意：一个类可以创建多个对象
三、类的组成
1.
类名：望文生义，每个单词首字母大写
2.
类的定义：
class
类名
{
// 1.
属性
// 2.
方法
}
3.
属性：
(1)
属性：也被称为成员变量
(2)
语法：数据类型 变量名
;
数据类型 变量名
=
值
;
(3)
位置：定义在类以内，方法以外
(4)
成员变量具有默认值：
整数类型：
0
小数类型：
0.0
字符类型：空字符
布尔类型：
false
对象类型：
null
(5)
成员变量的作用范围：至少在本类中有效
(6)
命名冲突：在本类中不允许有同名成员变量，
但是成员变量可以和局部变量命名冲突，局部变量
优先使用
4.
方法：
(1)
方法：成员方法
(2)
位置：定义类以内，其他方法以外
(3)
语法：
public static
返回值类型 函数名
(
形参
)
{
//
函数体
}
方法定义如下：
public
返回值类型 方法名
(
形参
){
//
方法体
}
(4)
方法的定义：分为方法的声明和方法的实现
声明：修饰符 返回值类型 方法名
(
参数
)
异
常
注意：修饰符可以有
0~n
实现：
{}
四、创建对象
1.
语法：类名 对象名
= new
类名
();
2.
对象的使用：
五、方法的重载
(overload)
【开发
+
面试
+
考试重
点】
1.
理解：一个类中定义了多个同名，但是形参不同
的方法
2.
要求：
注意：修饰符可以有
0~n
实现：
{}
对象名
.
属性名
对象名
.
方法名
(
实参
);
(1)
方法名相同
(2)
形参列表不同
(
参数的个数、顺序、数据类型
)
(3)
返回值类型、修饰符、异常没有要求
3.
使用：
六、构造方法
1.
构造方法：是一种特殊的方法，也称为构造器
2.
定义位置：定义在类以内，方法以外
3.
构造方法的要求：
4.
使用：
通过调用传递的实际参数，决定调用重载中的哪一
个方法
(1)
构造方法的方法名必须和类名一致
(2)
构造方法没有返回值类型
(
连
void
都没有
)
(3)
语法：
public
类名
(
形参
){}
(4)
构造方法允许重载（一个类中可以定义多个构
造方法：无参数的构造方法只能定义一个，可以定
义多个有参数的构造方法）
(5)
构造方法不允许手动调用
(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) set
方法：为属性赋值
public void set
属性名
(
数据类型 变量
名
){
this.
属性名
=
变量名
;
}
注意：
()
中的数据类型取决于赋值对应的属性
类型
(2) get
方法：获取属性值
public
返回值类型
get
属性名
(){
return
属性名
;
}
注意：返回值类型取决于 获取的属性类型
二、继承
碳素笔
是一种
笔
水杯
是一种
容器
狗
是一种
动物
A is-a
扫一扫
715
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
