Estructura básica del programa Java.

Directorio de artículos

Estructura básica del programa Java.
Variables de Java

Alcance variable

Tipos de datos básicos
Flujo del programa

Salida
De entrada
si juicio
más
mientras bucle
hacer mientras bucle
para bucle
Rotura
Seguir
Parámetros de línea de comando

La estructura básica de un programa Java completo es:

/**
 * 注释
 */public class Hello {
    public static void main(String[] args) {
        // 向屏幕输出文本:
        System.out.println("Hello, world!");
        /* 多行注释开始
        注释内容
        注释结束 */
    }
} // class定义结束

Java es un lenguaje orientado a objetos. La unidad básica de un programa es clase, y clase es una palabra clave. El nombre de clase definido aquí es Hola:

public class Hello { // 类名是Hello
    // ...
} // class定义结束

El nombre de la clase debe comenzar con una letra en inglés, seguida de una combinación de letras, números y guiones bajos.
Es habitual comenzar con una letra mayúscula.
Dentro de la clase, se pueden definir varios métodos:

public class Hello {
    public static void main(String[] args) { // 方法名是main
        // 方法代码...
    } // 方法定义结束
}

La palabra clave static es otro modificador, que indica un método estático. El método especificado por el programa de entrada Java debe ser un método estático, el nombre del método debe ser main y el parámetro entre paréntesis debe ser una matriz String.
Dentro del método, la declaración es el código de ejecución real. Cada línea de la declaración Java debe terminar con un punto y coma:

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, world!"); // 语句
    }
}

Java también admite comentarios de una o varias líneas. El compilador de Java ignorará los caracteres del comentario.

public class HelloWorld {
   /* 这是第一个Java程序
    *它将打印Hello World
    * 这是一个多行注释的示例
    */
    public static void main(String []args){
       // 这是单行注释的示例
       /* 这个也是单行注释的示例 */
       System.out.println("Hello World"); 
    }
}

Variables de Java

Hay varios tipos de variables en Java:

Variables locales
Variables de clase (variables estáticas)
Variables miembro (variables no estáticas)
En Java, las variables deben definirse antes de su uso.Al definir variables, puede darle un valor inicial. No escribir el valor inicial es equivalente a asignarle un valor predeterminado. El valor predeterminado es siempre 0.

public class Main {
//定义并打印变量
    public static void main(String[] args) {
        int x = 100; // 定义int类型变量x，并赋予初始值100
        System.out.println(x); // 打印该变量的值
    }
}

Alcance variable

En Java, las declaraciones de varias líneas están encerradas en {}. Muchas declaraciones de control, como juicios condicionales y bucles, toman {} como su propio alcance, por ejemplo:

if (...) { // if开始
    ...
    while (...) { while 开始
        ...
        if (...) { // if开始
            ...
        } // if结束
        ...
    } // while结束
    ...
} // if结束

Tipos de datos básicos

Java define los siguientes tipos de datos básicos:
byte:

El tipo de datos de byte es un entero con signo de 8 bits representado por el complemento de dos;
El valor mínimo es -128 (-2 ^ 7);
El valor máximo es 127 (2 ^ 7-1);
El valor predeterminado es 0;
El tipo de byte se usa en matrices grandes para ahorrar espacio, principalmente reemplazando enteros, porque la variable de byte ocupa solo una cuarta parte del tipo int;
例子： byte a = 100 ， byte b = -50。
corto ：
El tipo de datos cortos es un entero de dos bits con signo de 16 bits.
El valor mínimo es -32768 (-2 ^ 15);
El valor máximo es 32767 (2 ^ 15-1);
El tipo de datos cortos también puede ahorrar espacio como byte. Una variable corta es la mitad del espacio ocupado por una variable int;
El valor predeterminado es 0;
Ejemplo: corto s = 1000, corto r = -20000.
int:
El tipo de datos int es un entero con signo de 32 bits representado por el complemento de dos;
El valor mínimo es -2,147,483,648 (-2 ^ 31);
El valor máximo es 2,147,483,647 (2 ^ 31-1);
Por lo general, las variables enteras son por defecto tipo int;
El valor predeterminado es 0;
Ejemplo: int a = 100000, int b = -200000.
largo:
El tipo de datos largo es un entero de dos bits con signo de 64 bits;
El valor mínimo es -9,223,372,036,854,775,808 (-2 ^ 63);
El valor máximo es 9.223.372.036.854.775.807 (2 ^ 63 -1);
Este tipo se usa principalmente en sistemas que requieren enteros relativamente grandes;
El valor predeterminado es 0L;
Ejemplo: largo a = 100000L, largo b = -200000L.
Teóricamente, "L" no distingue entre mayúsculas y minúsculas, pero si se escribe como "l" es fácil confundirlo con el número "1" y no es fácil de distinguir. Entonces es mejor capitalizar.
flotador:
El tipo de datos flotantes es un número de coma flotante de 32 bits y precisión simple que cumple con el estándar IEEE 754;
flotante puede ahorrar espacio de memoria al almacenar grandes conjuntos de punto flotante;
El valor predeterminado es 0.0f;
Los números de coma flotante no se pueden usar para representar valores precisos, como la moneda;
Ejemplo: flotador f1 = 234.5f.
doble:
El tipo de datos doble es un número de coma flotante de doble precisión y 64 bits que cumple con el estándar IEEE 754;
El tipo predeterminado de número de coma flotante es de tipo doble;
El tipo doble tampoco puede representar valores precisos, como la moneda;
El valor predeterminado es 0.0d;
Ejemplo: doble d1 = 123.4.
booleano:
El tipo de datos booleanos representa un bit de información;
Solo hay dos valores: verdadero y falso;
Este tipo solo se usa como un signo para registrar la situación de verdadero / falso;
El valor predeterminado es falso;
Ejemplo: booleano uno = verdadero.
char:
El tipo char es un único carácter Unicode de 16 bits;
El valor mínimo es \ u0000 (es decir, 0);
El valor máximo es \ uffff (es decir, 65,535);
El tipo de datos char puede almacenar cualquier carácter;
Ejemplo: letra char = 'A';.

