Cheatsheets / Learn Java
Inheritance and Polymorphism
Inheritance in Java
Inheritance is an important feature of object-oriented
programming in Java. It allows for one class (child class) to // Parent Class
inherit the fields and methods of another class (parent class Animal {
class). For instance, we might want a child class Dog to // Animal class members
inherent traits from a more general parent class Animal . }
When defining a child class in Java, we use the keyword
extends to inherit from a parent class.
// Child Class
class Dog extends Animal {
// Dog inherits traits from Animal
// additional Dog class members
}
Main() method in Java
In simple Java programs, you may work with just one class
and one file. However, as your programs become more // Shape.java file
complex you will work with multiple classes, each of class Shape {
which requires its own file. Only one of these files in the public static void main(String[] args) {
Java package requires a main() method, and this is the Square sq = new Square();
file that will be run in the package.
}
For example, say we have two files in our Java package for
}
two different classes:
● Shape , the parent class. // Square.java file
class Square extends Shape {
● Square , the child class.
If the Java file containing our Shape class is the only one }
with a main() method, this is the file that will be run for
our Java package.
super() in Java
In Java, a child class inherits its parent’s fields and
methods, meaning it also inherits the parent’s // Parent class
constructor. Sometimes we may want to modify the class Animal {
constructor, in which case we can use the super() String sound;
method, which acts like the parent constructor inside the
Animal(String snd) {
child class constructor.
this.sound = snd;
Alternatively, we can also completely override a parent
}
class constructor by writing a new constructor for the
}
child class.
// Child class
class Dog extends Animal {
// super() method can act like the
parent constructor inside the child class
constructor.
Dog() {
super("woof");
}
// alternatively, we can override the
constructor completely by defining a new
constructor.
Dog() {
this.sound = "woof";
}
}
Protected and Final keywords in Java
When creating classes in Java, sometimes we may want to
control child class access to parent class members. We class Student {
can use the protected and final keywords to do just protected double gpa;
that. // any child class of Student can access
protected keeps a parent class member accessible to its
gpa
child classes, to files within its own package, and by
subclasses of this class in another package.
final protected boolean isStudent() {
Adding final before a parent class method’s access
modifier makes it so that any child classes cannot modify
return true;
that method - it is immutable. }
// any child class of Student cannot
modify isStudent()
}
Polymorphism in Java
Java incorporates the object-oriented programming
principle of polymorphism. // Parent class
Polymorphism allows a child class to share the class Animal {
information and behavior of its parent class while also public void greeting() {
incorporating its own functionality. This allows for the System.out.println("The animal greets
benefits of simplified syntax and reduced cognitive
you.");
overload for developers.
}
}
// Child class
class Cat extends Animal {
public void greeting() {
System.out.println("The cat meows.");
}
}
class MainClass {
public static void main(String[] args) {
Animal animal1 = new Animal(); //
Animal object
Animal cat1 = new Cat(); // Cat
object
animal1.greeting(); // prints "The
animal greets you."
cat1.greeting(); // prints "The cat
meows."
}
}
Method Overriding in Java
In Java, we can easily override parent class methods in a
child class. Overriding a method is useful when we want // Parent class
our child class method to have the same name as a class Animal {
parent class method but behave a bit differently. public void eating() {
In order to override a parent class method in a child class, System.out.println("The animal is
we need to make sure that the child class method has the
eating.");
following in common with its parent class method:
}
● Method name }
● Return type
// Child class
● Number and type of parameters class Dog extends Animal {
// Dog's eating method overrides
Additionally, we should include the @Override keyword
Animal's eating method
above our child class method to indicate to the compiler
that we want to override a method in the parent class. @Override
public void eating() {
System.out.println("The dog is
eating.");
}
}
Child Classes in Arrays and ArrayLists
In Java, polymorphism allows us to put instances of
different classes that share a parent class together in an // Animal parent class with child classes
array or ArrayList . Cat, Dog, and Pig.
For example, if we have an Animal parent class with child Animal cat1, dog1, pig1;
classes Cat , Dog , and Pig we can set up an array with
instances of each animal and then iterate through the list
cat1 = new Cat();
of animals to perform the same action on each.
dog1 = new Dog();
pig1 = new Pig();
// Set up an array with instances of each
animal
Animal[] animals = {cat1, dog1, pig1};
// Iterate through the list of animals and
perform the same action with each
for (Animal animal : animals) {
animal.sound();
}
