Java函数及习题总结

最新推荐文章于 2023-06-25 17:07:20 发布

苦瓜汁西瓜汁

最新推荐文章于 2023-06-25 17:07:20 发布

阅读量196

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/qq_45879990/article/details/104288675

版权

JavaSE 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

函数

函数的定义

（1）存在的意义：

函数主要解决的是那些重复的且具有独立功能的代码段
将这些具有独立功能的代码进行再次封装封装出来就成为是函数
降低了代码冗余复用函数，降低了主函数的代码量，将主函数进行适当的拆分，以便内存优化
将函数模块化

（2）函数的格式

访问权限函数类型返回值类型函数名(参数列表){
函数体
return 返回值;
}

格式解读：

访问权限：指的就是函数的使用范围(内部和外部) 有public、protected、默认不写、private；
函数类型：数的具体使用场景和场合，有static 静态函数、默认不写成员函数、abstract 抽象函数、native 本地函数、synchronized 同步函数；
函数名：就是自定义的名称(标识符)；
参数列表：参数列表有若干个参数类型,参数名... 组成主要用于接收外界传递给函数的一些数据；
函数体：具有独立功能的代码块；
return：仅仅表示结束当前函数，如果有返回值，则函数结束前将返回值返回给调用者；
返回值：指的就是这一具有独立功能的代码块的计算结果，需要传递给外界配合return；
返回值类型：就是返回值的数据类型(可兼容)。

函数的分类

1、无返回值无参数

public static void method(){

}

2、有返回值无参数

public static int method(){

return 整型数值

}

3、带参数函数

public static int method(String name){

return 整型数值

}

注意：有返回值的函数，参与函数的运算、输出、赋值；无返回值的函数，仅仅调用。

函数传参

（1）实际参数-实参：就是在调用函数的时候，给函数传递的数据叫做实参

（2）形式参数-形参：就是定义函数的时候，参数列表当中的数据，叫做形参

实参向形参传递的内容：常量在常量池中的地址、对象在堆内存中的地址

局部变量：但凡是在函数中创建的变量称之为是局部变量局部变量的作用域仅仅在当前的函数当中

注意：形式参数一定是局部变量

public class Test {
      public static void doubleValue(int num) {
          num = num * 2;
      }
     
      public static void main(String[] args) {
          int x = 1;
          doubleValue(x);
          System.out.println(x); 
     }
 }
/*
执行过程
（1）调用函数doubleValue(x)时，num被初始化为x值的一份拷贝，即num=1；
（2）在函数体内，num乘以2以后等于2，但是x还是1；
（3）函数执行结束后，变量num不再使用。
*/

函数栈

函数的运行是基于栈内存的，栈是一个先进后出的一个容器结构。

函数栈的运行过程：

函数的重载

函数的重载：指的就是同一个类中出现的同名函数

PS：函数重载与权限没关系，与返回值类型没关系，与参数名没关系，只有和参数类型的排列组合有关系(注意一下参数类型的向下兼容问题)

重载的好处就在于我们可以扩展函数的功能如函数重名，但是参数类型不一样，执行内容也可以不一样。

寻找适当函数的流程：
1.看是否有确切的参数定义 int+int 查看是否有(int,int)
2.看是否有可兼容的参数定义 int+int 查看是否有(double,double)
3.如果可兼容的参数定义有多个int+int,(double,int)或(int,double) 此时报错引用不明确

函数的递归调用

递归函数即自调用函数，在函数体内直接或间接的调用自己，即函数的嵌套是函数本身

递归主要去解决的问题：

（1）一般而言，但凡能够被迭代（循环）解决的问题，递归都可以，递归解决的问题，迭代就不一定了

（2）递归就是函数在进栈，进栈的次数多了，势必会占内存，无法避免的，在某些问题上，递归所写的代码要比迭代写的代码少
在某些问题上，迭代是写不出来的，所以只能用递归。

分治法介绍：

分治法是一种算法思想，分治法主要解决的问题是将大问题，进行拆分，拆分成若干个小的问题进行求解，最终将每个小问题的解进行合并，其实，分治法就是一种暴力破解法（穷举），也是一种搜索最优答案的算法。

常用函数

math类：Math.E、Math.PI、Math.abs(a)、Math.ceil(a)、Math.floor(a)、Math.hypot(x,y)、Math.max(a,b)、Math.min(a,b)、Math.pow(a,b)、Math.sqrt(a)、Math.random()、Math.rint(a)、Math.round(a)；

string类：String不是基本数据类型而是一个类，既然是类那么肯定有其相关的函数

功能分类：

