零基础学javaDay06

Day06

一、静态方法

1.概念

特定功能的代码块

2.好处

减少了代码的冗余

3.方法的分类

静态方法、成员方法、构造方法

4.注意

1. 方法编写的位置：类里
2. 方法与方法之间是平级关系（不能在一个方法中声明另一个方法）
3. 方法不被调用，永远就是个摆设

5.方法的语法结构分类

1. 无返回值无参数的方法
   语法结构：
   访问修饰符 static void 方法名(){
   …代码块…
   }

   需求：编写方法(printStar)，打印三角形

   public static void printStar(){
   		for(int i = 0;i<5;i++){
   			for(int j = 0;j<=i;j++){
   				System.out.print("*");
   			}
   			System.out.println();
   		}
   	}
   

2. 有参数的方法

   语法结构：

   ​ 访问修饰符 static void 方法名(参数类型 变量名){
   ​ …代码块…
   ​ }

   注意:

   1. 形参：形式参数，方法声明时，规定调用时要传入的数据类型及接收数据的变量

   2. 实参：实际参数，调用方法时传入的具体数据

   3. 实参与形参类型必须兼容

   4. 多个参数用逗号分隔

      需求1：编写方法(printStar01)，打印三角形，打印行数由调用方指定

      public static void printStar01(int num){
      		for(int i = 0;i<num;i++){
      			for(int j = 0;j<=i;j++){
      				System.out.print("*");
      			}
      			System.out.println();
      		}
      	}
      

      需求2：编写方法(printStar02)，打印三角形，打印行数及内容由调用方指定

      public static void printStar02(int num,String str){
      		for(int i = 0;i<num;i++){
      			for(int j = 0;j<=i;j++){
      				System.out.print(str);
      			}
      			System.out.println();
      		}
      	}
      

3. 有返回值的方法

   语法结构：
   public static 返回值类型 方法名([参数]){
   …代码块…
   return 返回数据;
   }

   注意：
   1.方法功能单一性
   2.return下面不能接执行语句，因为return表示结束当前方法
   3.声明方法时规定返回值类型
   4.return后面接的是要返回的具体数据
   5.声明方法时规定的返回值类型必修和return后的数据类型兼容
   6.方法A中有a和b的变量，方法B中也a和b的变量，这几个变量不互相冲突，因为方法中的变量叫做局部变量，作用域在该方法内

   需求1：编写方法(add),传入两个int值，求和

   public static int add(int a,int b){
   		int result = a+b;
   		return result;//返回具体参数
   	}
   

   需求2：编写方法(getMax),传入两个int值，比较最大值

   public static int getMax(int a,int b){
   		int max = (a>b)?a:b;
   		return max;
   	}
   

   总结 - 方法的使用：
   1.不需要外界传入参数和不需要返回给外界数据，就使用无参数无返回值的方法
   2.需要外界传入参数，就使用带参数的方法
   3.需要返回给外界数据，就使用带返回值的方法

   经验：声明一个方法
   1.考虑方法名
   2.考虑是否需要参数（传入数据）
   3.考虑是否需要返回数据（向外界传出数据）

二、方法的重载

1.含义

方法与方法之间的关系

2.好处

系统会根据实参类型自动匹配到对应方法

3.条件

1. 在同一个类里
2. 方法名一致
3. 参数列表的个数或者类型不一致
4. 与返回值无关

4.应用场景

在同一个类里，有多个方法功能一致，细节实现不一样，就可以考虑使用重载

5.需求

需求：编写一个方法，求两个int之和
需求：编写一个方法，求三个int之和
需求：编写一个方法，求两个double之和
需求：编写一个方法，求三个double之和

public static int add(int a,int b){
    return a+b;
}

public static int add(int a,int b,int c){
    return a+b+c;
}

public static double add(double a,double b){
    return a+b;
}

public static double add(double a,double b,double c){
    return a+b+c;
}

需求：编写一个方法，求两个int最大值
需求：编写一个方法，求三个int最大值
需求：编写一个方法，求四个int最大值

public static int getMax(int a,int b){
    return (a>b)?a:b;
}

public static int getMax(int a,int b,int c){
    int max = getMax(a,b);
    max = getMax(max,c);
    return max;
}

public static int getMax(int a,int b,int c,int d){
    int max = getMax(a,b);
    max = getMax(max,c);
    max = getMax(max,d);
    return max;
}

三、方法的递归

1.概念

方法调用方法自身

2.错误示范

方法死循环的调用方法自身
该代码会导致栈内存溢出的错误
原因：调用方法，就会在栈内存中开辟空间，用于存放该方法的局部变量，死循环的调用方法，栈内存就会满载并溢出

public static void method(){
		
		method();
	}

3.注意

1. 找规律
2. 找出口

4.需求

编写一个方法，传入n，求n的阶乘

阶乘：数学中的概念
5! = 1x2x3x4x5 --> 5! = 4!x5
4! = 1x2x3x4 --> 4! = 3!x4
3! = 1x2x3 --> 3! = 2!x3
2! = 1x2 --> 2! = 1!x2
1! = 1 --> 1! = 1 找出口
–> n! = (n-1)! * n 找规律

public static void main(String[] args){
		
    int num = method(5);
    System.out.println(num);
}

public static int method(int n){
    if(n != 1){
        return method(n-1)*n;
    }else{
        return 1;
    }
}

需求：有一对兔子，从出生后第3个月起每个月都生对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问n月的兔子总数为多少？
找规律：当月兔子个数 = 上月兔子个数+上上月兔子个数
找出口：第一个月和第二个月兔子都是1对

public static void main(String[] args){
		
    System.out.println(getRabbit(9));
}

