一、方法
这里写目录标题
1.概念：特定功能的代码块
2.好处：减少了代码的冗余量
1.方法的分类：静态方法、成员方法、构造方法
1.1 静态方法：
1.无返回值无参数的方法：
语法结构：访问修饰符 static void 方法名（）{
…代码块…
}
代码例举：
public class 类名{ public static void main(String[] arg){ 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.多个参数用逗号分隔
代码例举：
public class 类名{ public static void main(String[] arg){ printStar(5,"#"); printStart01(6); } public static void printStar(int num,String str){ for(int i=0;i<5;i++){ for(int j=0;j<=i;j++){ System.out.print(str); }System.out.println(); } } public static void printStar01(int num){ for(int i=0;i<num;i++){ for(int j=0;i<=j;j++){ System.out.print("*"); }System.out.println(); } } }
3.有返回值的方法：
语法结构：
public static 返回值类型 方法名（[参数]){
…代码块…
return 返回数据;
}
注意：
1.方法功能单一性
2.return下面不能接执行语句，因为return表示结束当前方法
3.声明方法时规定返回值类型
4.return后面接入的是要返回的具体数据
5.声明方法是规定难过的返回值类型必须是和return后面的数据类型兼容
6.方法A中有a和b的变量，方法B中也有a和b的变量，这几个变量不互相冲突，因为方法中的变量叫做局部变量，作用域在该方法内
public class 类名{ public static void main(String[] arg){ }public static int getMax(int a,int b){ int max=(a>b)?a:b; return max; } public static int add(int a,int b){ int result=a+b; return result; } }
4.总结：
方法的使用：
不需要外界传入参数和不需要返回给外界数据，就使用无参数无返回值的方法
需要外界传入参数，就使用带参数的方法
需要外界传入数据，就使用带返回值的方法
5.经验：
声明一个方法：
1.考虑方法名
2.考虑是否需要传入参数（传入数据）
3.考虑是否需要返回数据（向外界传出数据）
1.2 方法的重载
1.2.1 含义:
方法与方法之间的关系
1.2.2 好处
系统会根据实参类型自动匹配到对呀的方法
1.2.3 条件
1.在同一个类里
2.方法名一致
3.参数列表的个数或者类型不同
4.与返回值无关
1.2.4 应用场景
在同一个类里，有多个方法功能一致，细节实现不一样，就可以考虑使用重载
1.2.5 代码块理解
public class 类名{
public static void main(Stirng[] args){
System.out.println(num(10,20));
System.out.println(num(10,20,30));
System.out.println(num(10.1,20.1));
System.out.println(unm(10.1,20.1,30.1));
System.out.println(getMax(10,20,30));
System.out.println(getMax(10,20,30,40));
}
public static int num(int a,int b ){
return (a+b);
}
public static int num(int a,int b,int c){
return (a+b+c);
}
public static double num(double a,double b){
return (a+b);
}
public static double num(double a,double b,double c){
return (a+b+c);
}
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.3 递归
1.3.1 含义：
方法调用自身
错误示范：方法死循环的调用自身，该代码会导致栈内存溢出的错误
原因：调用方法，就会在栈内存中开辟空间，用于存放该方法的局部变量，死循环的调用方法，栈内存就会满载并溢出
public class 类名{ public static void main{ method(); } public static void method(){ method(); } }
1.3.2 注意：
1.找规律
2.找出口
1.3.3 代码块理解
编写一个方法，传入n，求n的阶乘
阶乘：数学中的概念
5! = 12345 --> 5! = 4!5
4! = 1234 --> 4! = 3!4
3! = 12*3 --> 3! = 2!3
2! = 12 --> 2! = 1!*2
1! = 1 --> 1! = 1 找出口
–> n! = (n-1)! * n 找规律public class 类名{ 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; } } }
1.3.4 斐波那契数列
案例：不死神兔
有一对兔子，从出生后第3个月起每个月都生对兔子，
小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，
问n月的兔子总数为多少？
找规律：当月兔子个数 = 上月兔子个数+上上月兔子个数
找出口：第一个月和第二个月兔子都是1对
import java.util.Scanner;
public class Test {
/**
* 不死神兔，兔子都不死，第N个月的兔子数量
* 第N个月共会有多少对兔子
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("请输入你想查询的第几个月后有多少对兔子：");
int n=scan.nextInt();
int rabbit = Rabbit(n);
System.out.println("第"+n+"个月后有"+rabbit+"对兔子");
}
private static int Rabbit(int month){
if (month==1||month==2){
return 1;
}
else {
return (Rabbit(month-1))+Rabbit(month-2);
}
}
}
1.4 方法版万年历
代码如下：
import java.util.Scanner; public class PerpetualCalendar{ public static void main(String[] args){ Scanner scan=new Scanner(System.in); System.out.print("请输入年份："); int year =scan.nextInt(); System.out.print("请输入月份："); int month=scan.nextInt(); //计算1900~输入年的总天数 int allDayOfYear=new allDayOfYear(1900,year); //计算1~输入月的总天数 int allDayOfMonth=new allDayOfMonth(1,month); //全部天数=年的总天数+月的总天数+1 int allDay=allDayOfYear+allDayOfMonth+1; //获取星期 int week=getWeek(allDay); //获取当月天数 int day=getDay(year,month); //打印日期 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.println(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 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.数组的初始化：
静态初始化：数据由程序员指定，长度由系统分配
动态初始化：长度由程序员指定，数据由系统分配（默认值）
整数类型 ：0
浮点类型 ： 0.0
字符类型 ： ’ ’
布尔类型 ： false
引用类型 ： null（空值）
静态初始化 VS 动态初始化：
一开始就知道数据：静态初始化
一开始就知道长度：动态初始化
5：静态初始化代码块理解
public class 类名{
public static void main(String[] args){
//静态初始化1
String[] names=new String[]{"陈一","王二","张三","李四","王五"};
//静态初始化2
String[] names1;
names1=new String[]{"陈一","王二","张三","李四","王五"};
//静态初始化3
String[] names2={"陈一","王二","张三","李四","王五"};
//设置指定下标上的元素
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);
}
}
}
5.1总结：
遍历时要使用到下标，就用for循环遍历
遍历时要不使用到下标，就用foreach遍历
6.动态初始化代码理解：
public class 类名{
public static void main(String[] args){
//动态初始化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);//榮c
//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);
}
}
}
7.案例：
定义一个10个长度的int数组，获取最大值
public class 类名{ 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); } }
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
