Notas de estudio de JAVA: colección

Empezando con JAVA

El nacimiento del imperio de Java

Características y beneficios de Java

• sencillez
• Frente a objetos
• portabilidad
• alto rendimiento
• repartido
• polimorfismo
• subprocesos múltiples
• seguridad
• Robustez

Tres versiones principales de Java

• Escribe una vez, corre a cualquier lugar

• JavaSE : Edición Estándar (programas de escritorio, desarrollo de consola...)

• JavaME : El desarrollo integrado (teléfonos móviles, pequeños electrodomésticos...) se ha enfriado

• JavaEE : Desarrollo a nivel empresarial (desarrollo del lado web, del lado del servidor...), basado en JavaSE

JDK JRE JVM

• JDK: kit de desarrollo de Java (herramientas de desarrollo de Java, incluidos JRE, JVM)
• JRE: entorno de ejecución de Java (entorno de ejecución de Java)
• JVM: Máquina virtual Java (máquina virtual Java, núcleo multiplataforma)

Instalar el entorno de desarrollo.

Desinstalar JDK

1. Eliminar el directorio de instalación de Java
2. Eliminar la variable de entorno JAVA_HOME
3. Eliminar el directorio JAVA en la ruta
4. versión Java

Instalar JDK

1. Busque JDK8 en Baidu y busque la dirección de descarga
2. Acepte el acuerdo y descargue la versión correspondiente a su computadora, como jdk-8u281-windows-x64.exe para un sistema operativo de 64 bits.
3. Haga doble clic para instalar JDK
4. Recuerde la ruta de instalación
5. Configurar variables de entorno
   1. Mi PC->Propiedades->Configuración avanzada del sistema->Variables de entorno
   2. Cree una nueva variable de sistema -> JAVA_HOME e ingrese la ruta de instalación de jdk correspondiente
   3. variable de ruta–>% JAVA_HOME%\bin
6. Pruebe si cmd es exitoso–>Java -version

Conceptos básicos de JAVA

Comentario

1. Comentario de una sola línea //
2. Comentarios de varias líneas /* */
3. Comentarios de documentación/** */

identificadores y palabras clave

• Todos los componentes de Java requieren nombres. Los nombres de clases, nombres de variables y nombres de métodos se denominan identificadores.

Notas sobre identificadores

• Todos los identificadores deben comenzar con una letra, $ (signo de dólar), _ (guión bajo)
• La primera letra puede ir seguida de cualquier combinación de letras, $, _ o números.
• Las palabras clave no se pueden utilizar como nombres de variables o nombres de métodos.
• Los identificadores distinguen entre mayúsculas y minúsculas
• Se puede nombrar en chino, pero no se recomienda . Incluso si se nombra en Pinyin, es bajo.

tipo de datos

Lenguaje fuertemente tipado

El uso de variables es necesario para cumplir estrictamente con las regulaciones. Todas las variables deben definirse antes de poder usarse.
Lenguajes de tipo débil: JavaScript, Python

Los tipos de datos Java se dividen en dos categorías.

Tipo primitivo (tipo primitivo), hay 8 tipos básicos, además todos son tipos de referencia
Tipo de referencia (tipo de referencia)

• amable
• interfaz
• formación

//整数
int num1 = 10; //最常用，只要别超过21亿（2^31-1）
byte num2 = 20; //-128~127
short num3 = 30;
long num4 = 30L; //long类型数字后面要加个L(尽量用大写，小写l容易与1搞混)

//小数：浮点数
float num5 = 50.1F; //float类型数字后面要加个F
double num6 = 3.141592653589793238;

//字符
char name = '国';
//字符串, String不是关键字，是类
//String namea = "薛之谦";

//布尔值：是非
boolean flag = true

¿Qué son los bytes?

• Bit: es la unidad más pequeña de almacenamiento interno de datos en una computadora. 11001100 es un número binario de ocho dígitos.
• Byte (byte, B): Es la unidad básica de procesamiento de datos en las computadoras, se acostumbra expresarlo con B mayúscula.
• 1B(byte) = 8 bits, 1 byte equivale a 8 bits
• Caracteres: se refiere a las letras, números, palabras y símbolos utilizados en las computadoras.
• 1 bit significa 1 bit
• 1Byte representa un byte 1B=8b
• 1024B = 1KB, 1024KB = 1M, 1024M = 1G

Preguntas de extensión y entrevista.

//整数扩展： 二进制0b		八进制0		十进制		十六进制0x
int i = 10;
int i2 = 010; //八进制 8
int i3 = 0x10; //十六进制 16
int i4 = 0b100; //二进制 4

//浮点数扩展：
//面试题：银行业务字母怎么表示钱? BigDecimal(数学工具类)
//float double是有问题的，最好避免使用浮点数进行比较
float f = 0.1f; 	//0.1
double d = 1.0/10;  //0.1
System.out.println(f==d); //false
//浮点数 位有限，舍入误差，大约
//最好避免使用浮点数进行比较
float f1 = 23131313131f;
float f2 = f1+1;
System.out.println(f1==f2); //true

//字符扩展：所有字符本质还是数字
char c1 = 'a';
char c2 = '中';

System.out.println(c1);		//a
System.out.println((int)c1);//强制类型转换,97
System.out.println(c2);		//中
System.out.println((int)c2);//强制类型转换,20013

//编码 Unicode表（97=a,65=A）2字节 0-65536
//U000~UFFFF 十六进制（u0061=a,相当于十进制的97）
System.out.println('\u0061');  //a '\'是转义字符
// \t 制表符
// \n 换行 ···

//布尔值扩展
boolean flag = true;
if(flag==true){
    
    } //新手
if(flag){
    
    }	//老手这样写 Less is More(代码要精简易读)

conversión de tipo

• Dado que Java es un lenguaje fuertemente tipado, se requiere conversión de tipos al realizar algunas operaciones.

• Capacidad alta–>baja:

  byte,corto,cahr -> int -> largo -> flotante -> doble

  Durante la operación, los datos de diferentes tipos primero se convierten al mismo tipo y luego se realiza la operación.

  • Forzar conversión, (tipo) nombre de variable, capacidad de mayor a menor
  • Conversión automática, capacidad de baja a alta.

//强制转换 （类型）变量名 高--低
//自动转换 低--高
int i = 128;
byte b = (byte)i; //强制转换 内存溢出 -128~127
double d =i; //自动转换

System.out.println(i); //128
System.out.println(b); //-128
System.out.println(d); //128.0
/*
   注意点：
   1.不能对布尔值进行转换
   2.不能把对象类型转换为不相干的类型
   3.在把高容器转换到低容量的时候，强制转换
   4.可能存在内存溢出，或者精度问题
 * */
