首页 > 代码库 > Day05_JAVA语言基础第五天

Day05_JAVA语言基础第五天

2024-08-28 19:59:51   218人阅读

1、函数(掌握)

1、概念（掌握）                    

        定义在类中，有特定功能的一小段程序     

2、格式(掌握)                                            

        修饰符 返回类型 函数名（参数类型 形式参数,...）{                              

            函数体；                              

            return 返回值;                         

        }                  

            解释：

                 A 修饰符: public static

                 B 返回值类型 :就是数据类型

                 C 函数名:见名知意，如果一个单词，首字母小写，如果多个单词组成，从第二个单词开始首字母大写

                 D 参数类型 ：数据类型

                 E 形式参数 ：接受实际参数的变量

                 F 实际参数 ：就是实际参与运算的变量

                 G 函数体：实现功能的代码

                 H 返回值 程序的结果,如果没有明确返回值可以不写

                 I return 返回值 ，那里调用程序，return就把结果返回到哪里 比如 int num = max(1,2);return把结果返回给num     

3、特点(掌握!!)

             A 函数和函数是平级关系，且只能定义在类中，不能在函数中嵌套函数

             B 函数只有被调用才会执行     

4、注意(掌握)                   

            无论函数的返回值是具体的数据类型还是void，任何函数都是以return语句结束的     

5、函数的调用(理解)                   

            A 有明确返回值函数的调用                            

                单独调用//没有意义                            

                输出调用//视频中老师用的最多的                            

                赋值调用//开发中用的最多的                   

            B  没有明确返回值函数的调用                            

                单独调用     

6、函数的重载-overload(掌握)                   

        概念                             

            在同一个类中，函数名相同，参数列表不同(参数类型和个数)，与返回值类型无关                   

        举例                              

  1. classDemo{

  2.      publicstaticvoid print(int x,int y){}

  3.      publicstaticvoid print(int a,int b,int c){}

  4.      publicstaticvoid print(double a){}

  5.      publicstaticvoid print(int a){}

  6. }

 

7、案例(掌握)

                    1、有明确返回值的案例

                             A求两个数据和

                             B 求两个数据的最大值

                             C 比较两个数是否相等

                    2、没有明确返回值的案例

                             A 打印矩形案例                             

                             B 打印99乘法表

2、数组(掌握)

1、概念(掌握)

                  数组是存储多个同一类型数据元素的容器(container)

 2、好处(理解)                  

                数组中的元素会被自动从0开始编号，方便我们获取     

3、格式(掌握)

                  A int[] arr =new int[2];            //念法:int类型的数组arr

                  B int arr[] = new int[2];              //念法:int 类型的arr数组,不推荐这么写,他和第一种格式其实一样的

                  C int[] arr = new int[]{1,2,3,7};  //大括号内可以没有任何东西

                  D int[] arr = {3,4,65,4};            //大括号内可以没有任何东西                       

 

                  推荐使用A D ,C存在的意义：作为实际参数传递

                  获取数组的长度：变量名.length;     

     4、内存图(理解)

                  堆：所有new出来的东西都在堆里

                  1、每一个实体都有地址值
                  2、每一个实体内的内容都有默认值

整数:         0
浮点数:      0.0
字符:         ’\u0000’  //char c = ‘\u0000’;
布尔:         false

                    技术分享

