方法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);
- 上述三个数组的内存图
![](https://i-blog.csdnimg.cn/blog_migrate/0c3750e10e85eb2d3dbbd2fced818711.jpeg)
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]);
}