palabra clave var

var sb = new StringBuilder();

Para el compilador, la declaración se convertirá automáticamente en:

StringBuilder sb = new StringBuilder();

Flujo del programa

Salida

println es una abreviatura de línea de impresión, que significa salida y avance de línea. Por lo tanto, si no desea ajustar después de la salida, puede usar print ():

public class Main {
    public static void main(String[] args) {
        System.out.print("A,");
        System.out.print("B,");
        System.out.print("C.");
        System.out.println();
        System.out.println("END");
    }
}

La salida formateada usa System.out.printf (). Al usar el marcador de posición%?, Printf () puede formatear los siguientes parámetros en el formato especificado:

public class Main {
    public static void main(String[] args) {
        double d = 3.1415926;
        System.out.printf("%.2f\n", d); // 显示两位小数3.14
        System.out.printf("%.4f\n", d); // 显示4位小数3.1416
    }
}

De entrada

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 创建Scanner对象
        System.out.print("Input your name: "); // 打印提示
        String name = scanner.nextLine(); // 读取一行输入并获取字符串
        System.out.print("Input your age: "); // 打印提示
        int age = scanner.nextInt(); // 读取一行输入并获取整数
        System.out.printf("Hi, %s, you are %d\n", name, age); // 格式化输出
    }
}

Importe java.util.Scanner a través de la instrucción import. Import es una instrucción que importa una clase y debe colocarse al comienzo del código fuente de Java. Cree un objeto de escáner y páselo en System.in. System.out representa la secuencia de salida estándar y System.in representa la secuencia de entrada estándar. Con el objeto Scanner, para leer la cadena ingresada por el usuario, use scanner.nextLine (), y para leer el número entero ingresado por el usuario, use scanner.nextInt (). El escáner convierte automáticamente los tipos de datos, por lo que no es necesario convertirlos manualmente.

si juicio

La sintaxis básica de la instrucción if es:

if (条件) {
    // 条件满足时执行
}

más

La instrucción if también puede escribir un else {…}. Cuando la condición es falsa, se ejecutará el bloque de instrucción else:

public class Main {
    public static void main(String[] args) {
        int n = 70;
        if (n >= 90) {
            System.out.println("优秀");
        } else if (n >= 60) {
            System.out.println("及格了");
        } else {
            System.out.println("挂科了");
        }
        System.out.println("END");
    }
}

mientras bucle

Antes del inicio de cada ciclo, el ciclo while primero determina si la condición es verdadera. Si el resultado del cálculo es verdadero, ejecute la instrucción dentro del ciclo una vez. Si el resultado del cálculo es falso, salte directamente al final del ciclo while y continúe ejecutándose.

public class Main {
    public static void main(String[] args) {
        int sum = 0; // 累加的和，初始化为0
        int n = 1;
        while (n <= 100) { // 循环条件是n <= 100
            sum = sum + n; // 把n累加到sum中
            n ++; // n自身加1
        }
        System.out.println(sum); // 5050
    }
}

hacer mientras bucle

El bucle do while es ejecutar el bucle primero y luego juzgar la condición, continuar el bucle cuando se cumpla la condición y salir cuando no se cumpla. Su uso es:

do {
    执行循环语句
} while (条件表达式);

Reescribe la suma de 1 a 100 usando un ciclo do while:

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        int n = 1;
        do {
            sum = sum + n;
            n ++;
        } while (n <= 100);
        System.out.println(sum);
    }
}

para bucle

El uso de for loop es:

for (初始条件; 循环检测条件; 循环后更新计数器) {
    // 执行语句
}

Reescribe la suma de 1 a 100 con un bucle for:

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i=1; i<=100; i++) {
            sum = sum + i;
        }
        System.out.println(sum);
    }
}

Rotura

Durante el ciclo, puede usar la instrucción break para saltar del ciclo actual. La declaración de interrupción siempre salta del bucle donde se encuentra.

public class Main {
    public static void main(String[] args) {
        for (int i=1; i<=10; i++) {
            System.out.println("i = " + i);
            for (int j=1; j<=10; j++) {
                System.out.println("j = " + j);
                if (j >= i) {
                    break;
                }
            }
            // break跳到这里
            System.out.println("breaked");
        }
    }
}

Seguir

continuar es terminar este ciclo antes de tiempo y continuar ejecutando el siguiente ciclo directamente.

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i=1; i<=10; i++) {
            System.out.println("begin i = " + i);
            if (i % 2 == 0) {
                continue; // continue语句会结束本次循环
            }
            sum = sum + i;
            System.out.println("end i = " + i);
        }
        System.out.println(sum); // 25
    }
}

Parámetros de línea de comando

El punto de entrada del programa ava es el método principal, y el método principal puede aceptar un parámetro de línea de comando, que es una matriz String []. La entrada de usuario de JVM recibe este parámetro de línea de comando y se pasa al método principal:

public class Main {
    public static void main(String[] args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}