3.方法 数组
方法
【1】什么是方法？
方法(method)就是一段用来完成特定功能的代码片段，类似于其它语言的函数(function)。
方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
【2】方法声明格式：
[修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表){
Java语句；… … …
}
【3】方法的调用方式：
对象名.方法名(实参列表)
【4】方法的详细说明
形式参数：在方法声明时用于接收外界传入的数据。
实参：调用方法时实际传给方法的数据。
返回值：方法在执行完毕后返还给调用它的环境的数据。
返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。
【5】代码：
public class TestMethod01{
//方法的定义：（写方法）
public static int add(int num1,int num2){
int sum = 0;
sum += num1;
sum += num2;
return sum;//将返回值返回到方法的调用处
}
public static void main(String[] args){
//10+20:
//方法的调用：（用方法）
int num = add(10,20);
System.out.println(num);
/*
int num1 = 10;
int num2 = 20;
int sum = 0;
sum += num1;
sum += num2;
System.out.println(sum);
*/
//30+90:
int sum = add(30,90);
System.out.println(sum);
/*
int num3 = 30;
int num4 = 90;
int sum1 = 0 ;
sum1 += num3;
sum1 += num4;
System.out.println(sum1);
*/
//50+48:
System.out.println(add(50,48));
}
}
【6】总结：
1.方法是：对特定的功能进行提取，形成一个代码片段，这个代码片段就是我们所说的方法
2.方法和方法是并列的关系，所以我们定义的方法不能写到main方法中
3.方法的定义--》格式：
修饰符 方法返回值类型 方法名(形参列表){
方法体;
return 方法返回值;
}
4.方法的作用：提高代码的复用性
5.总结方法定义的格式：
\1) 修饰符: 暂时使用public static --->面向对象一章讲解
\2) 方法返回值类型 : 方法的返回值对应的数据类型
数据类型： 可以是基本数据类型（byte,short,int,long,float,double,char,boolean） 也可以是引用数据类型
\3) 方法名 :见名知意，首字母小写，其余遵循驼峰命名， eg: addNum ,一般尽量使用英文来命名
\4) 形参列表 :方法定义的时候需要的形式参数 ： int num1, int num2 -->相当于告诉方法的调用者：需要传入几个参数，需要传入的参数的类型
实际参数：方法调用的时候传入的具体的参数： 10,20 -->根据形式参数的需要传入的
5)方法体：具体的业务逻辑代码
\6) return 方法返回值;
方法如果有返回值的话： return+方法返回值，将返回值返回到方法的调用处
方法没有返回值的话：return可以省略不写了，并且方法的返回值类型为：void
public class TestMethod02{
public static void add(int num1,int num2){
int sum = 0;
sum += num1;
sum += num2;
System.out.println(sum);
//return;
}
public static void main(String[] args){
//10+20:
//方法的调用：（用方法）
add(10,20);
//30+90:
add(30,90);
//50+48:
//System.out.println(add(50,48));//报错：TestMethod02.java:22: 错误: 此处不允许使用 '空' 类型
}
}
什么时候有返回值，什么时候没有返回值？ 看心情--》看需求
6.方法的定义需要注意什么？
1）形参列表要怎么写：定义几个参数，分别是什么类型的 ---》不确定因素我们会当做方法的形参
\2) 方法到底是否需要返回值 ，如果需要的话，返回值的类型是什么
7.方法的调用需要注意什么？
1）实际参数要怎么传入：传入几个参数，传入什么类型的
2） 方法是否有返回值需要接受
练习：
import java.util.Scanner;
public class TestMethod03{
public static void main(String[] args){
//功能：我心里有一个数，你来猜，看是否猜对
//1.你猜一个数
Scanner sc = new Scanner(System.in);
System.out.println("请你猜一个数：");
int yourGuessNum = sc.nextInt();
//2.我心里有一个数
int myHeartNum = 5;
//3.将两个数比对：
System.out.println(yourGuessNum==myHeartNum?"猜对了":"猜错了");
}
}
对猜数功能提取为一个方法：
import java.util.Scanner;
public class TestMethod03{
public static void main(String[] args){
//功能：我心里有一个数，你来猜，看是否猜对
//1.你猜一个数
Scanner sc = new Scanner(System.in);
System.out.println("请你猜一个数：");
int yourGuessNum = sc.nextInt();
//调用猜数的方法：
guessNum(yourGuessNum);
}
//方法的定义：功能：实现猜数功能：
public static void guessNum(int yourNum){
//我心里有一个数(1-6)
int myHeartNum = (int)(Math.random()*6)+1;
//将两个数比对：
System.out.println(yourNum==myHeartNum?"猜对了":"猜错了");
}
}
面试题：请问下面代码中两个数是否交换成功：
public class TestM{
public static void main(String[] args){
int a=10;
int b=20;
System.out.println("输出交换前的两个数："+a+"---"+b);
changeNum(a,b);
System.out.println("输出交换后的两个数："+a+"---"+b);
}
public static void changeNum(int num1,int num2){
int t;
t=num1;
num1=num2;
num2=t;
}
}
结果：没有交换成功：
原因：
方法的重载
【1】什么是方法的重载：
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。
注意本质：重载的方法，实际是完全不同的方法，只是名称相同而已！
【2】构成方法重载的条件：
❀不同的含义：形参类型、形参个数、形参顺序不同
❀ 只有返回值不同不构成方法的重载
如：int a(String str){}与 void a(String str){}不构成方法重载
❀ 只有形参的名称不同，不构成方法的重载
如：int a(String str){}与int a(String s){}不构成方法重载
public class TestMethod05{
public static void main(String[] args){
//10+20:
int sum = add(10,20);
System.out.println(sum);
//20+40+80:
//System.out.println(add(add(20,40),80));
System.out.println(add(20,40,80));
//30+60+90+120:
//System.out.println(add(add(30,60),add(90,120)));
System.out.println(add(30,60,90,120));
//9.8+4.7:
//System.out.println(add(9.8,4.7));
System.out.println(add(9.8,4.7));
}
//定义一个方法：两个数相加：两个int类型数据相加
public static int add(int num1,int num2){
return num1+num2;
}
//定义一个方法：三个数相加：
public static int add(int num1,int num2,int num3){
return num1+num2+num3;
}
//定义一个方法：四个数相加：
public static int add(int num1,int num2,int num3,int num4){
return num1+num2+num3+num4;
}
//定义一个方法：两个数相加：两个double类型的数据相加
public static double add(double num1,double num2){
return num1+num2;
}
}
总结：
1.方法的重载：在同一个类中，方法名相同，形参列表不同的多个方法，构成了方法的重载。
2.方法的重载只跟：方法名和形参列表有关，与修饰符，返回值类型无关。
3.注意：形参列表不同指的是什么？
（1）个数不同
add() add(int num1) add(int num1,int num2)
（2）顺序不同
add(int num1,double num2) add(double num1,int num2)
（3）类型不同
add(int num1) add(double num1)
4.请问下面的方法是否构成了方法的重载？
(1)add(int a) 和 add(int b) --->不构成,相当于方法的重复定义
(2)public static int add(int a) 和 public static void add(int b) --->不构成
public class TestMethod06{ public static void main(String[] args){ add(5); //级别：byte,short,char-->int-->long-->float--->double } public static void add(double num1){ System.out.println("------2"); } public static void add(float num1){ System.out.println("------3"); } public static void add(long num1){ System.out.println("------4"); } /* public static void add(int num1){ System.out.println("------1"); } */}
数组
【1】数组的定义
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。
数组的四个基本特点：
1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2.其元素的类型必须是相同类型，不允许出现混合类型。
3.数组类型可以是任何数据类型，包括基本类型和引用类型。
4.数组有索引的：索引从0开始，到 数组.length-1 结束
5.数组变量属于引用类型，数组也是对象。
PS:数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。
public class TestArray02{ public static void main(String[] args){ //数组的作用：用来存储相同类型的数据 //以int类型数据为案例：数组用来存储int类型数据 //1.声明(定义数组) int[] arr; //定义一个int类型的数组，名字叫arr //int arr2[]; //如果数组只声明，没有后续操作，那么这个数组相当于没定义 //int[] arr3 = null;//空 辨别：数组赋值为null和什么都没有赋值 不一样的效果 //2.创建 arr = new int[4];//给数组开辟了一个长度为4的空间 //编译期声明和创建会被合为一句话: int[] arr = new int[4]; //3.赋值 arr[0] = 12; arr[3] = 47; arr[2] = 98; arr[1] = 56; arr[2] = 66; /* arr[4] = 93; 出现异常：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4 Array 数组 Index 索引 OutOf 超出 Bounds 界限 Exception 异常 ---》数组索引越界异常 */ //4.使用 System.out.println(arr[2]); System.out.println(arr[0]+100); //通过数组一个属性来获取 length 长度 System.out.println("数组的长度是："+arr.length); }}
数组的遍历
import java.util.Scanner;public class TestArray03{ public static void main(String[] args){ //功能：键盘录入十个学生的成绩，求和，求平均数： //定义一个int类型的数组，长度为10 ： int[] scores = new int[10]; //定义一个求和的变量： int sum = 0; Scanner sc = new Scanner(System.in); for(int i=1;i<=10;i++){//i:控制循环次数 System.out.print("请录入第"+i+"个学生的成绩："); int score = sc.nextInt(); scores[i-1] = score; sum += score; } System.out.println("十个学生的成绩之和为："+sum); System.out.println("十个学生的成绩平均数为："+sum/10); //求第6个学生的成绩： //System.out.println(scores[5]); /* System.out.println(scores[0]); System.out.println(scores[1]); System.out.println(scores[2]); System.out.println(scores[3]); //.... System.out.println(scores[9]); */ //将数组中的每个元素进行查看--》数组的遍历： //方式1：普通for循环---》正向遍历： for(int i=0;i<=9;i++){ System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]); } //方式2：增强for循环: //对scores数组进行遍历，遍历出来每个元素都用int类型的num接收： int count = 0; for(int num:scores){ count++; //每次都将num在控制台输出 System.out.println("第"+count+"个学生的成绩为："+num); } /* 增强for循环： 优点：代码简单 缺点：单纯的增强for循环不能涉及跟索引相关的操作 */ //方式3：利用普通for循环： 逆向遍历： for(int i=9;i>=0;i--){ System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]); } }}
数组的三种初始化方式
数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。
静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
eg:int[] arr = {12,23,45};int[] arr = new int[]{12,23,45};注意：1.new int[3]{12,23,45};-->错误2.int[] arr ;arr = {12,23,45}; --->错误
动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。
eg:int[] arr ;arr = new int[3]arr[0] = 12;arr[1] = 23;arr[2] = 45;
默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
int[] arr = new int[3]; ---> 数组有默认的初始化值
数组应用：
（1）最值问题
【1】实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。
（2）查询问题
【1】查询指定位置的元素
【2】查询指定元素的位置--》找出元素对应的索引
【3】将查指定元素对应的索引的功能提取为方法：
（3）添加元素
（4）删除元素
数组的复制操作
import java.util.Arrays;public class TestArray14{ public static void main(String[] args){ //给一个源数组： int[] srcArr = {11,22,33,44,55,66,77,88}; //给一个目标数组： int[] destArr = new int[10]; //复制： System.arraycopy(srcArr,1,destArr,3,3); //遍历查看目标数组： System.out.println(Arrays.toString(destArr)); } }
二维数组
【1】引入：本质上全部都是一维数组：
public class TestArray15{ public static void main(String[] args){ //定义一个二维数组： int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3 int[] a1 = {1,2,3}; arr[0] = a1; arr[1] = new int[]{4,5,6,7}; arr[2] = new int[]{9,10}; }}
四种遍历方式：
public class TestArray15{ public static void main(String[] args){ //定义一个二维数组： int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3 int[] a1 = {1,2,3}; arr[0] = a1; arr[1] = new int[]{4,5,6,7}; arr[2] = new int[]{9,10}; //读取6这个元素： //System.out.println(arr[1][2]); //对二维数组遍历： //方式1：外层普通for循环+内层普通for循环： for(int i=0;i<arr.length;i++){ for(int j=0;j<arr[i].length;j++){ System.out.print(arr[i][j]+"\t"); } System.out.println(); } //方式2：外层普通for循环+内层增强for循环： for(int i=0;i<arr.length;i++){ for(int num:arr[i]){ System.out.print(num+"\t"); } System.out.println(); } //方式3：外层增强for循环+内层增强for循环： for(int[] a:arr){ for(int num:a){ System.out.print(num+"\t"); } System.out.println(); } //方式4：外层增强for循环+内层普通for循环： for(int[] a:arr){ for(int i=0;i<a.length;i++){ System.out.print(a[i]+"\t"); } System.out.println(); } }}
二维数组的初始化方式
数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。
静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
eg:
eg:int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};int[][] arr =new int[][] {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。
eg:int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组arr[0] = new int[]{1,2};arr[1] = new int[]{3,4,5,6};arr[2] = new int[]{34,45,56};
eg:int[][] arr = new int[3][2]; public class TestArray16{ public static void main(String[] args){ int[][] arr = new int[3][2]; //本质上：定义一维数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组： arr[1] = new int[]{1,2,3,4}; //数组遍历： for(int[] a:arr){ for(int num:a){ System.out.print(num+"\t"); } System.out.println(); } }}
默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
详述main方法
【1】main方法：程序的入口，在同一个类中，如果有多个方法，那么虚拟机就会识别main方法，从这个方法作为程序的入口
【2】main方法格式严格要求：
public static void main(String[] args){}
public static --->修饰符 ，暂时用这个 -->面向对象一章
void --->代表方法没有返回值 对应的类型void
main --->见名知意名字
String[] args --->形参 ---》不确定因素
【3】问题：程序中是否可以有其他的方法也叫main方法？
可以，构成了方法的重载。
public class TestArray10{ public static void main(String[] args){ } public static void main(String str){ }}
【4】形参为String[] 那么实参到底是什么？
public class TestArray10{ public static void main(String[] args){ //从侧面验证： //int[] arr1; //如果对数组只声明，没有后续操作，那么相当于 白定义了。 //int[] arr2 = null; //System.out.println(arr2.length);//Exception in thread "main" java.lang.NullPointerException //int[] arr3 = new int[0]; //System.out.println(arr3.length); //int[] arr4 = new int[4]; //System.out.println(arr4.length); //System.out.println(args.length);//0 //从这个结果证明，参数是String[],实参是 new String[0] //默认情况下，虚拟机在调用main方法的时候就是传入了一个长度为0的数组 System.out.println(args.length); for(String str:args){ System.out.println(str); } }}
手动传入实参：
有特殊符号的时候可以加上“”
没有特殊符号用空格隔开即可：
可变参数
public class TestArray12{
/*
1.可变参数：作用提供了一个方法，参数的个数是可变的 ,解决了部分方法的重载问题
int...num
double...num
boolean...num
2.可变参数在JDK1.5之后加入的新特性
3.方法的内部对可变参数的处理跟数组是一样
4.可变参数和其他数据一起作为形参的时候，可变参数一定要放在最后
5.我们自己在写代码的时候，建议不要使用可变参数。
*/
public static void main(String[] args){
//method01(10);
//method01();
//method01(20,30,40);
method01(30,40,50,60,70);
//method01(new int[]{11,22,33,44});
}
public static void method01(int num2,int...num){
System.out.println("-----1");
for(int i:num){
System.out.print(i+"\t");
}
System.out.println();
System.out.println(num2);
}
}
浙公网安备 33010602011771号