博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
java基础------函数与数组
阅读量:6840 次
发布时间:2019-06-26

本文共 11678 字,大约阅读时间需要 38 分钟。

函数(方法)

      定义:如果一个功能的代码要被复用起来,那么这时候可以把这里的功能代码封装起来,在java中把功能代码封装起来的是以函数的形式体现的。

      函数的格式:

          修饰符 返回值类型 函数名(形式参数.....){

              需要被封装的功能代码;

              return 结果;

                }

      例如:

          public static int add(){

              int a=2;

              int b=3;

              return a+b;

              }

      分析函数:

          修饰符:public static

          返回值类型:int  返回值类型就是指函数运行完毕后,返回结果的数据类型。

                注意: 某些函数是没有结果返回给调用者的,那么这时候返回值类型是void。

          函数名:add

              函数名的作用:如果需要调用该函数就需要使用的函数名。 函数名只要符合标识符的命名规则即可。 

              函数名的命名规范: 首单词全部小写,其他单词的首字母大写,其他小写。

          形式参数: 如果一个函数在运行的时候,存在的数据是要调用者确定的,那么这时候就应该定义形式参数。

          return:把一个结果返回给调用者。

      函数的作用:提高功能代码的复用性

      函数的特点:

          1. 函数的作用就是把一个功能代码给封装起来,已达到提高功能代码的复用性。

          2.函数定义好之后是需要被调用才会执行的。其中main函数是由jvm调用的,不需要我们手动调用。

          3.如果一个函数没有返回值返回给调用者,那么返回值类型必须是使用void表示。 

      如何定义一个函数:

          1. 返回值类型。
          2. 是否存在未知的参数(是否存在要由调用者确定的参数)。---->形式参数

class Demo1{    public static void main(String[] args)     {        //int max = getMax(14,5); //调用了需求1的函数,括号内填写的是实际参数,实际参数由调用者确定        //System.out.println("最大值:"+ max);//输出需求1的结果 结果为14        getMax(3,7);//调用了需求2的函数    }    /*    //需求1: 定义一个函数比较两个int类型的数据大小,把最大值返回给调用者。    public static int  getMax(int a, int b){  // 形式参数        int max = 0; //定义一个变量用于保存最大值的        if(a>b){            max = a;        }else{            max = b;        }        return max;//把结果返回给调用者    }*/    //需求2:定义一个函数比较两个int类型的数据大小,不需要把最大值返回给调用者,直接打印即可。    public static void getMax(int a, int b){        int max = 0; //定义一个变量用于保存最大值的        if(a>b){            max = a;        }else{            max = b;        }        System.out.println("最大值:"+ max);    }}
View Code
class Demo2 {    public static void main(String[] args) {        //String result = getGrade(91);//调用了需求1的函数,并把结果赋值给result        //System.out.println(result);//输出的结果为:A等级        print(7);//调用了需求2的函数    }//需求1: 定义一个函数判断一个分数的等级,把分数的等级返回给调用者。    public static String getGrade(int score){        String grade = "";    //定义一个变量存储等级        if(score>=90&&score<=100){            grade = "A等级";        }else if(score>=80&&score<=89){            grade = "B等级";        }else if(score>=70&&score<=79){            grade = "C等级";        }else if(score>=60&&score<=69){            grade = "D等级";        }else if(score>=0&&score<=59){            grade = "E等级";        }else{            grade = "补考等级";        }        return grade;//把等级返回给调用者    }    //需求2: 定义一个函数打印一个乘法表,不需要返回任何数据。     public static void  print(int row){        for(int i = 1 ; i<= row ; i++){            for (int j = 1 ;j<=i  ;j++ ){                System.out.print(i+"*"+j+"="+i*j+"\t");            }            //换行            System.out.println();        }    }}
View Code

      注意: 如果一个函数的返回值类型是具体的数据类型,那么该函数必须要保证在任意情况下都保证有返回值。(除了返回值类型是void以外)

class Demo3{    public static void main(String[] args)     {        String result = getGrade(10);//调用函数        System.out.println("对应的等级是:"+ result );    }    public static String getGrade(int score){
//未知的参数定义在形参中,由函数的调用者确定。 if(score>=90&&score<=100){ return "A等级"; }else if(score>=80&&score<=89){ return "B等级"; }else if(score>=70&&score<=79){ return "C等级"; }else if(score>=60&&score<=69){ return "D等级"; }else if(score>=0&&score<=59){ return "E等级"; }else{ //如果一个函数的返回值类型是具体的数据类型,那么该函数就必须要保证在任意情况下都保证有返回值。(除了返回值类型是void以外) return "补考等级"; } }}
View Code

      return 关键字的作用:

          1. 返回数据给函数的调用者。

          2. 函数一旦执行到了return关键字,那么该函数马上结束。 (能结束一个函数)

      注意:如果一个函数的返回值类型是void,那么也可以出现return关键字,但是return关键字的后面不能有数据。

      break关键字与return关键字的区别:

          1.break关键字是结束一个循环。

          2. return关键字是结束一个函数。

      函数的重载:在一个类中出现两个或者两个以上的同名函数,这个称作为函数的重载。