System.out.println((int)23.7); //23 丢失精度
char c = 'a';
int n = c+1;
System.out.println(n); //98
System.out.println((char)n); //b

//当操作数比较大时，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000; //10亿，下划线不会被打印出来
System.out.println(money); //1000000000
int years = 20;

int total = money*years;  //数据大，溢出
System.out.println(total); //-1474836480

long total2 = money*years; //默认是int，转换前就有溢出问题
System.out.println(total2); //-1474836480

long total3 = money*(long)years; //先把一个数转Long
System.out.println(total3); //20000000000

variables, constantes, alcance

• Qué es una variable: Es una cantidad que puede cambiar
• Java es un lenguaje fuertemente tipado, cada variable debe declarar su tipo
• Las variables Java son la unidad de almacenamiento más básica del programa. Los elementos incluyen el nombre de la variable, el tipo de variable y el alcance.

//数据类型 变量名 = 值;
type varName [=value][{
    
    ,varName[=value]}];
//可以使用逗号隔开同多个类型的变量，但不建议在一行定义多个变量

Alcance variable

• variable de clase (estática)
• variables de instancia
• variables locales

public class Variable{
    
    
    static int 	allClicks = 0; //类变量
    String str = "hello world"; //实例变量
    public void method(){
    
    
        int i=0; //局部变量
    }
}

constante

• Constante: un valor que no se puede cambiar después de la inicialización, un valor que no cambiará.
• Puede entenderse como una variable especial: una vez establecido su valor, no se permite cambiarlo mientras el programa se está ejecutando.

//常量一般用大写字符
final 常量名=值;
final double PI=3.14;
//修饰符 不存在先后顺序，static可以写final后面
static final doube PI=3.14; //类变量，该类下的全局范围

Convención de nomenclatura de variables

• Todos los nombres de variables, métodos y clases: conozca el significado al ver el nombre
• Variables miembro de clase: primera letra minúscula + principio de caso camello: apellido, mesSalario
• Variables locales: primera letra minúscula + principio de caso camello
• Constantes: letras mayúsculas y guiones bajos: MAX_VALUE
• Nombre de clase: mayúscula + principio de caso camello: Man, GoodMan
• Nombre del método: primera letra minúscula + principio de mayúsculas y minúsculas: run(), fastRun()

operador

• Operadores aritméticos: +, -, *, /, %, ++, –
• Operador de asignación: =
• Operadores relacionales: >, <, >=, <=, ==,!=, instancia de
• Operadores lógicos: &&, ||, !
• Operadores de bits: &, |, ^, ~, >>, <<, >>>
• Operador condicional:?
• Operadores de asignación extendida: +=, -=, *=, /=

int a=10;
int b=20;
System.out.println(a/b); //0
System.out.println((double)a/b); //0.5

long c=12300000000;
System.out.println(a+b); //int
System.out.println(a+c); //long 自动转换式子中容量大的数据类型

operadores de incremento y decremento

// ++自增 --自减 单目运算符
int a = 3;
int b = a++; //b=a,a=a+1 先赋值 即b=3 a=4
int c = ++a; //a=a+1,c=a 先自增 即a=5 c=5

System.out.println(a); //5
System.out.println(b); //3
System.out.println(c); //5
//幂运算 2^3 2*2*2=8
double pow = Math.pow(2,3); // (底数，指数)double型
System.out.println(pow); //8.0

//扩展：笔试题 i=5 s=(i++)+(++i)+(i--)+(--i) s=?
int i=5;
int s=(i++)+(++i)+(i--)+(--i);
System.out.println(s); //24

Operadores logicos

• && operación AND lógica: ambas variables son verdaderas, el resultado es verdadero
• || Operación lógica AND: si una de las dos variables es verdadera, el resultado es verdadero
• Negación, lo verdadero se vuelve falso, lo falso se vuelve verdadero

// 与(and) 或(or) 非(取反)
boolean a = true;
boolean b = false;

System.out.println(a&&b); // false
System.out.println(a||b); // true
System.out.println(!(a&&b)); // true

int c=5;
boolean d = (c<5)&&(c++<5); //第一个值为false，后面就不进行判定了
System.out.println(d); //false
System.out.println(c); //5 c++未执行

Operaciones de bits

/*
    A = 0011 1100
    B = 0000 1101

    A&B 0000 1100 按位与
    A|B 0011 1101 按位或
    A^B 0011 0001 异或
    ~B  1111 0010 非

    面试题：2*8 怎么算最快？ 2<<3
    <<左移  *2 效率极高！！
    >>右移  /2
   */
System.out.println(2<<3); // 16

Concatenación de cadenas

int a = 10;
int b = 20;

a+=b; // a = a+b
a-=b; // a = a-b

System.out.println(a); //10
//字符串连接符 + ，转化为String类型,然后拼接    注意！！
System.out.println(""+a+b); //1020
System.out.println(a+b+""); //30 先进行运算，再转为String拼接
System.out.println(a+b+"str"); //30str

operador ternario

// x ? y : z
//如果x为真，则结果为y,否则为z
//if(x) y; else z;
int score = 80;
String type = score<60?"不及格":"及格";
System.out.println(type); //及格

mecanismo de paquete

• Para organizar mejor las clases, Java proporciona un mecanismo de paquete, debido al espacio de nombres que distingue los nombres de las clases.
• Formato de sintaxis del paquete:

package pkg1[.pkg2[.pkg3...]];

• Generalmente, el nombre de dominio de la empresa invertido se utiliza como nombre del paquete: com.kuangstudy.www
• Para poder utilizar los miembros de un paquete, el paquete debe importarse en el programa Java.

import package1[.package2...].(className|*); //通配符* 导入包下所有的类

• Referencia: Manual de desarrollo de Java de Alibaba

JavaDoc genera documentación

El comando javadoc se utiliza para generar su propia documentación API.

Información de parámetros

• @autor nombre del autor
• @versión número de versión
• @since indica la versión más antigua de jdk utilizada
• @param nombre del parámetro
• @return valor de retorno
• @throws Situación de lanzamiento de excepción

Documentación API: https://docs.oracle.com/javase/8/docs/api/

/**
 * @author Kuangshen
 * @version 1.0
 * @since 1.8
 */
public class Demo05 {
    
    
    String name;

