上篇文章我们简单了解到方法的使用、方法的定义，了解到方法头和方法体；
这篇文章我们来深入的来了解方法的使用。
老规矩课程讲述之前，先分享教程，以防止看不懂：
学习教程推荐：
- 1.北京高淇Java300集（Java强烈推荐）
Java300集零基础适合初学者视频教程_Java300集零基础教程_Java初学入门视频基础巩固教程_Java语言入门到精通 - 2.JavaSE基础全套-从零开始进阶之大神（推荐）
JavaSE知识基础全套-从0开始进阶大神_JavaSE基础知识体系从入门到精通框架_/JAVA基础/数组/OOP/集合/IO流 - 3.Java全套课程-基础必备课程
JAVA全套课程_Java入门_Java零基础必备_Java编程课程_Java核心基础_EasyUI_SSM整合框架_Redis_高并发—全套课程 - 4.Java常用类基础实战
日常推荐Java常用类基础实战_通俗易懂实战入门教程_Java八大常用类核心基础/Java包装类/String类 - 5.Java基础入门必备数学知识【数据结构与算法】（推荐）
Java基础入门必学知识数据结构与算法_Java数据结构与算法基础到进阶_Java面试常见数据结构和算法问题_排序算法_递归_折半查询_栈和队列_链表 - 6.Java面向对象编程_OOP基础深入讲解
Java面向对象编程重基础深入讲解_OOP面向对象Java基础干货分享/JavaSE/面向对象编程/OOP程序设计 - 7.GOF23种设计模式-23中设计模式详解课程
GOF23种设计模式讲解_Java gof23种设计模式详解课程_从单例到备忘录模式 23种模式详解
一、 方法之间相互调用
不仅仅是主方法可以调用其他方法,自定义方法也是可以调用其他方法的
方法不能相互调用或者形成循环调用 只能是成单链式调用
- 数组元素求和
- 数组元素求平均值
方法不能循环或者互相调用
Stact 栈 ——> 栈内存
栈内存溢出
下面的方法是可行的：
创造条件：定义一个方法 返回一组双色球彩票数
双色球的规则
前六位 红球 1-33 不能重复 升序排列
最后一位蓝球1-16 可以和前六位重复
public static int[] getLottery(){
int[] lottery={1,5,….};
return lottery;
}
代码实现：
public class Test3 {
public static void main(String[] args) {
int[] lottery = getLottery();
System.out.println(Arrays.toString(lottery));
}
/*双色球的规则
前六位 红球 1-33 不能重复 升序排列
最后一位 蓝球 1-16 可以和前六位重复
*/
public static int[] getLottery(){
int[] lottery=new int[6];
for (int i = 0; i <6 ; i++) {
/*生成随机数*/
int num =(int)(Math.random()*33+1);
//判断 生成的数字是否已经包含了
while(isContain(lottery,num)){
/*重新生成数字 */
num =(int)(Math.random()*33+1);
}
lottery[i]=num;
}
// 数组工具类排序 OK
Arrays.sort(lottery);
int[] lottery2=new int[7];
// 数组的复制
System.arraycopy(lottery,0,lottery2,0,6);
// 处理第7位
lottery2[6]=(int)(Math.random()*16+1);
return lottery2;
}
/**
* 该方法用于判断给定的数组中是否包含指定的元素
* @param arr 给定的数组
* @param b 要查找的元素
* @return 找到返回true 未找到返回false
*/
public static boolean isContain(int[] arr,int b){
boolean flag= false;
for (int x:arr){
if(x==b){
flag=true;
break;
}
}
return flag;
}
}
`
二、方法的执行的内存流程：
- 栈内存
- 方法运行的区域
- 堆内存
`
- 数据存放的区域
- 方法区
- Java代码存储的区域
主方法调用其他方法时如a 方法, a方法的代码会被加载进栈内存执行
当方执行结束后栈内存中会自动清除a方法但是方法区中的a方法仍然在
`
三、方法的参数处理
1.按值传递和按引用传递
- 概念引入
- 参数分两种
- 形式上的参数
- 实际运行的参数
实参将数据传递给形参的量种方式
1）按值传递
实参传递给形参的数据是值 内存上形参和实参是不同的,是独立的,修改形参不会对实参产生影响
例如：你去饭馆吃饭 看见旁边一桌点了一份水煮鱼 你和服务员说 给我来一份一样的
服务员会复制一份水煮鱼给你 你把 自己的水煮鱼吃光了 对旁边的水煮鱼没有影响
2）按引用传递
实参传递给形参的不是真实的数据 是数据所在地址 是引用的堆内存中的地址
形参和实参指向的是内存中的同一个数据
修改形参会对实参产生影响 形参和实参事实上是同一个数据
- 当参数是基本数据类型时 数据不占用堆内存 按值传递
- 当参数是引用类型时 数据占用堆内存 按引用传递
3）应用案例： 定义一个方法 对一个整数类型的数组进行升序排列
定义排序方法
调用排序方法
方法的跨类和跨包调用不会影响按值和按引用传递
`
四、可变参数
可变参数的引入：
public class Test1 {
/*
* ... 可变参数
* 当 ... 作为形参时 传入的实参是可变的
* 在方法体内部 任然将可变参数当成数组使用
* 如果传入的实参是多个单独的变量 程序会自动将多个单独的变量放入数组
*
* 可变参数的好处
* 1 传入数组OK
* 2 传入多个单独的变量OK
* 3 传入的多个单独的变量的数量没有要求 可以变化的
* */
// 定义一个方法 遍历一个整数数组
public static void showArray(int... arr){
System.out.println("showArray 方法执行了");
for (int i = 0; i <arr.length ; i++) {
System.out.println(arr[i]);
}
}
public static void main(String[] args) {
int[] arr={1,2,3,4,5,6,7,8,9};
int a=11;
int b=22;
int c=33;
int d=44;
int e=55;
int f=66;
int g=77;
showArray(a,b,c,d);
showArray(arr);
}
}
可变参数的使用的注意事项：
`
五、方法的重载 overload
概念引入 ：
定义一个方法求两个byte变量的和
定义一个方法求两个short变量的和
定义一个方法求两个int变量的和
… …
上述的方法可以归为一类 他们的功能相同或者相似
但是他们需要的参数是不同的 那么这六个方法 方法命名是否可以有一些让我们舒服的处理方式吗? 如果是六十个? 如果是六百个? 怎么才能最简单呢? 使用同一个方法名
方法重载：在一个类中 多个同名方法的定义
方法重载没有减少代码量,仅仅是减少了相同或者相似功能方法的大量命名,方便我们记忆和调用
代码示例：
public class Test1 {
public static void main(String[] args) {
//a(10.0,10);
int[] arr={1,2,3};
b(arr);
}
/*
* 在一个类中 让多个方法同名是允许的 但是有条件
* 方法重载是有条件的
* 方法名必须相同
* 参数必须不同
* 在调用同名方法时无法根据方法名区分多个同名方法
* 但是可以根据传入的实参去匹配多个同名方法中的某一方法
* 参数可以有哪些不同 1个数不同 2数据类型不同 3顺序不同(数据类型)
* 在方法重载时 可变参数和数组作为方法参数认为是相同参数
* */
public static void a(double i){
System.out.println("方法1");
}
public static void a(int i){
System.out.println("方法2");
}
public static void b(int[] arr){
}
public static void b(String... arr){
}
}
编写一个案例：
定义一个方法 返回一个圆的周长 半径
定义一个方法 返回一个圆的面积 半径
定义一个方法 返回一个矩形的周长 长 宽
定义一个方法 返回一个矩形的面积 长 宽
定义一个方法 返回一个三角形的周长 三个边
定义一个方法 返回一个三角形的面积 三个边 海伦公式(百度)
要求 所有求周长的方法使用同一个方法名
所有求面积的方法使用同一个方法名
代码示例如下：
package demo3;
public class Test3 {
public static void main(String[] args) {
double perimeter = getPerimeter(4,5,3);
System.out.println(perimeter);
double areas = getAreas(3,4,5);
System.out.println(areas);
}
// 定义一个方法 返回一个圆的周长 半径
public static double getPerimeter(int r){
return 2*Math.PI*r;
}
// 定义一个方法 返回一个圆的面积 半径
public static double getAreas(int r){
return Math.PI*r*r;
}
// 定义一个方法 返回一个矩形的周长 长 宽
public static double getPerimeter(int a,int b){
return (a+b)*2;
}
// 定义一个方法 返回一个矩形的面积 长 宽
public static double getAreas(int a,int b){
return a*b;
}
// 定义一个方法 返回一个三角形的周长 三个边
public static double getPerimeter(int a,int b,int c){
// 任意两边值和大于第三边 任意两边之差 小于第三边
if (a+b>c&&a+c>b&&b+c>a) {
return a+b+c;
}
return 0;
}
// 定义一个方法 返回一个三角形的面积 三个边 海伦公式(百度)
public static double getAreas(int a,int b,int c){
// 任意两边值和大于第三边 任意两边之差 小于第三边
if (a+b>c&&a+c>b&&b+c>a) {
// 得到p值 三边和的一半
double p =(a+b+c)/2.0;
// 求s值
double s=p*(p-a)*(p-b)*(p-c);
// 对s进行开平方
return Math.sqrt(s);
}
return 0;
}
}
`
数组工具类的封装：
package demo3;
public class ArraysUtil {
// 6个
/**
* 升序排列一个byte数组
* @param arr 要排序的byte数组
*/
public static void sortASC(byte[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]>arr[j+1]){
byte temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
/**
* 升序排列一个short数组
* @param arr 要排序的short数组
*/
public static void sortASC(short[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]>arr[j+1]){
short temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
/**
* 升序排列一个int数组
* @param arr 要排序的int数组
*/
public static void sortASC(int[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]>arr[j+1]){
int temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
/**
* 升序排列一个long数组
* @param arr 要排序的byte数组
*/
public static void sortASC(long[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]>arr[j+1]){
long temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
/**
* 升序排列一个float数组
* @param arr 要排序的float数组
*/
public static void sortASC(float[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]>arr[j+1]){
float temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
/**
* 升序排列一个double数组
* @param arr 要排序的double数组
*/
public static void sortASC(double[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]>arr[j+1]){
double temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
// 6个
/**
* 降序排列一个byte数组
* @param arr 要排序的byte数组
*/
public static void sortDESC(byte[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]<arr[j+1]){
byte temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
/**
* 降序排列一个short数组
* @param arr 要排序的short数组
*/
public static void sortDESC(short[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]<arr[j+1]){
short temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
/**
* 降序排列一个int数组
* @param arr 要排序的int数组
*/
public static void sortDESC(int[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]<arr[j+1]){
int temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
/**
* 降序排列一个long数组
* @param arr 要排序的byte数组
*/
public static void sortDESC(long[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]<arr[j+1]){
long temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
/**
* 降序排列一个float数组
* @param arr 要排序的float数组
*/
public static void sortDESC(float[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]<arr[j+1]){
float temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
/**
* 降序排列一个double数组
* @param arr 要排序的double数组
*/
public static void sortDESC(double[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]<arr[j+1]){
double temp =arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
// 查找第一次 8个
/**
* 在给定的int数组中查找指定的int元素第一次出现的位置
* @param arr 给定的int数组
* @param b 要查找的int元素
* @return 如果找到元素,返回元素的索引;如果未找到元素,返回-1;
*/
public static int firstIndexOf(int[] arr,int b){
for (int i = 0; i < arr.length; i++) {
if(arr[i]==b){
return i;
}
}
return -1;
}
/**
* 在给定的byte数组中查找指定的byte元素第一次出现的位置
* @param arr 给定的byte数组
* @param b 要查找的byte元素
* @return 如果找到元素,返回元素的索引;如果未找到元素,返回-1;
*/
public static int firstIndexOf(byte[] arr,byte b){
for (int i = 0; i < arr.length; i++) {
if(arr[i]==b){
return i;
}
}
return -1;
}
// short long float double char boolean
// 查找最后一次 8个
/**
* 在给定的byte数组中查找指定的byte元素最后一次出现的位置
* @param arr 给定的byte数组
* @param b 要查找的byte元素
* @return 如果找到元素,返回元素的索引;如果未找到元素,返回-1;
*/
public static int lastIndexOf(byte[] arr,byte b){
for (int i = arr.length-1; i >= 0; i--) {
if(arr[i]==b){
return i;
}
}
return -1;
}
/**
* 在给定的int数组中查找指定的int元素最后一次出现的位置
* @param arr 给定的int数组
* @param b 要查找的int元素
* @return 如果找到元素,返回元素的索引;如果未找到元素,返回-1;
*/
public static int lastIndexOf(int[] arr,int b){
for (int i = arr.length-1; i >= 0; i--) {
if(arr[i]==b){
return i;
}
}
return -1;
}
// short long float double char boolean
// 判断包含 8个
/**
* 判断给定的int数组是否包含指定的int元素
* @param arr 给定的int数组
* @param b 指定的int元素
* @return 包含则返回true,不包含则返回false
*/
public static boolean isContain(int[] arr,int b){
int index = firstIndexOf(arr, b);
return index>=0?true:false;
}
/**
* 判断给定的byte数组是否包含指定的byte元素
* @param arr 给定的byte数组
* @param b 指定的byte元素
* @return 包含则返回true,不包含则返回false
*/
public static boolean isContain(byte[] arr,byte b){
int index = firstIndexOf(arr, b);
return index>=0?true:false;
}
// byte short int long float double boolean char
//判断给定数组 包含指定元素多少次 8个
/**
* 判断给定int数组 包含指定int元素多少次
* @param arr 给定的int数组
* @param b 指定的int元素
* @return 元素在数组中出现的次数
*/
public static int containTimes(int[] arr,int b){
int t =0;
for (int i = 0; i <arr.length ; i++) {
if(arr[i]==b){
t++;
}
}
return t;
}
// 判断给定数组 是否包含且仅包含一次给定的元素 8个
/**
* 判断给定int数组 是否包含且仅包含一次给定int的元素
* @param arr 给定的int数组
* @param b 要查找的in元素
* @return 包含且仅包含一次返回true 不包含或者包含多次返回false
*/
public static boolean isOne(int[] arr,int b){
int i = containTimes(arr, b);
return i==1?true:false;
}
}
本期 方法 知识点教学到此为止咯，内容可能少许杂乱，不过在理清楚所有知识点你将会收获丰硕哦~