      函数重载的要求:

          1. 函数名一致。

          2. 形参列表不一致。(形式参数的个数或者是对应的数据类型不一致)

          3. 与函数的返回值类型是无关的。

      函数重载的作用: 同一个函数名可以出现不同的函数,以应对不同个数或者不同数据类型的参数。

class Demo4 {    public static void main(String[] args) {        add1(1,2);//调用了含有两个参数的函数        add(1,2.0);//调用了含有三个参数的函数    }        // 一下两个函数都是以函数重载在做加法运算。    public static double add(int a, int b){        System.out.println("两个参数的总和: "+ (a+b));        return 3.14;    }    public static void add(int a , int b , int c){        System.out.println("三个参数的总和: "+ (a+b+c));    }}
View Code

数组

      定义:数组是存储同一种数据类型数据的集合容器。

      数组的定义格式:

          数据类型[]  变量名 = new 数据类型[长度];

      分析数组:

          左边: int[] arr    声明了一个int类型的的数组变量,变量名为arr。

              int : 表示该数组容器只能存储int类型的数据。

              [] : 这是一个数组类型。

              arr : 变量名。

          右边:new int[50] 创建了一个长度为50的int类型数组对象。

              new : 创建数组对象的关键字。

              int:表示该数组对象只能存储int类型数据。

              []: 表示是数组类型。

              50 : 该数组最多能存储50个数据。数组的容量。

      数组的好处: 对分配到数组对象中的每一个数据都能够分配到一个索引值(编号、角标、下标),索引值的范围是从0开始,最大是: 长度-1。

      局部变量: 如果一个变量是在一个函数(方法)的内部声明的,那么该变量就是一个局部变量。

      成员变量: 成员变量就是定义在方法之外,类之内的.

class Demo5 {    public static void main(String[] args)     {        //定义一个数组        int[] arr = new int[4];        arr[0] = 10;        arr[1] = 30;        arr[2] = 50;        arr[3] = 90;                 //System.out.println("数组的容量:"+ arr.length);    //数组里有一个length 的属性,可以查看数组的容量。        //System.out.println("arr[2] = "+ arr[2]);//查看索引值为2的数组的值    结果为:50                //查看数组中的所有数据。        for(int index = 0 ; index
View Code

      数组的内存分析图:

      数组中常见的问题:

          1. NullPointerException 空指针异常

          原因: 引用类型变量没有指向任何对象,而访问了对象的属性或者是调用了对象的方法。

          2. ArrayIndexOutOfBoundsException 索引值越界。

          原因:访问了不存在的索引值。

      数组的初始方式:

          动态初始化:数据类型[] 变量名 = new 数据类型[长度];

          静态初始化:数据类型[] 变量名 = {元素1,元素2.....};