    /**
     * @author kuangshen
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
    
    
        return name;
    }
    
}

1. Abra la línea de comando cmd en la carpeta donde se encuentra una determinada clase
2. Entrada: javadoc -encoding UTF-8 -charset UTF-8 Doc (nombre de clase).java
3. Los documentos API relacionados con esta clase se generarán automáticamente. Verifique la carpeta y encontrará que hay algunos archivos más.
4. Abra index.html (página de inicio) para ver los comentarios de la documentación.

Conceptos básicos de JAVA

control de procesos JAVA

Escáner de interacción del usuario

• La sintaxis básica que aprendimos antes no implementaba la interacción entre programas y personas . Java nos proporciona una clase de herramienta que puede obtener la entrada del usuario. java.util.Scanner es una nueva característica de Java5. Obtenemos la entrada del usuario a través de la clase Scanner.
• gramática básica

Scanner s = new Scanner(System.in);

• Obtenga la cadena del usuario a través de los métodos next () y nextLine () de la clase Scanner. Antes de leer, generalmente use hasNext () y hasNextLine () para determinar si todavía hay datos de entrada.

//创建一个扫描器对象
Scanner scanner = new Scanner(System.in);

System.out.println("使用next方式接收");
//判断用户有没有输入字符串
if(scanner.hasNext()){
    
      //使用hasNextLie()会接收一行 "hello word"
    //使用next方式接收
    String str = scanner.next(); 
    System.out.println("输入的内容为："+str);
    //input: hello word
    //输入的内容为：hello
}
//凡是属于IO流的类如果不关闭会一直占用资源
scanner.close();

próximo()

1. Se deben leer los caracteres válidos antes de poder completar la entrada.
2. El método next() eliminará los espacios en blanco que se encuentren antes de ingresar caracteres válidos.
3. Solo después de ingresar un carácter válido, el espacio en blanco ingresado después se usará como terminador.
4. next() no puede obtener una cadena con espacios

Proxima linea()

1. Utilice Enter como carácter final, es decir, devuelva todos los caracteres antes de ingresar el retorno de carro.
2. nextLine() puede obtener espacios en blanco

//从键盘接收数据
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据：");

String str = scanner.nextLine();
System.out.println("输入的内容为："+str);
scanner.close();

System.out.println("请输入整数：");
if(scanner.hasNextInt()){
    
    
    int i=scanner.nextInt();
    System.out.println("输入的整数为："+i);
}else {
    
    
    System.out.println("输入的不是整数数据");
}

estructura secuencial

• La estructura básica de Java es una estructura secuencial: a menos que se especifique lo contrario, las declaraciones se ejecutan una por una.
• La estructura secuencial es la estructura algorítmica más simple.
• Las declaraciones se ejecutan de arriba a abajo y se componen de varios pasos de procesamiento que se ejecutan en secuencia.
• Es una estructura de algoritmo básica que es inseparable de cualquier algoritmo.

Seleccionar estructura

• si estructura de selección única if()
• si estructura de selección doble if( ){ }else{ }
• si estructura de selección múltiple if( ){ }else if{ }else{}
• Estructura if anidada if( ){ if( ) }

int a = 80;
if(a>60){
    
    
    System.out.println("及格");
    if(a>80) System.out.println("且优秀");
}else if(a>0){
    
    
    System.out.println("不及格");
}else {
    
    
    System.out.println("缺考");
}

cambiar la estructura de selección múltiple

char grade = 'C'; //JDK新特性 可以是字符串(字符本质还是数字)
switch (grade){
    
    
    case 'A':
        System.out.println("优秀");
        break; //可选，跳出当前结构
    case 'B':
        System.out.println("良好");
        break;
    case 'C':
        System.out.println("合格");
        break;
    default: //默认，以上值没匹配到
        System.out.println("不及格");
        break;
}

Estructura de bucle

mientras bucle

//计算1+2+3+...+100
int i=0;
int sum=0;
while(i<100){
    
    
    i++;
    sum+=i;
}
System.out.println(sum); //5050

hacer... mientras bucle

//先执行后判断，至少执行一次
do{
    
    
    i++;
    sum+=i;
}while(i<100) //跟上面效果一样

en bucle

//（初始化;条件判断;迭代）
for(int i=0;i<100;i++){
    
    
    i++;
    sum+=i;
}
for(; ; ){
    
    ...} //死循环

Ejercicio 1

//练习：输出1-1000能被5整除的数，每行输出3个
for (int i = 1; i <= 1000; i++) {
    
    
    if(i%5==0){
    
    
        System.out.print(i+"\t"); //输出完不换行
    }
    if(i%(3*5)==0){
    
    
        System.out.println();
    }
}

Ejercicio 2

//练习2：输出九九乘法表
for(int i=1;i<=9;i++){
    
    
    for(int j=1;j<=i;j++){
    
    
        System.out.print(j+"*"+i+"="+i*j+"\t");
    }
    System.out.println();
}

Bucle for mejorado

int[] numbers = {
    
    10,20,30,40,50}; //定义一个数组
for (int x:numbers){
    
    
    System.out.println(x); //遍历数组的元素 10 20 30 40 50
}
//相当于
for(int i=0;i<5;i++){
    
    
    System.out.println(numbers[i]);
}

romper y continuar

• break se puede usar en el cuerpo de cualquier bucle y también se puede usar en una declaración de cambio para forzar una salida del bucle .
• continuar se usa en declaraciones de bucle para finalizar un determinado proceso de bucle , omitir las declaraciones restantes y juzgar la siguiente condición de bucle en el medio.
• etiqueta: un identificador seguido de una etiqueta de dos puntos:

//打印101-150之间所有的质数
int count = 0;
outer:for(int i=101;i<=150;i++){
    
    
    for (int j=2;j<i/2;j++){
    
    
        if(i%j==0)
            continue outer; //不建议使用标签
    }
    System.out.print(i+" ");
}

ejercicios de control de procesos

//打印等腰空心三角形
/*  例如：输入为4时
          *
         * *
        *   *
       * * * *
*/
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt(); //n为三角形高
for(int i=1;i<=n;i++){
    
    
    for(int j=1;j<=2*n-1;j++){
    
    
        if(i!=n){
    
     //若不为最后一行
            if(i+j==n+1)
                System.out.print("*"); //三角形左腰边
            else if(i+j==n+2*i-1)
                System.out.print("*"); //三角形右腰边
            else System.out.print(" ");
        }
        else if(j%2!=0){
    
      //最后一行，底边
            System.out.print("*");
        }else {
    
    
            System.out.print(" ");
        }
    }
    System.out.println(); //换行
}

método JAVA

definición del método

• Los métodos Java son similares a las funciones de otros lenguajes: son un fragmento de código que se utiliza para completar una función específica.
• Un método contiene un encabezado de método y un cuerpo de método.
  • Modificador: Opcional, define el tipo de acceso del método y le dice al compilador cómo llamar al método.
  • Tipo de valor de retorno: los métodos pueden devolver valores. returnValueType es el tipo de datos del valor de retorno del método. Algunos métodos no tienen valor de retorno, por lo que returnValueType es la palabra clave void.
  • Nombre del método: es el nombre real del método. El nombre del método y la lista de parámetros juntos constituyen la firma del método.
  • Tipo de parámetro: como un marcador de posición. Cuando se llama a un método, se pasa un valor al parámetro, que se denomina argumento o variable. La lista de parámetros se refiere al tipo de parámetro, el orden y el número de parámetros del método. Los parámetros son opcionales y los métodos no pueden contener parámetros.
    • Parámetros formales: se utilizan para recibir datos de entrada externos cuando se llama al método.
    • Parámetros reales: los datos realmente pasados ​​al método al llamar al método.
  • Cuerpo del método: el cuerpo del método contiene declaraciones específicas que definen la función del método.

修饰符 返回值类型 方法名（参数类型 参数名,...）{
    
    
   方法体...
   return 返回值；
}

llamada al método

• Método de llamada: nombre del objeto, nombre del método (lista de parámetros reales).
• Java admite dos formas de llamar a métodos, dependiendo de si el método devuelve un valor.
• Cuando un método devuelve un valor, la llamada al método generalmente se trata como un valor .

int larger = max(30,40);

• Si el valor de retorno del método es nulo, la llamada al método debe ser una declaración.
• Extensión: pasar por valor y pasar por referencia ( Java es pasar por valor ).
• Para llamar a métodos de otras clases, a menos que sea un método estático, se debe crear una instancia de esta clase (nuevo)

public class Demo01 {
    
    
   
