JavaSEDemo05

Introducción

• Este artículo es una nota compilada la noche del 24 de marzo de 2021
• Puede haber muchos detalles, léalo con paciencia.
• Mi contenido y mis respuestas no son necesariamente los mejores y más correctos. Doy la bienvenida a mis amigos en el área de comentarios para que corrijan y mejoren.

Especificación del uso de la declaración de devolución en el método nulo

• El método void generalmente no escribe una declaración de retorno, por supuesto, también se puede escribir.
• La especificación de uso de la declaración return en el método void: (1) nada va seguido de return; (2) return debe ser la última oración.
• (1) Si escribimos un valor después de la declaración de retorno
• Ejemplo de código:

public static void method(){
    
    
        return null;
    }

• Figura
  
• Explicación del error No se puede devolver un valor de un método cuyo tipo de valor de retorno es nulo
• (2) Si escribimos una declaración después de la declaración de devolución

    public static void method(){
    
    
        return;
        System.out.println();
    }

• Figura
  
• Explicación: Frase inalcanzable;

API variable y API inmutable

• API variable: una API que opera en una memoria existente dada
• API inmutable: una API que necesita asignar nueva memoria para ejecutarse durante la ejecución. La nueva palabra clave crea un objeto cuando es una API inmutable, que asigna nuevo espacio para el objeto.
• Entre ellos, el más común, el tipo String de Java no tiene ninguna API variable, porque cualquier cambio que realice en la cadena solo crea un nuevo objeto de cadena.

Intercambio de datos y transferencia de parámetros de métodos

public class Test {
    
    
    public static void main(String[] args) {
    
    
        int a = 10;
        int b = 20;
        swap(a,b);
        System.out.println("main方法中a:"+a+" b:"+b);
    }
    public static void swap(int a,int b){
    
    
        int temp = a;
        a = b;
        b = temp;
        System.out.println("swap方法中a:"+a+" b:"+b);
    }
}

Resultados de ejecución del programa

swap方法中a:20 b:10
main方法中a:10 b:20

• ¿Por qué no se intercambian los valores de ayb en el método principal?
• Debido a que Java utiliza la transferencia de valor, la transferencia de valor consiste en copiar los parámetros reales del método pasado a los parámetros formales y no afectará a los parámetros reales originales.
• Escribí sobre la transferencia de valor y la transferencia de referencia en otro blog. Si está interesado, puede hacer clic en Ir al
  21/03/2021 Problemas encontrados al pasar parámetros al método en Java
• Por favor, consulte el diagrama de memoria.
  
• Entonces, ¿cómo intercambiar datos? Podemos usar clases para empaquetar datos (tenga en cuenta que la clase de empaque no es lo mismo)
• Nota: La clase de usuario y la prueba en este código están en dos archivos java respectivamente

//定义一个User类
public class User {
    
    
    int a = 10;
    int b = 20;
}
---------------------------------------------------
//测试类
public class Test {
    
    
    public static void main(String[] args) {
    
    
        User user = new User();
        swap(user);
        System.out.println("main方法中a:"+user.a+" b:"+user.b);
    }
    public static void swap(User user){
    
    
        int temp = user.a;
        user.a = user.b;
        user.b = temp;
        System.out.println("swap方法中a:"+user.a+" b:"+user.b);
    }
}

Resultados de ejecución del programa

swap方法中a:20 b:10
main方法中a:20 b:10

• ¿Por qué se puede realizar el intercambio de datos después de empaquetar los datos con clases?
• Porque cuando creamos un objeto, Java asignará memoria para el objeto en el montón. Accedemos a las variables miembro almacenadas en el montón a través del objeto. El parámetro pasado en el método de intercambio es la dirección del objeto en el montón, y el los datos intercambiados también están en la variable de pila.
• Por favor, consulte el diagrama de memoria.
  

¿Por qué no se puede usar el tipo de valor de retorno para determinar si el método está sobrecargado?

    public void add(double a,double b){
    
    

    }
    public double add(double a,double b){
    
    
        double sum = a + b;
        return sum;
    }

• Supongamos que definimos dos métodos con el mismo nombre, la misma lista de parámetros y diferentes tipos de valor de retorno. (El código anterior es incorrecto)
• Si queremos llamar a un método con un valor de retorno, el compilador llama a un método sin un tipo de valor de retorno para nosotros. ¿No es una broma?
• El compilador es estúpido y poco claro.

parámetro variable

    public static void show(int a,int...b){
    
    
    }

• El código anterior: int ... b es un parámetro variable
• No importa cuántos parámetros ingrese más tarde, puede recibir
• Condiciones de uso:
• (1) Solo puede haber un parámetro variable
• (2) Los parámetros variables deben escribirse al final de la lista de parámetros
• (3) Formato de escritura: tipo de datos ... los tres puntos del nombre del parámetro y el tipo de datos antes y después del nombre del parámetro y si hay un espacio entre el nombre del parámetro
• (4) Los parámetros variables son similares a las matrices y también tienen longitud: nombre de parámetro. Longitud

public class Test {
    
    
    public static void main(String[] args) {
    
    
        System.out.println(show(1,2,3,4,5,6,7));
    }
    public static int show(int...a){
    
    
         return a.length;
    }
}

Resultados de ejecución del programa