      如果程序一开始你就已经确定了数据,那么这时候建议使用静态初始化。如果一开始数据还不太明确,这时候就建议使用动态初始化。

class Demo6{    public static void main(String[] args)     {                /*        //动态初始化        int[] arr = new int[10];        Scanner scanner = new Scanner(System.in);//创建扫描器对象        for(int i  = 0 ; i< arr.length ; i++){            arr[i] = scanner.nextInt();//调用扫描器的nextInt()扫描数据,并把数据赋值于数组中        }        */        //静态初始化        int[] arr = {10,20,30,40,50};                //查看数组的所有数据        for(int index = 0 ; index
View Code
/*    需求: 定义一个函数接收一个int类型的数组对象,找出数组对象中的最大元素并返回给调用者。*/class Demo7 {    public static void main(String[] args)     {        int[] arr = {-12,-14,-5,-26,-4};//静态初始化        int max = getMax(arr);        System.out.println("最大值:"+ max); //结果为:-4    }    public static int  getMax(int[] arr){        int max = arr[0]; //用于记录最大值        for(int i = 1 ; i < arr.length ; i++){            if(arr[i]>max){  //如果发现有元素比max大,那么max变量就记录该元素。                max = arr[i];            }        }        return max;//把max的值返回给调用者    }}
View Code

      数组常见的操作:

          选择排序(直接排序):使用一个元素与其他的元素挨个比较一次,符合条件交换位置。

          需求: 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的第一位。

class Demo8{    public static void main(String[] args)     {        int[] arr = {12,5,17,8,9};  //对于有5个元素的数组,只需要找出4个最大值就可以排序了。        selectSort(arr);    }    public static void selectSort(int[] arr){                //对以下注释的代码进行优化        for(int j = 0; j
arr[j]){ //交换位置 int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } } /* //把老大放在第一个位置 for(int i=1;i
arr[0]){ int temp = arr[i]; arr[i] = arr[0]; arr[0] = temp; } } //把老二放在第二个位置 for(int i = 2 ; i< arr.length ; i++){ if(arr[i]>arr[1]){ int temp = arr[i]; arr[i] = arr[1]; arr[1] = temp; } } //把老三放在第三个位置 for(int i = 3 ; i< arr.length ; i++){ if(arr[i]>arr[2]){ int temp = arr[i]; arr[i] = arr[2]; arr[2] = temp; } } //把老四放在第四个位置 for(int i = 4 ; i< arr.length ; i++){ if(arr[i]>arr[3]){ int temp = arr[i]; arr[i] = arr[3]; arr[3] = temp; } }*/ //遍历数组,查看效果 System.out.print("目前的元素:"); for (int i = 0 ; i
View Code

          冒泡排序:冒泡排序的思想就是使用相邻的两个元素挨个比较一次,符合条件交换位置。

          需求: 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的最后一位。

class Demo9 {    public static void main(String[] args)     {        int[] arr = {12,8,17,5,9}; // 最大的索引值: 4   容量:5          bubbleSort(arr);    }    public static void bubbleSort(int[] arr){        //对以下注释的代码进行优化        for(int j = 0 ; j
arr[i+1]){ int temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; } } }/* // 把最大值放在最后一个位置 for(int i = 0 ; i
arr[i+1]){ int temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; } } //把老二放在倒数第二个位置上。 for(int i = 0 ; i
arr[i+1]){ int temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; } } //把老三放在倒数第三个位置上。 for(int i = 0 ; i
arr[i+1]){ int temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; } } //把老四放在倒数第四个位置上。 for(int i = 0 ; i
arr[i+1]){ int temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; } }*/ //遍历数组,查看效果 System.out.print("目前的元素:"); for (int i = 0 ; i
View Code

          二分查找法:定义三个变量分别记录要查找元素的范围最大索引值、中间索引值、最小索引值,每次都是使用中间索引值的元素与目标元素比较一次,如果不是我们所需要的元素,那么缩小查找的范围。

          注意:使用二分查找法的前提必须是有序的数组。

          需求:定义一个函数接收一个数组对象和一个要查找的目标元素,函数要返回该目标元素在数组中的索引值,如果目标元素不存在数组中,那么返回-1表示。

class Demo10 {    public static void main(String[] args)     {        int[] arr = {12,16,19,23,54};        //int index = searchEle(arr,23);//调用searchEle(),但是效率低        int index = halfSearch(arr,116);        System.out.println("元素所在的索引值是:"+ index);    }                public static int halfSearch(int[] arr, int target){        //定义三个变量分别记录最大、最小、中间的查找范围索引值        int max = arr.length-1;        int min = 0;        int mid = (max+min)/2;        while(true){            if(target>arr[mid]){                min = mid+1;            }else if(target
View Code
/*需求: 定义 一个函数接收一个char类型的数组对象,然后翻转数组中的元素。    例如:char[] arr = {'a','b','c','d','e'};翻转元素后的结果为e、d、c、b、a*/class Demo11{    public static void main(String[] args){        char[] arr = {'a','b','c','d','e'};        reverse(arr);    }    public static void reverse(char[] arr){        for(int startIndex = 0 ,endIndex = arr.length-1 ;   startIndex
View Code

       二维数组:二维数组就是数组中的数组。

      二维数组的定义格式:数据类型[][] 变量名 = new 数据类型[长度1][长度2];

      二维数组的初始化方式:

          动态初始化:数据类型[][] 变量名 = new 数据类型[长度1][长度2];

          静态初始化:数据类型[][]  变量名 = {

{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..};

      二维数组的内存分析图:

      数组的特点:

          1. 数组只能存储同一种数据类型的数据。

          2. 数组是会给存储到数组中的元素分配一个索引值的,索引值从0开始,最大的索引值是length-1;

          3. 数组一旦初始化,长度固定。

          4. 数组中的元素与元素之间的内存地址是连续的。

class Demo12{    public static void main(String[] args)     {            //定义了一个二维数组        int[][] arr = new int[3][4];        arr[1][1] = 100;        /*        System.out.println("二维数组的长度:"+ arr.length);  //长度为3        System.out.println("二维数组的长度:"+ arr[1].length); //长度为4        */        System.out.println("数组的元素:"+ arr[1][1]);结果为100            }}
View Code

 

转载于:https://www.cnblogs.com/birdshdbn/p/9746441.html

你可能感兴趣的文章
在线API
查看>>
一些链接
查看>>
前端踩过的坑
查看>>
C#图片处理示例(裁剪,缩放,清晰度,水印)
查看>>
使用ConcurrentHashMap一定线程安全?
查看>>
dispatchTouchEvent & onInterceptTouchEvent & onTouchEvent
查看>>
配置struts时web.xml中<url-pattern>*.action</url-pattern>
查看>>
.Net Core扩展 SharpPlugs简单上手
查看>>
项目启动时注意事项
查看>>
第37篇 Asp.Net源码解析(二)--详解HttpApplication
查看>>
Java的继承
查看>>
Tomcat7 配置 ssl
查看>>
HLG 1349 Graph [floyed]
查看>>
Java Array 常见报错
查看>>
条件注释判断浏览器版本<!--[if lt IE 9]>
查看>>
Switching JRE Version
查看>>
caffe之mac下环境搭建
查看>>
Redis系列-远程连接redis并给redis加锁
查看>>
记一次网易前端实习面试
查看>>
vue
查看>>