    public static void main(String[] args) {
    
    
        int add = Demo01.add(1,2); // 通过类名直接调用静态方法
        System.out.println(add); // 3
    }
	// static静态方法，否则就要new实例化来调用
    public static int add(int a,int b){
    
    
        return a+b;
    }
}

Pasar por valor (java) y pasar por referencia

Sobrecarga de métodos

La sobrecarga es un método en una clase que tiene el mismo nombre de método pero diferentes listas de parámetros.

Reglas para la sobrecarga de métodos:

• Los nombres de los métodos deben ser los mismos.
• Las listas de parámetros deben ser diferentes (diferente número, tipo de parámetro u orden)
• Los tipos de devolución pueden ser iguales o diferentes.
• Simplemente tener diferentes tipos de retorno no es suficiente para sobrecargar un método

teoría de implementación

• Cuando los nombres de los métodos son los mismos, el compilador los comparará uno por uno según la cantidad de parámetros y tipos de parámetros del método de llamada para seleccionar el método correspondiente. Si la coincidencia falla, el compilador informará un error.

Paso de parámetros de línea de comando

• A veces desea pasar mensajes a un programa cuando se está ejecutando. Esto se logra pasando argumentos de la línea de comando a la función main().

public static void main(String[] args) {
    
    
    //args.length 数组长度
    for (int i = 0; i < args.length; i++) {
    
    
        System.out.println("args["+i+"]: "+args[i]);
    }
}

parámetro variable

• A partir de Jdk 1.5, Java admite pasar parámetros variables del mismo tipo a un método.
• En una declaración de método, agregue puntos suspensivos (…) después de especificar el tipo de parámetro.
• Solo se puede especificar un parámetro variable en un método y debe ser el último parámetro del método.

//打印最大值
public static void printMax(int... num){
    
    
    if(num.length==0){
    
    
        System.out.println("没有值传入");
        return;
    }
    int result = num[0];
    for (int i = 1; i < num.length; i++) {
    
    
        if(num[i] > result){
    
    
            result = num[i];
        }
    }
    System.out.println("最大值是："+result);
}
public static void main(String[] args) {
    
    
    printMax(1,2,3,4); //最大值是：4
    printMax(new int[]{
    
    1,2,3,4,5}); //最大值是：5
}

recursividad

Recursión significa: el método A llama al método A, ¡que se llama a sí mismo!

La estrategia recursiva requiere solo una pequeña cantidad de código para describir múltiples cálculos repetidos en el proceso de resolución de problemas, lo que reduce en gran medida la cantidad de código en el programa. El poder de la recursividad radica en definir colecciones infinitas de objetos con declaraciones finitas.

estructura recursiva

• Encabezado recursivo: cuando no llama a su propio método, caerá en un bucle infinito sin encabezado.
• Cuerpo recursivo: ¿cuándo necesita llamar a su propio método?

//阶乘 n! n*(n-1)*...*2*1
public static int f(int n){
    
    
    if(n==1) return 1;
    return n*f(n-1); //递归：调用自身
}
public static void main(String[] args) {
    
    
    System.out.println(f(5)); //5!= 120
}

matriz JAVA

Definición de matriz

• Una matriz es una colección ordenada de datos del mismo tipo.
• Una matriz describe varios datos del mismo tipo, ordenados y combinados en un orden determinado.
• Entre ellos, cada dato se denomina elemento de matriz y cada elemento de matriz puede acceder a ellos a través de subíndices.

Creación de declaración de matriz

• Las variables de matriz primero deben declararse antes de poder utilizar una matriz en un programa.

dataType[] arrayRefVar; //首选
dataType arrayRefVar[]; //效果相同,但不是首选

• El lenguaje Java utiliza el nuevo operador para crear una matriz. La sintaxis es la siguiente

dataType[] arrayRefVar = new dataType[arraySize]; 
//int[] nums=new int[10]

• Se accede a los elementos de la matriz por índice, y el índice de la matriz comienza desde 0
• Obtenga la longitud de la matriz: arrays.length

int[] nums; //1.声明一个数组
nums = new int[3]; //2.创建一个数组
//3.给数组元素赋值
nums[0]=1;
nums[1]=2;
nums[2]=3;
for (int num : nums) {
    
     //打印数组所有元素
    System.out.println(num);
}

Tres tipos de inicialización de matrices.

• inicialización estática

//静态初始化：创建+赋值
int[] a={
    
    1,2,3};
Man[] mans={
    
    new Man(1,1),new Man(2,2)}

• inicialización dinámica

//包含默认初始化
int[] a=new int[2]; //默认值为0
a[0]=1;
a[1]=2;

• Inicialización predeterminada
  • La matriz es un tipo de referencia y sus elementos son equivalentes a las variables de instancia de la clase, por lo que una vez que se asigna espacio a la matriz, cada elemento de la matriz se inicializa implícitamente de la misma manera que la variable de instancia.

Características básicas de las matrices.

• Se determina su longitud y, una vez creada la matriz, su tamaño no se puede cambiar.
• Sus elementos deben ser del mismo tipo, no se permiten tipos mixtos.
• Los elementos de una matriz pueden ser de cualquier tipo de datos, incluidos tipos básicos y tipos de referencia.
• Las variables de matriz son tipos de referencia y las matrices también se pueden ver como objetos, donde cada elemento es equivalente a una variable miembro del objeto.
• La matriz en sí es un objeto. En Java, los objetos están en el montón, por lo que ya sea que la matriz almacene tipos primitivos u otros tipos de objetos,

La matriz en sí está en el montón.

límites de matriz

El rango legal de subíndices es: [0, longitud-1], si se sale de los límites, se informará un error.

Uso de matrices

• Para cada bucle

int[] arrays = {
    
    1,2,3,4,5};
//打印全部的数组元素 JDK1.5 没有下标
for (int array : arrays) {
    
    
    System.out.println(array);
}

• Matriz como parámetro de entrada del método

//打印数组元素
public static void printArray(int[] a){
    
    
    for (int i = 0; i < a.length; i++) {
    
    
        System.out.print(a[i]+" ");
    }
}

• Matriz como valor de retorno

//反转数组
public static int[] reverse(int[] arrays){
    
    
    int[] result = new int[arrays.length];
    //反转的操作
    for (int i = 0; i < arrays.length; i++) {
    
    
        result[i] = arrays[arrays.length-i-1];
    }
    return result;
}

Matrices multidimensionales

• Las matrices multidimensionales pueden considerarse como matrices de matrices: por ejemplo, una matriz bidimensional es una matriz especial y cada elemento es una matriz unidimensional.

int arr[][] = new int[3][2]; //二维数组,三行两列

int[][] array = {
    
    {
    
    1,2},{
    
    3,4},{
    
    5,6}};
//打印二维数组所有元素
for (int i = 0; i < array.length; i++) {
    
     //arrays.length=3
    for (int j = 0; j < array[i].length; j++) {
    
    
        System.out.print(array[i][j]+" ");
    }
    System.out.println();
}

clase de matrices

• Clase de utilidad de matriz java.util.Arrays
• Dado que el objeto de matriz en sí no tiene métodos que podamos usar, la API proporciona una clase de herramienta Arrays para que la usemos.
• Los métodos de la clase Array son todos métodos estáticos modificados por estático. Cuando se usan, se llaman directamente usando el nombre de la clase y se pueden llamar sin un objeto.
• Funciones comunes
  • Asigne un valor a la matriz: método de relleno.
  • Clasificación: método de clasificación, orden ascendente.
  • Comparación de matrices: el método igual compara si los valores de los elementos de la matriz son iguales.
  • Buscar elementos de la matriz: binarioSearch realiza una operación de búsqueda binaria en la matriz ordenada.

int[] a = {
    
    1,2,3,4,9000,32145,451,21};
System.out.println(a); // [I@28d93b30 (hashcode)

//Arrays.toString 打印数组元素
System.out.println(Arrays.toString(a)); //[1, 2, 3, 4, 9000, 32145, 451, 21]

//二分法查找某值 返回下标
System.out.println(Arrays.binarySearch(a, 9000)); // 4

//填充
Arrays.fill(a,2,4,0); //数组[a[2]~a[4])之间填充0
System.out.println(Arrays.toString(a)); //[1, 2, 0, 0, 9000, 32145, 451, 21]

//升序排序
Arrays.sort(a);

Ordenamiento de burbuja

• La clasificación de burbujas es el algoritmo de clasificación más famoso entre los ocho algoritmos de clasificación.
• Código: dos capas de bucles, la capa exterior burbujea durante varias rondas y la capa interior se compara secuencialmente.
• Cuando vemos bucles anidados, debemos concluir inmediatamente que la complejidad temporal de este algoritmo es O(n^2) .

//冒泡排序
//1.比较数组中两个相邻的元素，如果第一个数大于第二个数，交换它们位置
//2.每一次比较，都会产生一个最大或最小的数字(升序为最大数)
//3.下一轮则可以少一次排序
//4.依次循环，直到结束
public static int[] sort(int[] array){
    
    
    int temp=0;
    //外层循环，次数length-1
    for (int i = 0; i < array.length-1; i++) {
    
    
        //内层循环：如果第一个数大于第二个数，交换它们位置
        for (int j = 0; j < array.length-1-i; j++) {
    
    
            if(array[j]>array[j+1]){
    
    
                temp=array[j];
                array[j]=array[j+1];
                array[j+1]=temp;
            }
        }
    }
    return array;
}

public static void main(String[] args) {
    
    
    int[] a={
    
    8,1,35,47,19,-2};
    int[] sort = sort(a);
    System.out.println(Arrays.toString(sort)); //[-2, 1, 8, 19, 35, 47]
}

matriz dispersa

//创建一个二维数组 11*11  0：没有棋子，1：黑棋  2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始的数组
System.out.println("原始的数组：");
for (int[] array : array1) {
    
    
    for (int i : array) {
    
    
        System.out.print(i+"\t");
    }
    System.out.println();
}

//转换为稀疏数组保存
//1.有效值的个数
int sum = 0; //有效值总数
for (int i = 0; i < 11; i++) {
    
    
    for (int j = 0; j < 11; j++) {
    
    
        if(array1[i][j]!=0){
    
    
            sum++;
        }
    }
}
//2.创建一个稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;

//3.遍历二维数组，将有效值存放到稀疏数组
int count = 0;
for (int i = 0; i < array1.length; i++) {
    
    
    for (int j = 0; j < array1[i].length; j++) {
    
    
        if(array1[i][j]!=0){
    
    
            count++;
            array2[count][0] = i;
            array2[count][1] = j;
            array2[count][2] = array1[i][j];
        }
    }
}

//4.输出稀疏数组
System.out.println("稀疏数组：");
for (int i = 0; i < array2.length; i++) {
    
    
    for (int j = 0; j < array2[i].length; j++) {
    
    
        System.out.print(array2[i][j]+"\t");
    }
    System.out.println();
}
/* 结果：
输出原始的数组
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
稀疏数组
11	11	2	
1	2	1	
2	3	2	
*/
System.out.println("============还原==========");
int array3[][] = new int[array2[0][0]][array2[0][1]];
for(int i = 1;i<array2.length;i++){
    
    
		array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
for (int[] array : array3) {
    
    
    for (int i : array) {
    
    
         System.out.print(i + " ");
    }
    System.out.println();
}

orientado a objetos

Primera introducción a la orientación a objetos.

Orientado a procesos y orientado a objetos

• pensamiento orientado a procesos
  • Los pasos son claros y sencillos, qué hacer en el primer paso, qué hacer en el segundo paso…
  • Orientado a procesos es adecuado para manejar algunos problemas más simples.
• pensamiento orientado a objetos
  • Los pájaros del mismo plumaje se juntan, un modo de pensamiento de clasificación. Cuando piense en un problema, primero pensará en qué clasificaciones se necesitan para resolver el problema y luego pensará en estas clasificaciones individualmente. Finalmente, el pensamiento orientado a procesos se lleva a cabo en los detalles de una determinada categoría.
  • ¡La orientación a objetos es adecuada para abordar problemas complejos y problemas que requieren la cooperación de varias personas!
• Para describir cosas complejas, para captarlas desde una perspectiva macro y analizarlas razonablemente en su conjunto, necesitamos utilizar la orientación a objetos para analizar todo el sistema. Sin embargo, todavía es necesario abordar microoperaciones específicas con un enfoque orientado a los procesos.

¿Qué es la orientación a objetos?

• Programación orientada a objetos (POO)
• Esencia: organizar el código en forma de clases y organizar (encapsular) datos en forma de objetos .
• abstracto
• Tres características principales
  • encapsulación
  • heredar
  • Polimorfismo
• Desde un punto de vista epistemológico, primero hay objetos y luego clases. Los objetos son cosas concretas y las clases son abstracciones de objetos.
• Desde la perspectiva de la ejecución del código, primero hay clases y luego objetos. Las clases son plantillas para objetos.

La relación entre clases y objetos.

• Una clase es un tipo de datos abstracto. Es una descripción/definición general de un determinado tipo de cosa, pero no representa una cosa específica.
  • Animales, plantas, móviles, ordenadores…
  • La clase de persona, la clase de mascota, la clase de gato, etc. se utilizan para describir/definir las características y comportamientos que debe tener una cosa específica.
• Los objetos son instancias concretas de conceptos abstractos. Por ejemplo, Zhang San es una instancia concreta de una persona y el perro de Zhang San, Wangcai, es una instancia concreta de un perro.

Crear e inicializar objetos.

• Utilice nuevo para crear objetos.
• Cuando se crea usando la nueva palabra clave, además de asignar memoria, el objeto creado también se inicializará de forma predeterminada y se llamará al constructor de la clase.
• El constructor de una clase también se denomina método constructor y debe llamarse al crear un objeto. Tiene las siguientes características:
  • Debe ser el mismo que el nombre de la clase.
  • No hay ningún tipo de devolución y no se puede escribir anulación.
• Incluso si una clase no escribe nada, seguirá habiendo un constructor predeterminado.

Constructor

public class Person {
    
    
    //一个类即使什么都不写，也会存在一个默认的无参构造方法
    //显示地定义构造器
    String name;
    
    //作用：1. 使用new关键字，本质是在调用构造器
    //2. 用来初始化对象的值
    public Person(){
    
    } //无参构造
    
    //有参构造 3.一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
    
    
        this.name=name;
    }
	//Alt+insert 快捷键插入构造方法
}

Análisis de memoria

//定义一个宠物类
public class Pet {
    
    
    public String name; //默认 null
    public int age; 	//默认 0
    //无参构造

