六、
Scanner(
扫描仪
)
1.
作用：可以让用户输入信息，提高人机交互
++(
自增
) --(
自减
)
实际开发应用：
a++
和
++a
：将
a
自身变量值进行加
1
a--
和
--a
：将
a
自身变量值进行减
1
面试
/
考试常见内容：
int c = a++;
先使用，再加
1
int c = ++a;
先计算加
1
，再使用
(1)
语法：
布尔表达式
?
表达式
1:
表达式
2
(2)
原理：先判断表达式是否成立，结果为
true
，执行表达式
1
，否则执行表达式
2
2.
导包：
(1)
语法：
import
包名
1.
包名
2.
类名
;//
导入
指定类
import
包名
1.
包名
2.*;//
导入包中
所有 类
(2)
位置：定义在
package
语句的后面，所有类上
面
(3)
例如：
import java.util.Scanner;
3.
步骤：
第三章：分支结构
一、
if
分支结构
1.
基本
if
结构：
(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);//
输
入一个字符
(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
嵌套结构
二、等值分支结构
(switch...case
结构
)
1.
语法：
(1)
语法：
if(
判断条件
/
布尔表达式
){
if(
判断条件
/
布尔表达式
){
//
}else if(
判断条件
){
}else{}
}else {
}
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.
循环：通过某个条件，重复并且有规律的执行一
段代码
(1)
必须先赋值，再使用
报错：可能尚未初始化变量
(2)
作用范围：从定义位置开始，到定义它的代码
块结束
报错信息为：找不到符号
(3)
在重合的作用范围内，不允许命名冲突
报错信息为：已在方法
xxx
中定义了变量
xx
2.
循环组成部分：循环变量的初始化、循环条件、
循环变量的改变、循环体
3.
循环分类：
while
循环、
do..while
循环、
for
循环
二、
while
循环
1.
语法：
2.
执行原理：
//
循环变量的初始化
while(
循环条件
){
//
循环体
//
循环变量改变
}
3.
循环特点：
三、
do..while
循环
1.
语法：
先执行循环变量的初始化，接着判断循环条件，如
果循环条件满足
——
结果为
true
，则执行循环体，然
后执行循环变量的改变，接着再次判断循环条件，
如果满足
——true
，则再次执行循环体，同时循环变
量进行改变
...
直到循环条件不满足
-
结果为
false
，则终止、跳出循环结构。
(1)
先判断，再执行，执行次数：
0~n
次
(2)
如果程序写的不合适，可能会出现死循环
//
循环变量的初始化
do{
//
循环体
//
循环变量的改变
}while(
循环条件
); //
分号不能省
2.
执行原理：
3.
特点：先执行，再判断，执行次数为
1~n
次。
四、
for
循环
1.
语法：
2.
执行原理：
先执行循环变量的初始化，然后执行循环体，接着
对循环变量进行改变，判断循环条件，满足
-
结果为
true
，则再次的执行循环体，对循环变量进行概
念，判断循环条件
....
直到循环条件结果为
false
，结束、跳出循环结构。
for(
循环变量的初始化
;
循环条件
;
循环变量的改
变
){
//
循环体
}
3.
执行特点：
(1)
先判断，再执行，执行次数
0~n
次
(2) for()
中的循环变量初始化可以定义在外面，
但是变量的作用范围扩大了
(3) for
中的判断条件如果为空语句，则默认结果
为
true
五、循环控制语句 【开发
+
面试
+
考试重点】
1. break
：终止、结束当前循环结构；可以应用在
swtich..case
结构中，防止
case
穿透
2. continue
：中止、结束本次循环，从而进入下一
次循环
六、循环的嵌套
1.
理解：在循环结构中，定义一个完整的循环结构
循环总结：
while
和
for
：循环特点相同 先判断，再执行
do...while
：先执行，再判断
实际开发：
for
循环比较常用
while
循环：循环次数不明确时，建议使用
while
循环
for
循环：循环次数明确时，建议使用
for
2.
循环的次数：外层循环次数
*
内层循环次数
3.
循环控制语句应用的嵌套中：
4.
利用循环结构打印图形：外层循环控制行数、内
层循环控制列数
第五章：函数
一、函数
1.
理解：执行一段特定功能的代码，并且可以通过
名字进行反复的调用
2.
函数的使用流程：
外层循环和内层循环
break
：终止、结束本层循环
continue
：中止、结束本层本次循环
3.
函数的定义位置：定义类以内，其他函数以外的
位置
(
与
main
函数并列
)
二、函数的基本使用
1.
函数的定义：
(1)
函数的定义：确定函数的功能和函数名
a.
函数的声明：确定函数的名字
b.
函数的实现：确定函数的功能
(2)
函数的调用：通过名字进行反复的使用
2.
函数的调用：
三、参数的使用
public static void
函数名
(){
//
函数的实现
}
函数的定义：函数的声明和函数的实现
(1)
函数的声明：
public static void
函数名
()
注意：函数名 ，望文生义，采用驼峰命名法
形式命名
(2)
函数的实现：
{}
(1)
通过函数名直接使用函数对应的功能
(2)
语法：函数名
();
1.
多数情况下，函数与调用者之间需要数据的交
互；调用者必须提供必要的数据，才能使函数完
成相应的功能，调用者和函数之间交互的数据，
称为参数
2.
形式参数：
(1)
形式参数：简称形参，函数和调用者之间的一
种约定，约定了调用者需要给函数传递什么数据
(2)
定义：
public static void
函数名
(
数据类型
变量名
,
数据类型 变量名
,
数据类型 变量名
3){
}
(3)
使用：形参相当于 函数内部的局部变量
(4)
一个函数可以定义多个形参，称为形参列表
(0~n
个
)
3.
实际参数：
四、函数的返回值
1.
理解：函数和调用者之间的一种数据交互，调用
者通过函数获取一些数据结果
(
函数给调用者一
定的结果
)
2.
返回值的语法：
(1)
实际参数：简称实参，函数调用时，传递的数
据
(2)
实参的作用：给形参赋值
(3)
注意：实参的个数、顺序、数据类型必须和形
参一致
定义一个函数
selectMax
，接收两个整数
m,n
，打
印两个数据中的较大值；在
main
函数中调用此函数
public static
函数返回值 函数名
(
形参列表
)
{
//
函数的实现、函数体
}
3.
函数的返回值分类：
(1)
返回值类型为：
void
，代表函数没有返回
值，函数不需要给调用者任何结果返回
public static void
函数名
(
参数
){}
(2)
返回值类型为：
8
种基本数据类型或是对象，
代表函数有返回值，函数必须给调用者返回值对应
类型的数据
public static
返回值类型 函数名
(
参数
)
{
return xxx;
}
4.
函数返回值的处理：
5. return
的作用：
五、函数的执行机制
1.
理解：
(1)
第一种处理方式：定义同类型的变量接收返回
值
(2)
第二种处理方式：
(1)
将函数返回值进行返回值给调用者
(2)
结束当前的函数
程序以
Main
函数作为入口，进入
main
函数从上往
下依次执行，如果遇到函数的调用，则优先执行被
调用的函数内部代码，被调用函数执完毕之后，带
着带着返回值返回到调用为止，继续后续代码内容
2.
函数的嵌套调用：被调用的函数内部，又调用了
其他的函数
六、递归调用
1.
理解：一个函数中调用自身函数
2.
注意：如果使用递归解决问题，必须给递归设置
一个出口，否则出现无穷递归，最终运行报错，
错误信息为：
java.lang.StackOverflowError(
栈溢出
)
3.
递归的思想：
4.
案例：
(1)
递进：每一次推进，计算都比上一次变得简
单，直至简单到无需继续推进，就能获得结果。也
叫到达出口。
(2)
回归：基于出口的结果，逐层向上回归，依次
计算每一层的结果，直至回归到最顶层。
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.
数组的使用：
4.
细节：
(1)
声明数组：确定数据类型
数据类型
[]
数组名
; //
建议
数据类型 数组名
[];
数据类型
[]
数组名
;
int[] a;
(2)
分配空间：确定数组的长度
数组名
= new
数据类型
[
长度
];
a = new int[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.
思想：
2.
扩容的实现：
注意：数组的声明和初始化一起完成
(1)
创建一个更大空间的新数组，通常为原数组的
2
倍
(2)
将原数组的内容进行一一赋值到新的数组中
(3)
新地址覆盖旧地址
(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;
四、二维数组
1.
二维数组：类似于
excel
表格，有行和列构成
2.
行标和列标都是从
0
开始，访问二维数组通过行
和列进行访问：数组名
[
行下标
/
高纬
][
列下标
/
低
维
]
3.
二维数组的定义：数据类型
[][]
数组名
= new
数
据类型
[
行数
][
列数
];
System.out.println("
扩容之后的
长度为：
"+a.length);
for(int i=0;i<a.length;i++){
System.out.print(a[i]+"
");
}
(2)
第二种方式：借助工具类：
java.util.Arrays.copyOf(
数组名
,
新数组的
长度
);
五、数组的排序
1.
排序：将数组中元素按照一定的排序顺序进行存
储
2.
排序方式：从小到大
int[][] a= new int[4][3];// 4
行
3
列二维
数组
(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;
}
扫一扫
2693
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
