Java:79-93 【方法：调用、重载】【数组：初始化、访问、异常、遍历】

• 方法：可以在程序中反复被调用

1. 三种调用方式
2. 返回值和参数列表确认
3. 执行流程

   package 第五章;
   /*
     方法：
       1.方法是并列关系，不可以嵌套（即写在里面）
       2.方法没有先后顺序
       3.一个方法如果要运行，一定要进行调用
       4.标准格式：
           修饰词 返回值类型 方法名称(参数列表){
           方法体;
           return 返回值;
           }
           (1)修饰词：public static
           (2)返回值类型：方法执行完之后，要给出的结果类型
           (3)方法名：符合java标识符规则，"见名知意"，符合"小驼峰命名法"
           (4)参数列表：方法执行过程中要用的数据，可以为一个或多个（为多个时使用逗号隔开）
                      如果方法在执行过程中不需要使用调用者给的数据，则没有参数列表，即为()
           (5)方法体：执行方法的业务代码
           (6)return：1.单独使用：表示结束return所在的整个方法/函数
                     2.return 返回值：需要使用在要求有值返回的方法中，一般写在最后一行
       5.方法调用：
           (1)单独调用：方法名称(参数列表);  //方法名称();
           (2)打印调用：System.out.println(方法名称(参数列表));
           (3)赋值调用：数据类型 变量名称 = 方法名称(参数列表);
           注：方法没有返回值时【为void并且没有return】，只能使用单独调用【例：九九乘法表】
              方法有返回值的时候，三种调用方式都可以用
       6.方法的返回值和参数列表：
           (1)参数列表有无、方法返回值类型有无都依据当前业务需求
           (2)开发方法三要素：
                1.返回值类型：如果一个方法执行完成后，需要给调用者一个结果，并且返回值类型与return后的数据类型需一致
                            否则，返回值类型就为void
                2.方法名称：
                3.参数列表：如果方法完成需要一些数据才能实现，那么该方法就要有参数列表【多个参数用逗号分隔】
                          如果方法不需要任何数据条件就可以完成，那么该方法就不需要参数列表【无参数：()内无任何内容】
       7.方法执行流程：
           (1)先从调用者函数里进行调用，将要计算的值传递给调用的方法
           (2)方法接收后进行计算，然后将结果反馈给调用者
           (3)调用者接受到反馈的结果后进行使用或输出
    */
   public class Method {
       public static double sum(double num1,int num2,int num3){
           System.out.println("方法执行了！");
           double result = num1+num2+num3; //3.被main调用将值传输过来后进行计算
           return result;  //4.将计算后的值反馈给main方法里的a
       }
       public static void main(String[] args) {
           //单独调用
           System.out.println("单独调用");
           sum(1,2,3); //这里num1 num2 num3的值是1 2 3，但是结果没有输出
           System.out.println();
           //打印调用
           System.out.println("打印调用");
           System.out.println(sum(1,5,10));  //这里num1 num2 num3的值是1 5 10
           System.out.println();
           //赋值调用
           System.out.println("赋值调用");
           double a = sum(1,3,5); //1.main方法调用sum方法 2.将1 5 10三个值传到sum方法里进行运算
           System.out.println("a接受到的值为："+a); //5.将返回的a的值接收后输出
           System.out.println();
   
           //单独调用------九九乘法表
           method(); //method被调用以后会变为橙色，没调用为灰色
           //打印调用------九九乘法表
           //System.out.println(method()); //写法错误，编译报错，因为该方法没有返回值
           //赋值调用------九九乘法表
           //void b = method();  写法错误，编译报错，因为该方法没有返回值,不能实现对其它变量的赋值
           System.out.println();
   
           //boolean调用
           method1(2,5); //直接调用
           System.out.println(method1(3,3)); //打印调用
           boolean c = method1(3,4); //赋值调用-1
           System.out.println(c); //赋值调用-2
       }
   
       //九九乘法表------【无返回值】---内部数据是固定的，给谁都是九行九列，必须不变！
       public static void method(){ //void：空返回值类型---自行完成结果，不需要向调用者反馈，自行打印乘法表结果
           for(int i=1;i<=9;i++){
               for(int j=1;j<=i;j++){
                   System.out.print(j+"*"+i+"="+(j*i)+"\t");
               }
               System.out.println();
           }
       }
   
       //boolean返回调用
       public static boolean method1(int a, int b){
   //        方法一：
   //        if(a==b){
   //            return true;
   //        }else{
   //            return false;
   //        }
   //        方法二：
             return a==b; //a==b本身就是boolean类型的值，优先推荐此写法
   //        方法三：三元运算
   //        boolean result;
   //        result = a==b? true : false;
   //        return result;
       }
   }
   

   单独调用
   方法执行了！
   
   打印调用
   方法执行了！
   16.0
   
   赋值调用
   方法执行了！
   a接受到的值为：9.0
   
   1*1=1	
   1*2=2	2*2=4	
   1*3=3	2*3=6	3*3=9	
   1*4=4	2*4=8	3*4=12	4*4=16	
   1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
   1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
   1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
   1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
   1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	
   
   true
   false

