Notas de estudio de Java-01

Es porque la JVM (máquina virtual java) correspondiente está instalada en el sistema correspondiente (window, linux, mac), por lo que se puede compilar en cada plataforma

La diferencia entre JRE y JDK

JDK es un kit de desarrollo de programas Java que incluye el JRE y las herramientas utilizadas por los desarrolladores.
JRE es el entorno de tiempo de ejecución para los programas de Java, incluidas las bibliotecas principales requeridas por la JVM y el tiempo de ejecución.
Si queremos ejecutar un programa Java existente, solo necesitamos instalar JRE
Si queremos desarrollar un nuevo programa Java, entonces necesitamos instalar JDK

unidad de almacenamiento de computadora

Tanto la memoria como el disco duro se pueden almacenar, y el elemento de información más pequeño de un dispositivo de almacenamiento de computadora se llama bit (también llamado bit / bit / b)
La unidad más pequeña de almacenamiento en una computadora se llama byte (byte / B)

Dos comandos de uso común

ventana + R para abrir cmd
Letra de unidad: puede cambiar a la letra de unidad especificada

El nombre de la carpeta del CD puede cambiar a la letra de la unidad especificada, y el nombre del archivo se puede completar presionando la tecla Tabulador
cd .. puede cambiar al directorio de archivos anterior
cd .\ puede cambiar al directorio raíz del archivo actual
dir Ver toda la información del archivo en la carpeta
cls borrar pantalla
salir salir

escribe un hola mundo

Cree una nueva carpeta (javaCoding), cree un nuevo documento de texto HelloWorld.txt en la carpeta y escriba el siguiente contenido

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

Luego cambie el sufijo txt a java, que es HelloWorld.java

Luego haga clic en la carpeta con el mouse e ingrese cmd

Aparecerá una ventana cmd, ingrese javac HelloWorld.java en la ventana y presione Enter

En este punto, el archivo de clase de bytecode compilado aparecerá en la carpeta

Luego ingresamos java HelloWorld en la ventana cmd y se desplegará el contenido

Nota: Si la salida de contenido en el archivo contiene chino, el comando compilado es

javac -codificación UTF-8 nombre de archivo.java

constante

Es la cantidad que no va a cambiar, una vez dado el valor inicial no se puede modificar posteriormente

tipo	ilustrar	ejemplo
constante de cadena	Contenido entre comillas dobles	"aabbcc"
constante entera	número sin punto decimal	1
constante decimal	números con decimales	1.1
constante de caracter	Contenido encerrado entre comillas simples, y solo uno	'a'
constante booleana	verdadero o falso	FALSO
constante vacía	nulo (valor vacío)	no es capaz de salida

tipo de datos

Java es un lenguaje fuertemente tipado, y cada dato debe tener un tipo de datos claro antes de que pueda usarse. Diferentes tipos de datos también asignan diferentes espacios de memoria
Los tipos de datos básicos se pueden dividir en 4 categorías, a saber, tipo entero (incluido byte, corto, int y largo), tipo de punto flotante (incluido flotante y doble), tipo booleano y tipo de carácter (char)

Valor por defecto y bytes ocupados

variable

Un valor cuyo valor puede cambiar mientras se ejecuta el programa

tipo de variable nombre de variable = valor de variable;

int num = 100;  // 定义了一个变量名为num的变量，是数字型，初始值为100
// 或者这种方式
int num;
num = 100;

Aviso:

Al definir el tipo largo, debe agregar L después
Al definir el tipo de flotador, debe estar en la parte posterior de la máquina F

public static void main(String[] args) {
        // 声明浮点数时，再后面要加上f或者F
        float pi = 3.1415926f;
        System.out.println(pi);
        // 声明long类型时，需要在后面加上L或者l
        long count = 123456789L;
        System.out.println(count);
    }

conversión de tipo

Dividido en conversión de tipo automática y conversión de tipo obligatoria
Los decimales son de tipo doble por defecto
El número predeterminado es de tipo int

conversión automática de tipo

Asigne un valor o variable que represente un rango pequeño a otra variable con un rango de datos grande (es decir, de pequeño a grande )

double num = 10;  // 由数字型转成双精度型，会自动转换

elenco (no recomendado)

Asigne un valor o variable que represente un rango amplio a otra variable que represente un rango pequeño (es decir, de mayor a menor )

Tipo de datos de destino Nombre de variable = (Tipo de datos de destino) Valor o variable

int num = (int)9.99; // 9 把浮点型转成整数型，从大到小，需要强制转换

operador aritmético

Hay 5 tipos +(suma) -(resta) *(multiplicación) /(división) %(resto)

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a + b); // 30
        System.out.println(b - a); // 10
        System.out.println(a * b); // 200
        System.out.println(b / a); // 2
        System.out.println(b % a); // 0
        float c = 9.99f;
        System.out.println(a + c); // 19.99
    }

tipo de carácter + tipo de número Si el valor de carácter no es un número, se convertirá en el número correspondiente al código ASCII para el cálculo

public static void main(String[] args) {
        char a = 'a'; // a 对应的ASCII码值为 97
        int b = 20;
        System.out.println(a + b); // 117
    }

Cuando un operador aritmético contiene valores de múltiples tipos de datos básicos, el tipo de toda la expresión aritmética se promoverá automáticamente

reglas de promoción

Cuando byte / short / char participe en la operación, se promoverá automáticamente al tipo int

