JAVA-函数(下)_java有如下函数 y=-CSDN博客

本文链接：https://blog.csdn.net/weixin_44161261/article/details/104283478

上一次咱们讲了函数的分类、函数传参、函数栈等问题，今天我们接着讲关于函数的东西。

函数的重载(同一个类中出现的同名函数)

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

重载优点：可以扩展函数的功能(函数重名，但是参数类型不一样，执行内容也可以不一样)

寻找适当函数的流程

1.看是否有确切的参数定义 int+int 查看是否有(int,int)

2.看是否有可兼容的参数定义 int+int 查看是否有(double,double)

3.如果可兼容的参数定义有多个int+int,(double,int)或(int,double) 此时报错（引用不明确）

如下就会报错（引用不明确）

class Test01{
    public static void main(String[] args){
        int a=3;
        int b=4;
        System.out.println(add(a,b));
    }
    public static double add(double a,int b){
        System.out.println("double+int");
        return a+b;
    }
    public static double add(int a,double b){
        System.out.println("int+double");
        return a+b;
    }
}

函数的递归调用

俗话说得好（人用迭代，神用递归）还不快看看递归！！！

递归的体现：函数自身调用函数自身

一般而言，但凡能够被迭代（循环）解决的问题，递归都可以；递归解决的问题，迭代就不一定了。
递归其实是分治法的一种实现方式（一种实现思路）
递归就是函数在进栈，进栈的次数多了，势必会占内存，无法避免的。
分治法是一种算法思想，分治法主要解决的问题是将大问题，进行拆分，拆分成若干个小的问题进行求解，最终将每个小问题的解进行合并。其实，分治法就是一种暴力破解法（穷举），也是一种搜索最优答案的算法

递归：先递，后归

前进段：指的就是讲问题从大化小
结束段：问题无法再继续化小，则处理当前的问题
返回段：将小问题处理完毕之后，向上返回（有些问题是不需要返回的）

常用函数

我们目前常用的函数可以大致上分为两大类

Math类
String类

Math类

    Math.E（比任何其他值都更接近 e（即自然对数的底数）的 double 值）
   Math.PI（比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值）
   Math.ceil(a)（返回大于指定数字的最小整数）
   Math.floor(a)（返回小于指定数字的最大整数）
   Math.hypot(x,y)（返回 sqrt(x2 +y2)，没有中间溢出或下溢）
Math.rint(a)（四舍五入）

class Test01{
    public static void main(String[] args){
        System.out.println(Math.E);
        System.out.println(Math.PI);

        //大于指定数字的最小整数
        System.out.println(Math.ceil(-2.1));

        //小于指定数字的最大整数
        System.out.println(Math.floor(2.3));

        //求两点之间的距离 x=deltX y=deltY
        System.out.println(Math.hypot(3,4));

        //四舍五入
        System.out.println(Math.rint(3.5));
    }
}

   Math.abs(a)（返回a的绝对值）
   Math.max(a,b)（返回两个 double 值中较大的一个）
   Math.min(a,b)（返回两个 double 值中较小的一个）
   Math.pow(a,b)（返回a^b的值）
   Math.sqrt(a)（返回a的正平方根）
   Math.random()（返回带正号的 double 值，该值大于等于 0.0 且小于 1.0）
   Math.round(a)（返回最接近参数的 long）

class Test01{
    public static void main(String[] args){
        //返回绝对值
        System.out.println(Math.abs(-1));

        //返回最大的值
        System.out.println(Math.max(1,2));

        //返回最小的值
        System.out.println(Math.min(1,2));

        //返回2^2
        System.out.println(Math.pow(2,2));

        //开平方
        System.out.println(Math.sqrt(4));

        //产生[0.0，1.0)的随机数
        System.out.println(Math.random());

        //返回最接近参数的 long
        System.out.println(Math.round(3.4));
    }
}

String类

查询相关

char charAt(int index)（获取指定角标处的字符）
int indexOf(int ch) （在字符串中从左到右查找指定元素第一次出现的位置）
int lastIndexOf(int ch) （在字符串中从右到左查找指定元素第一次出现的位置）
int length() （返回此字符串的长度）
substring(int beginIndex, int endIndex) （返回一个新字符串，它是此字符串的一个子字符串）

class Test02{
    public static void main(String[] args){
        String s="abcd";
        //获取指定角标处的字符
        System.out.println(s.charAt(0));

        //在字符串中从左到右查找指定元素第一次出现的位置   
        System.out.println("abcccccd".indexOf('c'));

        //在字符串中从右到左查找指定元素第一次出现的位置   
        System.out.println("abcccccd".indexOf('c'));

        //返回字符串的长度   
        System.out.println(s.length());

        //返回一个新字符串，它是此字符串的一个子字符串
        s="abababab";
        System.out.println(s.substring(0,3));//[0,3)
    }
}

判断相关

boolean contains(String s)（当且仅当此字符串包含指定的 char 值序列时，返回 true）
boolean endsWith(String s)（测试此字符串是否以指定的后缀结束）
boolean startsWith(String prefix) （测试此字符串从指定索引开始的子字符串是否以指定前缀开始）
int compareTo(String anotherString)（按字典顺序比较两个字符串）
boolean equals(String anotherString)（将此字符串与指定的对象比较）
boolean equalsIgnoreCase(String anotherString) （将此 String 与另一个 String 比较，不考虑大小写）
boolean isEmpty() （当且仅当 length() 为 0 时返回 true）

class Test02{
    public static void main(String[] args){
        String s="abcd";
        /*
        "abcd"
         0123
        */
        //判断指定子串是否包含在s中
        System.out.println(s.contains("ab"));
        //判断指定子串是否在s的结尾
        System.out.println(s.endsWith("cd"));

        //按照字典顺序比较两个字符串的大小
        System.out.println("abc".compareTo("abd"));
        //返回值有负数 0 正数
        //负数 前者在后者ASCII之前
        //0 前者和后者相等
        //正数 前者在后者ASCII之后
        /*
        abc
        abd c-d=-1
        */
        System.out.println("abc".compareTo("abc"));

        //比较两个字符串是否相等(比的是内容)
        System.out.println("abc".equals("abc"));

        //IgnoreCase忽略大小写
        System.out.println("ABC".equalsIgnoreCase("abc"));

        //当且仅当 length() 为 0 时返回 true
        String s="";
        System.out.println(s.isEmpty());
        
    }
}

修改相关

注意！！！对字符串的修改永远都不是对其自身进行的修改;字符串本身是不可变的！！！

对字符串的修改往往都是新建个字符串将修改后内容赋值并返回新的字符串

String replace(char oldChar, char newChar) （返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的）
String toUpperCase() （使用默认语言环境的规则将此 String 中的所有字符都转换为大写）
String toLowerCase() （使用默认语言环境的规则将此 String 中的所有字符都转换为小写）
String trim() （返回字符串的副本，忽略前导空白和尾部空白）

class Test{
    public static void main(String[] args){

        //返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
        s="abababab";
        System.out.println(s.replace('a','c'));

        //使用默认语言环境的规则将此 String 中的所有字符都转换为大写
        System.out.println(s.toUpperCase());

        //使用默认语言环境的规则将此 String 中的所有字符都转换为小写
        s="ABABABAB";
        System.out.println(s.toUpperCase());

        //返回字符串的副本，忽略前导空白和尾部空白
        System.out.println("  abc abc abc   ".trim());
    }
}

以为函数到此为止？？？

怎么可能！！！

有没有感觉少了什么

当然是题，看下一篇就OK了