4. 方法重载
5. 重载多样性

   package 第五章;
   /*
       8.方法重载(Overload)：
          (1)解决的问题：对于功能类似的方法而言(功能相同但方法名称太多导致不必要的麻烦，因此提出方法重载的概念)
          (2)本质：多个方法名称相同，参数列表不同
          (3)重载多样性：1.参数个数不同
                       2.参数类型不同
                       3.多个类型的参数顺序不同
          (4)方法的重载与返回值类型无关（即static后的类型），因此不可以通过方法的返回值来判断方法是否发生重载
          (5)方法的重载与参数名也无关（即()内的参数名称）
          (6)也就是说：方法重载方法名要相同，除此之外只与参数列表有关【多样性三个】
    */
   public class Overload {
       public static void main(String[] args) {
           System.out.println(method(10,100,1000)); //执行4，都是method方法名，用哪个取决于参数列表个数
           System.out.println(method(5.6,5)); //执行2，会舍弃小数，而不是四舍五入
           System.out.println(method(1,2.14)); //执行3，会舍弃小数，而不是四舍五入
           System.out.println(method(5,10)); //执行1
           System.out.println(method(1,2,3,4)); //执行5
       }
       //1.比较对象---2个参数
       public static int method(int num1,int num2){
           System.out.println("两个参数"); //用于验证执行哪个方法
           int result = num1+num2;
           return result;
       }
       //2.类型不同
       public static int method(double num1,int num2){ //和1类型不同：将double类型强转为int型
           System.out.println("类型不同");
           int result = (int)(num1+num2);
           return result;
       }
       //3.类型不同，顺序不同
       public static int method(int num1,double num2){ //和2多个类型的参数顺序不同
           System.out.println("类型和顺序不同");
           int result = (int)(num1+num2);
           return result;
       }
       //4.个数不同---3个
       public static int method(int num1,int num2,int num3){ //和1和5个数不同
           System.out.println("个数不同--3个参数");
           int result = num1+num2+num3;
           return result;
       }
       //5.个数不同---4个
       public static int method(int num1,int num2,int num3,int num4){ //和1和4个数不同
           System.out.println("个数不同--4个参数");
           int result = num1+num2+num3+num4;
           return result;
       }
   //    //方法重载与返回值类型无关----因为将5 10传输过来后，()里两个都是int型，程序不知道执行这个还是1，会报错
   //    public static double method(int num1,int num2){
   //        System.out.println("两个参数");
   //        double result = num1+num2;
   //        return result;
   //    }
   
   //    //方法重载与参数名称也无关
   //    public static int method(int a,int b){ //因为()内的参数名称都是该方法的局部变量，只在该方法起作用
   //        System.out.println("两个参数");     //执行只传递值，因此两个方法即使参数名不同也会被认为相同而报错
   //        double result = num1+num2;
   //        return result;
   //    }
   }
   

   个数不同--3个参数
   1110
   类型不同
   10
   类型和顺序不同
   3
   两个参数
   15
   个数不同--4个参数
   10

