方法and数组基本知识
一、方法
方法：封装了一段功能逻辑代码，以实现重复使用
语法：权限修饰符(状态修饰符)，返回值类型，方法名（形参）{方法体 return}
实参：调用方法时，如果这个方法需要参数，我们必须传入参数，我们传入的这个参数叫做实际参数；实参：可以传常量，也可以传变量
class Ffa{
public static void main(String[] args) {
System.out.println("Hello World!");
send();//调用方法
send();
}
public static void send(){
System.out.println("发射炮弹");
}
}
1.1方法的注意事项
-
1.放法定义在类中，方法和方法是平级关系，不能嵌套定义。
-
2.方法不调用不执行，可以重复调用。
-
3.调用方法时，如果方法有形参，那你调用时，必须传入实参，实体的数据类型和个数都要和形参保持一致。
-
4.当你调用方法时，如果该方法有返回值，你就可以接收该方法返回的结果，方法，返回什么数据类型，你就用什么数据类型来收
1.2定义方法时，需要明确的俩点
1.方法要不要形参，如果要，要几个，数据类型是啥；
2.方法要不要明确返回值，要，返回什么类型。`
- 练习一：获取两个数的最大值
class MethodDemo3 {
public static void main(String[] args) {
//getMax 方法名
int max=getMax(20,60);
System.out.println("最大值是："+max);
int max2=getMax(200,60);
System.out.println("最大值是："+max2);
//如果这个方法有返回值，你为了打印看一下，这个方法的返回值，你可以输出调用
System.out.println("最大值是："+getMax(200,60));
System.out.println(getMax(200,6000));
//如果没有返回值，你不能输出调用。
}
public static int getMax(int a,int b){
int max=a>b?a:b;
return max;
}
- 练习二：比较两个数是否相等
Scanner sc=new Scanner(System.in);
System.out.println("请输入第一个数字");
int a=sc.nextInt();
System.out.println("请输入第二个数字");
int b=sc.nextInt();
boolean flag=isEquals(a,b);
if(flag){
System.out.println("相等");
}else{
System.out.println("不相等");
}
}
public static boolean isEquals(int a,int b){
//boolean f=a==b?true:false;
// boolean f=a==b;
// return f;
return a==b;
}
}
- 练习三：根据键盘录入的数字，打出相应的乘法表
import java.util.Scanner;
class FfJjtable{
public static void main(String[]args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入第一个数字");
int x = sc.nextInt();
JjcfbTable(x);
//System.out.println("请输入第二个数字");
}
public static void JjcfbTable(int n){
for(int i=1;i<=n;i++){
for(int j=1;j<=i;j++){
System.out.print(j+"*"+i+"="+(j*i)+"\t");
}
System.out.println();
}
}
}
1.3方法重载（overload）
- 方法重载：允许一个类中，可以定义多个同名方法，只要他们的形参个数或形参类型不同即可，跟返回值没有关系，不要有返回值区分
- “ 两同一不同”；同一个类，相同方法名，参数列表不同，参数个数不同，参数类型不同
- 举例
Arryays类中重载的sort() / binarySearch() - 判断是否是重载
跟方法的权限修饰符，返回值类型，形参变量名，方法体都没有关系；严格按照定义判断 - 在通过对象调用方法时，如何确定一个指定的方法；
class MethodDemo2 {
public static void main(String[] args) {
System.out.println("Hello World!");
//调用方法
add();
//调用方法
add2(8,9);
//调用方法时，如果这个方法需要参数，我们必须传入参数，我们传入的这个参数叫做实际参数，简称实参。
//注意：实参的数据类型和个数，要和方法的形参的数据类型和个数保持一致。
add2(18,19);
int a=20;
int b=90;
//实参，可以传常量，也可以传变量
add2(a,b);
//下面的代码，想要用你上面调用完方法之后的那个相加的结果，
//当你调用方法时，如果该方法有返回值，你就可以接收该方法返回的结果，方法，返回什么数据类型，你就用什么数据类型来收
int sum=add3(a,b);
System.out.println("返回的结果:"+sum);
return; //可以省略不写。
}
//两个数相加的功能
public static void add(){
int a=10;
int b=20;
int sum=a+b;
System.out.println("sum:"+sum);
return; //结束方法 如果你的方法的返回值类型没有明确也就是void ,最后面这个return可以省略不写。
}
//两个数相加的功能,给方法可以设计形式参数，简称形参
public static void add2(int x,int y){
int sum=x+y;
System.out.println("sum:"+sum);
return;
}
//方法可以来明确返回值类型
// void 无明确返回值类型，意思就是该方法，不返回任何结果
// 一旦该方法明确了返回类型，那么必须由 return关键字，带回一个与明确类型一致的结果
public static int add3(int x,int y){
int sum=x+y;
return sum; // return 返回结果，并结束方法。
}
}
public static void main(String[] args) {
调用时，根据形参，进行匹配调用
double sum1=add(1,2);
int sum2=add(1,2,3);
int sum3=add(1,2,3,4);
System.out.println("sum1:"+sum1);
System.out.println("sum2:"+sum2);
System.out.println("sum3:"+sum3);
}
public static int add(int a,int b){
System.out.println("两个int类型的参数的方法调用了");
return a+b;
}
//***************************************
public static add(int a,int b){
return a+b;
}
//***************************************
public static double add(int a,double b){
System.out.println("一个int类型的参数和一个double类型的参数的方法调用了");
return a+b;
}
//***************************************
public static int add(int a,int b,int c){
return a+b+c;
}
//***************************************
public static int add(int a,int b,int c,int d){
return a+b+c+d;
}
}
二、数组
-
数组：可以看做一个容器，可以存储多个数据类型一致的元素。
-
为什么要有数组：为了方便的存储多个元素。
-
数组的静态初始化，由我们为数组元素赋值，由系统计算长度
-
数组静态初始化，
-
数据类型[] 数组名
int[]arr2={20,20,20,20}
所谓数组的初始化，就是在内存中，要为数组开辟空间，并为数组元素赋值。
怎么初始化，new 就可以
-
数组的初始化，分为两种
- 动态初始化
- 静态初始化
-
常见的数组内的元素初始值
// byte shrot int long 整型数组 元素的初始值 是0
System.out.println(arr[0]); //0
//double float 浮点型数组，元素的初始值是 0.0
System.out.println(arr2[0]); //0.0
// 布尔类型的数组，元素的默认值是 false;
System.out.println(arr3[0]); //false
// 字符数组，元素的默认值是空格字符 \u0000
System.out.println(arr4[0]);//空格字符
System.out.println(' '); //空格
System.out.println(""); //空串 长度0
2.1动态数组
动态初始化：由我们规定数组长度，由系统为数组元素赋初始值。
举例：定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。
int[] arr=new int[3];
//我可以数组元素重新赋值
arr[0]=10;
arr[1]=20;
arr[2]=30;
//数组的元素，会编有索引(角标)，从0开始
//通过索引来获取数组中的元素
int a=arr[0];
int b=arr[1];
int c=arr[2];
System.out.println(a);
System.out.println(b);
System.out.println(c);
//arr 数组名，数组对象的引用
int[] arr=new int[3];
//打印数组的地址值
System.out.println(arr); //15db9742
arr[0]=10;
arr[1]=20;
arr[2]=30;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
- 练习：输出三个数组对象地址值，并判断两个数组的地址值，是否相等；
int[] arr=new int[3];
arr[0]=20;
arr[1]=120;
arr[2]=600;
int[] arr2=new int[3];
arr2[0]=200;
int[] arr3=arr;
arr3[0]=1000;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
System.out.println(arr3[0]);
System.out.println(arr3[1]);
System.out.println(arr3[2]);
//输出三个数组对象的地址值
System.out.println(arr); //[I@15db9742
System.out.println(arr2);//[I@6d06d69c
System.out.println(arr3);//[I@15db9742
//判断两个数组对象的地址值，是否相等
System.out.println(arr==arr3);
- 上述三个数组的内存图
2.2静态数组
- 数组的静态初始化：由我们为数组元素赋值，由系统计算长度
int[] arr=new int[]{20,30,40,50};
int a=arr[0];
arr[3]=500;
System.out.println(a);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
//数组的静态初始化,简写，你可以省略new
int[] arr2={20,30,40,50};
System.out.println(arr2[3]);
- 静态数组初始化内存图
- 两个数组的内存图
2.3数组的遍历
int[] arr=new int[]{20,30,40,50};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
int[] arr=new int[]{20,30,40,50};
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
- 反向数组遍历
int[] arr=new int[]{20,30,40,50};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
em.out.println(arr[2]);
System.out.println(arr[3]);
int[] arr=new int[]{20,30,40,50};
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
- 反向数组遍历
int[] arr=new int[]{20,30,40,50};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
236
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
