- Métodos (Métodos)
está diseñado para usar ciertas funciones del programa para ayudar a resolver problemas. En otros lenguajes de programación, llamamos subrutinas / funciones de "métodos" de Java.
1.1 Definición de métodos
Java es un lenguaje orientado a objetos. Sus métodos son los mismos que las variables. Cada método tiene su propio objeto de clase. La clase integra múltiples métodos para formar un objeto de clase con funciones específicas. Cada método también puede considerarse como un bloque. Cuando utilice el método, preste atención a sus propiedades de objeto de clase, parámetros y reglas de valor de retorno, a saber
1. En la clase, cree un método (Declarar) para crear (Métodos).
2. Si el método declarado no ejecuta datos de retorno, debe estar precedido por void, si es para ejecutar datos de retorno, no debe estar precedido por void. Debe haber una devolución en el contenido. En resumen, vacío y retorno no pueden coexistir.
3. Al usar métodos, primero debe generar un nuevo objeto con la nueva clase y luego ejecutar el método en el nuevo objeto.
4. Cuando utilice el método, preste atención a los parámetros entre el programa que realiza la llamada y el programa llamado, que deben ser consistentes, es decir (a) Los tipos de parámetros deben ser consistentes. Si se viola este tipo de regla, el programa no se ejecutará.
class Study {
int credit = 0;
void addcredit(int i) {
credit +=i;
}
int totalcredit() {
return credit;
}
}
public class Student {
public static void main(String[] args) {
Test a = new Test();
Test b = new Test();
a.addcredit(12);
b.addcredit(9);
b.addcredit(6);
System.out.println("a.addcredit:"+a.totalcredit());//12
System.out.println("b.addcredit:"+b.totalcredit());//15
}
}
1.2 Métodos de instancia (Métodos de instancia)
Este método solo se puede utilizar cuando el objeto de clase al que pertenece el método existe, de modo que el método que existe con la existencia del objeto se denomina "método de instancia".
public class Number {
int n=0;
void addN(int i) {
n=i;
}
int getN() {
return n;
}
}
public static void main(String[] args) {
Number N; //删除后报错
N = new Number();//删除报错
N.addN(10);
System.out.println("使用方法 N.getN:"+N.getN());//10
}
- Los métodos de clase (métodos de clase)
cuando se declara el método, el prefijo "estático" puede mantener que el método declarado siempre exista, sin tener que pasar por el proceso de generación de nuevos objetos, se puede ejecutar directamente, llamados "métodos de clase".
public class Number {
static int n=0;
static void addN(int i) {
n=i;
}
static int getN() {
return n;
}
}
public static void main(String[] args) {
Number.addN(10);
System.out.println(" N.getN:"+Number.getN());//10
Number.n = 20;
System.out.println("Number.n:"+Number.n);//20
}
En comparación con los métodos de instancia, los métodos de clase ya no pueden ser objetos nuevos, y puede usar directamente variables en estática.
- Las
características de constructor de la clase Constructor (Constructor) son:
1. El nombre del constructor debe ser el mismo que el de la clase a la que pertenece.
2. El constructor es un método, a diferencia de otros métodos generales, no hay datos de retorno (sin retorno), y no hay un vacío inicial.
3. El constructor genera un nuevo objeto en la clase para inicializar y ejecutar.
4. En la clase, si no hay un constructor, el sistema proporcionará automáticamente un constructor en blanco oculto predeterminado (Constructor predeterminado).
public class Mynumber {
int n;
Mynumber(){
n = 3;
System.out.println("Here is Constructor and n="+n);
}
int getnumber() {
return n;
}
}
public static void main(String[] args) {
Mynumber a = new Mynumber();
System.out.println("Here is main and a.getnumber()="+a.getnumber());//3
}
4.
Hay varios métodos en la clase de sobrecarga de métodos con el mismo nombre y la misma función pero diferentes parámetros, los tipos de datos y el número de parámetros son diferentes. Cuando se llama a la clase a ejecutarse, el método con el mismo tipo de parámetro y número se acepta automáticamente para ejecutarse. Dicho objeto se denomina "sobrecarga de método".
public class adder {
int add(int a,int b) {
return a+b;
}
double add(double a, double b) {
return a+b;
}
int add(int x, int y, int z) {
return x+y+z;
}
}
public static void main(String[] args) {
int j;
double k;
int m;
adder ad = new adder();
j=ad.add(5, 7);
k=ad.add(1.2, 1.32);
m=ad.add(12, 12,52);
System.out.println("j="+j);//12
System.out.println("k="+k);//2.52
System.out.println("m="+m);//76
}
- Sobrecarga del constructor
public class adder {
int c;
double k;
adder(int a,int b) {
c=a+b;
System.out.println("int c="+c);
}
adder(double a, double b) {
k=a+b;
System.out.println("double k="+k);
}
}
public static void main(String[] args) {
adder add_int = new adder(2,3);//5
adder add_double = new adder(13.2,2.3);//15.5
}
- Los modificadores públicos / privados (Modificaciones)
declaran variables (Variables) o métodos (Métodos ) en la clase que pueden tener como prefijo modificadores públicos y privados para limitar su entorno de uso y tiempo.
1. Cuando las variables (Métodos) y los Métodos (Métodos) tienen el prefijo public, son variables públicas o métodos públicos, y se pueden ejecutar y llamar a otros tipos de objetos.
2. Cuando las variables y los métodos tienen el prefijo privado, son variables privadas o métodos privados. Solo se permiten los métodos en sus propios objetos de clase, y no se debe llamar a otros objetos de clase.
3. Cuando no hay un premodificador, es la configuración predeterminada (Predeterminada), que permite ejecutar llamadas en el mismo paquete (paquete), y no se puede llamar en paquetes diferentes. Además, el modificador protegido tiene la misma función.
6.1 Sin modificaciones (modificaciones predeterminadas)
class Number {
int number;
}
public class Lab {
public static void main(String[] args) {
Number i = new Number();
i.number=10;
System.out.printf("i.n=%d",i.number);//i.number=10
}
}
Nota: Cuando las variables y los métodos no tienen pre-modificadores, es la configuración predeterminada (Predeterminada), que solo se puede ejecutar y llamar en el mismo paquete (paquete), y no se puede usar en paquetes diferentes.
6.2 Premodificador público
public class Number {
public int N;
}
import text_two.Number;
public class Lab {
public static void main(String[] args) {
Number i = new Number();
i.N=10;
System.out.printf("i.N=%d",i.N);//i.N=10
}
}
Los paquetes deben importarse en diferentes paquetes: formato: import <nombre de paquete>. <Nombre de clase>; y la clase del paquete importado debe ser pública. Si está bajo el mismo paquete, solo se requiere la palabra clave pública variable.
6.3 Cuando las variables y los métodos tienen el prefijo privado, solo se permite usar los métodos en sus propios objetos de clase, y no se debe llamar a otros objetos de clase.
class Study {
private int credit = 0;
public void addcredit(int i) {
credit +=i;
}
public int totalcredit() {
return credit;
}
}
public class Lab {
public static void main(String[] args) {
Study joe = new Study();
Study george = new Study();
joe.addcredit(12);
george.addcredit(9);
joe.addcredit(6);
george.addcredit(3);
System.out.println("joe studied:"+joe.totalcredit()+"credites");//joe studied:18credites
System.out.println("george studied:"+george.totalcredit()+"credites");//george studied:12credites
}
}
- esta palabra clave
Cuando un constructor llama a otro constructor sobrecargado con this (), this () debe colocarse en la primera línea del constructor.
7.1 Clase
En una clase compleja, para simplificar el diseño del programa y aumentar la legibilidad del programa, esto se usa en el método, lo que significa la palabra clave del objeto de clase.
class Mynumber {
private int n;
public void setnumber(int i) {
this.n=i;
}
public int getnumber() {
return n;
}
}
public class Lab {
public static void main(String[] args) {
Mynumber M = new Mynumber();
M.setnumber(10);
System.out.println("My.getnumber:"+M.getnumber());
}
}