• 方法练习：

  package 第五章;
  /*
    例题：
      1.比较两个数是否相等
        【参数类型分别为：两个byte类型，两个short型，两个int类型，两个long类型，并在main方法中进行测试】
      2.模拟输出语句中的println方法效果，传递什么类型的数据就输出什么类型数据，只允许定义一个方法名println
   */
  public class Demo1_Method {  //byte、short、int、long都为整型
      public static void main(String[] args) { //要转换为整数是因为这四种类型都为整数，不强制转换会报错
          //两数比较：
          System.out.println(method((byte)1.2,1)); //byte
          System.out.println(method((short)1.2,(short)2.3)); //short
          System.out.println(method((int)2.5,2)); //2.5为输入要进行比较的数字，要调用int方法就要将2.5转换
          System.out.println(method((long)1.11,(long)2.22)); //long
          //输出println
          System.out.println(println("张三")); //String
          System.out.println(println((double)11)); //double
          System.out.println(println(0.1f)); //float
          System.out.println(println((byte)100.567)); //long
          System.out.println(println((char)14)); //char
      }
      //1.两数比较
      public static boolean method(byte a1,byte a2){  //byte
          return a1==a2;
      }
      public static boolean method(short a1,short a2){  //short
          if(a1==a2){
              return true;
          }else{
              return false;
          }
      }
      public static boolean method(int a1,int a2){  //int
          boolean result;
          if(a1==a2){
              result = true;
          }
          else{
              result = false;
          }
          return result;
      }
      public static boolean method(long a1,long a2){  //long
          boolean result = a1==a2? true : false;
          return result;
      }
  
      //2.模拟输出println效果
      public static String println(String a){
          System.out.println("传递的为String："+a);
          return a;
      }
      public static double println(double a){
          System.out.println("传递的为double："+a);
          return a;
      }
      public static float println(float a){
          System.out.println("传递的为float："+a);
          return a;
      }
      public static byte println(byte a){
          System.out.println("传递的为byte："+a);
          return a;
      }
      public static long println(long a){
          System.out.println("传递的为long："+a);
          return a;
      }
      public static char println(char a){
          System.out.println("传递的为char："+a);
          return a;
      }
      
  //    //3.判断是否可以发生重载----(1)方法名相同  (2)参数：个数、类型、多类型参数顺序，至少满足一个不同
  //    public static void sum(){}  //可以
  //    public static void sum(int x){}  //可以
  //    public void sum(int x, int b){}  //不可以
  //    public static void sum(double num1, double num2){}  //可以
  //    public static void sum(int x, double y){}  //不可以，和后面一行代码冲突，参数类型相同
  //    public void sum(int a, double b){}  //不可以，和前面一行代码冲突，参数类型相同
  //    public static void Sum(){}  //不可以，Sum中S大写，是一个单独的方法，没法发生重载
  //    void sum(int i, int j){}  //不可以
  }
  

  true
  false
  true
  false
  传递的为String：张三
  张三
  传递的为double：11.0
  11.0
  传递的为float：0.1
  0.1
  传递的为byte：100
  100
  传递的为char：
  

• 数组：