Cuando int participa en la operación, se promocionará automáticamente a tipo largo

Cuando long participa en la operación, se promoverá automáticamente a tipo flotante

Cuando float participa en las operaciones, se promocionará automáticamente a tipo doble

Si es una operación de cadena +, los caracteres están conectados

public static void main(String[] args) {
        String a = "999";
        System.out.println(a + 0); // 9990
    }

operador unario (++ --)

Pre-incremento o pre-decremento primero aumentará o disminuirá, y luego participará en otras operaciones adyacentes

public static void main(String[] args) {
        // 单独使用
        int a = 10;
        int res = (++a);
        System.out.println(res); // 11
        // 参与运算
        int b = 99;
        int res2 = ++b + --b + b;
        // 1. ++b 会先自增，此时b也就是(99 + 1)，然后再参与临近的运算  b = 100
        // 2. --b 会先自减，此时的b也就是(100 - 1)，然后再参与运算(99 + 1) + (100 - 1)  b = 99
        // 3. 然后再+b (99 + 1) + (100 - 1) + 99  b = 99
        System.out.println(res2); // 298
        System.out.println(b); // 99
    }

Después del autoincremento o post-decremento, primero participarán en otras operaciones adyacentes y luego aumentarán o disminuirán ellos mismos.

public static void main(String[] args) {
        // 单独使用
        int a = 10;
        int res = (a--);
        System.out.println(res); // 10
        System.out.println(a); // 9
        // 参与运算
        int b = 99;
        int res2 = b++ + b-- + b;
        // 1. b++ 会先参与临近的运算，也就是 99 + ?(这里的问好是因为后面临近的运算也是b的操作，
        // 不是确定的值) 然后再自增，此时b也就是(99 + 1)  b = 100
        // 2. b-- 会先参与临近的运算，也就是 99 + 100 然后再自减，此时的b也就是(100 - 1)  b = 99
        // 3. 然后再+b 99 + 100 + 99  b = 99
        System.out.println(res2); // 298
        System.out.println(b); // 99
    }

operador relacional

Los resultados de los operadores relacionales son booleanos, es decir, verdadero o falso. Los operadores relacionales producen un resultado booleano
== != > >= < <= Hay 6 tipos en total, usados para juzgar
La doble igualdad requiere que tanto el tipo como el valor sean iguales

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a == b); // false
        System.out.println(a != b); // true
        System.out.println(a > b); // false
        System.out.println(a < b); // true
        System.out.println('1' == 1); // false
    }

Operadores lógicos (y o no, XOR lógico)

Juzgando si la expresión es verdadera, el resultado del juicio también es verdadero o falso
AND & cortocircuito AND && o | cortocircuito o || no! XOR lógico ^

la señal	ilustrar	ejemplo
&	Solo cuando las expresiones antes y después son verdaderas, es verdadera sentencia antes y despues Se puede juzgar que el anverso y el reverso no son del mismo tipo.	0 y 1 // 0 falso y verdadero // falso verdad verdad verdad
&&	Solo cuando las expresiones antes y después son verdaderas, es verdadera Pero si la anterior es falsa, la segunda no será juzgada, y directamente se devolverá falsa. Antes y después el tipo debe ser consistente, para poder juzgar	0 && 1 // informará directamente de un error false && true // false true && true // true
\|	Las expresiones antes y después son todas falsas, por lo que es falsa sentencia antes y despues Se puede juzgar que el anverso y el reverso no son del mismo tipo.	0 \| 1 // 1 falso \| verdad verdad falso \| falso // falso
\|\|	Las expresiones antes y después son todas falsas, por lo que es falsa Pero si la anterior es verdadera, la segunda no será juzgada, y se devolverá verdadera directamente. Antes y después el tipo debe ser consistente, para poder juzgar	0 \|\| 1 // informará directamente de un error falso \|\| verdad verdad falso \|\| falso // falso
!	Operación negativa, verdadero devolverá falso, falso devolverá verdadero	!verdadero Falso !falso verdadero
^	Operación XOR, a ^ b (los resultados a y b son diferentes si son verdaderos)	verdadero ^ falso // verdadero verdadero ^ verdadero // falso

Operador ternario (ternario)

Formato:

expresión relacional? expresión1: expresión2;

Si la expresión es verdadera, ejecuta la expresión 1, de lo contrario, ejecuta la expresión 2

int a = true ? 10 : 20;
System.out.println(a);

Por supuesto, también se pueden hacer llamadas en cadena (no recomendable, es desordenado, mejor usar if o switch)

int a = true ? 10 : true ? 20: true ? 30 : 0;
System.out.println(a);

Uso simple de la clase Scanner

Necesita usar la clase Scanner
El primer paso: realizar el paquete de importación

import java.util.Scanner;

El segundo paso: nueva clase Scanner, crear un objeto de instanciación específico

Scanner input = new Scanner(System.in);

Paso 3: recibir los datos ingresados por el usuario y realizar restricciones de entrada

int num = input.nextInt(); // 规定用户只能输入数字型

Código completo:

public static void main(String[] args) {
        // 提示用户输入
        System.out.println("请您输入一个整数数字：");
        // 接收用户输入
        Scanner input = new Scanner(System.in);
        // 规定用户只能输入数字型
        int num = input.nextInt();
        // 显示用户输入的内容
        System.out.println("您输入的数字为：" + num);
    }