### 2.5 Complex Numbers

Example 2-5 shows the definition of a class that represents complex numbers. You may recall from algebra class that a complex number is the sum of a real number and an imaginary number. The imaginary number i is the square root of -1. This ComplexNumber class defines two double fields, which represent the real and imaginary parts of the number. These fields are declared private, which means they can be used only within the body of the class; they are inaccessible outside the class. Because the fields are inaccessible, the class defines two accessor methods, real( ) and imaginary( ), that simply return their values. This technique of making fields private and defining accessor methods is called encapsulation. Encapsulation hides the implementation of a class from its users, which means that you can change the implementation without it affecting the users.

Notice that the ComplexNumber class doesn't define any methods, other than the constructor, that set the values of its fields. Once a ComplexNumber object is created, the number it represents can never be changed. This property is known as immutability; it is often useful to design objects that are immutable like this.

ComplexNumber defines two add( ) methods and two multiply( ) methods that perform addition and multiplication of complex numbers. The difference between the two versions of each method is that one is an instance method and one is a class, or static, method. Consider the add( ) methods, for example. The instance method adds the value of the current instance of ComplexNumber to another specified ComplexNumber object. The class method doesn't have a current instance; it simply adds the values of two specified ComplexNumber objects. The instance method is invoked through an instance of the class, like this:

`ComplexNumber sum = a.add(b);`

The class method, however, is invoked through the class itself, rather than through an instance:

`ComplexNumber sum = ComplexNumber.add(a, b);`
##### Example 2-5. ComplexNumber.java
```package je3.classes;

/**
* This class represents complex numbers, and defines methods for performing
* arithmetic on complex numbers.
**/
public class ComplexNumber {
// These are the instance variables.  Each ComplexNumber object holds
// two double values, known as x and y.  They are private, so they are
// not accessible from outside this class.  Instead, they are available
// through the real( ) and imaginary( ) methods below.
private double x, y;

/** This is the constructor.  It initializes the x and y variables */
public ComplexNumber(double real, double imaginary) {
this.x = real;
this.y = imaginary;
}

/**
* An accessor method.  Returns the real part of the complex number.
* Note that there is no setReal( ) method to set the real part.  This means
* that the ComplexNumber class is "immutable".
**/
public double real( ) { return x; }

/** An accessor method. Returns the imaginary part of the complex number */
public double imaginary( ) { return y; }

/** Compute the magnitude of a complex number */
public double magnitude( ) { return Math.sqrt(x*x + y*y); }

/**
* This method converts a ComplexNumber to a string.  This is a method of
* Object that we override so that complex numbers can be meaningfully
* converted to strings, and so they can conveniently be printed out with
* System.out.println( ) and related methods
**/
public String toString( ) { return "{" + x + "," + y + "}"; }

/**
* This is a static class method.  It takes two complex numbers, adds
* them, and returns the result as a third number.  Because it is static,
* there is no "current instance" or "this" object.  Use it like this:
* ComplexNumber c = ComplexNumber.add(a, b);
**/
public static ComplexNumber add(ComplexNumber a, ComplexNumber b) {
return new ComplexNumber(a.x + b.x, a.y + b.y);
}

/**
* This is a non-static instance method by the same name.  It adds the
* specified complex number to the current complex number.  Use it like
* this:
**/