day05方法的使用
一、方法概述
1.1 没有方法存在的问题
我们看一个需求，比如现在张工、李工两个人都需要求两个整数的和。不使用方法，代码如下。
// 1、李工。
int a = 10;
int b = 20;
int c = a+b;
System.out.println("和是：" + c);
// 2、张工。
int a1 = 10;
int b1 = 20;
int c1 = a1+b1;
System.out.println("和是：" + c1);
阅读上面的代码，我们不难发现。两次求和的代码中，除了求和的数据不一样，代码的组织结构完全一样。
1.2什么是方法
方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复调用。这句话什么意思呢？意思是，把一段功能代码围在一起，别人都可以来调用它。
下图是方法的完整格式
像这种做相同事情的代码，就可以用方法进行封装。需要用到这段代码功能时，让别人调用方法就行。代码如下
/*
目标：掌握定义方法的完整格式，理解方法的好处
需求：假如现在很多程序员都要进行2个整数求和的操作
方法定义格式：
修饰符 返回值类型 方法名( 形参列表 ) {
方法体代码(需要执行的功能代码)
return 返回值;
}
方法调用格式：
方法名(参数);
*/
public class MethodDefine01 {
public static void main(String[] args) {
// 1.李工
int c = sum(10, 20);
System.out.println("和是：" + c);
// 2.张工
int c1 = sum(20, 30);
System.out.println("和是：" + c1);
// 3.王工
int c2 = sum(50, 60);
System.out.println("和是：" + c2);
}
public static int sum(int a,int b) {
int c = a + b;
return c;
}
}
1.2 方法的执行流程
当调用一个方法时，执行流程，按照下图中标注的序号执行。
① 通过sum方法名找到sum方法
② 把10传递给方法中的参数a
③ 把20传递给方法中的参数b；
④ 执行方法中的代码，此时int c=a+b;; 相当于 int c = 10+20; c的值为30
return c 的含义是，把c的结果返回给调用处。 也就是调用sum方法的结果为30,
1.3 使用方法的好处
最好，我们总结一下，用方法有什么好处，可以归纳为下面2点：
- 提高了代码的复用性，提高了开发效率。
- 让程序的逻辑更清晰。
如下图所示：写好一个方法之后，每一个人都可以直接调用，而不用再重复写相同的代码。所以是提高了代码的复用性，不用写重复代码，自然也提高了开发效率。
那么让程序的逻辑更加清晰，是如何体现的呢？ 比如，我们后期会用所学习的技术，做一个ATM系统，ATM系统中有查看账户、存钱、取钱、修改密码等功能，到时候我们可以把每一个功能都写成一个方法。如下图所示，这样程序的逻辑就更加清晰了。
-
总结
1.什么是方法？ 答：方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复调用 2.方法的完整格式是什么样的？ //格式如下： 修饰符 返回值类型 方法名( 形参列表 ){ 方法体代码(需要执行的功能代码) return 返回值; } 3.方法要执行必须怎么办？ 必须调用才执行; //调用格式: 方法名(...); 4.使用方法有什么好处？ 答：提高代码的复用性，提高开发效率，使程序逻辑更清晰二、方法的其他形式
实际开发中，需要按照方法解决的实际业务需求，设计出合理的方法形式来解决问题。
实际上设计一个合理的方法，需要重点关注下面三点
设计一个合理的方法的原则如下：
-
如果方法不需要返回数据，返回值类型必须申明成void（无返回值申明）, 此时方法内部不可以使用return返回数据。
-
方法如果不需要接收外部传递进来的数据，则不需要定义形参，且调用方法时也不可以传数据给方法。
-
没有参数，且没有返回值类型（void）的方法，称为值无参数、无返回值方法。此时调用方法时不能传递数据给方法。
三、方法使用常见的问题（细节）
- 1. 方法在内种没有先后顺序，但是不能把一个方法定义在另一个方法中。
- 2. 方法的返回值类型写void（无返回申明）时，方法内不能使用return返回数据，
如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。
- 3. return语句的下面，不能编写代码，属于无效的代码，执行不到这儿。因为
return的作用是结束方法和返回值
- 4. 方法不调用就不会执行, 调用方法时，传给方法的数据，必须严格匹配方法的参数情况。（数据类型与位置都必须匹配）
- 5. 调用有返回值的方法，有3种方式：
① 可以定义变量接收结果
② 或者直接输出调用，
③ 甚至直接调用；
- 6. 调用无返回值的方法，只有1种方式： 只能直接调用。
- 代码演示
/*
目标：了解使用方法时的几个常见问题
1.方法在类中没有先后顺序，但是不能把一个方法定义在另一个方法中。
2.方法的返回值类型写void（无返回申明）时，方法内不能使用return返回数据，
如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。
3.return语句的下面，不能编写代码，属于无效的代码，执行不到这儿。
4.方法不调用就不会执行, 调用方法时，传给方法的数据，必须严格匹配方法的参数情况。
5.调用有返回值的方法，有3种方式：
① 可以定义变量接收结果
② 或者直接输出调用，
③ 甚至直接调用；
6.调用无返回值的方法，只有1种方式： 只能直接调用。
*/
public class MethodDefine03 {
// 1.方法在类中没有先后顺序，但是不能把一个方法定义在另一个方法中。
// 2.方法的返回值类型写void（无返回申明）时，方法内不能使用return返回数据，
// 如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。
public static void test() {
System.out.println("test");
}
// 3.return语句的下面，不能编写代码，属于无效的代码，执行不到这儿。
public static int sum(int a, int b) {
int c = a + b;
return c;
}
public static void main(String[] args) {
// 4.方法不调用就不会执行, 调用方法时，传给方法的数据，必须严格匹配方法的参数情况。
test();
sum(1, 2);
// 5.调用有返回值的方法，有3种方式：
// ① 可以定义变量接收结果
// ② 或者直接输出调用，
// ③ 甚至直接调用；
int ret = sum(1, 2);
System.out.println("ret = " + ret);
System.out.println(sum(1, 2));
sum(1, 2);
// 6.调用无返回值的方法，只有1种方式： 只能直接调用。
test();
}
}
四、方法的案例
4.1案例1
//需求1：计算1-n的和
public class MethodTest04 {
public static void main(String[] args) {
int ret1 = sum(5);
System.out.println("1-5的和是：" + ret1);
int ret2 = sum(100);//同一个方法可以多次被调用
System.out.println("1-100的和是：" + ret2);
}
// 需求1：计算1-n的和
public static int sum(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
// i = 1, 2, 3, ... n
sum += i;
}
return sum;
}
}
4.2方法案例2
需求2：判断一个整数是奇数还是偶数
*/
public class MethodTest04 {
public static void main(String[] args) {
odd(10);
odd(3);
}
// 需求2：判断一个整数是奇数还是偶数
public static void odd(int number) {
if (number % 2 == 0) {
System.out.println(number + "是一个偶数!");
} else {
System.out.println(number + "是一个奇数!");
}
}
五、方法在计算机中的执行原理
我们知道Java程序的运行，都是在内存中执行的，而内存区域又分为栈、堆和方法区。那Java的方法是在哪个内存区域中执行呢？
答案是栈内存。 每次调用方法，方法都会进栈执行；执行完后，又会弹栈出去。
方法进栈和弹栈的过程，就类似于手枪子弹夹，上子弹和击发子弹的过程。最后上的一颗子弹是，第一个打出来的；第一颗上的子弹，是最后一个打出来的。
假设在main方法中依次调用A方法、B方法、C方法，在内存中的执行流程如下：
- 每次调用方法，方法都会从栈顶压栈执行没执行
- 每个方法执行完后，会从栈顶弹栈出去
5.1 有返回值的方法，内存分析
下面我们分析一下，求两个整数和的代码，在内存中的执行原理。
public class MethodDemo {
public static void main(String[] args) {
int rs = sum(10, 20);
System.out.println(rs);
}
public static int sum(int a, int b) {
int c = a + b;
return c;
}
}
如下图所示：以上代码在内存中的执行过程，按照①②③④⑤⑥⑦的步骤执行.
5.2 无返回值的方法，内存分析
刚才我们分析的是有有参数有返回值的方法内存原理。下面再分析一个无返回值、无参数的内存原理。
public class Demo2Method {
public static void main(String[] args) {
study();
}
public static void study(){
eat();
System.out.println("学习");
sleep();
}
public static void eat(){
System.out.println("吃饭");
}
public static void sleep(){
System.out.println("睡觉");
}
}
总结
1.方法的运行区域在哪里？
答：栈内存。
2.栈有什么特点？方法为什么要在栈中运行自己？
答：先进后出。保证一个方法调用完另一个方法后，可以回来继续执行。
3.首先就是.class文件加载到方法区中（方法和变量），并且只会加载一次
六、方法参数的传递机制
实际上参数还可以是传递引用类型。接下来，学习一下当参数是基本类型时、和参数是引用类型时的区别。
先记住一个结论：Java的参数传递机制都是：值传递
package com.itheima._02methodparameter;
/*
目标：理解方法的参数传递机制：值传递
*/
public class MethodParameter01 {
public static void main(String[] args) {
int a = 10;
change(a); // change(10);
System.out.println("main: " + a); // 10
}
public static void change(int a) {
System.out.println("change1: " + a); // 10
a = 20;
System.out.println("change2: " + a); // 20
}
}
所谓值传递：指的是在传递实参给方法的形参的时候，传递的是实参变量中存储的值的副本。 形参是什么？实参又是什么呢？ 请看下面这个张图
- 答案
所谓值传递：指的是在传输实参给方法的形参的时候，传输的是实参变量中存储的值的副本
实参：在方法内部定义的变量。
形参：定义方法时“(…)”中所声明的参数
6.1 参数传递的基本类型数据
接下来，看一下方法参数传递是基本类型数据时，内存中是怎么执行的。
Java的参数传递机制都是：值传递，传递的是实参存储的值的副本。
对于基本类型参数，方法调用时，实际参数的值会被复制给形式参数，形式参数在方法执行中对其进行操作不会影响到实际参数的值。例如，当我们将一个int类型的变量作为参数传递给方法时，方法内部对该参数进行修改不会改变原始变量的值。
6.2 参数传递的是引用数据类型
/* 目标：理解引用类型的参数传递机制：值传递 */
public class MethodParameter02 {
public static void main(String[] args) {
int[] arrs = new int[]{10, 20, 30};
change(arrs);
System.out.println("main:" + arrs[1]);
}
public static void change(int[] arrs) { System.out.println("方法内1：" + arrs[1]);
arrs[1] = 222;
System.out.println("方法内2：" + arrs[1]); }
}
接下来，看一下方法的参数是引用类型的数据时，内存中是怎么执行的
我们发现调用change方法时参数是引用类型，实际上也是值传递，只不过参数传递存储的地址值。此时change方法和main方法中两个方法中各自有一个变量arrs，这两个变量记录的是同一个地址值[I@4c873330，change方法把数组中的元素改了，main方法在访问时，元素已经被修改了。
- 代码演示
public class demo08 {
public static void main(String[] args) {
int[] arr ={1,1,1};
arr2(arr);
System.out.println(Arrays.toString(arr));
}
public static int[] arr2(int[] arr){
arr3(arr);
arr[2]=3;
return arr;
}
public static int[] arr3(int[] arr){
arr[1] = 2;
return arr;
}
}
如上代码所示，最直观的就是我们通过把数组当做实参进行传递，arr2和aa3分别对数组的元素进行了访问修改然后返回给调用处，我们也没有对返回处进行新的接受，数组的结果一样得到了同步的修改，是因为他们三者共享的是一块数据空间，修改的是同一个数据，即使我们没有接受返回值。
- 说明
对于引用类型参数，方法调用时，实际参数和形式参数指向同一个地址，所以在方法执行中对形式参数的操作实际上就是对实际参数的操作。这意味着，如果我们将一个对象作为参数传递给方法，并在方法内部修改了该对象的属性，那么这个修改会影响到原始对象。
举个例子来说明，如果我们将一个StringBuilder对象和一个int类型的变量作为参数传递给方法，并在方法内部对StringBuilder对象进行修改和对int类型变量进行赋值，那么在方法执行后，StringBuilder对象的值会被修改，而int类型变量的值不会受到影响。
总结起来，基本类型参数是按值传递的，而引用类型参数是按引用传递的。这是因为基本类型在传递参数时是复制了一份值，而引用类型在传递参数时是传递了地址。
- 总结
1.基本类型和引用类型的参数在传递的时候有什么不同？
= 都是值传递
- 基本类型的参数传递存储的数据值。
- 引用类型的参数传递存储的地址值。
-Java方法的执行原理可以通过以下步骤来理解。
1.首先，当我们编写Java源代码时，它会被编译器编译成字节码文件（.class文件）。
2.然后，JVM的类加载器会加载这些字节码文件和相关的Java API到JVM中。
3.接下来，JVM会将字节码文件加载到方法区。方法区是JVM的一部分，用于存储类的结构信息、常量池、静态变量等。在方法区中，JVM会解析字节码文件并创建相应的类和对象。
-当我们调用一个Java方法时
1.JVM会在方法区中找到该方法的字节码指令，并按照指令的顺序执行。
2.在执行过程中，JVM会使用虚拟机栈来管理方法的调用和返回。
3.虚拟机栈是用于存储方法的局部变量、操作数栈和方法调用的信息的内存区域。
4.每当一个方法被调用时，JVM会在虚拟机栈中创建一个新的栈帧，用于存储该方法的局部变量和操作数栈。
5.当方法执行完毕后，JVM会将栈帧出栈，返回到调用方法的位置。
-在方法的执行过程中
1.JVM还会使用堆内存来存储对象实例。
2.堆内存是用于存储动态分配的对象的内存区域。
3.当我们在方法中创建一个对象时，JVM会在堆内存中分配内存空间，并初始化对象的属性。
4.在方法执行完毕后，JVM会自动回收不再使用的对象的内存空间。
-总结起来，
Java方法的执行原理可以概括为：编写Java源代码 -> 编译成字节码文件 -> JVM加载字节码文件 -> JVM解析字节码文件并创建类和对象 -> 调用方法时，JVM按照字节码指令顺序执行方法 -> 使用虚拟机栈管理方法的调用和返回 -> 使用堆内存存储对象实例。
七、方法重载
所谓方法重载指的是：一个类中，出现多个相同的方法名，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。
我们在这里要能够认识，哪些是重载的方法。
1.什么是方法重载？
答：一个类中，多个方法的名称相同，但它们形参列表不同。
2.方法重载需要注意什么？
- 一个类中，只要一些方法的名称相同、形参列表不同，
那么它们就是方法重载了，
其它的都不管（如：修饰符，返回值类型是否一样都无所谓）。
- 形参列表不同指的是：
形参的个数、类型、顺序不同，不关心形参的名称。
3、方法重载有啥应用场景？
答：开发中我们经常需要为处理一类业务，提供多种解决方案，
此时用方法重载来设计是很专业的。
- 代码演示
/* 目标：认识方法重载，掌握其应用场景
需求：定义方法进行两个整数求和，定义方法进行三个整数求和，定义方法进行四个整数求和 */
public class MethodOverload01 {
public static void main(String[] args) { System.out.println(add(1, 2)); System.out.println(add(1, 2, 3)); System.out.println(add(1, 2, 3, 4));
}
// 定义方法进行两个整数求和
public static int add(int a, int b) {
return a + b;
}
// 定义方法进行三个整数求和
public static int add(int a, int b, int c) {
return a + b + c;
}
// 定义方法进行四个整数求和
public static int add(int a, int b, int c, int d) { return a + b + c + d;
}
}
下面案例中有多个test方法，但是参数列表都不一样，它们都是重载的方法。调用时只需要通过参数来区分即可
public class MethodOverLoadDemo1 {
public static void main(String[] args) {
// 目标：认识方法重载，并掌握其应用场景。
test();
test(100);
}
public static void test(){
System.out.println("===test1===");
}
public static void test(int a){
System.out.println("===test2===" + a);
}
void test(double a){
}
void test(double a, int b){
}
void test(int b, double a){
}
int test(int a, int b){
return a + b;
}
}
八、return单独使用
1.return的作用：结束方法，返回值
2. return; 在无返回值方法中的作用：立即结束当前方法的执行
3.return后面不能再接语句，因为return有结束方法的作用，所以后面的代码是无法执行，也会进行报错。
- 代码案例
/*
目标：掌握return单独使用
return; 在无返回值方法中的作用：立即结束当前方法的执行
*/
public class MethodReturn01 {
public static void main(String[] args) {
System.out.println("程序开始。。。");
chu(10, 0);
System.out.println("程序结束。。。");
}
public static void chu(int a, int b) {
if (b == 0) {
System.out.println("您的数据有问题，不能除0~~");
return; // 跳出并结束当前方法的执行。
}
int c = a / b;
System.out.println("除法结果是: " + c);
}
}
九、可变参数
9.1概念
Java允许同一个类中多个同名同功能但参数不同的方法，封装成一个方法。就可以通过可变参数来实现。
9.2语法
访问修饰符 返回值类型 方法名 （数据类型...形参名）{
}
9.3快速入门
//类HSP 方法sum->计算2个数的和，5个数的和。
public class Var{
pulic static void main(String[] args){
HSP m = new HSP();
Systeam.out.println(m.sum(1,100,20,10,80);
Systeam.out.println(m.sum(1,100);
}
}
class HSP{
/*解析：
1.int...表示接收的是可变参数，类型是int，即可接收多个（0-多）
2.使用可变参数时，可以当做数组来使用
*/
pulic int sum(int...nums){
int res = 0;
for(int i =0;i< nums.length;i++){
res += nums[i];
}
return res;
十、方法的案例
案例1：输出数组内容
需求：输出一个int类型的数组内容，要求输出格式为：[11, 22, 33, 44, 55]。
分析：
1.方法是否需要接收数据进行处理？
方法要打印int类型数组中的元素，打印哪一个数组需求并不明确；
所以可以把int数组写成参数，让调用者指定
2.方法是否需要返回数据？
方法最终的目的知识打印数组中的元素。
不需要给调用者返回什么，所以不需要返回值，返回值类型写void
3.方法内部的业务：遍历数组，并输出相应的内容
public class demo08 {
public static void main(String[] args) {
int[] arr ={11,22,33,44};
printArray(arr);
}
public static void printArray(int[] arr){
if (arr == null) {
System.out.println(arr); // null
return; // 跳出当前方法
}
System.out.print("[ ");
for (int i = 0; i < arr.length; i++) {
if(i !=arr.length-1){
System.out.print(arr[i]+", ");
}else {
System.out.print(arr[arr.length-1]);
}
}
System.out.println(" ]");
}
案例2
需求：比较两个int类型的数组是否一样，返回true或者false
分析：
1.方法是否需要接收数据进行处理？
因为，方法中需要两个int数组比较，但是需求并不明确是哪两个数组；
所以，需要接收两个int类型的数组，形参声明为：int[] arr1，int[] arr2
2.方法是否需要返回数据？
因为,方法最终的结果需要true或者false;
所以，返回值类型是boolean
3. 方法内部的业务：判断两个数组内容是否一样。
/*
目标：完成判断两个int类型的数组内容是否一样，一样返回true，不一样返回false
*/
public class MethodParameter04 {
public static void main(String[] args) {
int[] arr1 = {10, 20, 30};
int[] arr2 = {10, 20, 30};
System.out.println(equals(arr1, arr2));
}
public static boolean equals(int[] arr1, int[] arr2) {
// 1.判断arr1和arr2是否都是null
if (arr1 == null && arr2 == null) {
return true; // 相等的
}
// 2.判断arr1是null，或者arr2是null
if (arr1 == null || arr2 == null) {
return false; // 不相等
}
// 3.判断2个数组的长度是否一样，如果长度不一样，直接返回false
if (arr1.length != arr2.length) {
return false; // 不相等
}
// 4.两个数组的长度是一样的，接着比较它们的内容是否一样
// arr1 = [10, 20, 30]
// arr2 = [10, 20, 30]
for (int i = 0; i < arr1.length; i++) {
// 判断当前位置2个数组的元素是否不一样，不一样直接返回false
if (arr1[i] != arr2[i]) {
return false; // 不相等的
//注意，这里不用像往常一样写break，因为return有结束方法的功能
}
}
return true; // 两个数组是一样的
}
}
案例3
把找出数组的最大值案例，改造成方法，返回数组的最大值。
public class MethodParameter05 {
public static void main(String[] args) {
int[] faceScores = {15, 9000, 10000, 20000, 9500, -5};
int max = getArrayMax(faceScores);
System.out.println("数组的最大值是：" + max);
}
public static int getArrayMax(int[] arr){
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
int data = arr[i];
if(data > max){
max = data;
}
}
return max;
}
}
案例4
需求
定义一个方法，接收一个整数n(n的范围在5到10之间)。
方法中实现：以接收到的整数n作为一个数组的长度，创建一个动态数组。
然后生成n个范围在[1,100]之间的数字，
保存到数组中，要求生成的数字不能重复。最终，把生成的数组返回
-1 0 ~ 99
程序执行，在控制台输出效果【效果不唯一】
调用方法，传入的整数是: 5
返回的数组是: {13,58,43,25,66};
调用方法，传入的整数是: 7
返回的数组是: {18,35,27,6,76,33,24};
public static int[] createArray(int n) {
if (n < 5 || n > 10) {
System.out.println("数据n " + n + "非法");
return new int[0]; // {}, 长度为0的数组
}
// 生成数组
int[] arr = new int[n]; // {95, 57, 92, 53, 0, 0, 0, 0}
// 索引 0 1 2 3 4 5 6 7
// i
// j
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
// 如果数字重复,需要重新生成.
while (true) {
// i = 4
int number = r.nextInt(100) + 1;
boolean repeat = false; // 假设没有重复
// 遍历前面这些数据看是否有重复的
for (int j = 0; j < i; j++) {
if (number == arr[j]) {
repeat = true; // 找到重复的, 结束循环
break;
}
}
if (repeat) {
// 重复啦!
System.out.println("重复啦! " + number);
} else {
// 不重复
arr[i] = number;
break;
}
}
}
return arr;
}
}
案例5
请定义一个方法，方法的功能是打印nn乘法表。在主方法中键盘录入取值范围为[1-9]的变量n，测试方法。 执行效果如下
请输入一个1-9之间的整数：
4
乘法表：
1×1=1
1×2=2 2×2=4
1×3=3 2×3=6 3×3=9
1×4=4 2×4=8 3×4=12 4×4=16
public class Demo4 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//键盘录入一个整数
System.out.println("请输入一个1-9之间的整数：");
int n = sc.nextInt();
//调用方法
method(n);
}
//定义乘法表方法
public static void method(int n) {
System.out.println("乘法表：");
//外层循环n次
for (int i = 1; i <= n; i++) {
//内存循环i次
for (int j = 1; j <= i; j++) {
System.out.print(j + "×" + i + "=" +j*i + "\t");
}
//每行结尾执行换行
System.out.println();
}
}
}
案例6
请输入第一个整数：10
请输入第二个整数：30
请输入第三个整数：20
从大到小的顺序是： 30 20 10
public class Demo5 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//分别输入三个整数
System.out.println("请输入第一个整数:");
int a = sc.nextInt();
System.out.println("请输入第二个整数:");
int b = sc.nextInt();
System.out.println("请输入第三个整数:");
int c = sc.nextInt();
//调用方法
method(a,b,c); }
//定义方法
public static void method(int a, int b, int c) {
//定义变量存储最大值
int max = 0;
//定义变量存储最小值
int min = 0;
//判断最大值
if(a > b && a > c ){
max = a;
}else if(b > a && b > c){
max = b;
}else{
max = c;
}
//判断最小值
if(a < b && a < c ){
min = a;
}else if(b < a && b < c){
min = b;
}else{
min = c;
} //计算中间值
int mid = a + b + c - max - min;
//按照从大到小的顺序输出
System.out.println("从大到小的顺序是：" + max + " "+ mid + " " + min);
}
}
案例7
数字是有绝对值的，负数的绝对值是它本身取反，非负数的绝对值是它本身。请定义一个方法，方法能够得到小数类型数字的绝对值并返回。请定义方法并测试。
public class Demo6 {
public static void main(String[] args) {
double num = -3.14;
//调用方法
double abs = abs(num);
//打印结果
System.out.println(num +"的绝对值是" + abs);
}
//定义绝对值方法
public static double abs(double num){
if(num < 0){
//如果数字是负数则取反
return -num;
}else{
//如果是非负数则返回本身
return num;
}
}
}
案例8
请定义一个方法，对正数的小数进行四舍五入的操作(不考虑负数情况)。四舍五入之后的结果是一个int整数类型并返回。最后对方法进行测试。
public class Demo7 {
public static void main(String[] args) {
double num = 3.44;
//调用方法
int abs = round(num);
//打印结果
System.out.println(num +"四舍五入之后是" + abs);
}
//定义四舍五入方法
public static int round(double num){
//将小数乘以10后强转为int,再对10取余，能过获取到十分位(小数第一位)
int a = (int)(num * 10) % 10;
if(a < 5){
//如果a小于5,则四舍
return (int)num;
}else{
//如果a大于等于5,则五入
return (int)num + 1;
}
}
}
System.out.println(num +"的绝对值是" + abs);
}
//定义绝对值方法
public static double abs(double num){
if(num < 0){
//如果数字是负数则取反
return -num;
}else{
//如果是非负数则返回本身
return num;
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