    public void shout(){
    
    
        System.out.println("叫了一声");
    }
}

//应用类，创建调用对象
public class Application {
    
    
    public static void main(String[] args) {
    
    
        
        Pet dog = new Pet();

        dog.name = "旺财";
        dog.age = 3;
        dog.shout();
    }
}

Un breve resumen de clases y objetos.

1. Clases y Objetos
   Una clase es una plantilla: abstracta, un objeto es una instancia concreta

2. Definición de método
   , llamada

3. Tipo de objeto de referencia
   : tipo básico (8)

   Los objetos son operados por referencias: pila---->montón

4. Atributo: variable miembro de campo

   Valor inicial predeterminado:

   ​ Número: 0 0.0

   char: u0000

   ​ booleano:falso

   ​ Referencia: nula

   Tipo de atributo modificador nombre de atributo = valor de atributo

5. Creación y uso de objetos.

   • El objeto usa una nueva palabra clave para crear un objeto, constructor Persona persona = nueva Persona();
   • Atributo del objeto persona.nombre;
   • Método de objeto person.sleep();

encapsulación

• Revelar lo que debería revelarse, ocultar lo que debería ocultarse.
  • Nuestra programación debe perseguir una "alta cohesión y un bajo acoplamiento". Alta cohesión significa que los detalles de datos internos de la clase se completan por sí mismos y no se permite interferencia externa; bajo acoplamiento: solo una pequeña cantidad de métodos están expuestos para uso externo.
• Encapsulación (ocultación de datos)
  • En general, se debe prohibir el acceso directo a la representación real de los datos en un objeto y, en su lugar, se debe acceder a través de la interfaz de manipulación, lo que se conoce como ocultación de información.
• efecto
  1. Mejore la seguridad del programa y proteja los datos
  2. Ocultar detalles de implementación del código
  3. interfaz unificada
  4. La mantenibilidad del sistema aumentó

heredar

• La esencia de la herencia es abstraer un determinado lote de clases para modelar mejor el mundo.
• extiende significa "extender". Una subclase es una extensión de la clase principal, representada por la palabra clave extiende.
• ¡Las clases en Java solo tienen herencia única, no herencia múltiple! Una clase sólo puede heredar de una clase principal.
• La herencia es una relación entre clases, además de dependencias, combinaciones, agregaciones, etc.
• Hay dos clases en la relación de herencia, una es la subclase (clase derivada) y la otra es la clase principal (clase base), y la subclase hereda la clase principal.
• En cierto sentido, debería haber una relación "es un" entre la subclase y la clase principal.

//学生类(子类)继承 人类(父类)
public class Student extends Person{
    
