Polynomials/Inheritance

Inheritance

First, let's talk about what inheritance is.

In Java, all code is contained in a class or multiple classes. These classes are essentially collections of related data (fields), and behaviors that utilize that data (methods). Classes can encapsulate and abstract away complexity, so they're very useful. But managing complexity and eliminating redundancy also requires the ability to share code between classes. This is the idea behind inheritance - defining an object that implements the same fields and the same methods as another class, but with a few modifications.

The inheritance relationship is an "is-a" relationship. To ask if B should inherit from A, ask if B is-an A. For example, suppose we have implemented a class representing Polynomials, and we want to implement a new class that represents quadratics. In deciding whether the Quadratic class should inherit from the Polynomial class, we ask if a Quadratic is a Polynomial, and the answer is yes. So the Quadratic class should inherit from the Polynomial class.

This allows us to utilize behaviors already defined by the polynomial (for example, getting the degree, or evaluating the polynomial at a particular value of x), but also define new behaviors (such as solving the quadratic equation to find roots).

The Java Classes

We can define a simple polynomial class that implements

Superclass: Polynomial Class

To begin, we can define a Polynomial class that implements a few behaviors that we want all polynomials to have: the ability to evaluate the polynomial at a particular value of x, and the ability to get the degree of the polynomial.

import java.util.Arrays;

public class SimplePolynomial {
	private double[] coeffs;

	public SimplePolynomial(double[] coeffs) {
		this.coeffs = Arrays.copyOf(coeffs,coeffs.length);
	}

	public SimplePolynomial(SimplePolynomial p) {
		this(p.coeffs);
	}

	public double eval(double x) { 
		int n = coeffs.length-1;
		double result = coeffs[n];
		for(int j=n-1; j>=0; j--) { 
			result = result*x + coeffs[j];
		}
		return result;
	}

	public double degree() { 
		return this.coeffs.length;
	}
}

Subclass: Quadratic Class

To create a quadratic class that implements the same methods (degree and evaluate) and constructors, we first specify that the SimpleQuadratic class extends the SimplePolynomial class:

public class SimpleQuadratic extends SimplePolynomial {

There are a few other things that the Quadratic class needs to do that the Polynomial class does not:

• Modify the constructor to check to make sure there are 3 coefficients, and that the leading coefficient is nonzero
• Implement a method to compute the roots of the quadratic using the quadratic formula

Here is a class that will do that:

import java.util.Arrays;

public class SimpleQuadratic extends SimplePolynomial {

	public SimpleQuadratic(double a, double b, double c) {
		super(new double[] {a,b,c});
	}

	public double[] getRoots() {
		// Use the quadratic formula
		double x1, x2;

		double a = this.coeffs[2];
		double b = this.coeffs[1];
		double c = this.coeffs[0];

		x1 = (-b + Math.sqrt(b*b-4*a*c))/(2*a);
		x2 = (-b - Math.sqrt(b*b-4*a*c))/(2*a);

		return new double[] {x1,x2};
	}
}