Lecture1 方法简介
- 方法：所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块
- 方法在类的内部定义，不能嵌套定义（即不能定义在另一个方法里）
- 方法的声明：语法格式
访问修饰符 返回类型 方法名(参数列表){
方法体;
}
- 方法分类：
- 无参无返回值
- 无参带返回值
- 带参无返回值
- 带参带返回值
Lecture2 方法类型
- 无参无返回值方法案例：
/**
* 使用方法进行星号打印
*/
public class MethodDemo {
//打印输出星号
public void printStar() {
System.out.println("**********************");
}
public static void main(String[] args) {
//创建MethodDemo类的对象methodDemo
MethodDemo methodDemo = new MethodDemo();
//使用对象名.方法名()调用方法
methodDemo.printStar();
System.out.println("欢迎来到Java的世界");
methodDemo.printStar();
}
}
- 无参带返回值方法案例：
/**
* 使用方法计算矩形面积
*/
public class RectangleArea {
//求矩形面积的方法
public int area() {
int length = 10;
int width = 5;
int calArea = length * width;
return calArea;//返回语句返回面积
}
public static void main(String[] args) {
RectangleArea rectangleArea = new RectangleArea();
System.out.println("矩形的面积为：" + rectangleArea.area());
}
}
- 带参无返回值方法案例：
/**
* 使用方法求两个float类型数据的最大值，并在方法中将最大值输出
*/
public class MaxDemo {
//求最大值的方法
public void max(float a, float b) {
float max;
if (a > b) {
max = a;
} else {
max = b;
}
System.out.println("最大值是：" + max);
}
public static void main(String[] args) {
MaxDemo maxDemo = new MaxDemo();
float m = 2.1f, n = 3.7f;
maxDemo.max(m, n);
}
}
- 带参带返回值方法案例：
/**
* 定义一个求n!的方法
* 然后计算1!+2!+3!+4!+5!
*/
public class FacDemo {
//求n!的阶乘
public int fac(int n){
int s = 1;
for(int i = 1; i <= n; i++){
s *= i;
}
return s;
}
public static void main(String[] args) {
FacDemo facDemo = new FacDemo();
//求1!+2!+3!+4!+5!
int sum = 0;
for(int i = 1; i <= 5; i++){
sum += facDemo.fac(i);
}
System.out.println("阶乘结果为："+sum);
}
}
Lecture3 数组作为方法参数
- 数组作为方法参数案例一：
/**
* 使用方法打印输出数组的元素
*/
public class ArrayMethod {
//输出数组元素的方法
public void printArray(int[] arr) {
for (int n : arr) {
System.out.print(n + " ");
}
System.out.println();//格式调整
}
public static void main(String[] args) {
ArrayMethod arrayMethod = new ArrayMethod();
int[] array = {10, 20, 30, 40, 50};
arrayMethod.printArray(array);
}
}
- 数组作为方法参数案例二：
import java.util.Scanner;
/**
* 使用方法查找数组元素的值
*/
public class ArraySearch {
//查找数组元素值的方法
public boolean search(int n, int[] arr) {
boolean flag = false;//默认没找到
for (int m : arr) {
if (m == n) {
flag = true;
break;//使用break语句提高程序的效率
}
}
return flag;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
ArraySearch arraySearch = new ArraySearch();
int[] array = {1, 2, 3, 4, 5};
System.out.println("请输入要查询的值：");
int n = sc.nextInt();
boolean flag = arraySearch.search(n, array);
if (flag) {
System.out.println("找到了");
} else {
System.out.println("没找到");
}
}
}
Lecture4 方法重载
- 方法重载：方法名相同，参数列表不同
- 方法重载案例：
/**
* 定义三个方法，实现int、double和数组类型和的问题
*/
public class MathDemo {
//求两个int类型数的和
public int plus(int a, int b) {
return a + b;
}
//求两个double类型的数的和
public double plus(double a, double b) {
return a + b;
}
//求数组元素的累加和
public int plus(int[] arr) {
int sum = 0;
for (int n : arr) {
sum += n;
}
return sum;
}
public static void main(String[] args) {
int m = 5, n = 10;
int[] array = {1, 2, 3, 4, 5, 6};
MathDemo mathDemo = new MathDemo();
System.out.println("int类型的和：" + mathDemo.plus(m, n));
System.out.println("double类型的和：" + mathDemo.plus(m, n));
System.out.println("数组元素的累加和：" + mathDemo.plus(array));
}
}
Lecture5 方法传值
- 基本数据类型的传值：基本数据类型传值，形式参数的改变对实际参数没有影响（传递的是值）
案例一：
public class ExchangeDemo1 {
//定义交换方法
public void swap(int a, int b) {
int temp;
System.out.println("交换前: a = " + a + ", b = " + b);
temp = a;
a = b;
b = temp;
System.out.println("交换后: a = " + a + ", b = " + b);
}
public static void main(String[] args) {
int m = 4, n = 5;
ExchangeDemo1 swapDemo = new ExchangeDemo1();
System.out.println("交换前: m = " + m + ", n = " + n);
swapDemo.swap(m, n);
System.out.println("交换后: m = " + m + ", n = " + n);
}
案例二：
public class ExchangeDemo2 {
public void add(int n) {
n++;
System.out.println("方法中n的值：" + n);
}
public static void main(String[] args) {
int n = 10;
System.out.println("方法调用前n的值：" + n);
ExchangeDemo2 exchangeDemo2 = new ExchangeDemo2();
exchangeDemo2.add(n);
System.out.println("方法调用后n的值：" + n);
}
}
- 数组的传值：数组类型传值，形式参数的改变对实际参数有影响（传递的是地址 -- 数组第一个元素的地址）
public class ArrayDemo {
//定义一个用于修改数组某个元素值的方法
public void update(int[] arr) {
arr[3] = 15;
System.out.println("修改后数组arr的元素为：");
for (int n : arr) {
System.out.print(n + " ");
}
System.out.println();
}
public static void main(String[] args) {
ArrayDemo arrayDemo = new ArrayDemo();
int[] array = {1, 2, 3, 4, 5};
System.out.println("方法调用前数组array的元素为；");
for (int n : array) {
System.out.print(n + " ");
}
System.out.println();
arrayDemo.update(array);
System.out.println("方法调用后数组array的元素为；");
for (int n : array) {
System.out.print(n + " ");
}
System.out.println();
}
}
Lecture6 可变参数列表
- 可变参数列表：又称为可变元参数或者可变参数类型
案例一：
public class ArgsDemo1 {
//求和
public void sum(int... n) {
int sum = 0;
for (int i : n) {
sum += i;
}
System.out.println("sum = " + sum);
}
public static void main(String[] args) {
ArgsDemo1 argsDemo = new ArgsDemo1();
argsDemo.sum(1);
argsDemo.sum(1, 2);
argsDemo.sum(1, 2, 3);
}
}
案例二：参数列表中如果有两个以上的参数，可变参数一定是在最后；可以将数组传递给可变参数列表，但是数组作为参数时，是不能将多个值传递给数组的
public class ArgsDemo2 {
//查找
public void search(int n, int... a) {
boolean flag = false;
for (int i : a) {
if (i == n) {
flag = true;
break;
}
}
if (flag) {
System.out.println("找到了");
} else {
System.out.println("没找到");
}
}
public static void main(String[] args) {
ArgsDemo2 argsDemo2 = new ArgsDemo2();
argsDemo2.search(3, 1, 2, 3, 4, 5);
int[] a = {4, 5, 6, 7, 8};
argsDemo2.search(3, a);
}
}
Tips：若此时定义另一个search方法 -- public void search(int n, int[] array)，并不是方法重载而是重复定义
- 可变参数列表作为方法参数的重载问题：可变参数列表所在的方法是最后被访问的；可变参数列表和数组可以同时作为方法参数。
案例：
public class ArgsDemo3 {
public int plus(int a, int b) {
System.out.println("不带可变参数列表的方法被调用");
return a + b;
}
public int plus(int... a) {
int sum = 0;
for (int i : a) {
sum += i;
}
System.out.println("带可变参数列表的方法被调用");
return sum;
}
public int plus(int[] arr, int... a) {
int sum1 = 0, sum2 = 0;
for (int i : arr) {
sum1 += i;
}
for (int i : a) {
sum2 += i;
}
return sum1 + sum2;
}
public static void main(String[] args) {
ArgsDemo3 argsDemo3 = new ArgsDemo3();
System.out.println("和为：" + argsDemo3.plus(1, 2));
int[] arr = {1, 2, 3};
System.out.println("可变参数列表和数组同时作为方法参数" + argsDemo3.plus(arr, 1, 2, 3, 4));
}
}