5、数组操作(掌握)                  

            1、数组遍历 

  1. int[] arr ={1,3,5,6,3,5,2};

  2. for(int i=0; i<arr.length; i++){

  3.      int element = arr[i];     \\element:元素

  4.      System.out.println(element);

  5. }               

            2、获取数组最值

  1. /*
  2. 方式一：临时变量为元素值
  3. 思路：
  4. 1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。
  5. 通过一个变量进行临储。
  6. 2，让数组中的每一个元素都和这个变量中的值进行比较。
  7. 如果大于了变量中的值，就用该该变量记录较大值。
  8. 3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。
  9. */
  10. publicstaticint getMax(int[] arr)
  11. {
  12. int max = arr[0];
  14. for(int x=1; x<arr.length; x++)
  15. {
  16. if(arr[x]>max)
  17. max = arr[x];
  18. }
  19. return max;
  21. }
  23. /*
  24. 方式二：临时变量为角标
  25. 初始化为数组中任意一个角标。
  26. */
  28. publicstaticint getMax_2(int[] arr)
  29. {
  30. int max =0;
  31. for(int x=1; x<arr.length; x++)
  32. {
  33. if(arr[x]>arr[max])
  34. max = x;
  35. }
  36. return arr[max];
  37. }
 

                                    

            3、数组查找：给定一个值，查找该值在数组中对应的索引

  1. int[] arr ={1,3,5,6};
  2. //查找5所定义应的角标
  3. int index = getIndex(arr,5);
  4. /**
  5. 查找元素所对应的角标
  6. */
  7. publicstaticint getIndex(int[] arrays,int element){
  8.   for(int i=0; i<arrays.length; i++){
  9.     if(arrays[i]== element){
  10.       return i;
  11.    }
  12.  }
  13. }
 
        4、数组间元素的拷贝:将A数组中的元素拷贝到B数组中
  1. import java.util.Arrays;
  4. publicclassArrayUtil{
  6. publicstaticvoid main(String[] args){
  7. int[] arr1 ={1,3,5};
  8. int[] arr2 ={1,6,3};
  11. copy(arr2, arr1);
  12. System.out.println(Arrays.toString(arr1));
  13. System.out.println(Arrays.toString(arr2));
  14. }
  15. /**
  16. * 将arr1数组中的元素拷贝到arr2中,前提：两个数组的长度必须一致
  17. * 需要的知识点：数组的遍历，数组中元素的获取，数组中元素的修改
  18. * @param arr1
  19. * @param arr2
  20. */
  21. publicstaticvoid copy(int[] arr1,int[] arr2){
  22. int length = arr1.length>arr2.length?arr2.length:arr1.length;
  23. for(int i=0; i<length; i++){
  24. arr2[i]= arr1[i];
  25. }
  26. }
  27. }
 
 

6、常见问题(掌握)

                 A 数组越界异常：

                        ArrayIndexOutOfBoundsException                         

                        你访问了不存在的索引。                  

                B 空指针异常:

                        NullPointerException                         

                        一个实例(对象)已经不存在了，你还去访问它的内容      

7、二维数组(理解)

                  A 格式

                         第一种定义通过定义长度的方式定义了二维数组的长度，并且定义了一维数组的长度 int[][] arr = new int[6][3]

                         第二种定义通过长度仅定义了二维数组的长度，没有初始化一维数组int[] [] arr= new int[2][]

                         第三种定义通过直接给出元素定义了二维数组的长度和每一个一维数组的长度 int[][] arr = {{2,23},{33}}

                  B 案例                         

                    抽烟案例                              

                            

  1. /**
  2. 一条烟中10包烟
  3. 每包烟有20支烟
  4. 那么就把一条烟看成一个二维数组，里面的包是一维数组
  5. */
  6. classSmokeDemo
  7. {
  8.     publicstaticvoid main(String[] args)
  9.     {
  10.          int[][] tiaoyan =newint[10][20];
  11.        
  12.          tiaoyan[9]=newint[2];
  13.        
  15.          for(int i=0; i<tiaoyan.length; i++)
  16.          {
  17.               int[] baoyan = tiaoyan[i];
  18.               for(int j=0; j<baoyan.length; j++)
  19.               {
  20.                    System.out.println("正在抽第"+(i+1)+"盒烟中的第"+(j+1)+"根烟");
  21.               }
  22.          }
  23.     }
  24. }
 
 

3、今天必须掌握的内容。以及常见的笔试题和面试题(学完这个就可以放心学习后面的知识了)

 
对于基本类型数组来说里面的每一个元素存的是数值，对于引用类型数组来说里面的每一个元素存的是地址值
1、谈谈什么是方法以及方法的声明格式
2、谈谈方法的调用以及注意事项(注意事项就是方法的特点)
      分为有返回值方法和无返回值方法的调用，详情见上面
3、谈谈什么是数组以及一维数组的声明格式
        详情见上面
4、如何操作数组中的元素
        数组名[索引]来操作数组中的元
5、如何获取数组中的最值
        详情见上面
6、数组中常见的两个异常以及异常产生的原因
7、说说方法的重载
 
8、练习的代码：数组的遍历，获取数组中的最值，查询某个数据在数组中的索引，数组中元素的拷贝。
9、定义一个reverse(int[] arr)方法,将数组中的元素反转,比如{1,2,3}反转后就是{3,2,1}
10、求两个数的和
11、求两个数中的最大值
13、定义两个equals方法，一个用于比较两个int是否相同，另一个用于比较两个double是否相同
14、定义方法，在可控制太打印矩形
15、什么时候定义有返回值类型的方法，什么时候定义无返回值类型的方法
        刚开始，需求会写明，需求明确说要有返回值那就定义返回值，需求明确说不需要，就不需要定义返回值。后期随着知识的增加我们会详细的去分析，但是目前掌握到这种程度就好
 



来自为知笔记(Wiz)



Day05_JAVA语言基础第五天


联系
我们