Java学习笔记2024/2/3
1. 方法
1.1 什么是方法
package com.angus.method.whatIsTheMethod_1;
public class note {
public static void main(String[] args) {
//什么是方法
//方法是程序当中最小的执行单元
//调用方法和使用数组很类似
//方法->方法名
//数组->数组名->地址值
//什么时候用到方法
//重复的代码,具有独立功能的代码可以抽取到方法当中
//方法有什么好处
//可以提高代码的复用性
//可以提高代码的可维护性
System.out.println("^^");
}
}
1.2 方法的格式
package com.angus.method.theFormatOfTheMethod_2;
public class note {
public static void main(String[] args) {
//关于方法的格式只要学习两点
//如何打包
//打包好后如何调用
//方法定义
//把一些代码打包在一起,该过程称为方法定义
//方法调用
//方法定义后并不是直接运行的,需要手动调用才能执行,
//该过程称为方法调用
//方法的定义格式
//分为三种解析
//最后一种可操作性最高,也是方法最完整的定义格式
//第一种
//最简单的方法定义和调用
//方法定义
//格式:
//public static Void 方法名(){
// 方法体(就是打包起来的代码);
//}
//范例:
//public static Void playGame(){
// 七个打印语句;
//}
//方法调用
//格式:
//方法名();
//范例:
//playGame();
//注意:方法必须先定义后调用,否则程序将报错
//看代码
//看到方法进入方法
//执行完毕后回到调用处
//第二种
//带参数的方法定义和调用
//一个参数的定义和调用
//public static void 方法名(参数){...}
//public static void method(int number){...}
//方法名(参数);
//method();
//method(变量);
//多个参数
//public static void 方法名(参数1,参数2,...){...}
//public static void method(int number1,int number2,...){...}
//方法名(参数1,参数2,...);
//getSun(10,20);
//getSun(变量1,变量2);
//注意:方法调用时,参数的数量与类型必须与方法定义中
//小括号里面的变量一一对应,否则程序将报错
//形参和实参
//形参:
//全称为形式参数,是指方法定义中的参数
//实参:
//全称为实际参数,是指方法调用中的参数
//注意:方法调用时,形参和实参必须一一对应,否则程序将报错
//方法定义的小技巧
//1.我要干啥? ->方法体
//2.我干这件事情需要啥才能完成? ->形参
//第三种
//带返回值方法的定义和调用
//方法的返回值其实就是方法运行的最终结果
//如果在调用处要根据方法的结果,去编写另外一段代码逻辑
//为了在调用处拿到方法产生的结果,就需要定义带有返回值的方法
//定义
//格式:
//public static 返回值类型 方法名(参数){
//方法体;
//return 返回值;
// }
//范例:
//public static int getSum(int a, int b){
// int c = a + b;
// return c;
// }
//调用
//直接调用: ->一般用于没有返回值类型的
//方法名(实参);
//赋值调用: ->最常用
//整数类型 变量名 = 方法名(实参);
//输出调用:
//System.out.println(方法名(实参));
System.out.println("^^");
}
}
package com.angus.method.theFormatOfTheMethod_2;
public class demo1 {
public static void main(String[] args) {
//最简单的方法定义和调用格式
playGame();
System.out.println("^^");
}
public static void playGame(){
System.out.println("afa");
System.out.println("acaca");
System.out.println("阿拉敖灿哦");
}
}
package com.angus.method.theFormatOfTheMethod_2;
public class demo2 {
public static void main(String[] args) {
GFinfo();
System.out.println("^^");
}
public static void GFinfo(){
System.out.println("小美");
System.out.println("1.63");
System.out.println("萌妹子");
}
}
package com.angus.method.theFormatOfTheMethod_2;
public class demo3 {
public static void main(String[] args) {
qiuHe();
System.out.println("^^");
}
public static void qiuHe() {
int a = 10;
int b = 10;
int sum = a + b;
System.out.println(sum);
}
}
package com.angus.method.theFormatOfTheMethod_2;
public class demo4 {
public static void main(String[] args) {
getSum(10,20);
System.out.println("^^");
}
public static void getSum(int a, int b) {
int sum = a + b;
System.out.println(sum);
}
}
package com.angus.method.theFormatOfTheMethod_2;
public class demo5 {
public static void main(String[] args) {
//目标：掌握带返回值方法的定义和调用格式
//直接调用 ->一般不用于返回值的调用
getSum(1,1,1);
//赋值调用
int sum =getSum(1,1,1);
System.out.println(sum);
//输出调用
System.out.println(getSum(1,1,1));
System.out.println("^^");
}
public static int getSum(int num1,int num2,int num3){
int re = num1 + num2 + num3;
return re;
}
}
package com.angus.method.theFormatOfTheMethod_2;
public class demo6 {
public static void main(String[] args) {
//目标：掌握带返回值方法的定义和调用格式
//计算全年的总营业额
int sum1 = getSum(1,1,1);
int sum2 = getSum(2,2,2);
int sum3 = getSum(3,3,3);
int sum4 = getSum(4,4,4);
int sum = sum1 + sum2 + sum3 + sum4;
System.out.println(sum);
System.out.println("^^");
}
public static int getSum(int num1,int num2,int num3){
int re = num1 + num2 + num3;
return re;
}
}
package com.angus.method.theFormatOfTheMethod_2;
public class test1 {
public static void main(String[] args) {
//需求：定义一个方法，求长方形的周长，将结果在方法中进行打印。
c(1,1);
System.out.println("^^");
}
//我要干甚么? 求长方形的周长
//需要啥完成它? 长和宽
public static void c(int a, int b) {
int C = (a + b) * 2;
System.out.println(C);
}
}
package com.angus.method.theFormatOfTheMethod_2;
public class test2 {
public static void main(String[] args) {
//需求：定义一个方法，求圆的面积，将结果在方法中进行打印。
//目标：根据不同的需求，选择定义无参的方法，还是带参数的方法 -> 带参
getS(3);
System.out.println("^^");
}
public static void getS(double r) {
double S = r * r * 3.14;
System.out.println(S);
}
}
package com.angus.method.theFormatOfTheMethod_2;
public class test3 {
public static void main(String[] args) {
//目标：要能区分出什么时候使用带返回值的方法 ->要在调用处用到返回值的时候
//需求：定义方法，比较两个长方形的面积
double S1 = getArea(1,1);
double S2 = getArea(2,2);
if (S1 > S2){
System.out.println("第一个面积大");;
} else {
System.out.println("第二个面积大");;
}
System.out.println("^^");
}
public static double getArea(double length,double width) {
double area = length * width ;
return area;
}
}
1.3 方法的重载
package com.angus.method.overloadingOfMethod_3;
public class note {
public static void main(String[] args) {
// 方法的重载
//
// 在同一个类中,定义了多个同名的方法,这些同名的方法具有同种的功能
// 每个方法具有不同的参数类型或参数个数,这些同名的方法,就构成了重载关系
//
// 简单记:
// 就是看是不是在同一个类中,方法名是不是相同,形参是不是不同,不看返回值
// 形参不同有哪些不同:个数,类型,顺序(不建议用)
System.out.println("^^");
}
}
package com.angus.method.overloadingOfMethod_3;
public class test1 {
public static void main(String[] args) {
long num1 = getNum(1);
int num2 = getNum(2);
if (num2 == num1) {
System.out.println("相等");
} else {
System.out.println("不相等");
}
System.out.println("^^");
}
public static long getNum(long num) {
return num;
}
public static int getNum(int num) {
return num;
}
public static short getNum(short num) {
return num;
}
public static byte getNum(byte num) {
return num;
}
}
package com.angus.method.overloadingOfMethod_3;
public class test2 {
public static void main(String[] args) {
com((byte)1,(byte)2);
com((short)2,(short)3);
com(3,4);
com(56464646464464166L,6841864164164164189L);
byte a = 1;
byte b = 1;
com(a,b);
byte b1 = 5;
byte b2 = 5;
com(b1,b2);
int c = 2;
int d = 2;
com(c,d);
System.out.println("^^");
}
//方法重载的好处
//1.一个单词就可以干很多事情
//2.调用方法变得非常容易
public static void com(byte b1,byte b2) {
System.out.println("byte");
System.out.println(b1 == b2);
}
public static void com(short s1,short s2) {
System.out.println("short");
System.out.println(s1 == s2);
}
public static void com(int i1,int i2) {
System.out.println("int");
System.out.println(i1 == i2);
}
public static void com(long n1,long n2) {
System.out.println("long");
System.out.println(n1 == n2);
}
}
package com.angus.method.overloadingOfMethod_3;
public class test3 {
public static void main(String[] args) {
//需求:设计一个方法用于数组遍历,要求遍历的结果是在一行上的,例如:[1,2,3,4,5]
int arr[] = {1,2,3,4,5};
getArr(arr); //把数组名放进去,要记住方法名+数组名才可以调用
System.out.println(); //只做换行处理,换行了下面的才不会接着
System.out.println("^^");
}
public static void getArr(int arr[]){ // (int类型 数组名[]) ,要记住数据类型+变量名/数组名[],调用时变量直接写数值,数组写数组名,不绝对哈,这只是目前的领悟
System.out.print("["); //->不换行,下面的才会接着
for (int i = 0; i < arr.length; i++) {
if ( i == arr.length - 1) {
System.out.print(arr[i]);
} else {
System.out.print(arr[i] + ", ");
}
}
System.out.print("]"); //->上一个不换行,自己才能接着
}
}
package com.angus.method.overloadingOfMethod_3;
public class test4 {
public static void main(String[] args) {
//设计一个方法求数组的最大值,并将最大值值返回
int arr[] = {1,5,6,7,2,4,6,9};
int max = getMax(arr);
System.out.println(max);
System.out.println("^^");
}
public static int getMax(int[] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
}
package com.angus.method.overloadingOfMethod_3;
public class test5 {
public static void main(String[] args) {
//定义一个方法判断数组中的某一个数是否存在,将结果返回给调用处
int arr[] = {1,2,3,4,5,6,7,8,9};
boolean pan = pan(arr,9);
System.out.println(pan);
System.out.println("^^");
}
//1.干啥 -> 定义一个方法判断数组中的某一个数是否存在,将结果返回给调用处
//2.怎么干,需要啥 -> 数组,某一个数
//3.返否 -> 返,因为判断
public static boolean pan(int arr[], int num) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
return true;
}
}
return false;
}
}
//return结束方法并返回结果
//break结束循环或者switchpackage com.angus.method.overloadingOfMethod_3;
public class test6 {
public static void main(String[] args) {
//复制数组
//需求: 定义一个方法copyOfRange(int[] arr,int from,int to)
//功能: 将索引arr中从索引from(包含from)开始,
//到索引to结束(不包含to)的元素复制到新数组中,
//将新数组返回
//老数组
int arr[] = {1,2,3,4,5,6,7,8,9};
//返回,又得定义一个新数组
int newArr2[] = copyOfRange(arr,3,7);
//遍历
for (int i = 0; i < newArr2.length; i++) {
System.out.print(newArr2[i] + " "); //下次注意,打印的是元素newArr2[i],不是索引i
}
System.out.println();
System.out.println("^^");
}
public static int[] copyOfRange(int[] arr,int from,int to) {
//index自增,伪造索引思想
int index = 0;
//新数组
int newArr1[] = new int[to - from];
for (int i = from; i < to; i++) { //遍历的话,不是谁固定遍历,而是只要有循环都可以遍历,所以数组赋值给数组的操作才能进行 -> test6_6演示
//老数组复制给新数组
newArr1[index] = arr[i];
index++;
}
//返回
return newArr1;
}
}
package com.angus.method.overloadingOfMethod_3;
public class test6_6 {
public static void main(String[] args) {
int arr[] = {1,2,3};
int brr[] = {4,5,6};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
System.out.println(brr[i]);
}
System.out.println("^^");
}
}
未完待续...