一、break和continue关键字的使用
1.break
应用范围：分支结构【针对switch语句】和循环结构
作用：跳出整个switch语句或者直接跳出整个循环语句，结束循环
//演示break的使用
for(int i = 0;i < 10;i++) {
if(i == 5) {
//直接跳出整个循环，导致循环结束
break;
}
System.out.println(i);
}
//需求：实现嵌套for循环
for(int i = 0;i < 3;i++) {
for(int j = 0; j < 5;j++) {
System.out.println("i = " + i + ",j = " + j);
//默认跳出的是当前的循环：就近原则
break;
}
}
//标签----主要是相当于给每层循环起一个名字，一般用于多层循环嵌套中，一般结合break使用
out:for(int i = 0;i < 3;i++) {
in:for(int j = 0; j < 5;j++) {
System.out.println("i = " + i + ",j = " + j);
//表示指明break需要跳出的是外层循环
break out;
}
}
//i = 0,j = 02.continue
应用范围：循环语句
作用：表示结束当前循环，继续下一次循环，并不会结束整个循环
//演示continue的使用
for(int i = 0;i < 10;i++) {
//当遇到偶数的时候，结束循环，代码不往下继续执行，但是遇到奇数的话，没有任何影响
if(i % 2 == 0) {
//结束当前循环，继续下一次循环
break;
//continue;
}
System.out.println(i);
}
for(int i = 0;i < 3;i++) {
for(int j = 0;j < 5;j++) {
System.out.println("i = " + i + ",j = " + j);
//一般会和if语句结合使用
//continue;
}
continue;
}
//需求：输出100~200之间能被3整除的数
for(int i = 100;i <= 200;i++) {
if(i % 3 == 0) {
continue;
}
System.out.println(i);
}总结： a.明确break和continue的应用范围
b.当出现break和continue语句时，他们的后面将不能再出现其他的语句，否则编译不通过
c.break直接结束整个循环，但是continue结束的是当前循环 d.标签的出现，可以让break作用于执行的范围
二、函数
1.什么是函数
对于功能相同的代码，为了简化代码的书写，可以将功能相同的代码提取出来，为了可以方便多次重复使用，在Java中，使用函数【方法】来体现
函数就是对一段具有特殊功能代码段的抽取，又被称为方法
函数存在的意义：提高程序的复用性和可读性
2.函数的声明【定义】
语法
访问权限修饰符 其他修饰符 返回值数据类型 函数名称（参数类型1 参数名称1，参数类型2 参数名称2....）{
//具有特殊功能的代码段
return 一个常量或者变量【返回值】；
}
举例：
public static void main(String[] args){
}
说明：
a.函数的定义包含两部分：声明部分和实现部分
b.目前接触到的访问权限修饰符只有public【公开的】，定义函数都加上public
c.其他的修饰符只有一个static【静态的】要么不写，要么写上
d.返回值数据类型:函数在运行之后所得到的结果，void【空】表示没有返回值
e.函数名称；符合命名规则就可以【小驼峰】，尽量做到顾名思义【函数名称代表了函数所实现的功能】
f.参数列表：如果在抽取函数的时候，涉及到未知项参与运算，未知项就可以被设置为参数
实际参数：【实参】，实际参与运算的数据
形式参数：【形参】，在方法中定义，用于接收实际参数的变量
g.具有特殊功能的代码段:函数体
h.return：结束整个方法
返回值：功能实现之后的结果，由return返回给调用者
3.提取一个函数的注意事项
a.明确实现的功能的结果是什么？【是否需要有返回值---是否需要设置返回值类型】
b.明确是否有未知项参与运算【是否需要设置参数，需要设置几个参数，并且每个参数的类型是什么】
4.函数的调用
如果要使用一个函数中的功能的时候，就需要手动调用这个函数
格式：函数名称（参数）；
如果没有参数，格式：函数名称();
class TestDemo
{
public static void main(String[] args)
{
//需求：求一个数和80的和
int a = 10;
int sum = a + 80;
int b = 20;
int sun1 = b + 80;
int num = 100;
add(num);
}
public static void add(int num) {
int sum = num + 80;
System.out.println(sum);
}
}
注意：
a.main函数作为一个程序的入口，要想自定义的函数被执行，应该在main函数中直接或者间接的进行调用
b.main函数中只能调用其他的函数，不能定义函数
c.在自定义的函数之间也是可以进行相互的调用的，但是在自定义的函数中不能调用main函数
5.函数的调用的时候各个函数的执行顺序
a.JVM首先去调用main函数，所以main函数作为程序的入口函数第一个被执行
b.main函数中的代码从上往下依次执行
c.如果main函数在执行的过程中，遇到了被调用的函数，main函数中的代码会暂停在这个地方，会进入到自定义的函数中，当自定义中的代码执行完成之后，再次返回到原来暂停的地方，接着向下执行
//演示函数的调用的顺序
class FunctionDemo
{
public static void main(String[] args)
{
//直接
show1();
}
public static void show1() {
System.out.println("show1方法被调用");
//间接
show2();
}
public static void show2() {
System.out.println("show2方法被调用");
//在自定义的函数中调用main函数，会造成死循环
//String[] arr= {"32","43"};
//main(arr);
}
}
class FunctionDemo
{
public static void main(String[] args)
{
System.out.println("start");
//直接调用函数
print();
System.out.println("end");
}
//1.目前定义函数定义在类中，只能与main函数平级
//2.函数中不能定义函数【函数之间不能嵌套】
//需求：打印九九乘法表
/**
*@function:打印九九乘法表
*@return :不需要设置返回值
*@param：不需要设置参数
*/
public static void print() {
for(int i = 1;i <= 9;i++) {
for(int j = 1;j <= i;j++) {
System.out.print(j + "x" + i + "=" + i * j + " ");
}
System.out.println();
}
}
}
6.static修饰一个方法
被static修饰的方法被称为静态方法，反之，被称为非静态方法
main函数本身是一个静态方法
//演示静态和非静态
class FunctionDemo
{
//非静态全局变量
int num;
//静态全局变量
static String str;
public static void main(String[] args)
{
//局部变量,必须要有初始值
int a = 10;
//结论三：在静态的方法中不能访问非静态全局变量,可以访问静态全局变量
/*
//错误演示
System.out.println(num);
num = 10;
System.out.println(num);
*/
System.out.println(str);//null
str = "hello";
System.out.println(str);//hello
//结论一：在静态方法中只能调用静态方法，不能调用非静态方法
show();
//错误: 无法从静态上下文中引用非静态 方法 display()
//display();
}
//静态方法
public static void show() {
System.out.println("show");
}
//非静态方法
public void display() {
System.out.println("display");
}
//非静态方法
public void check() {
//结论二：在非静态的方法中，既可以调用静态方法，也可以调用非静态方法
//调用静态方法
show();
//调用非静态方法
display();
//结论四：在非静态方法中，既可以访问静态全局变量，也可以访问非静态全局变量
System.out.println(num);
num = 10;
System.out.println(num);
System.out.println(str);
str = "hello";
System.out.println(str);
}
}
穿插：局部变量和全局变量
局部变量:在方法内部或者语句内部定义的变量【局部变量对应的方法或者语句执行结束之后，局部变量会自动被释放从而销毁】
注意：在定义局部变量的时候一定要有初始值
全局变量：直接在类中定义，和函数平级，它在整个类中有效
注意：全局变量在定义的时候，可以不用赋初始值，在不初始化的情况下，系统会默认给全局变量分配初始值
分配默认初始值的规则：
整型：0
浮点型：0.0
char：\u0000【有时是一个空格，有时是方框【口】】
boolean：false
引用数据类型：null
静态全局变量:被static修饰的全局变量，本质上还是一个全局变量
非静态全局变量：没有static修饰的全局变量
7.参数
a.分类：实际参数【实参】和形式参数【形参】
b.在调用函数的时候，实际上是实参给形参赋值的过程，这个过程称为传参
形参其实就是一个变量，实参其实就是一个数值，传参就是把一个数值给一个形参赋值
传参的时候注意事项：实参的数量和类型必须和形参保持完全的一致【一一对应】
//演示参数的使用
int num1 = 10;
int num2 = 20;
//在函数的功能实现部分，实际参与运算的是形参，不管形参如何变化，对实参没有任何的影响
exchange(num1,num2);
System.out.println("main交换结束之后，num1 = " + num1 + ",num2 = " + num2);
}
//需求：交换两个变量的值
/**
*@param:参与交换的两个变量
*@return:不需要
*/
//num1 = 10 num2 = 20
public static void exchange(int num1,int num2) {
int temp = num1;
num1 = num2;
num2 = temp;
System.out.println("exchange交换结束之后，num1 = " + num1 + ",num2 = " + num2);注意：在命名的时候，实参和形参变量名称可以一致【局部变量】
8.方法压栈
栈：是内存中一块空间【理解为一个开口向上的容器】
栈的特点：先进后出，后进先出【举例：羽毛球的筒】
方法的调用的顺序，其实就是方法入栈的过程，当执行完毕之后，会依次出栈
对应的方法当出栈之后，对应的空间就会被释放【在方法中定义的局部变量也被释放】
9.方法的返回值—return
a.方法的返回值指的是一个方法执行完成之后的结果
void：表示返回值为空
使用return返回方法的执行结果，用于结束方法
b.return关键字的使用
1>在没有返回值的方法中使用return
作用：结束整个方法，该方法出栈
//演示return的使用
class ReturnUsageDemo
{
public static void main(String[] args)
{
show();
//在调用有返回值的函数时，想要使用返回值，可以用一个变量将结果接出来
int result = add(3,6);
System.out.println(result);
System.out.println(add(10,20));
//错误: 此处不允许使用 '空' 类型
//没有返回值的函数，不能直接打印
//System.out.println(show());
int result1 = compare(100,200);
System.out.println(result1);
}
//1.没有返回值，但是使用return
public static void show() {
for(int i = 0;i < 3;i++) {
for(int j = 0;j < 5;j++) {
System.out.println("i =" + i + ",j = " + j);
//结束方法
//不管return处于多少层循环之中，只要遇到return语句，都会直接结束整个方法
return;
//break;
//continue;
}
}
}
//2.有返回值，必须使用return来进行返回
//需求：求两个数的和
public static int add(int num1, int num2) {
int sum = num1 + num2;
//注意：有返回值的函数中，return后面必须跟一个具体的变量或者常量，而且类型一定要和返回值类型保持一致
return sum;
}
//3.有返回值，而且在方法中有分支结构，那么每一个分支都需要有返回值
//需求：比较两个数的大小，返回较大的一个
public static int compare(int a,int b) {
if(a > b) {
return a;
} else if(a < b) {
return b;
} else {
return a;
}
}
}注意：return后面就不能跟具体的数值，只能return单独使用
2>有返回值，必须使用return来进行返回
注意：有返回值的函数中，return后面必须跟一个具体的变量或者常量，而且类型一定要和返回值类型保持一致
3>有返回值，而且在方法中有分支结构，那么每一个分支都需要有返回值
10.递归
概念：在一个方法体中调用方法本身，称为方法的递归
方法递归中其实包含了一种隐式的循环，他会重复的执行某段代码【函数的函数体】，这种重复无须使用循环语句来进行控制
//演示递归
class DiGuiUsageDemo
{
public static void main(String[] args)
{
System.out.println("Hello World!");
//sum(1);
//sum(10);
int result = sum(100);
System.out.println(result);
}
//需求：使用递归计算1~某个数之间所有数的和
/*
int sum = 0;
for(int i = 1;i <= 100;i++) {
sum += i;//sum = sum + i;
}
sum = 1;
sum = 1 + 2;
sum = 1 + 2 + 3;
....
sum = 1 + 2 + 3 + 4.....+ 100;
计算1~100之间的和-----》用前99个数的和+ 100
前99个数的和 ----》前98个数的和 + 99
前98个数的和 -----》前97个数的和 +98
sum(100) ----》sum(99) + 100
sum(99)----》sum(98) + 99
.....
sum(n) ----》sum(n - 1) + n
*/
public static int sum(int n) {
if(n == 1) {
return 1;
} else {
return sum(n -1) + n;
}
}
}
class DiGuiUsageDemo02
{
public static void main(String[] args)
{
// 1,2,3,4,5,6,7,8,9,10
//斐波那契数列：1,1,2,3,5,8,13,21,34,55....
//需求：随便报个数，然后获取对应的值
/*
分析：
1.第一个位置和第二个位置上的数是固定的，是1
2.第n个位置上的数：第n-1 的数 + n- 2的数
fun(3) = fun(1) + fun(2); 1 + 1 = 2
fun(4) = fun(3) + fun(2);
.....
fun(9) = fun(8) + fun(7);
fun(10) = fun(9) + fun(8);
......
fun(n) = fun(n - 1) + fun(n -2);
*/
int result = fun(6);
System.out.println(result);
}
public static int fun(int n) {
if(n == 1 || n == 2) {
return 1;
}else {
return fun(n - 1) + fun(n -2);
}
}
}