     /*Person extends Object*/
    ...
}

• Si una subclase hereda la clase principal, tendrá todos los métodos de la clase principal, pero las propiedades y métodos privados no se pueden heredar .
• En Java, todas las clases heredan directa o indirectamente la clase Objeto de forma predeterminada (Ctrl+H puede ver las relaciones de clase)
• Las clases modificadas por final no se pueden heredar (no hay descendientes).

súper y esto

1. super() llama al constructor de la clase padre y debe ser el primero en el constructor
2. super solo debe aparecer en métodos o constructores de subclases
3. **super() y this()** no pueden llamar al constructor al mismo tiempo, porque esto también debe escribirse en la primera línea

• La diferencia entre super y this: super representa una referencia al objeto de la clase principal y solo se puede usar bajo condiciones de herencia; esto llama a su propio objeto y se puede usar sin herencia.

super(); //隐藏代码，默认调用了父类的无参构造，要写只能写第一行

Anulación del método

• Reescritura: el método de la subclase debe ser coherente con el método de la clase principal, pero el cuerpo del método es diferente.
• Anular es la reescritura de métodos y no tiene nada que ver con los atributos.
• La anulación de métodos solo es relevante para los métodos no estáticos y no tiene nada que ver con los métodos estáticos (los métodos estáticos no se pueden anular)

public class B {
    
    
    public static void test(){
    
     //静态方法
        System.out.println("B==>test()");
    }
}

public class A extends B{
    