1. 初始化
2. 数组访问
3. 常见异常
4. 遍历

   package 第五章;
   /*
     数组：
        1.用于存放相同数据类型的多个数据
        2.特点：(1)数组为引用数据类型
               (2)存储的数据为相同的数据类型
               (3)数组长度在运行期不可改变
        3.数组初始化：
            (1)静态初始化【指定内容】
               标准格式：数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3,...};
               省略格式：数据类型[] 数组名 = {数据1,数据2,数据3,...};
               分两步格式：数据类型[] 数组名;
                         数组名 = new 数据类型[]{数据1,数据2,数据3,...};
               注：省略格式不可以拆分为分两步格式写
                  右边[]内数组长度不可以写，否则报错
                  左右两边数据类型要一致
            (2)动态初始化【指定长度】---默认值
               标准格式：数据类型[] 数组名 = new 数据类型[数组长度];
               分两步格式：数据类型[] 数组名;
                         数组名 = new 数据类型[数组长度];
               其中：数据类型：用于指定开辟多大的内存空间
                    new：java关键字，用于开辟空间
                    数组长度：表示数组中存储的数据的个数
               注：左右两边数据类型要一致
        4.长度计算：格式：int len = 数组名.length;  注：不论数组为什么数据类型，长度都为int型
        5.数组的访问：
            (1)直接输出数组名称，得到的不是数据内容，而是数组对应的内存地址：哈希值【通过16进制表示】
               二进制：01  八进制：01234567  十进制：0123456789  十六进制：0123456789abcdef
            (2)访问方式：下标访问---格式：数组名[索引值]  注：索引值为一个整数，表示当前数组中元素的编号
            注：1.如果数组长度为n，那么数组最大的下标值为n-1【因为第一个元素为数组第0项】
               2.使用动态方式初始化数组后，数组就会有默认值存在
                 规则：整数类型：默认值为0 【byte、short、int、long】
                      字符类型：'\u0000' 【char】【是不可见字符】
                      浮点数类型：默认值为0.0 【float、double】
                      布尔类型：false
                      引用数据类型：null 【Java严格区分大小写，不可以写为Null】
        6.数组常见异常：
            (1)数组下标越界----例：int[] arry7 = {}; 输出arry[0]
            (2)空指针异常----例：int[] arry8 = null;
        7.数组的遍历：
            (1)本质：对数组所有元素逐个访问，从0到n-1
    */
   public class Array {
       public static void main(String[] args) {
           //动态初始化
           String[] arry1 = new String[10]; //创建一个数组，用于存放10个长度的字符串
           int[] arry2;
           arry2 = new int[100]; //分两步格式
           char[] arry6 = new char[3];
           //静态初始化
           int[] arry3;
           arry3 = new int[]{1,2,3,4}; //分两步格式----省略格式不可以拆分为分两步
           String[] arry4 = new String[]{"Hello","Java","c++"}; //标准格式
           double[] arry5 = {1.1,2.2,3.3}; //省略格式
   
           //计算数组长度
           int len = arry5.length; //写法一
           System.out.println("arry5的长度为："+len);
           System.out.println("arry5的长度为："+arry5.length); //写法二
   
           //数组访问
           System.out.println(arry1); //直接输出数组名会得到数组内存地址：[Ljava.lang.String;@1b6d3586
           //哈希值--- [：代表数组  String：代表数据类型  @1b6d3586：哈希值，以16进制表示
           int a = arry3[0]; //下标访问：【0为第一个元素】
           System.out.println(a); //写法一
           System.out.println(arry3[3]); //写法二
   
           //动态初始化后默认值
           arry2[5]=1000;
           System.out.println(arry2[5]); //如果初始化后进行赋值，则输出赋的值
           System.out.println(arry1[0]); //String为引用数据类型，初始化后没有赋值，则输出默认值null
           System.out.println("byte、short、int、long默认值："+arry2[0]); //输出0
           System.out.println("char默认值："+arry6[0]); //输出为空，因为char默认值为不可见字符
           System.out.println("float、double默认值："+arry5[0]); //输出1.1，因为是静态化初始数组，已经有值
           System.out.println();
   
           //数组遍历
           int[] arry9 = new int[5];
           for(int i=0;i<5;i++){
               System.out.println(arry9[i]);
           }
           System.out.println("=============");
           int[] arry10 = new int[]{9,9,9,9,9,9,9};
           for(int j=0;j<arry10.length;j++){  //写为j<arry10.length,是便于当数组长度改变时，不用修改循环值
               System.out.println(arry10[j]);
           }
   
           //常见异常
           System.out.println(arry2[100]); //下标越界---第1种
           int[] arry7 = {}; //下标越界---第2种
           System.out.println(arry7[0]);
           int[] arry8 = null; //空指针异常
           System.out.println(arry8[0]);
   //      注：三个异常编译只提示第一个，要输出后面的要讲前面的异常注释掉
   
           //快捷键使用
   //        arry1.fori
       }
   }
   

   arry5的长度为：3
   arry5的长度为：3
   [Ljava.lang.String;@1b6d3586
   1
   4
   1000
   null
   byte、short、int、long默认值：0
   char默认值： 
   float、double默认值：1.1
   
   0
   0
   0
   0
   0
   =============
   9
   9
   9
   9
   9
   9
   9
   Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
   	at 第五章.Array.main(Array.java:89)

5. 下标越界提示如下：
6. 空指针异常提示如下：

• 求数组最大值和最小值

  package 第五章;
  //求数组最大值最小值
  public class Demo2_Array_MaxMin {
      public static void main(String[] args) {
          int[] arr = {5,78,52,41,98};
          int max = arr[0];
          int min = arr[0];
          for (int i = 1; i < arr.length; i++) {
              if(arr[i]>max){
                  max = arr[i];
              }
          }
          System.out.println("max="+max);
          for (int i = 1; i < arr.length; i++) {
              if(arr[i]<min){
                  min = arr[i];
              }
          }
          System.out.println("min="+min);
      }
  }
  

  max=98
  min=5