7

El método común y el método de construcción tienen el mismo nombre

• Los métodos y constructores comunes con el mismo nombre están permitidos en Java, pero esto no se recomienda

public class User {
    
    
    String name;
    int age;
    //无参构造方法
    public User() {
    
    
        System.out.println("无参构造方法被调用");
    }
    //全参构造方法
    public User(String name, int age) {
    
    
        this.name = name;
        this.age = age;
        System.out.println("全参构造方法被调用");
    }
    //普通方法
    void User(){
    
    
        System.out.println("普通方法被调用");
    }
}
---------------------------------------------------
public class Test {
    
    
    public static void main(String[] args) {
    
    
        User u1 = new User();
        User u2 = new User("张三",20);
    }
}

Resultados de ejecución del programa

无参构造方法被调用
全参构造方法被调用

• Cuando creamos un objeto, solo llamamos al método de construcción, si queremos llamar a un método normal, una vez creado el objeto, lo llamamos mediante el nombre del objeto y el nombre del método.

El constructor llama al constructor con el mismo nombre

public class User {
    
    
    int number;
    int age;
    //全参构造方法
    public User(int number, int age) {
    
    
        this.number = number;
        this.age = age;
    }
    //无参构造方法
    public User() {
    
    
        this(0,0);
    }
}

• Como en el código anterior, el método de construcción de parámetros completos se llama en el método de construcción sin parámetros, y los parámetros reales son 0 y 0
• La especificación del método de construcción para llamar al método de construcción del mismo nombre: esta declaración debe ser la primera oración
• De lo contrario, se producirá el siguiente error:
  
  Explicación del error: la primera instrucción del método de construcción debe llamarse cuando se llama a this ().

esto y programación en cadena

• Usamos un fragmento de código para demostrar el efecto de la programación en cadena.

//苹果类
public class Apple {
    
    
    int apple = 0;
    //返回值类型为本类Apple类,返回this,即返回调用此方法的对象，调用时可以连续调用。
    public Apple addApple(){
    
    
           apple++;
           return this;
    }
    //打印苹果的数量
    public void print(){
    
    
        System.out.println("共有苹果:"+apple+"个");
    }
}
-----------------------------------
//测试类
public class Test {
    
    
    public static void main(String[] args) {
    
    
        Apple apple = new Apple();
        //一共调用了3次addApple方法,apple增加了3次
        apple.addApple().addApple().addApple().print();
    }
}

Resultados de ejecución del programa

共有苹果:3个

esto se usa para pasar la referencia del objeto

/* 定义父亲类和儿子类,父亲可以采摘苹果,儿子也可以采摘苹果
*/
public class Son {
    
    
       //定义苹果数量
      int apple;
      //定义一个儿子类中的摘苹果的方法
      public void pickApple(){
    
    
      //此方法中创建了一个Father类对象
         Father father = new Father();
         //将调用此方法的对象，传给父亲类中的摘苹果的方法
         father.pickApple(this);
      }


}
--------------------------------
public class Father {
    
    
       //定义一个父亲类中的摘苹果的方法,参数为Son类型的对象
    public void pickApple(Son son){
    
    
          son.apple = 50;
    }
    //main方法
    public static void main(String[] args) {
    
    
        Son son = new Son();
        son.pickApple();
        System.out.println(son.apple);
    }
}

Resultados de ejecución del programa

50

Se ve desordenado, echemos un vistazo al mapa de memoria.

modificador de acceso java

Firma del método

• Consiste en el nombre del método y la lista de parámetros. Las firmas de métodos se utilizan a menudo para sobrecargar y reescribir métodos.

Método de recursión y práctica

• El método se llama a sí mismo
• La recursividad del método debe tener una dirección clara, de lo contrario el programa continuará para siempre, formando un bucle sin fin
• Título del ejercicio:
  Un mono recoge muchos melocotones y come. Come melocotones de acuerdo con esta regla: come una más de la mitad del melocotón el primer día, come una más de la mitad de la mitad restante el segundo día y come el segundo día el tercer día Una mitad más del restante ... y así sucesivamente. En el séptimo día, resultó que sólo quedaba un melocotón. ¿Cuántos melocotones recogió el mono?
• Ideas para la resolución de problemas: podemos usar ideas matemáticas para resolver este problema.
• Establezca una F (n), F es la cantidad de melocotones yn es la cantidad de días
• Sabemos que F (7) = 1, el séptimo día es el sobrante del sexto día y la mitad de la comida se come el sexto día.
• Es decir, F (7) = F (6) -F (6) / 2 -1;
• Conversión, obtenemos F (6) = [F (7) +1] x 2
• Continuar obteniendo F (5) = [F (6) +1] X 2
• F (4) = [F (5) +1] X 2
• La ley es F (n) = [F (n + 1) + 1] X 2
• Al mismo tiempo, la condición de terminación de la recursividad es F (7) = 1
• Código:

public class Monkey {
    
    
    public static void main(String[] args) {
    
    
        System.out.println("最初有"+F(1)+"个桃子");
    }
    public static int F(int n){
    
    
               if(n ==7){
    
    
                   return 1;
               }else{
    
    
                   return (F(n+1)+1)*2;
               }
    }
}

Resultados de ejecución del programa

最初有190个桃子