What Are Abstract Classes<\/h2>\n![\"abstract](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/787\/abstract-class-UML-diagram-overcoded.jpg\" "\\"abstract-class-UML-diagram-overcoded\\"")
<\/a>UML Diagram showing an partially abstract Shape class and subclassed Square classs<\/figcaption><\/figure>\nIn practical terms, abstract classes are like molds for creating a very basic structure of an object. The details, such as methods, fields, and related polymorphic relationships, can be a range across many subclassed objects.<\/p>\n
For example, an abstract Shape class might broadly define a geometric model as requiring a method to return the number of sides. All subclassed objects, such as Square<\/code>, Triangle<\/code>, or Dodecahedron<\/code> would implement this method in a way that other developers could\u00a0depend<\/em> on it to return the number of sides for that particular object (i.e. Square.getSideCount() == 4; \/\/ true<\/code>).<\/p>\nWhen to Use Abstract Classes<\/h2>\n
Abstract classes are better suited for use among similar subclass objects. For example, an application that models several geometric shapes such as Square<\/code>, Rectangle<\/code>, Rhomboid<\/code>, and Dodecahedron<\/code> would be better served through the subclassing of a Shape<\/code> abstract class rather than an interface. Interfaces are better suited for wide implementation by unrelated classes. For example, Serializable<\/code>, Clonable<\/code>, Printable<\/code>, etc.<\/p>\nAbstract classes are better suited for use among similar subclasses that need to implement methods and fields using more restrictive access modifiers such as private<\/code>, package-private<\/code>, or protected<\/code>. By contrast, all abstract<\/code>, static<\/code>, and default<\/code> methods in Interfaces implicitly have public access.<\/p>\nAbstract classes are better suited when a developer wishes to declare non-static or non-final fields. This allows subclasses to modify such values via specific implementation whereas Interfaces fields are public static final<\/code>\u2014the equivalent of a constant<\/code>.<\/p>\nPartially abstract classes offer a high degree of dynamism and flexibility. These implementations can become burdensome to maintain once attributes and methods start mixing accessor restriction levels or inheriting from multiple sources. Many modern IDEs, like IntelliJ by Jetbrains, provide some degree of helpful prompting.<\/p>\n![\"intellij](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/787\/intellij-abstract-subclass-nag-overcoded.jpg\" "\\"intellij-abstract-subclass-nag-overcoded\\"")
<\/a>Modern IDEs like IntelliJ by Jetbrains can help spot implementation issues when utilizing abstract classes<\/figcaption><\/figure>\nExample Code of Abstract Class<\/h2>\n
Below is example code of how one might implement a Shape abstract superclass from which a Square concretion can be subclassed. Note the mixed-use of abstract and non-abstract methods here. This is an approach best suited for abstract classes, rather than interfaces, since Shape and Square share so much in common.<\/p>\n
package AbstractClasses;\r\n\r\n\/**\r\n * Abstract class implantation that requires certain attributes to be\r\n * present in all subclass objects, specific method implementations, and\r\n * some abstract methods to be implemented specifically by subclassing objects.\r\n *\/\r\npublic abstract class Shape {\r\n\r\n \/\/ Define required fields for all Shape type objects\r\n public int sides;\r\n public int width;\r\n public int length;\r\n\r\n \/**\r\n * Define the constructor class requiring a number of sides to be defined.\r\n * @param sides - int number of sides for a Geometry.\r\n *\/\r\n Shape(int sides, int length, int width){\r\n this.sides = sides;\r\n this.length = length;\r\n this.width = width;\r\n };\r\n\r\n \/**\r\n * Abstract method to return the number of sides an\r\n * object is defined as having.\r\n * @return int - number of sides.\r\n *\/\r\n public int getSides(){\r\n return this.sides;\r\n }\r\n\r\n \/**\r\n * Return the calculated area of a shape.\r\n * @return float - area of the shape.\r\n *\/\r\n public abstract float getArea();\r\n}\r\n\r\n\/**\r\n * Subclass of Shape defining the behavior of a Square geometry.\r\n *\/\r\nclass Square extends Shape{\r\n \r\n \/**\r\n * Define the constructor class requiring a number of sides to be defined.\r\n * @param sides - int number of sides for a Geometry.\r\n * @param width - float value of shape width and length (same for squares)\r\n *\/\r\n Square(int sides, int width) {\r\n super(sides, width, width);\r\n }\r\n\r\n \/**\r\n * Class-specific implementation to calculate the area\r\n * of a square using length x width formula.\r\n * @return - float value of Square area.\r\n *\/\r\n @Override\r\n public float getArea() {\r\n return this.width * this.width;\r\n }\r\n}\r\n<\/pre>\nThis code illustrates the mixed-use of abstract and concrete methods along with publicly accessible fields. The Square subclass extends the Shape superclass, being required to implement a custom getArea()<\/code> method specific to the formula used to calculate the area of a Square (width ^ 2).<\/p>\nNote the custom use of the Square<\/code> constructor here as well — while still making use of the signature required by the Shape superclass. This implements a somewhat contrived requirement set forth in the Superclass that all Shape<\/code>-type objects require a length and width measurement.<\/p>\nAbstract Classes vs. Interfaces<\/h2>\n
In some popular programming languages like Python<\/a>, there are mechanisms in place to support multiple inheritance of partially abstract classes. This allows a subclass to inherit from multiple superclasses with both abstract and implemented methods.<\/p>\nIn other languages like Java, multiple inheritance is not\u00a0strictly\u00a0<\/em>allowed. I say “strictly” because one can\u00a0implement\u00a0<\/em>multiple interfaces in subclassed objects. Interfaces are very much like fully<\/em> abstract classes in that none of their methods are implemented (1<\/a>).<\/p>\nProgramming languages like Java also differentiate abstract classes from Interfaces in several other notable, yet subtle ways. For example, Java allows fields to have access restrictions other than public static final<\/code> which are required for interfaces. This allows more flexibility at the cost of complexity.<\/p>\nTL;DR<\/strong>\u2014Essentially, the developers of Java decided that if one chooses multiple inheritances it must be from fully abstract superclasses.<\/p>\nFinal Thoughts<\/h2>\n
Abstract classes are foundational to the polymorphic and inheritance aspects of modern object-oriented design. Proper implementation of components such as interfaces and abstract base classes work to allow robust use of design patterns, such as the Observer<\/a>.<\/p>\nI remember thinking how simple<\/em> abstract classes, inheritance, polymorphic behavior, and related object-oriented concepts were when first taught. That feeling faded quickly<\/em><\/strong> once I started becoming aware of the seemingly endless gotchas, edge-cases, and variety of contexts in which these concepts could apply.<\/p>\nAbstract classes are powerful tools to leverage in Object-oriented design but must be studied with care, applied with forethought, and perpetually reconsidered\/refactored to ensure implementations that will avoid embarrassment during one’s next code review. Check out our ever-evolving list of the most popular computer science and programming books<\/a> for some great references!<\/p>\nReferences<\/h2>\n\n- Oracle. \u201cThe Java Tutorials – Abstract Methods and Classes.\u201d\u00a0Oracle<\/i>, 18 Mar. 2014, docs.oracle.com\/javase\/tutorial\/java\/IandI\/abstract.html.<\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"
Abstract classes are types of programming architectures that allow developers to define broad behaviors that can be applied to more specific constructs. In object-oriented programming, Abstract classes are used to support polymorphism and inheritance among superclass and subclass objects. Depending on the language, abstract classes may be called protocols, interfaces, or a myriad of other […]<\/p>\n","protected":false},"author":2,"featured_media":794,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[1,655,246,10],"tags":[335,333,300,20,323,334,272],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/787"}],"collection":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/comments?post=787"}],"version-history":[{"count":6,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/787\/revisions"}],"predecessor-version":[{"id":796,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/787\/revisions\/796"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/794"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=787"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=787"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=787"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
<\/a>In practical terms, abstract classes are like molds for creating a very basic structure of an object. The details, such as methods, fields, and related polymorphic relationships, can be a range across many subclassed objects.<\/p>\n
For example, an abstract Shape class might broadly define a geometric model as requiring a method to return the number of sides. All subclassed objects, such as Abstract classes are better suited for use among similar subclass objects. For example, an application that models several geometric shapes such as Abstract classes are better suited for use among similar subclasses that need to implement methods and fields using more restrictive access modifiers such as Abstract classes are better suited when a developer wishes to declare non-static or non-final fields. This allows subclasses to modify such values via specific implementation whereas Interfaces fields are Partially abstract classes offer a high degree of dynamism and flexibility. These implementations can become burdensome to maintain once attributes and methods start mixing accessor restriction levels or inheriting from multiple sources. Many modern IDEs, like IntelliJ by Jetbrains, provide some degree of helpful prompting.<\/p>\n Below is example code of how one might implement a Shape abstract superclass from which a Square concretion can be subclassed. Note the mixed-use of abstract and non-abstract methods here. This is an approach best suited for abstract classes, rather than interfaces, since Shape and Square share so much in common.<\/p>\n This code illustrates the mixed-use of abstract and concrete methods along with publicly accessible fields. The Square subclass extends the Shape superclass, being required to implement a custom Note the custom use of the In some popular programming languages like Python<\/a>, there are mechanisms in place to support multiple inheritance of partially abstract classes. This allows a subclass to inherit from multiple superclasses with both abstract and implemented methods.<\/p>\n In other languages like Java, multiple inheritance is not\u00a0strictly\u00a0<\/em>allowed. I say “strictly” because one can\u00a0implement\u00a0<\/em>multiple interfaces in subclassed objects. Interfaces are very much like fully<\/em> abstract classes in that none of their methods are implemented (1<\/a>).<\/p>\n Programming languages like Java also differentiate abstract classes from Interfaces in several other notable, yet subtle ways. For example, Java allows fields to have access restrictions other than TL;DR<\/strong>\u2014Essentially, the developers of Java decided that if one chooses multiple inheritances it must be from fully abstract superclasses.<\/p>\n Abstract classes are foundational to the polymorphic and inheritance aspects of modern object-oriented design. Proper implementation of components such as interfaces and abstract base classes work to allow robust use of design patterns, such as the Observer<\/a>.<\/p>\n I remember thinking how simple<\/em> abstract classes, inheritance, polymorphic behavior, and related object-oriented concepts were when first taught. That feeling faded quickly<\/em><\/strong> once I started becoming aware of the seemingly endless gotchas, edge-cases, and variety of contexts in which these concepts could apply.<\/p>\n Abstract classes are powerful tools to leverage in Object-oriented design but must be studied with care, applied with forethought, and perpetually reconsidered\/refactored to ensure implementations that will avoid embarrassment during one’s next code review. Check out our ever-evolving list of the most popular computer science and programming books<\/a> for some great references!<\/p>\n Abstract classes are types of programming architectures that allow developers to define broad behaviors that can be applied to more specific constructs. In object-oriented programming, Abstract classes are used to support polymorphism and inheritance among superclass and subclass objects. Depending on the language, abstract classes may be called protocols, interfaces, or a myriad of other […]<\/p>\n","protected":false},"author":2,"featured_media":794,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[1,655,246,10],"tags":[335,333,300,20,323,334,272],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/787"}],"collection":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/comments?post=787"}],"version-history":[{"count":6,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/787\/revisions"}],"predecessor-version":[{"id":796,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/787\/revisions\/796"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/794"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=787"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=787"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=787"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}Square<\/code>, Triangle<\/code>, or Dodecahedron<\/code> would implement this method in a way that other developers could\u00a0depend<\/em> on it to return the number of sides for that particular object (i.e. Square.getSideCount() == 4; \/\/ true<\/code>).<\/p>\nWhen to Use Abstract Classes<\/h2>\n
Square<\/code>, Rectangle<\/code>, Rhomboid<\/code>, and Dodecahedron<\/code> would be better served through the subclassing of a Shape<\/code> abstract class rather than an interface. Interfaces are better suited for wide implementation by unrelated classes. For example, Serializable<\/code>, Clonable<\/code>, Printable<\/code>, etc.<\/p>\nprivate<\/code>, package-private<\/code>, or protected<\/code>. By contrast, all abstract<\/code>, static<\/code>, and default<\/code> methods in Interfaces implicitly have public access.<\/p>\npublic static final<\/code>\u2014the equivalent of a constant<\/code>.<\/p>\n<\/a>Example Code of Abstract Class<\/h2>\n
package AbstractClasses;\r\n\r\n\/**\r\n * Abstract class implantation that requires certain attributes to be\r\n * present in all subclass objects, specific method implementations, and\r\n * some abstract methods to be implemented specifically by subclassing objects.\r\n *\/\r\npublic abstract class Shape {\r\n\r\n \/\/ Define required fields for all Shape type objects\r\n public int sides;\r\n public int width;\r\n public int length;\r\n\r\n \/**\r\n * Define the constructor class requiring a number of sides to be defined.\r\n * @param sides - int number of sides for a Geometry.\r\n *\/\r\n Shape(int sides, int length, int width){\r\n this.sides = sides;\r\n this.length = length;\r\n this.width = width;\r\n };\r\n\r\n \/**\r\n * Abstract method to return the number of sides an\r\n * object is defined as having.\r\n * @return int - number of sides.\r\n *\/\r\n public int getSides(){\r\n return this.sides;\r\n }\r\n\r\n \/**\r\n * Return the calculated area of a shape.\r\n * @return float - area of the shape.\r\n *\/\r\n public abstract float getArea();\r\n}\r\n\r\n\/**\r\n * Subclass of Shape defining the behavior of a Square geometry.\r\n *\/\r\nclass Square extends Shape{\r\n \r\n \/**\r\n * Define the constructor class requiring a number of sides to be defined.\r\n * @param sides - int number of sides for a Geometry.\r\n * @param width - float value of shape width and length (same for squares)\r\n *\/\r\n Square(int sides, int width) {\r\n super(sides, width, width);\r\n }\r\n\r\n \/**\r\n * Class-specific implementation to calculate the area\r\n * of a square using length x width formula.\r\n * @return - float value of Square area.\r\n *\/\r\n @Override\r\n public float getArea() {\r\n return this.width * this.width;\r\n }\r\n}\r\n<\/pre>\ngetArea()<\/code> method specific to the formula used to calculate the area of a Square (width ^ 2).<\/p>\nSquare<\/code> constructor here as well — while still making use of the signature required by the Shape superclass. This implements a somewhat contrived requirement set forth in the Superclass that all Shape<\/code>-type objects require a length and width measurement.<\/p>\nAbstract Classes vs. Interfaces<\/h2>\n
public static final<\/code> which are required for interfaces. This allows more flexibility at the cost of complexity.<\/p>\nFinal Thoughts<\/h2>\n
References<\/h2>\n
\n