（1）查询相关：char charAt(int index)、int indexOf(int ch) 、int lastIndexOf(int ch) 、int length() 、substring(int beginIndex, int endIndex) 等

（2）判断相关：boolean contains(String s)、boolean endsWith(String s)、boolean startsWith(String prefix) 、int compareTo(String anotherString)、boolean equals(String anotherString)、boolean equalsIgnoreCase(String anotherString) 、boolean isEmpty() 等

（3）修改相关：String replace(char oldChar, char newChar) 、String toUpperCase() 、String toLowerCase() 、String trim() 等

注意：对字符串的修改永远都不是对其自身进行的修改，字符串本身是不可变的，对字符串的修改往往都是新建个字符串将修改后内容赋值并返回新的字符串!

习题总结

import java.util.Scanner;
class Demo04_01{
    public static void main(String[] args){
        //1.先输入一个数字
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入一个数字:");
        long num=scanner.nextLong();
        //2.调用函数将num拆分求和
        int sum=sumDigits(num);
        System.out.println(sum);
    }
    public static int sumDigits(long n){
        int sum=0;
        while(true){
            sum+=n%10;
            n/=10;
            if(n==0){
                return sum;
            }
        }
    }
}

import java.util.Scanner;
class Demo04_02{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入一个数字:");
        int num=scanner.nextInt();
        
        if(isPalindrome(num)){  // pause1
            System.out.println("是回文");
        }else{
            System.out.println("不是回文");
        }
        //return ;
    }
    public static boolean isPalindrome(int num){
        
        return reverse(num)==num; 
    }
    public static int reverse(int num){
        int sum=0;
        while(true){
            sum=sum*10+num%10;
            num/=10;
            if(num==0){
                return sum;
            }
        }
    }
}

import java.util.Scanner;
class Demo04_03{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入行数：");
        displayPattern(scanner.nextInt());
    }
    public static void displayPattern(int line){
        for(int i=1;i<=line;i++){
            for(int k=1;k<=line-i;k++){
                if(line<10){
                    System.out.print("  ");
                }else{
                    System.out.print("   ");
                }
            }
            for(int j=i;j>=1;j--){
                if(line<10){
                    System.out.printf("%-2d",j);
                }else{
                    System.out.printf("%-3d",j);
                }
            }
            System.out.println();
        }
    }
}

class Demo04_05{
    public static void main(String[] args){
        System.out.println(sqrt(9));
    }
    public static double sqrt(long n){
        double lastGuess=1;
        double nextGuess=(lastGuess+n/lastGuess)/2;
        while(true){
            if(Math.abs(nextGuess-lastGuess)<0.00001){
                return nextGuess;
            }
            lastGuess=nextGuess;
            nextGuess=(lastGuess+n/lastGuess)/2;
        }
    }
}

class Demo04_06{
    public static void main(String[] args){
        int count=0;    //表示回文素数的个数
        int num=2;      //表示可能的回文素数的数字 从2开始~?
        while(true){
            //如果num是 回文素数
            if(isHuiWenAndSuShu(num)){
                count++;
                System.out.print(num+" ");
                if(count%10==0){
                    System.out.println();
                }
            }
            if(count==100){
                break;
            }
            num++;
        }
    }
    public static boolean isHuiWenAndSuShu(int num){
        return isHuiWen(num)&&isSuShu(num);
    }
    public static boolean isHuiWen(int num){
        return reverse(num)==num;
    }
    public static int reverse(int num){
        int sum=0;
        while(true){
            sum=sum*10+num%10;
            num/=10;
            if(num==0){
                return sum;
            }
        }
    }
    public static boolean isSuShu(int num){
        for(int i=2;i<=num/2;i++){
            if(num%i==0){
                return false;
            }
        }
        return true;
    }
}

class Demo04_07{
    public static void main(String[] args){
        int count=0;
        int num=2;
        while(true){
            if(isFanZhuanSuShu(num)){
                count++;
                System.out.print(num+" ");
                if(count%10==0){
                    System.out.println();
                }
            }
            if(count==100){
                return; 
            }
            num++;
        }
    }
    
    public static boolean isFanZhuanSuShu(int num){
        return isSuShu(num)&&isSuShu(reverse(num))&&!isHuiWen(num);
    }
    //回文功能
    public static boolean isHuiWen(int num){
        return reverse(num)==num;
    }
    //素数功能
    public static boolean isSuShu(int num){
        for(int i=2;i<=num/2;i++){
            if(num%i==0){
                return false;
            }
        }
        return true;
    }
    //反转功能
    public static int reverse(int num){
        int sum=0;
        while(true){
            sum=sum*10+num%10;
            num/=10;
            if(num==0){
                return sum;
            }
        }
    }
}