introducción básica
En algunos casos, necesitamos definir métodos miembro (métodos para abreviar). Por ejemplo, los seres humanos: Además de algunos atributos (edad, nombre...), los humanos también tenemos algunos comportamientos como: podemos hablar, correr..., a través del aprendizaje, también podemos resolver problemas aritméticos. En este momento, es necesario utilizar métodos de miembros para completar. Ahora se requiere completar la clase Person.
Definición de métodos miembro
público (modificador de acceso) devuelve el nombre del método del tipo de datos ( lista de parámetros.. ) {//instrucción del cuerpo del método; devuelve el valor devuelto;
}
explicar:
(1) Lista de parámetros formales: indica la entrada del método miembro,
por ejemplo: person(int n), getSum(int num1, int num2)(2) Tipo de datos de retorno: indica la salida del método miembro , void indica que no hay valor de retorno
(3) Cuerpo del método: indica que para realizar un determinado bloque de código funcional
(4) La declaración de devolución no es necesaria .
Caso de inicio rápido
(1) Agregue el método de miembro de voz para generar "Soy una buena persona"
public class Method {
//编写一个main方法
public static void main(String[] args) {
Person p1 = new Person();//创建对象
p1.speak(); //调用方法
}
}
class Person {
public void speak() {
System.out.println("我是一个好人");
}
}
(2) Agregue el método miembro cal01, que puede calcular el resultado de 1+..+1000
public class Method {
//编写一个main方法
public static void main(String[] args) {
Person p1 = new Person();//创建对象
p1.cal01(); //调用cal01方法
}
}
class Person {
public void cal01() {
int res = 0;
for(int i = 1; i <= 1000; i++) {
res += i;
}
System.out.println("cal01方法的计算结果=" + res);
}
}
(3) Agregue el método miembro cal02, que puede recibir un número n y calcular el resultado de 1+..+n
public class Method {
//编写一个main方法
public static void main(String[] args) {
Person p1 = new Person();//创建对象
p1.cal02(5); //调用cal02方法，同时给n = 5
p1.cal02(10); //调用cal02方法，同时给n = 10
}
}
class Person {
public void cal02(int n) {
//循环完成
int res = 0;
for(int i = 1; i <= n; i++) {
res += i;
}
System.out.println("cal02方法 计算结果=" + res);
}
}
(4) Agregue el método miembro getSum, que puede calcular la suma de dos números
public class Method {
//编写一个main方法
public static void main(String[] args) {
Person p1 = new Person();//创建对象
/*把 方法 getSum 返回的值，赋给 变量 returnRes
然后调用getSum方法，同时num1=10, num2=20
*/
int returnRes = p1.getSum(10, 20);
System.out.println("getSum方法返回的值=" + returnRes);
}
}
class Person {
public int getSum(int num1, int num2) {
int res = num1 + num2;
return res;//返回res的值
}
}Beneficios de los métodos de miembro
(1) Mejorar la reutilización del código
(2) Los detalles de la implementación pueden ser encapsulados y luego llamados por otros usuarios
¿Por qué necesita métodos de miembros?
Requisitos de referencia:
Atraviese una matriz y genere el valor de cada elemento de la matriz.
Solución 1: el método tradicional es usar un solo bucle for para generar la matriz.
Solución 2: defina una clase MyTools, luego escriba un método miembro y llame al método para lograr
public class Method {
//编写一个 main 方法
public static void main(String[] args) {
int [][] map = {
{0,0,1},{1,1,1},{1,1,3}};//遍历数组 , 输出数组的各个元素值
//遍历 map 数组
for(int i = 0; i < map.length; i++) {
for(int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + "\t");
}
System.out.println();
}
}
}Este es el método tradicional, atravesar directamente, pero si se requiere atravesar la matriz de mapas nuevamente, ¿es necesario escribir un ciclo for? Está bien recorrer una o dos veces, pero si la empresa requiere 100 o 1000 recorridos, ¿no sería necesario escribir 100 o 1000 bucles for? Esto es demasiado ineficiente y laborioso, y el código no es muy legible, por lo que debemos usar el método para completar la salida en este momento:
public class Method {
//编写一个 main 方法
public static void main(String[] args) {
int [][] map = {
{0,0,1},{1,1,1},{1,1,3}};//遍历数组 , 输出数组的各个元素值
MyTools tool = new MyTools();//创建 MyTools 对象
tool.printArr(map);//使用方法
class MyTools {
public void printArr(int[][] map) {
System.out.println("=======");
for(int i = 0; i < map.length; i++) {//对map数组进行遍历输出
for(int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + "_");
}
System.out.println();
}
}
}El método tool.printArr(mapa) se usa aquí ; en este momento, se puede ahorrar mucho esfuerzo para realizar el recorrido, que es más eficiente que los métodos tradicionales, ahorrando tiempo y esfuerzo