Javase 第三周笔记

Javase 第三周期笔记

图片上传失败故粘贴为纯文本
函数

2021年1月18日
11:22

1.函数的语法格式
函数的书写
修饰符 函数类型 返回值类型 函数名(数据类型 数据1,数据类型 数据2,…)
{
独立功能的代码片段;
return 函数的计算结果;
}

修饰符：指的是函数的访问权限，public private 默认 protected
函数类型：
本地函数native
静态函数static
同步函数 synchronized
返回值类型：
如果函数没有返回值 则为void
函数名：就是函数的名称
参数列表：指的是外界向函数传入的数据（实际参数），由这些参数变量进行接收（形参）
函数体：具有独立功能的代码片段；
return：
仅仅表示函数结束
如果函数有返回值，则return后跟返回值
如果没有返回值，则return可以不写，但是是存在的隐藏的

根据形参和返回值来看，函数有如下几个分类
有参数有返回值

有参数无返回值

无参数有返回值

无参数无返回值

2.函数的运行原理

函数的运行是基于栈运行的
栈：是一种先进后出的容器，这里面所说的栈是指JVM中的栈内存空间
每一个函数，叫做栈帧，栈帧中所包含的内容有函数的定义，参数列表，函数的执行内容代码
一个函数要运行，就相当于这个栈帧进入到栈内存中-入栈
一个函数即将结束，将这个栈帧从栈顶移出-出栈

如果栈内存中有多个栈帧，先运行的是最上面的栈帧，底下的栈帧暂停运行，直到该栈帧到栈顶

3. 函数重载
   同一个类中可以出现多个同名函数，这个现象就叫做函数的重载
   如何来区分同名函数是否是重载关系
   必须是同名，和返回值类型无关（返回值类型只和函数的计算功能相关）
   和权限也没有关系，和形式参数的名称也无关
   只和形式参数有关 包括参数类型不同，数量不同，位置不同

寻找重载函数的流程：

1. 看是否有确切的参数定义匹配
2. 看是否有可兼容的参数定义匹配
3. 如果可兼容的参数定义匹配较多，会报引用确定报错 引用不明确

4.函数递归
函数的递归就是指函数自身调用自身。
但凡迭代能够解决的问题，递归都可以解决；递归能够解决的问题，迭代不一定能
相对而言，从内存的角度而言，函数如果过多的自我调用，势必会对占用更多内存
通常来讲，同样的问题用递归写要比用迭代写代码量较少
写递归时，一定要先确定递归结束条件-递归边界
public class Sample
{
public static void main(String[] args)
{
public static void test(int n)
{
System.out.println(n);
if (n == 1)
{
return;
}
else
{
test(n - 1);
}
}
public static void show()
{
System.out.println(“Hello!”);
show();
}
}
}

Demo68
import java.util.Scanner;
public class demo68
{
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
System.out.print(“Enter a number:”);
int number = scanner.nextInt();
System.out.println(isPalindrome(number));
}
public static boolean isPalindrome(int number)
{
int revNumber = reverse(number);
return number == revNumber;
}
public static int reverse(int number)
{
int result = 0;
while (number != 0)
{
result = result * 10 + number % 10;
number /= 10;
}
return result;
}

Demo67
import java.util.Scanner;
public class demo67
{
public static void main(String[] args)
{
Scanner input = new Scanner();
long shuzi = input.nextInt(System.in);
System.out.println(sumDigits(shuzi));
private int sumDigits(long shuzi)
{
int sum = 0;
int weishu;
while(shuzi != 0)
{
weishu = shuzi % 10;
shuzi = shuzi / 10;
sum += weishu;
}
return sum;
}
}
}

Demo81
public class demo81
{
public static void main(String[] args)
{
String x = “x”;
String y = “y”;
String z = “z”;
hano(3,x,y,z);
}
public static void hano(int level,String begin,String mid,String end)
{
if (level == 1)
{
System.out.println(begin+"->"+end);
}
else
{
hano(level - 1,begin,end,mid);
System.out.println(begin+"->"+end);
hano(level - 1,mid,begin,end);
}
}
}

Demo74
public class demo74
{
public static void main(String[] args)
{
int number = 2;
int count = 0;
while (count < 100)
{
if (isSuShu(number) && isHuiWen(number))
{
System.out.print(number + “\t”);
count++;
if (count % 10 == 0)
{
System.out.println();
}
}
number++;
}
}
public static boolean isHuiWen(int number)
{
int revNumber = reverse(number);
return revNumber == number;
}
public static int reverse(int number)
{
String str = “”;
while (number != 0)
{
str = str + number % 10;
number /= 10;
}
return Integer.parseInt(str);
}
public static boolean isSuShu(int number)
{
for (int i = 2 ; i <= number / 2; i++)
{
if (number % i == 0)
{
return false;
}
}
return true;
}
}

在这里插入图片描述