基本介绍：
在某些情况下，我们需要定义成员方法（简称方法）比如人类：除了有一些属性外（年龄，姓名）
我们人类还有一些行为比如：可以说花，跑步，通过学习，还可以做算术题。这时就需要成员方法才能完成
案例演示：
public class Method01 {
public static void main(String[] args) {
//方法使用
/*
1、方法写好后，不去调用是没有效果的
2、先创建对象，再调用方法即可
*/
Person p1 = new Person();//创建对象
p1.speak();//调用方法
p1.cal01();
p1.cal02(10);//调用cal02方法 同时给n赋值10
p1.cal02(15);//可以多次调用方法
//调用getSum,同时sum1=10 sum2=20
//把方法getSum返回的值,赋给变量returnRes
int returnRes = p1.getSum(10, 20);
System.out.println("getSum返回的值=" + returnRes);
}
}
class Person {
String name;
int age;
//方法（成员方法）
//public：表示方法公开
//void:表示没有返回值
//speak:表示方法名
//():表示形参列表
//{}:方法体，要执行的代码
//System.out.println("这是一个人");:该方法输出的内容
public void speak() {
System.out.println("这是一个人");
}
//添加一个cal01 成员方法,可以计算从1+..+1000的结果
public void cal01() {
//循环完成
int res = 0;
for(int i = 1; i <= 1000; i++) {
res += i;
}
System.out.println("1+..+1000的和=" + res);
}
public void cal02(int n) {
int res = 0;
for(int i = 1; i <= n; i++) {
res += i;
}
System.out.println("1+..+1000的和=" + res);
}
/*
1.int 表示方法执行后,返回一个int值
2.getSum 方法名
3.(int num1, int num2)形参列表,2个形参,可以接收用户传入的两个数
4.return res;表示把res的值,返回
*/
public int getSum(int num1, int num2) {
int res = num1 + num2;
return res;
}
}
不使用方法遍历数组：
public class Method02 {
public static void main(String[] args) {
int[][] map = {{0, 0, 1}, {1, 1, 1}, {1, 1, 3}};
for(int i = 0; i < map.length; i++) {
for(int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " ");
}
System.out.println();
}
for(int i = 0; i < map.length; i++) {
for(int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " ");
}
System.out.println();
}
for(int i = 0; i < map.length; i++) {
for(int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " ");
}
System.out.println();
}
}
}
代码冗余，可读性差，维护麻烦
使用方法遍历数组：
public class Method02 {
public static void main(String[] args) {
int[][] map = {{0, 0, 1}, {1, 1, 1}, {1, 1, 3}};
MyTools tool = new MyTools();
//多次调用方法即可
tool.printArr(map);
tool.printArr(map);
tool.printArr(map);
}
}
//把输出的功能,写到一个类方法中,然后调用该方法即可
class MyTools {
//方法,接收一个二维数组
public void printArr(int[][] map) {
for(int i = 0; i < map.length; i++) {
for(int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " ");
}
System.out.println();
}
}
}提高了代码的复用性
将实现的细节封装起来，供其他用户调用就行
当不写访问修饰符时使用默认修饰符，主要有四种（public，protected，默认，private）
1、一个方法最多有一个返回值，当要返回多个结果，使用数组。
2、返回类型可以为任意类型，包括基本类型或引用类型（数组，对象）
案例演示：
public class MethodDetail {
public static void main(String[] args) {
AA a = new AA();
int[] res = a.geta(1, 4);
System.out.println("和=" + res[0]);
System.out.println("差=" + res[1]);
}
}
class AA {
//一个方法最多有一个返回值,如何返回多个结果,使用数组
public int[] geta(int n1, int n2) {
int[] resArr = new int[2];
resArr[0] = n1 + n2;
resArr[1] = n1 - n2;
return resArr;
}
}3.方法要求有返回数据类型， 则方法体中最后的执行语句必须为return值；而且要求返回值类型必须和return的值类型一致或兼容
案例演示：
public double a(){
double a = 1.1;
int n = 1;
return a; //ok
return 1.1;//ok
return n;//ok 会自动进行类型转换
}4.如果方法是void，则方法体重可以没有return语句，或者只写return
案例演示：
public void aa(){
return; //可以写return，但是不能返回数据类型
}遵循驼峰命名法，最好见名知意。
1.一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，比如arr(int n1, int n2)
2.参数类型可以为任意类型，包含基本类型或者引用类型，比如arr(int[][] map)
3.调用参数的方法时，一定对应着参数列表传入相同类型或者兼容类型的参数
4.方法定义时的参数称为形式参数，简称参数；方法调用时的参数称为实际参数，简称实参，实参和形参的类型要一致或兼容、个数、顺序必须一致！
完成功能的具体语句，可以是输入、输出、变量、运算、分支、循环、方法调用，但不允许方法里面再定义方法。即：方法不能嵌套定义。
案例演示：
public void a(){
public void b(){ //编译就报错
}
}1、同一个类中的方法调用，直接调用就行。
案例演示：
public class MethodDetail {
public static void main(String[] args) {
A a = new A();
a.say();
}
}
class A {
//同一个类中的方法调用，直接调用就行。
public void print(int n) {
System.out.println("print()方法被调用 n=" + n);
}
public void say() {//say调用 print 直接调用
print(10);
System.out.println("继续执行say");
}
}2、跨类中的方法A类调用B类的方法，需要通过对象名调用
案例演示：
public class Method4 {
public static void main(String[] args) {
B b = new B();
b.b1();
}
}
class A{
public void m1(){
System.out.println("m1方法被调用");
//先创建B对象，再调用方法
B b = new B();
b.b1();
}
}
class B{
public void b1(){
System.out.println("b1方法调用");
}
}1.编写一个类，有一个方法判断一个数是奇数还是偶数，返回Boolean。
import java.util.Scanner;
public class MethodExercise01 {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
AA a = new AA();
System.out.println("请输入一个数");
int arr = myScanner.nextInt();
if(a.bb(arr)) {
System.out.println("这个数是偶数");
}else {
System.out.println("这个数是奇数");
}
}
}
// 创建一个类
class AA {
// 创建一个新方法
public boolean bb(int n) {
// if(n % 2 != 0) {
// return true;
// }else {
// return false;
// } 可以简化
// return n % 2 != 0 ? true; false; 再简化
return n % 2 == 0;
}
}2.根据行、列、字符打印对应行数和列数的字符。
import java.util.Scanner;
public class MethodExercise02 {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
AA a = new AA();
System.out.println("请输入行");
int arr = myScanner.nextInt();
System.out.println("请输入列");
int brr = myScanner.nextInt();
System.out.println("请输入需要打印的字符");
char crr = myScanner.next().charAt(0);
System.out.println("===开始打印===");
a.bb(arr, brr, crr);
}
}
// 创建一个类
class AA {
// 创建一个新方法
// 思路
// 1.方法的返回类型 void
// 2.方法的名字
// 3.方法的形参
// 4.方法体，循环
public void bb(int n, int m, char c) {
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
System.out.print(c + " ");
}
System.out.println();//换行
}
}
}基本数据类型，传递的是值（值拷贝），形参的任何改变不影响实参。
案例演示：
public class MethodParameter01 {
public static void main(String[] args) {
int a = 1;
int b = 2;
// 创建AA的对象
AA aa = new AA();
aa.swap(a, b);
System.out.println("main方法中的值a=" + a + "\tb=" + b);
}
}
// 创建一个类
class AA {
public void swap(int a, int b) {
System.out.println("\na和b交换前的值\na=" + a + "\tb=" + b);
//完成了a和b的交换
int tmp = a;
a = b;
b = tmp;
System.out.println("\na和b交换后的值\na=" + a + "\tb=" + b);
}
}引用数据类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参。
案例演示：
public class MethodParameter02 {
public static void main(String[] args) {
//测试
B b = new B();
int[] arr = {1, 2, 3};
b.test(b);
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");//输出结果200 2 3
}
System.out.println();
}
}
// 创建一个类
class B {
public void test(int[] arr) {
arr[0] = 200;//修改元素
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");//输出结果200 2 3
}
System.out.println();
}
}案例演示2：
对象属性也会影响
public class Method {
public static void main(String[] args) {
Persons p = new Persons();
p.name = "jcak";
p.age = 10;
B b = new B();
b.test(p);
System.out.println("main方法中的年龄为：" + persons.age);
}
}
class Persons{
String name;
int age;
}
class B{
public void test(Persons p){
p.age = 100;//修改对象属性
}
}1.编写类Mytools类，编写一个方法可以打印二维数组的数据
public class MethodExercise03 {
public static void main(String[] args) {
MyTools a = new MyTools();
int[][] aa = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};
a.bb(aa);
}
}
// 创建一个类
class MyTools {
// 创建一个新方法,接收二维数组
public void bb(int[][] map) {
for(int i = 0; i < map.length; i++) {
for(int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " ");
}
System.out.println();//换行
}
}
}2.编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。克隆对象，
注意要求得到新的对象和原来的对象是两个独立的对象，只是他们属性相同
public class MethodExercise04 {
public static void main(String[] args) {
/*
编写一个方copyPerson,可以复制一个Person对象，返回复制的对象。克隆对象
注意要求得到的新对象和原来的对象是两个独立的对象，只是他们的属性相同
*/
Person p = new Person();
p.name = "jack";
p.age = 10;
//创建tools
MyTools tools = new MyTools();
Person p2 = toosl.copyPerson(p);
//到此p和p2是Person的对象,但是是两个独立的对象,属性相同
System.out.ptintln("P的属性 age=" + p.age + "名字=" + p.name);
System.out.ptintln("P2的属性 age=" + p2.age + "名字=" + p2.name);
//可以通过对象比较看看是否为同一个对象
System.out.ptintln(p == p2);
}
}
// 创建一个类
class Person {
String name;
int age;
}
class MyTools {
// 编写思路
// 1.方法的返回类型 Person
// 2.方法的名字copyPerson
// 3.方法的形参(Person p)
// 4.方法体，创建一个新对象，并复制属性，返回即可
public Person copyPerson(Person p) {
Person p2 = new Person();
p2.name = p.name;
p2.age = p.age;
return p2;
}
}