Notas de revisión de basura personal de javase 13 Paquete de Java, enumeración de Java (enum) y paquete (paquete), así como la interfaz


Ventajas del empaquetado de Java

  1. Un buen empaque puede reducir el acoplamiento.

  2. La estructura interna de la clase se puede modificar libremente.

  3. Puede controlar las variables miembro con mayor precisión.

  4. Ocultar información e implementar detalles.
    Pasos para lograr la encapsulación de Java

  5. Modifique la visibilidad del atributo para restringir el acceso al atributo (generalmente restringido a privado), por ejemplo:

public class Person {
    
    
    private String name;
    private int age;
}

En este código, los atributos de nombre y edad se establecen en privado, a los que solo puede acceder esta clase y no pueden acceder otras clases, por lo que la información está oculta.
2. Proporcionar acceso de método público externo a cada atributo de valor, es decir, crear un par de métodos de asignación para acceder a atributos privados, por ejemplo:

public class Person{
    
    
    private String name;
    private int age;public int getAge(){
    
    
      return age;
    }public String getName(){
    
    
      return name;
    }public void setAge(int age){
    
    
      this.age = age;
    }public void setName(String name){
    
    
      this.name = name;
    }
}/*采用 this 关键字是为了解决实例变量(private String name)和局部变量(setName(String name)中的name变量)之间发生的同名的冲突

Veamos un ejemplo de una clase de paquete java:

/* 文件名: EncapTest.java */
public class EncapTest{
    
    
 
   private String name;
   private String idNum;
   private int age;
 
   public int getAge(){
    
    
      return age;
   }
 
   public String getName(){
    
    
      return name;
   }
 
   public String getIdNum(){
    
    
      return idNum;
   }
 
   public void setAge( int newAge){
    
    
      age = newAge;
   }
 
   public void setName(String newName){
    
    
      name = newName;
   }
 
   public void setIdNum( String newId){
    
    
      idNum = newId;
   }
}
/* F文件名 : RunEncap.java */
public class RunEncap{
    
    
   public static void main(String args[]){
    
    
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");
 
      System.out.print("Name : " + encap.getName()+ 
                             " Age : "+ encap.getAge());
    }
}
/*
以上代码编译运行结果如下:

Name : James Age : 20

// Es bastante simple, no hay problema.

Enumeración de Java (enum)
La enumeración de Java es una clase especial, que generalmente representa un conjunto de constantes, como 4 estaciones de un año, 12 meses de un año, 7 días de la semana y las direcciones son sureste, noroeste, etc.
Las clases de enumeración de Java se definen mediante la palabra clave enum y cada constante está separada por una coma.
Por ejemplo, defina una clase de enumeración de colores.

enum Color
{
    
    
    RED, GREEN, BLUE;
}
 
public class Test
{
    
    
    // 执行输出结果
    public static void main(String[] args)
    {
    
    
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}/*
执行以上代码输出结果为:

RED

Las clases de enumeración también se pueden declarar en clases internas:

public class Test
{
    
    
    enum Color//每个枚举都是通过 Class 在内部实现的,且所有的枚举值都是 public static final 的。
    {
    
    
        RED, GREEN, BLUE;
    }
 
    // 执行输出结果
    public static void main(String[] args)
    {
    
    
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}
/*执行以上代码输出结果为:
RED*/
//相当于:
class Color
{
    
    
     public static final Color RED = new Color();
     public static final Color BLUE = new Color();
     public static final Color GREEN = new Color();
}

Iteración de elementos de enumeración
Puede utilizar la instrucción for para iterar elementos de enumeración:

