zoukankan      html  css  js  c++  java
  • 05_方法和数组

    Day05笔记
    课程内容
    1、方法
    2、数组
    方法
    方法的概述
    1、概念:
         有些代码表示一个独立的功能,这个功能还经常使用,那么就把这段代码用大括号{}包起来,给这个代码起一个名字,将来只要写这个名字,就表示要调用这段代码。这段代码就是一个方法。
    2、定义格式:
         修饰符 返回值类型 方法名称 (参数列表) {
              方法体语句;
              return语句;
    }
    3、相关概念的解释:
         1、修饰符:描述方法的权限、静态、抽象。当前阶段全部都是public static
         2、返回值类型:
              当前方法生产出来的数据的数据类型
         3、方法名称:
              将来用于表示这段代码,一旦写出了方法名称,就表示要执行这段代码
              第一个单词的首字母小写,从第二个单词开始,首字母大写
    一般定义成一个动词或者动宾结构
         4、参数列表:
              表示这段代码在完成功能的过程中,需要获取的外界的资源
              在定义方法的时候,参数列表指的是:形式参数,只是表示一个不知道的数据
              声明参数的格式:数据类型1 变量名1, 数据类型2 变量名2
         5、方法体语句:
              真正要经常使用的代码,表示这段代码的真正功能和逻辑,表示真正完成这个功能        使用的代码
         6、return语句:
              这段代码最终生产出来的结果,结果数据的数据类型应该和返回值类型一致
              return也表示当前方法结束
    4、调用格式:
         方法名称(实际参数);
    5、方法调用内容解释:
         1、方法名称:
              不是定义方法,所以不需要写方法的返回值类型
         2、实际参数:
              真正确定方法中需要使用的资源,传入的是真正的数据(就一定是有初始化过的变        量或者是常量)
    代码示例
    class Demo01_方法定义 {
        public static void main(String[] args) {
            System.out.println("Hello World!");
            //盖饭 gf = 做饭(烂白菜, 镉大米, 地沟油);
            int a = 10;
            int b = 20;
            int sum = getSum(a, b);
            System.out.println(sum);
        }

        /*定义一个做饭的方法
        public static 盖饭 做饭(菜 c, 米 m, 油 y) {
            y热了
            c放入已经热了的y中
            对c进行搅拌
            把m蒸熟
            将熟了的c放到蒸熟的m上

            return cm;
        }
        */

        //定义求和的方法,可以计算两个数字的和
        //返回值类型:int,两个整数求和,结果还是一个整数
        //参数列表:int a, int b
        public static int getSum(int a, int b) {
            int sum = a + b;
            return sum;
        }
    }
    方法的注意事项
    1、调用的注意事项:方法定义出来之后,不调用就不会执行
         单独调用:不对方法进行输出、也不使用一个变量来接收方法的返回值,只是单独的对方法进行调用。方法只是完成某些功能,没有什么具体产出。
         输出调用:有返回内容的方法,可以进行输出调用。在输出语句中,输出的内容是一个方法的调用。其实输出的是这个方法的返回值。(只能对返回内容输出一次)
         赋值调用:有返回内容的方法,可以使用一个变量,接收方法的返回值。可以对这个变量反复使用。
    2、方法定义注意事项:
         1、方法不能嵌套定义,但是可以相互调用,甚至可以自己调用自己
         2、方法和方法都是平级关系
    3、参数列表:
         1、形式参数:表示将来要使用的那个数据,但是现在不清楚数据具体内容,所以使用一个变量来表示。需要加上数据类型(其实是对变量的声明),变量和变量之间使用逗号进行分割。
         2、实际参数:表示在方法调用时,真正使用的那个数据。(本质是对变量的赋值和使用)。不需要加上数据类型,参数和参数之间使用逗号分割。
    4、return语句:
         1、表示方法结束,用于表示方法返回内容
         2、如果方法有具体的返回内容,那么就必须有return语句,return后面就必须跟上一个具体的数据,这个数据的数据类型必须和方法声明中的返回值类型一致。
         3、如果方法没有具体的返回内容,那么就可以不写return语句,如果一定要写上return语句,可以写一个【return;】,用于表示方法结束。如果写的是return;或者是没写return语句,那么方法的返回值类型必须是void,表示没有任何返回内容
         4、返回值:一定是返回给方法的调用者。
    代码示例
    class Demo02_方法的注意事项 {
        public static void main(String[] args) {
            //直接调用
            printHL();
            //System.out.println(printHL());
            //输出调用
            System.out.println(getMax(10, 20));
            //赋值调用
            int max = getMax(10, 20);
            System.out.println(max);
        }

        //打印5次HelloWorld
        public static void printHL() {
            for (int i = 1; i <= 5; i++) {
                System.out.println("HelloWorld");
            }
            return;
        }

        //两个数据获取较大值方法
        public static int getMax(int a, int b) {
            int max = a > b ? a : b;
            return max;
        }
        /*打印25次HelloWorld
        public static void print() {
            //编译报错,方法不能嵌套定义
            public static void print5() {
            
            }

            print5
        }
        */
    }
    练习1
    定义一个方法,可以获取三个整数的最大值
    键盘录入三个整数,调用方法,获取最大值
    代码示例
    import java.util.Scanner;
    class Demo03_方法练习获取最值 {
        /*
        定义一个方法,可以获取三个整数的最大值
        键盘录入三个整数,调用方法,获取最大值
        */
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int x = sc.nextInt();
            int y = sc.nextInt();
            int z = sc.nextInt();
            int max = getMax(x, y, z);
            System.out.println("最大值为:" + max);
        }

        //获取三个整数最大值的方法,返回值类型int,参数列表int a, int b, int c
        public static int getMax(int a, int b, int c) {
            if (a > b && a > c) {
                return a;
            } else if ( b > a && b > c) {
                return b;
            } else {
                return c;
            }

            /*
            int max = a > b ? (a > c ? a : c) : (b > c ? b : c);
            return max;
            */
        }
    }
    练习2
    定义一个方法,判断两个整数是否相等
    键盘录入两个整数,调用方法,判断是否相等
    代码示例
    import java.util.Scanner;
    class Demo04_方法练习判断相等 {
        /*
        定义一个方法,判断两个整数是否相等
        键盘录入两个整数,调用方法,判断是否相等
        */
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int x = sc.nextInt();
            int y = sc.nextInt();
            boolean result = isEqual(x, y);
            System.out.println("这两个数字" + (result ? "" : "不") + "相等");
        }

        /*
            定义一个方法,判断两个整数是否相等
            返回值类型:boolean
            参数列表:int a, int b
        */
        public static boolean isEqual(int a, int b) {
            /*if (a == b) {
                return true;
            } else {
                return false;
            }

            return a == b ? true : false;*/

            return a == b;
        }
    }
    练习3
    定义一个方法,可以打印指定行数和列数的星星矩形
    键盘录入两个整数,分别表示行数和列数,调用方法,打印矩形
    代码示例
    import java.util.Scanner;
    class Demo05_方法练习打印矩形 {
        /*
        定义一个方法,可以打印指定行数和列数的星星矩形
        键盘录入两个整数,分别表示行数和列数,调用方法,打印矩形
        */
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int row = sc.nextInt();
            int col = sc.nextInt();
            printRect(row, col);
        }
        /*
            返回值类型:void,打印不是返回值
            参数列表:int row, int col
        */
        public static void printRect(int row, int col) {
            for (int i = 1; i <= row; i++) {
                //打印col个星星
                for(int j = 1; j <= col; j++) {
                    System.out.print("*");
                }
                //加一个换行
                System.out.println();
            }
        }
    }
    方法在内存中的情况
    Jvm虚拟机的内存划分
    1、jvm是运行java代码的容器,需要分成一些不同的区域,不同的区域有不同的特殊作用。
    2、区域的说明:
         1、栈内存:先进后出,对于方法先进后出。作用:执行方法的。【常用】
         2、堆内存:用于存储数据量较大的数据。比如数组、对象【常用】
         3、方法区:用于存储类的字节码对象,存储一些静态变量,存储常量【常用】
         4、本地方法区:和本地方法相关,在java代码中,有一些要和C语言代码交互的方法,称为本地方法,加上native关键字的就是本地方法。
         5、寄存器:和cpu有关,用于控制代码的执行流程,和程序计数器有关。
    方法调用时内存描述
    1、方法调用的步骤
         1、启动jvm虚拟机之后,默认调用main方法,就会在栈内存中,开辟一块空间,专门用于主方法中变量的声明和计算,形象的称为“方法进栈”,这个专门用于执行当前方法的区域,称为“栈帧”
         2、主方法中调用了其他的方法,在主方法不出栈的前提下,其他方法进栈,主方法将自己的一些数据传递给被调用的方法,被调用方法,执行完成之后,将结果返回给主方法,被调用的方法出栈
         3、继续执行主方法
    2、图示:
         
    方法的重载
    1、没有方法重载的时候:
         很多方法,逻辑相似的,但是参数列表是不同的,就需要有很多的方法名称。
         调用者(程序员)需要记忆很多的方法名称,就非常不方便。
         希望逻辑相似的代码,参数不同的方法,可以使用相同的方法名称。
    2、方法重载:
         定义:在同一个类中,方法名相同,参数列表不同,与返回值类型无关【记忆】
         名称:重载,overload,超载
    3、注意事项:
         1、在同一个类中,不能是无关类、也不能是子父类,必须是同一个类
         2、方法名称相同:连大小写都必须一模一样
         3、参数列表不同:
              参数的数据类型不同
              参数的个数不同
              参数的数据类型的顺序不同
              【注意】参数的名称不同,不能认为成参数列表不同,而是参数列表相同
         4、与返回值类型无关:调用方法的时候,无法判断需要什么返回值类型,所以相同方法名称,相同的参数列表,不同的返回值类型,对于虚拟机而言,没有任何区别,无法区分到底应该调用哪个方法
    代码示例
    class Demo06_方法的重载 {
        public static void main(String[] args) {
            int a = 10;
            int b = 20;
            int c = 30;
            /*System.out.println(getSum2(a, b));
            System.out.println(getSumD2(12.34, 43.21));
            */
            System.out.println(getSum(a, b));
            System.out.println(getSum(1, 2, 3));
            System.out.println(getSum(12.34, 43.21));
            
            System.out.println(getSum(1, 2.0));
            System.out.println(getSum(1.0, 2));


        }
        /*
        public static double getSum(int a, int b) {
            return a + b;
        }

        定义方法,计算int和double的和
        public static double getSum(int i, double d) {
            return i + d;
        }*/

        //定义方法,计算int和double的和
        public static double getSum(int a, double b) {
            System.out.println("int + double 被调用了");
            return a + b;
        }

        //定义方法,计算double和int的和
        public static double getSum(double a, int b) {
            System.out.println("double + int 被调用了");
            return a + b;
        }

        //定义方法,计算两个int的和
        public static int getSum(int a, int b) {
            return a + b;
        }
        //定义方法,计算三个int类型的和
        public static int getSum(int a, int b, int c) {
            return a + b + c;
        }
        //定义方法,计算两个double的和
        public static double getSum(double a, double b) {
            return a + b;
        }

        /*
        //定义一个方法,计算两个int类型数据的和
        public static int getSum2(int a, int b) {
            return a + b;
        }

        //定义一个方法,计算三个int类型数据的和
        public static int getSum3(int a, int b, int c) {
            return a + b + c;
        }

        //定义一个方法,计算两个double类型数据的和
        public static double getSumD2(double a, double b) {
            return a + b;
        }
        */
    }
    数组
    数组的概述
    1、数组:用于存储相同数据类型的数据的,容器
    2、使用数组的原因:
         如果没有数组,所有的变量都需要使用变量名称,变量名称过多的时候,就不方便操作,变量和变量之间,没有关系,没有固定的规律。
         数组的解决方案:只需要有一个容器的名称,容器中每个位置都有自己的序号,元素存储进来之后,就可以通过【容器名称 + 元素序号】来获取和修改这个位置的元素。本质:就是通过有规律的序号,访问没有规律的元素内容。
    3、数组的定义方式:
         元素的数据类型[] 数组名称 = new 元素的数据类型[数组的大小];
    4、数组的定义解释:
         元素的数据类型:在数组中有数据,就称为元素,数据的类型就是元素类型
         []:表示当前数组是一个一维数组
         数组的名称:数组本身也是一个变量,有自己的变量名称
         =:赋值符号,将=后面创建出来的数组的地址,赋值给=前面的变量
         new:在堆内存中开辟一块存储空间
         数组的大小:数组是一个容器,有存储的空间,能存储多少数据,数组的大小就是多少
    5、打印内容的解释:[I@15db9742
         1、[:表示一个一维数组
         2、I:表示数组中存储的数据类型是int
         3、@:表示一个普通的分隔符
         4、15db9742:数组有一个内存地址,通过hashCode方法,将内存地址计算成一个数字,称为哈希码值,转成十六进制,15db9742
         说明:简称这个打印的内容为:数组的内存地址
    代码示例
    class Demo07_数组的定义 {
        public static void main(String[] args) {
            //定义一个int类型的数组
            int[] arr = new int[3];
            System.out.println(arr);
        }
    }
    数组的初始化
    1、初始化:给数组的数据分配内存空间,并且给元素赋值
    2、分类:动态初始化、静态初始化
    3、动态初始化:
         元素的数据类型[] 数组名称 = new 元素的数据类型[数组中元素的个数]
         数组中的元素赋值:
              数组名称[元素的索引] = 元素值;
         注意事项:
               1、所有的元素,都需要使用这个格式来一一赋值
              2、元素的索引:从0开始,到元素个数-1结束
              3、如果没有给元素赋值,那么数组的元素有一个默认的初始化值,0
    4、静态初始化:
         元素的数据类型[] 数组名称 = new 元素的数据类型[]{元素值的罗列}
         注意事项:
              1、在后面的方括号中,不要写任何元素个数
              2、元素值的罗列,使用逗号分割
              3、罗列的元素,数据类型必须和声明中的元素数据类型一致
              4、静态初始化有一个简写的格式【常用】
                   元素的数据类型[] 数组名称 = {元素值的罗列};
                   这种写法,不能将数组的声明和数组的赋值分离开
    代码示例1
    class Demo08_数组的动态初始化 {
        public static void main(String[] args) {
            int[] arr = new int[3];
            //默认的初始化值
            System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
            arr[0] = 10;
            arr[1] = 20;
            arr[2] = 30;
            System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
        }
    }
    代码示例2
    class Demo09_静态初始化 {
        public static void main(String[] args) {
            int[] arr = new int[]{10, 20, 30};
            System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
            //编译报错,不能在静态初始化格式中,参与动态初始化的格式
            //int[] arr2 = new int[3]{10, 20, 30};
            //编译报错,后面的元素值,和声明不符
            //int[] arr3 = new int[]{12.34, 23.45, 43.21};

            int[] arr4 = {100, 200, 300};
            System.out.println(arr4[0] + "..." + arr4[1] + "..." + arr4[2]);


            int[] arr5;
            arr5 = new int[]{11, 22, 33};

            int[] arr6;
            arr6 = {666, 888};
        }
    }
    数组在内存中的理解
    一个数组的内存图
    1、创建数组在内存中的过程:
         1、在栈内存中声明一个引用,将来存储数组的地址
         2、在堆内存中开辟一块空间,存储元素
         3、给数组中的元素进行默认的初始化赋值,都变成了0
         4、将堆内存中的数组的地址,赋值给栈内存中的引用
    2、图示:
       
    3、代码示例
    class Demo10_一个数组的内存图 {
        public static void main(String[] args) {
            int[] arr = new int[3];
            System.out.println(arr[1]);
            arr[1] = 666;
            System.out.println(arr[1]);
        }
    }
    两个数组的内存图
    1、说明:
         只要碰到了new关键字,一定是要在堆内存中开辟一块新的空间
    2、图示:
       
    3、代码示例
    class Demo11_两个数组的内存图 {
        public static void main(String[] args) {
            int[] arr1 = new int[3];
            arr1[1] = 666;
            int[] arr2 = new int[3];
            arr2[1] = 888;
            System.out.println(arr1[1] + "..." + arr2[1]);
        }
    }
    两个引用指向同一个数组
    1、说明:
         两个引用中记录的是同一个数组的地址
         通过任意一个引用操作了数组中的内容,将来通过另一个引用找到数组之后,都是改变过的情况
    2、图示:
       
    3、代码示例
    class Demo12_两个引用指向同一个数组 {
        public static void main(String[] args) {
            int[] arr1 = new int[3];
            arr1[1] = 666;
            int[] arr2 = arr1;
            arr2[1] = 888;
            System.out.println(arr1[1] + "..." + arr2[1]);
        }
    }
    数组的异常
    异常
    1、例外情况:代码中,程序中,出现了和生活中不太相符的情况,就是例外情况,将这种情况封装成一个对象,称为“异常对象”。有了异常之后,就可以结束程序或者跳转程序。
    2、在数组操作过程中,经常出现的两个异常:
         数组索引越界异常
         空指针异常
    数组索引越界异常
    1、Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
         异常   在  线程  主          数组索引 超过了边界   异常:数组索引越界异常
    2、原因:访问了数组中不存在的索引
    3、避免:不要访问数组中不存在的索引
    class Demo13_数组索引越界异常 {
        public static void main(String[] args) {
            int[] arr = {11, 33, 55};
            arr[0] = 666;
            arr[1] = 888;
            arr[2] = 999;
            arr[3] = -666;
        }
    }
    空指针异常
    1、Exception in thread "main" java.lang.NullPointerException
         异常   在  线程  主             空   指针  异常:空指针异常
    2、原因:
         栈内存中的引用,为空,不再指向任何堆内存中的数据,但仍然要强行访问堆内存中的数据。
    3、指针:是C语言中的概念,指针类型的变量,存储的不是具体的数据,而是指的数据的地址。在java中已经不能直接操作内存地址,该这个指针类型为【引用类型】。空指针异常,其实就是空引用异常,都是表示无法获取数据的地址。
    4、避免:在操作任何一个引用之前,可以先判断这个引用是否为null,如果为null,就不进行操作。
    class Demo14_空指针异常 {
        public static void main(String[] args) {
            int[] arr = {11, 22, 33};
            System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
            arr = null;
            if (arr != null) {
                System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
            }
        }
    }
    数组的操作
    数组的遍历
    1、遍历:把数组中的每个元素都获取出来,对每个元素进行输出
    2、方法:获取到所有的元素的索引,根据索引获取到元素
    3、索引范围:0~元素的个数-1
    4、获取元素个数:数组名称.length
    class Demo15_数组的遍历 {
        public static void main(String[] args) {
            int[] arr = {11, 33, 55, 22, -66};
            //遍历这个数组,获取所有的索引
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println();
        }
    }
    数组获取最值
    1、数组中有若干元素,获取数组的最大值
    2、声明一个最大值变量
    数组的反转
    1、数组中有若干元素,将第一个元素和最后一个元素交换,第二个元素和倒数第二个元素交换
    数组的查找
    1、数组中有若干元素,找到某个指定值,在数组中的索引

  • 相关阅读:
    HDU 5835 Danganronpa 贪心
    HDU 5842 Lweb and String 水题
    HDU 5832 A water problem 水题
    Codeforces Beta Round #14 (Div. 2) A. Letter 水题
    Western Subregional of NEERC, Minsk, Wednesday, November 4, 2015 Problem K. UTF-8 Decoder 模拟题
    Western Subregional of NEERC, Minsk, Wednesday, November 4, 2015 Problem I. Alien Rectangles 数学
    Western Subregional of NEERC, Minsk, Wednesday, November 4, 2015 Problem H. Parallel Worlds 计算几何
    Western Subregional of NEERC, Minsk, Wednesday, November 4, 2015 Problem F. Turning Grille 暴力
    Western Subregional of NEERC, Minsk, Wednesday, November 4, 2015 Problem C. Cargo Transportation 暴力
    Western Subregional of NEERC, Minsk, Wednesday, November 4, 2015 Problem G. k-palindrome dp
  • 原文地址:https://www.cnblogs.com/man-tou/p/10635884.html
Copyright © 2011-2022 走看看