     //继承
    public static void test(){
    
    
        System.out.println("A==>test()");
    }
}

public class Application {
    
    
    public static void main(String[] args) {
    
    
        //方法的调用之和左边定义的类型有关
        A a = new A();
        a.test(); //打印 A==>test()

        //父类的引用指向了子类，但静态方法没有被重写
        B b = new A();
        b.test(); //打印 B==>test()
    }
}

Modificar A.java, B.java

public class B {
    
    
    public void test(){
    
     //非静态方法
        System.out.println("B==>test()");
    }
}
public class A extends B{
    
    
    @Override //重写了B的方法
    public void test() {
    
    
        System.out.println("A==>test()");
    }
}

//父类的引用指向了子类
B b = new A(); //子类重写了父类的方法，执行子类的方法
b.test(); //打印变成了 A==>test()
/* 
静态方法是类的方法，非静态方法是对象的方法
有static时，b调用了B类的方法，因为b是b类定义的
没有static时，b调用的是对象的方法，而b是A类new出来的对象，调用A的方法
*/

• Los métodos estáticos son métodos de clases, los métodos no estáticos son métodos de objetos.

• Cuando hay estática, b llama al método de la clase B, porque b está definido por la clase B.

• Cuando no hay estática, b llama al método del objeto y b está definido por la clase A.

• b es el objeto creado por A nuevo y se llama al método de A.

• Los métodos estáticos pertenecen a clases, los métodos no estáticos pertenecen a objetos

• punto importante:

  1. Los nombres de los métodos y las listas de parámetros deben ser los mismos.
  2. El alcance del modificador se puede ampliar pero no reducir (público>proteger>privado)
  3. El alcance de las excepciones lanzadas se puede reducir, pero no se puede ampliar.
  4. Los métodos modificados por **estático (perteneciente a clases, no a instancias), final (métodos constantes) y privado (privado)** no se pueden anular.
  5. Anulando, el método de la subclase debe ser coherente con el método de la clase principal.

• ¿Por qué reescribir?

  1. Las funciones de la clase principal no son necesariamente requeridas por la subclase o pueden no satisfacerse.

     control + Enter: anular;

Polimorfismo

• Compilación dinámica: Tipo: Extensibilidad
• Es decir, un mismo método puede adoptar diferentes comportamientos dependiendo del objeto emisor.
• Se determina el tipo real de un objeto, pero puede haber muchas referencias al objeto.
• Condiciones de existencia polimórficas.
  • Tener relación de herencia
  • La subclase anula el método de la clase principal
  • La referencia de la clase principal apunta al objeto de la clase secundaria.

Student s1 = new Student();
Person s2  = new Student();
Object s3  = new Student();
//子类能调用的方法都是你自己的或者继承父类的
//父类可以指向子类，但是不能调用子类独有的方法
s2.run();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大

• punto importante:
  1. El polimorfismo es polimorfismo de método, no polimorfismo de atributo.
  2. Clase principal y subclase, existe una excepción de conversión de tipo relacionada: ClassCastException
  3. Condiciones de existencia: relación de herencia, el método debe reescribirse, la referencia de la clase principal apunta al objeto de la clase secundaria.

Métodos que no se pueden anular

1. Método estático, pertenece a la clase, no pertenece a la instancia.
2. constante final
3. método privado privado

instancia de y conversión de tipo

• comparación de tipos de referencia de instancia para determinar de qué tipo es un objeto

public static void main(String[] args) {
    
    

    // Object > String
    // Objest > Person > Student
    // Objest > Person > Teacher
    Object object = new Student();
	// X instanceof Y，X引用指向的对象是不是Y的子类
    System.out.println(object instanceof Student); //true
    System.out.println(object instanceof Person); //true
    System.out.println(object instanceof Teacher); //false
    System.out.println(object instanceof Object); //true
    System.out.println(object instanceof String); //false
	
    //类型之间的转化：父-子（高-低）,低可以转换为高
    Person obj = new Student(); //只能用Person方法（重写了用子类重写过的方法）
    (Student)obj.go(); //强转之后可以用Student方法(Student->go())
}

conversión de tipo

1. La referencia de la clase principal apunta al objeto de la clase secundaria.
2. La conversión de una subclase a una clase principal y la transformación ascendente perderán algunos de sus métodos originales.
3. Convierta la clase principal en una subclase, elimínela, fuerce la conversión y luego llame al método de la subclase
4. Método conveniente de llamada (transformación), que reduce el código repetido y es simple.

Estático

• Se puede acceder a las variables estáticas directamente utilizando el nombre de la clase, también llamadas variables de clase.
• Las variables estáticas (o métodos) de una clase son compartidas por todos los objetos (instancias).
• El código de área estático se inicializa juntos al cargar la clase y se ejecuta como mínimo y solo una vez (la primera vez que sea nuevo).
• Matemáticas->Número aleatorio:

//静态导入包
import static java.lang.Math.random;

public class Application {
    
    
    public static void main(String[] args) {
    
    

        //第一种随机数，不用导包
        System.out.println(Math.random()); //0.7562202902634543

        //第二种随机数，静态导入包
        System.out.println(random()); //0.5391606223844663
    }
}

{
    
    
  //匿名代码块
}
static {
    
    
  //静态代码块
}

public class noName {
    
    
    //2  赋初始值
    {
    
    
        System.out.println("匿名代码块");
    }
    //1  只执行一次
    static {
    
    
        System.out.println("静态代码块");
    }
    //3
    public noName(){
    
    
        System.out.println("构造方法");
    }
}

clase abstracta

• La clase modificada por resumen es una clase abstracta y el método modificado es un método abstracto.
• No hay necesidad de métodos abstractos en clases abstractas, pero las clases con métodos abstractos deben declararse como clases abstractas.
• Las clases abstractas no pueden usar new para crear objetos, se usa para que las subclases hereden.
• Los métodos abstractos solo tienen declaraciones de método y no tienen implementación, dejando que las subclases los implementen.
• Una subclase hereda una clase abstracta y debe implementar todos los métodos de la clase abstracta; de lo contrario, la subclase también debe declararse como una clase abstracta.

//abstract 抽象类 类只能单继承（接口可以多继承）
public abstract class Action {
    
    

    //约束~有人帮我们实现~
    //抽象方法只有方法名，没有方法的实现
    public abstract void doSth();