public static int getRabbit(int month){
    if(month==1 || month==2){
        return 1;
    }else{
        return getRabbit(month-1) + getRabbit(month-2);
    }
}

四、方法版万年历

public static void main(String[] args){
    Scanner scan = new Scanner(System.in);
    System.out.println("请输入年："); //2021
    int year = scan.nextInt();
    System.out.println("请输入月："); //7
    int month = scan.nextInt();

    //1.计算1900~输入年的总天数
    int allDayOfYear = getAllDayOfYear(1900,year);

    //2.计算1~输入月的总天数
    int allDayOfMonth = getAllDayOfMonth(year,1,month);

    //3.年的总天数 + 月的总天数
    int allDay = allDayOfYear + allDayOfMonth + 1;

    //4.获取星期
    int week = getWeek(allDay);

    //5.获取当月天数
    int day = getDay(year,month);

    //5.打印日期
    printCalendar(year,month,day,week);
}

//打印日期
public static void printCalendar(int year,int month,int day,int week){
    System.out.println(" --- " + year + "年 - " + month + "月 ---");
    System.out.println("一\t二\t三\t四\t五\t六\t日");

    int num = 0;
    for(int i = 1;i<week;i++){
        System.out.print("\t");
        num++;
    }

    for(int i = 1;i<=day;i++){
        System.out.print(i + "\t");
        num++;
        if(num%7==0){
            System.out.println();
        }
    }
}

//获取星期
public static int getWeek(int allDay){
    if(allDay%7 == 0){
        return 7;
    }
    return allDay%7;
}

//获取开始月到结束月的天数
public static int getAllDayOfMonth(int year,int startMonth,int endMonth){
    int allDayOfMonth = 0;
    for(int i = startMonth;i<endMonth;i++){
        allDayOfMonth += getDay(year,i);
    }
    return allDayOfMonth;
}

//获取当月天数
public static int getDay(int year,int month){
    int day = 0;
    switch(month){
        case 1:case 3:case 5:case 7:case 8:case 10:case 12:
            day=31;
            break;
        case 4:case 6:case 9:case 11:
            day=30;
            break;
        case 2:
            if(isLeapYear(year)){
                day=29;
            }else{
                day=28;
            }
            break;
    }
    return day;
}

//获取开始年到结束年的天数
public static int getAllDayOfYear(int startYear,int endYear){
    int allDayOfYear = 0;
    for(int i = startYear;i<endYear;i++){
        if(isLeapYear(i)){
            allDayOfYear+=366;
        }else{
            allDayOfYear+=365;
        }
    }
    return allDayOfYear;
}

//判断是否是闰年
public static boolean isLeapYear(int year){
    if(year%4==0&&year%100!=0 || year%400== 0){
        return true;
    }
    return false;
}

五、一维数组

1.概念

一组数据的容器（数组可以存放多个数据）

2.注意

1. 数组是引用数据类型
2. 数组中的数据又叫做元素
3. 每个元素都有编号叫做下标/索引
4. 下标从0开始
5. 数组初始化后，会在内存中开辟一连串连续的空间
6. 数组一旦初始化后长度不可以改变（数组没有扩容和删除）
7. 数组的操作：添加、修改、查询

3.数组的声明

数据类型[] 数组名;

4.数组的初始化

静态初始化：数据由程序员指定，长度由系统分配

//静态初始化1
//String[] names = new String[]{"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};

//静态初始化2
//String[] names;
//names = new String[]{"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};

//静态初始化3
String[] names = {"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};

//设置指定下标上的元素
names[3] = "林成";

//获取指定下标上的元素
String n = names[3];
System.out.println("获取指定下标上的元素：" + n);//林成

//ArrayIndexOutOfBoundsException - 数组下标越界异常
//System.out.println(names[100]);

//获取元素个数
int len = names.length;
System.out.println("获取元素个数：" + len);//5

System.out.println("-----------");

//遍历 - for循环
for(int i = 0;i<names.length;i++){
    System.out.println(names[i]);
}

System.out.println("-----------");

//遍历 - foreach(增强for循环)
for(String str:names){//遍历数组，依次把元素赋值给str
    System.out.println(str);
}
/**
	遍历时要使用到下标，就用for循环遍历
	遍历时要不使用到下标，就用foreach遍历	
*/

动态初始化：长度由程序员指定，数据由系统分配(默认值)
整数类型：0
浮点类型：0.0
字符类型：’ ’
布尔类型：false
引用类型：null(空)

//动态初始化1
String[] names = new String[5];//5->5个长度

//设置指定下标上的元素
names[0] = "林成a";
names[1] = "林成b";
names[2] = "林成c";
names[3] = "林成d";
names[4] = "林成e";

//获取指定下标上的元素
String n = names[3];
System.out.println("获取指定下标上的元素：" + n);//林成

//ArrayIndexOutOfBoundsException - 数组下标越界异常
//System.out.println(names[100]);

//获取元素个数
int len = names.length;
System.out.println("获取元素个数：" + len);//5

System.out.println("-----------");

//遍历 - for循环
for(int i = 0;i<names.length;i++){
    System.out.println(names[i]);
}

System.out.println("-----------");

//遍历 - foreach(增强for循环)
for(String str:names){//遍历数组，依次把元素赋值给str
    System.out.println(str);
}

/**
	遍历时要使用到下标，就用for循环遍历
	遍历时要不使用到下标，就用foreach遍历	
*/

六、一维数组的案例

需求

定义一个10个长度的int数组，获取最大值

public static void main(String[] args){
		
    int[] is = {3,2,4,35,34,5,25,34,32,18};

    int max = is[0];//假设数组中第0个下标位置的元素为最大值

    for(int i = 1;i<is.length;i++){
        if(max < is[i]){
            max = is[i];
        }
    }

    System.out.println("最大值为：" + max);

}