Java06--方法+重载+数组

1 方法

1.1 概述

被命名的代码块，方法可以含参数可以不含参数

可以提高代码的复用性

1.2 形式

修饰符  返回值  方法名(【参数】){
       方法体;
}

1.3 练习1：方法调用

package day0203_平年闰年;
public class Test1_方法 {
       public static void main(String[] args) {
              System.out.println(1);
              f();
System.out.println(2);
       }
       private static void f() {
              System.out.println(3);//132
       }
}

1.4 练习2：方法参数

package day0203_平年闰年;
public class Test1_参数 {
       public static void main(String[] args) {
                     System.out.println(1);
                     f(2);
                     System.out.println(2);
              }
       static void f(int x){
              System.out.println(x*x);//142
       }
}

1.5 练习3：方法返回值

package day999;
public class tt {
       public static void main(String[] args) {
              System.out.println(1);
              int num=f3(5);
              System.out.println(num);
              String str = f4("学习使我快乐");
              System.out.println(str);
              System.out.println(2);
       }
       public static String f4(String desc){
              return desc+",我信你个鬼";
       }
       public static int f3(int i){
              return i*10;
       }
}

2 方法的重载

2.1 概念

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数列表(也就是说参数的个数和类型不同)。

程序调用方法时，可以通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法。

2.2 练习1：数字求和

package day005;
public class Test5_方法重载 {
       public static void main(String[] args) {
              int a=10;
              int b=20;
              String name="lisi";
              f1();
              f1(a);
              f1(a,b);
              f1(a,b,name);
       }
       private static void f1(int a, int b, String name) {
              System.out.println(a+b+name);//30name
       }
       private static void f1() {
              System.out.println("f1()");
       }
       private static void f1(int a) {
              System.out.println(a);
       }
       private static void f1(int a, int b) {
              System.out.println(a+b);
       }     
}

2.3练习2：数字的打印

3 数组

3.1 概念

数组Array是用于储存多个相同类型数据的集合。

想要获取数组中的元素值，可以通过元素的下标来获取，下标是从0开始的。

3.2 创建数组

一般分为动态初始化和静态初始化
动态初始化：int[] a = new int[5];
新建int[],长度是5

刚创建好的数组都是默认值0，int类型的数据默认值是0

把数组的地址值给变量a保存

静态初始化1：int[] a ={1,2,3,4,5,6,7,8};
静态初始化2：int[] a =new int[]{1,2,3,4,5};

3.3 练习1：数组中存入hello

package day004;
import java.util.Arrays;
public class Test6_数组 {
       public static void main(String[] args) {
              System.out.println("test...");
              f1();
       }
       private static void f1() {
           int[] i = new int[]{1,2,3,4,5};
              System.out.println(Arrays.toString(i));
              char[] a = new char[5];
              a[0]='h';
              a[1]='e';
              a[2]='l';
              a[3]='l';
              a[4]='o';
              System.out.println(Arrays.toString(a));
       }
}

3.4 数组的长度

length属性获取数组长度

数组一旦创建，长度不可变

允许0长度的数组

3.5 数组的遍历

从头到尾，依次访问数组的位置。

3.5.1 形式

for(int i=0;i<a.length;i++){
       syso(a[i]);
}

3.5.2 练习1：输出每个月的天数

package day004;
public class Test9_GetDay{
       public static void main(String[] args){
              int[] days=new int[]{31,29,31,30,31,30,31,31,30,31,30,31};
              for(int i=0;i<days.length;i++){
                     System.out.println((i+1)+"月有"+days[i]+"天");
              }
       }
}

3.5.3 练习2： 遍历数组，存入1到10

package day004;
public class Test7_数组遍历 {
       public static void main(String[] args) {
              f1();
       }
       private static void f1() {
              int[] arr=new int[10];
              for (int i = 0; i < arr.length; i++) {
                     arr[i]=i+1;
              }
System.out.println(Arrays.toString(arr));
       }
}

3.5.4 练习3：创建随机数组

获取100以内的随机值的数组

package com.tedu.hello;
import java.util.Arrays;
import java.util.Random;
public class t {
       public static void main(String[] args) {
              f();
       }
       private static void f() {
              int[] a = new int[5];
              for (int i = 0; i < a.length; i++) {
                     a[i]=1+new Random().nextInt(100);
              }
              System.out.println(Arrays.toString(a));
       }
}

3.6 数组工具类Arrays

3.6.1 Arrays.toString(数组)

把数组里的数据，用逗号连接成一个字符串。

格式：[10, 14, 20, 46, 51]

3.6.2 Arrays.sort(数组)

对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。

对引用类型数组，使用优化后的合并排序算法。

3.6.3 Arrays.copyOf(数组，新的长度)

把数组复制成一个指定长度的新数组。

新数组长度大于原数组，相当于复制，并增加位置。–数组的扩容

新数组长度小于原数组，相当于截取前一部分数据。–数组的缩容

3.6.4 测试

int[] a = Arrays.copyOf(arr, 10);//数组的复制，大于原来长度相当于扩容

System.out.println(Arrays.toString(a));//[12, 30, 20, 90, 34, 0, 0, 0, 0, 0]

System.out.println(a.length);//10       

int[] a2 = Arrays.copyOf(arr, 3);//数组的复制，晓宇原来长度相当于截取前几个数据

System.out.println(Arrays.toString(a2));//[12, 30, 20]

System.out.println(a2.length);//10

4 拓展

4.1 了解二维数组

存放数组的数组，也就是说数组里存的还是数组的数据形式。

4.2 了解冒泡排序

相邻位置比较，从小到大排序，如果小就往前换。i代表从头到尾遍历循环数据。

package day0000;
import java.util.Arrays;
import java.util.Random;
public class TT {
       public static void main(String[] args) {
              int[] arr = new int[]{43, 36, 45, 18, 24,9,20,32};
              int[] arrnew = f1(arr);
              System.out.println(Arrays.toString(arrnew));
       }
       private static int[] f1(int[] a) {
              //外循环控制循环次数，如果5个数字，循环4次就行
              for (int i = 0; i < a.length-1; i++) {
                     //内循环控制比大小，循环次数和外循环一样
                     for (int j = 0; j < a.length-1; j++) {
                            if(a[j]>a[j+1]){
                                   int t = a[j];
                                   a[j]=a[j+1];
                                   a[j+1]=t;
                            }
                     }
              }          
              return a;
       }

4.3 了解其他算法

如：合并算法，二分算法，快速算法等，冒泡最常见，也是面试中出现率最高的