    //1.不能new抽象类，只能靠子类去实现它，仅作为一个约束
    //2.抽象方法只能出现在抽象类中，抽象类可以有普通方法
    //3.抽象类有构造器，可以派生子类
    //4.抽象类的意义：约束，提高开发效率。但是类只能单继承，所以有局限 用的不多
}

interfaz

• Clase ordinaria: solo implementación concreta
• Clase abstracta: implementación y especificación concretas (método abstracto)
• Interfaz: solo especificaciones, sin implementación de métodos, restricciones profesionales. Separación de restricciones e implementación: programación orientada a interfaz ~
• Una interfaz es una especificación, que define un conjunto de reglas, la idea de “lo que eres… lo que debes hacer…”.
• La esencia de las interfaces son las limitaciones, al igual que las leyes humanas, que se formulan y todos las respetan.

//interface接口,接口都要有实现类
//实现类（implements 可以继承多个接口）
//多继承，利用接口实现多继承
public interface UserService {
    
    
    //定义的属性都是常量,默认修饰 public static final
    public static final int AGE = 99; //一般不用
    //所有的定义的方法都是抽象的 默认public abstract
    public abstract void run();
    void add();
    void query();
    void delete();
}

public class UserServiceImpl implements UserService{
    
    
    @Override
    public void add(String name) {
    
    
    }
    @Override
    public void delete(String name) {
    
    
    }
    @Override
    public void update(String name) {
    
    
    }
    @Override
    public void query(String name) {
    
    
    }
}

punto importante

• La interfaz no tiene constructor y no se puede crear una instancia.
• Las clases de implementación deben anular los métodos en la interfaz.
• Las implementaciones pueden implementar múltiples interfaces.

clase interna

• Una clase interna consiste en definir otra clase dentro de una clase. Por ejemplo, si una clase B se define en la clase A, entonces B es la clase interna de A y A es una clase externa relativa a B.
  1. Clase interna miembro: puede operar las propiedades y métodos privados de la clase externa
  2. Clase interna estática: modificación estática, no se puede acceder a las propiedades privadas de la clase externa
  3. Clase interna local: clase definida en el método de la clase externa
  4. Clase interna anónima: clase inicializadora sin nombre
• Puede haber varias clases en una clase Java, pero solo puede haber una clase pública.

public class Outer {
    
    
    private int id = 10;

    public void out() {
    
    
        System.out.println("这是一个外部类的方法");
    }

    class Inner {
    
    
        public void in() {
    
    
            System.out.println("这是一个内部类的方法");
        }

        //获得外部类的私有属性
        public void getId() {
    
    
            System.out.println(id);
        }
    }
}

public class Application {
    
    
    public static void main(String[] args) {
    
    
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();
    }
}

public class Outer {
    
    
    //局部内部类
    public void method(){
    
    
        class Inner{
    
    
            public void in(){
    
    
                
            }
        }
    }
}

public class Outer {
    
    
    public static void main(String[] args) {
    
    
        //Apple apple = new Apple();
        //没有名字初始化类
        new Apple().eat();
        new UserService(){
    
    
            @Override
            public void hello() {
    
    
                
            }
        };
    }
}
class Apple{
    
    
    public void eat(){
    
    
        System.out.println("eat");
    }
}
interface UserService{
    
    
    void hello();
}

anormal

• Cuando los programas de software se están ejecutando, a menudo pueden encontrar problemas anormales. Las excepciones en inglés (Exception) significan excepciones. Estas excepciones requieren que escribamos programas para manejarlas de manera razonable para no causar que el programa falle.
• Las excepciones se refieren a varias condiciones inesperadas que ocurren durante el funcionamiento del programa: no se pueden encontrar archivos, errores de conexión de red, parámetros ilegales, etc.
• Se producen excepciones durante la ejecución del programa y afectan el flujo de ejecución normal.

clasificación sencilla

• Excepciones marcadas: Las excepciones más representativas son excepciones causadas por errores o problemas del usuario, que no pueden ser previstos por el programador. Por ejemplo, se generan excepciones cuando el usuario quiere abrir un archivo que no existe y estas excepciones no pueden simplemente ignorarse en el momento de la compilación.
• Excepciones de tiempo de ejecución: son excepciones que el programador puede evitar. A diferencia de las excepciones marcadas, las excepciones de tiempo de ejecución se pueden ignorar en el momento de la compilación.
• Error: el error no es una excepción, sino un problema que escapa al control del programador. Los errores de código suelen ignorarse. Por ejemplo, cuando la pila se desborda y ocurre una excepción, no se pueden verificar durante la compilación.

Mecanismo de manejo de excepciones

• lanzar una excepción
• excepción de captura
• Palabras clave de manejo de excepciones: intentar, atrapar, finalmente, lanzar, lanzar

public static void main(String[] args) {
    
    
    int a = 1;
    int b = 0;

    try {
    
     //try监控区域
        System.out.println(a/b);
    }catch (ArithmeticException e){
    
     //catch 捕获异常
        System.out.println("程序出现异常，变量b不能为0");
    }catch (Exception e){
    
    
        e.printStackTrace();
    }finally {
    
     //一定会执行，处理善后工作，如关闭资源
        System.out.println("finally");
    }
    
    if(b==0){
    
     //抛出异常一般在方法中使用
        throw new ArithmeticException(); //主动抛出异常
    }
}
//Ctrl+Alt+T 快捷键插入 try-catch

• Suponga que desea detectar varias excepciones, desde pequeñas hasta grandes.
• Comando de tecla de método abreviado de excepción + opción + T

public class Application {
    
    
    public static void main(String[] args) {
    
    
        try {
    
    
            new Application().test(1,0);
        } catch (ArithmeticException e) {
    
    
            e.printStackTrace();
        }
    }
    //假设这个方法中，处理不了这个异常。方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
    
    
        if(b==0){
    
    
            //主动抛出异常，一般在方法中使用
            throw new ArithmeticException();
        }
    }
}

Excepción personalizada

• La mayoría de las excepciones que ocurren durante la programación se pueden describir utilizando las clases de excepción integradas de Java. Además, los usuarios también pueden personalizar las excepciones. Las excepciones definidas por el usuario solo necesitan heredar la clase Exception
• Utilice clases y clasificaciones de excepción personalizadas en programas
  1. Crear una clase de excepción personalizada
  2. Lanzar un objeto de excepción mediante la palabra clave throw en el método
  3. Si la excepción se maneja en el método de la excepción lanzada actualmente, puede usar la declaración try-catch para capturarla y manejarla; de lo contrario, use la palabra clave throws en la declaración del método para indicar la excepción que se lanzará al método. persona que llama, continúe y realice el siguiente paso.
  4. Capture y maneje excepciones en la persona que llama al método de excepción.

//自定义异常类
public class MyException extends Exception{
    
    
    //传递数字 > 10 抛出异常
    private int detail;
    public MyException(int message){
    
    
        this.detail = message;
    }
    //toString: 异常的打印信息
    @Override
    public String toString() {
    
    
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}

public class Test {
    
    
    //可能会存在异常的方法
    static void test(int a) throws MyException {
    
    
        if (a > 10) {
    
    
            throw new MyException(a); //抛出
        }
        System.out.println("传递的参数为 " + a);
    }

    public static void main(String[] args) {
    
    
        try {
    
    
            test(11);
        } catch (MyException e) {
    
    
            System.out.println("MyException=>" + e);
        }
    }
}