Los programas Java utilizan clases abstractas para implementar conceptos abstractos en la naturaleza. La función de una clase abstracta es organizar muchas clases relacionadas juntas para proporcionar una clase común, es decir, una clase abstracta, y las clases específicas organizadas por ella se derivarán de ella como sus subclases. Una clase abstracta caracteriza el comportamiento público y lo transfiere a sus clases derivadas a través del mecanismo de herencia. Los métodos definidos en clases abstractas se denominan métodos abstractos. Estos métodos solo tienen la declaración del encabezado del método y usan un punto y coma para reemplazar la definición del cuerpo del método, es decir, solo se define la forma de interfaz del método miembro sin operaciones específicas. . Sólo la redefinición de métodos miembro abstractos por una clase derivada implementa realmente operaciones relacionadas con la clase derivada.
Después de que cada subclase hereda el método abstracto de la clase principal, lo redefine con diferentes declaraciones y cuerpos de métodos, formando varias subclases con el mismo nombre, el mismo valor de retorno y la misma lista de parámetros, con el mismo propósito pero con ciertas diferencias en términos específicos. implementaciones. El propósito de definir un método abstracto en una clase abstracta es implementar una interfaz, es decir, todas las subclases presentan un método con el mismo nombre al mundo exterior. Una clase abstracta es una colección de atributos públicos de todas sus subclases y una clase que contiene uno o más métodos abstractos. Una de las ventajas de utilizar clases abstractas es que puede aprovechar al máximo estas propiedades públicas para mejorar la eficiencia del desarrollo y mantenimiento de programas. Las restricciones sobre clases abstractas y métodos abstractos son las siguientes:
(1) Cualquier clase modificada con el modificador abstracto se denomina clase abstracta. Cualquier método miembro modificado con el modificador abstracto se denomina método abstracto.
(2) Una clase abstracta puede tener cero o más métodos abstractos, o también puede contener métodos no abstractos.
(3) No hay necesidad de métodos abstractos en clases abstractas, pero las clases con métodos abstractos deben ser clases abstractas.
(4) Para los métodos abstractos, solo el nombre del método y su tipo se especifican en la clase abstracta sin escribir su código de implementación.
(5) Una clase abstracta puede derivar subclases, y todos los métodos abstractos definidos en la clase abstracta deben implementarse en las subclases derivadas de la clase abstracta.
(6) Las clases abstractas no pueden crear objetos. El trabajo de creación de objetos se implementa mediante subclases derivadas de clases abstractas.
(7) Si hay un método abstracto con el mismo nombre en la clase principal, no puede haber otro método abstracto con el mismo nombre en la subclase.
(8) abstract no puede modificar la misma clase en paralelo con final.
(9) El resumen no se puede utilizar para modificar el mismo método en paralelo con privado, estático, final o nativo.
El lenguaje Java estipula que cuando una clase tiene un método abstracto, la clase debe declararse como una clase abstracta.
Cuando una subclase hereda una clase principal, si hay métodos abstractos en la clase principal y la subclase siente que puede implementar todos los métodos abstractos de la clase principal, entonces la subclase debe implementar todos los métodos abstractos de la clase principal, como como:
/** * La subclase Dog hereda la clase abstracta Animal e implementa el método abstracto enjoy * @author gacl * */class Dog extends Animal { /** * La clase Dog agrega sus propios atributos únicos*/ public String furColor; ( String n, String c) { super(n);//Llamar al constructor de la clase padre Animal this.furColor = c } @Override public void enjoy() { System.out.println("El perro ladra.. .." ); }} Si la subclase considera que el método abstracto en la clase principal no se puede implementar, entonces declare la subclase como una clase abstracta, como por ejemplo:
/** * La subclase Cat aquí hereda de la clase abstracta Animal y, naturalmente, hereda el método abstracto enjoy() declarado en la clase Animal * Sin embargo, la subclase Cat considera que no es apropiado implementar este método enjoy(). en sí mismo, por lo que se declara como una clase abstracta, * Luego, quien implemente este método abstracto enjoy y quien herede la subclase, implementará este método abstracto enjoy(). * @author gacl * */abstract class Cat extends Animal { /** * Cat agrega sus propios atributos únicos*/ public String eyeColor public Cat(String n, String c) { super(n);//Llamar a la clase principal; Método de construcción del animal this.eyeColor = c }} La subclase Cat aquí hereda de la clase abstracta Animal y, naturalmente, hereda el método abstracto enjoy () declarado en la clase Animal. Sin embargo, la subclase Cat considera que no es apropiado implementar este método enjoy () por sí solo, por lo que. se llama a sí mismo Declarado como una clase abstracta, entonces quien implemente el método abstracto enjoy y quien herede la subclase, luego implementará el método abstracto enjoy (). como:
/** * La subclase BlueCat hereda la clase abstracta Cat e implementa el método abstracto enjoy heredado de la clase padre Cat * @author gacl * */class BlueCat extends Cat { public BlueCat(String n, String c) { super(n , c); } /** * Implementa el método abstracto enjoy */ @Override public void enjoy() { System.out.println("El gato azul maúlla..."); El código de prueba completo es el siguiente:
paquete javastudy.summary;/** * Clase padre Animal * Agrega resumen delante de la clase, es decir, declarala así: clase abstracta Animal * De esta manera, la clase Animal se convierte en una clase abstracta */clase abstracta Animal { public Nombre de cadena; animal público (nombre de cadena) { this.name = nombre } /** * Método abstracto * Solo existe la definición del método, pero no hay implementación. */ public abstract void enjoy(); }/** * La subclase Cat aquí hereda de la clase abstracta Animal y, naturalmente, hereda el método abstracto enjoy() declarado en la clase Animal, * pero la subclase Cat siente que debe ser implementado por sí mismo Este método enjoy() también es inapropiado, por lo que se declara a sí mismo como una clase abstracta. * Entonces, quien implemente este método abstracto enjoy, y quien herede una subclase, quien implemente este método abstracto disfrute(). * @author gacl * */abstract class Cat extends Animal { /** * Cat agrega sus propios atributos únicos*/ public String eyeColor public Cat(String n, String c) { super(n);//Llamar a la clase principal; Método de construcción de Animal this.eyeColor = c; }}/** * La subclase BlueCat hereda la clase abstracta Cat e implementa el método abstracto enjoy heredado de la clase principal Cat * @author gacl * */class BlueCat extends Cat { public BlueCat(String n, String c) { super(n, c } /** * Implementa el método abstracto enjoy */ @Override public void enjoy() { System.out.println("Blue Cat maúlla. .."); } }/** * La subclase Perro hereda la clase abstracta Animal e implementa el método abstracto enjoy * @author gacl * */class Dog extends Animal { /** * La clase Perro agrega sus propios atributos únicos * / cadena pública furColor; public Dog(String n, String c) { super(n);// Llama al constructor de la clase padre Animal this.furColor = c } @Override public void enjoy() { System.out.println("Dog; ladra ...."); }} public class TestAbstract { /** * @param args */ public static void main(String[] args) { /** * Después de declarar la clase Cat como una clase abstracta, no se puede crear una instancia de la clase Cat. * Debido a que la clase abstracta está incompleta y le faltan brazos y piernas, no se puede crear una instancia de la clase abstracta. */ //Cat c = new Cat("Catname","blue"); //Llama al método de disfrute BlueCat que implementaste c = new BlueCat("BlueCatname","blue"); c.enjoy();//Llama al método de disfrute que implementaste}}