enum Color
{
    
    
    RED, GREEN, BLUE;
}
public class MyClass {
    
    
  public static void main(String[] args) {
    
    
    for (Color myVar : Color.values()) {
    
    
      System.out.println(myVar);
    }
  }
}
/*执行以上代码输出结果为:
RED
GREEN
BLUE

Usar clases de enumeración en switch Las clases de enumeración
se usan a menudo en declaraciones switch:

enum Color
{
    
    
    RED, GREEN, BLUE;
}
public class MyClass {
    
    
  public static void main(String[] args) {
    
    
    Color myVar = Color.BLUE;

    switch(myVar) {
    
    
      case RED:
        System.out.println("红色");
        break;
      case GREEN:
         System.out.println("绿色");
        break;
      case BLUE:
        System.out.println("蓝色");
        break;
    }
  }
}
/*执行以上代码输出结果为:
蓝色


La clase de enumeración definida por los métodos values ​​(), ordinal () y valueOf () enum hereda la clase java.lang.Enum de forma predeterminada e implementa las interfaces java.lang.Seriablizable y java.lang.Comparable.

Los métodos values ​​(), ordinal () y valueOf () se encuentran en la clase java.lang.Enum:
values ​​() devuelve todos los valores en la clase de enumeración.
El método ordinal () puede encontrar el índice de cada constante de enumeración, al igual que un índice de matriz.
El método valueOf () devuelve la constante de enumeración del valor de cadena especificado.

enum Color
{
    
    
    RED, GREEN, BLUE;
}
 
public class Test
{
    
    
    public static void main(String[] args)
    {
    
    
        // 调用 values()
        Color arr[] = Color.values();
 
        // 迭代枚举
        for (Color col : arr)
        {
    
    
            // 查看索引
            System.out.println(col + " at index " + col.ordinal());
        }
 
        // 使用 valueOf() 返回枚举常量,不存在的会报错 IllegalArgumentException
        System.out.println(Color.valueOf("RED"));
        // System.out.println(Color.valueOf("WHITE"));
    }
}
/*执行以上代码输出结果为:

RED at index 0
GREEN at index 1
BLUE at index 2
RED

Miembros de la clase de enumeración La
enumeración puede usar sus propias variables, métodos y constructores al igual que las clases ordinarias.El constructor solo puede usar el modificador de acceso privado, por lo que no se puede llamar desde afuera.

enum Color
{
    
    
    RED, GREEN, BLUE;
 
    // 构造函数
    private Color()
    {
    
    
        System.out.println("Constructor called for : " + this.toString());
    }
 
    public void colorInfo()
    {
    
    
        System.out.println("Universal Color");
    }
}
 
public class Test
{
    
        
    // 输出
    public static void main(String[] args)
    {
    
    
        Color c1 = Color.RED;
        System.out.println(c1);
        c1.colorInfo();
    }
}
/*执行以上代码输出结果为:

Constructor called for : RED
Constructor called for : GREEN
Constructor called for : BLUE
RED
Universal Color

Paquete Java (paquete) que
actúa en el paquete
1, en el mismo paquete, y es fácil encontrar funciones similares o relacionadas como clase o tejido de interfaz.

2. Al igual que las carpetas, los paquetes también utilizan un método de almacenamiento de directorios en forma de árbol. Los nombres de las clases en el mismo paquete son diferentes y los nombres de las clases en diferentes paquetes pueden ser los mismos. Cuando se llaman clases con el mismo nombre de clase en dos paquetes diferentes al mismo tiempo, se debe agregar el nombre del paquete para distinguir. Por lo tanto, el paquete puede evitar conflictos de nombres.

3. El paquete también tiene derechos de acceso limitados, y solo las clases con derechos de acceso al paquete pueden acceder a las clases de un paquete.

Importar palabra clave
Para poder utilizar un miembro de un paquete, necesitamos importar explícitamente el paquete en el programa Java. Utilice la instrucción "importar" para completar esta función.

import package1[.package2…].(classname|*);

Ejemplo
El siguiente paquete de nómina ya contiene la clase Empleado A continuación, agregue una clase Boss al paquete de nómina. El prefijo de nómina se puede omitir cuando la clase Boss se refiere a la clase Empleado. Los ejemplos de la clase Boss son los siguientes.

package payroll;
 
public class Boss
{
    
    
   public void payEmployee(Employee e)
   {
    
    
      e.mailCheck();
   }
}

¿Qué pasa si la clase Boss no está en el paquete de nómina? La clase Boss debe utilizar uno de los siguientes métodos para hacer referencia a clases en otros paquetes.

Utilice el nombre completo de la clase para describir, por ejemplo:

payroll.Employee
se introduce con la palabra clave de importación, utilizando el comodín "*"

import payroll. *;
Use la palabra clave import para importar la clase Empleado:

nómina de importación. Empleado;
注意 :

Se puede incluir cualquier número de declaraciones de importación en el archivo de clase. La declaración de importación debe estar después de la declaración del paquete y antes de la declaración de clase.

// Me gusta más la gestión de paquetes.

Interfaz Java

Interface (en inglés: Interface), en el lenguaje de programación JAVA, es un tipo abstracto y una colección de métodos abstractos. Las interfaces generalmente se declaran como interfaz. Una clase hereda los métodos abstractos de la interfaz heredando la interfaz.

Las interfaces no son clases, la forma de escribir interfaces es similar a las clases, pero pertenecen a conceptos diferentes. La clase describe las propiedades y métodos del objeto. La interfaz contiene los métodos que implementará la clase.

A menos que la clase que implementa la interfaz sea una clase abstracta, la clase debe definir todos los métodos en la interfaz.

No se puede crear una instancia de la interfaz, pero se puede implementar. Una clase que implementa una interfaz debe implementar todos los métodos descritos en la interfaz; de lo contrario, debe declararse como una clase abstracta. Además, en Java, los tipos de interfaz se pueden usar para declarar una variable, pueden convertirse en un puntero nulo o estar vinculados a un objeto implementado por esta interfaz.

Las interfaces son similares a las clases:
una interfaz puede tener varios métodos.
El archivo de interfaz se guarda en un archivo que termina en .java y el nombre del archivo usa el nombre de la interfaz.
El archivo de código de bytes de la interfaz se guarda en un archivo que termina en .class.
El archivo de código de bytes correspondiente a la interfaz debe estar en la estructura de directorio que coincida con el nombre del paquete.

La diferencia entre interfaces y clases: las
interfaces no se pueden utilizar para crear instancias de objetos.
La interfaz no tiene constructor.
Todos los métodos de la interfaz deben ser métodos abstractos.
La interfaz no puede contener variables miembro, excepto variables estáticas y finales.
La interfaz no es heredada por la clase, sino que debe ser implementada por la clase.
La interfaz admite herencia múltiple.

La interfaz tiene las siguientes características: La
interfaz es implícitamente abstracta: al declarar una interfaz, no es necesario utilizar la palabra clave abstracta.
Todos los métodos de la interfaz también son implícitamente abstractos y la palabra clave abstract tampoco es necesaria en la declaración.
Los métodos de la interfaz son todos públicos.

Interfaz implementa
el momento en que la clase implementa la interfaz, las clases de interfaz para implementar todos los métodos. De lo contrario, la clase debe declararse como una clase abstracta.
La clase usa la palabra clave implements para implementar la interfaz. En la declaración de clase, la palabra clave Implements se coloca después de la declaración de clase.
Para implementar la sintaxis de una interfaz, puede utilizar esta fórmula:

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

ejemplo:

interface Animal {
    
    
   public void eat();
   public void travel();
}
public class MammalInt implements Animal{
    
    
 
   public void eat(){
    
    
      System.out.println("Mammal eats");
   }
 
   public void travel(){
    
    
      System.out.println("Mammal travels");
   } 
 
   public int noOfLegs(){
    
    
      return 0;
   }
 
   public static void main(String args[]){
    
    
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}
/*以上实例编译运行结果如下:

Mammal eats
Mammal travels

Al reescribir métodos declarados en una interfaz, debe prestar atención a las siguientes reglas:

Cuando una clase implementa un método de interfaz, no puede lanzar una excepción obligatoria, solo puede lanzarse en la interfaz o en una clase abstracta que herede la interfaz.
La clase debe mantener el mismo nombre de método al reescribir el método y debe mantener el mismo tipo de valor de retorno o compatible.
Si la clase que implementa la interfaz es una clase abstracta, entonces no es necesario implementar los métodos de la interfaz.
Al implementar la interfaz, también preste atención a algunas reglas:

Una clase puede implementar múltiples interfaces al mismo tiempo.
Una clase solo puede heredar una clase, pero puede implementar múltiples interfaces.
Una interfaz puede heredar otra interfaz, que es similar a la herencia entre clases.

Herencia de la
interfaz Una interfaz puede heredar otra interfaz, que es similar a la forma de herencia entre clases. La herencia de la interfaz utiliza la palabra clave extensions, y la interfaz secundaria hereda el método de la interfaz principal.

La siguiente interfaz de deportes es heredada por la interfaz de hockey y fútbol:

public interface Sports
{
    
    
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}
 public interface Hockey extends Sports
{
    
    
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}
 //Hockey接口自己声明了四个方法,从Sports接口继承了两个方法,这样,实现Hockey接口的类需要实现六个方法。

Supongo que te gusta

Origin blog.csdn.net/qq_45864370/article/details/108608854
Recomendado
Clasificación