An class merely defines what an object will be if it is created. An object is an actual, created instance of a class. A class is like a blueprint for a house, while the object is the actual house. A single blueprint can be used to make many different houses.
There is no difference. These are two ways of saying the same thing.
A local variable is only accessible within the method where it's declared. A member variable, a.k.a. a field, is accessible in any method in the class.
Complex numbers are one of the features needed
in a programming language for
serious scientific computation.
Unfortunately no popular computer language other than Fortran provides them
as a built-in data type.
public class ComplexNumber extends Object {
public double u;
public double v;
}We also have to write code to explicitly add the numbers, multiply them or do anything else we might need to do with complex numbers. If we need to add complex numbers in more than one place, then we need to write the addition code again, or, at the very least, copy and paste it.
A better implementaion of a complex number class will shield us from the exact storage of the data, i.e. x and y vs. r and theta. It will also provide methods that let us perform any operation we might need to perform on or with a complex number.
Before writing code we need to ask ourselves what we'll do with a complex number. Most objects first require a constructor, a method that is called when you create a new complex number. A more complicated object may also require a destructor method that's called when you get rid of an object; but since this is a fairly simple object, we'll let Java's built-in garbage collection take care of that for us.
Since these are complex numbers it's not unlikely that we'll need to add them, subtract them, multiply them and divide them. We'll also want to be able to access their real and imaginary parts as well as their absolute values and arguments. The following class does all that.
//
public class Complex extends Object {
private double u;
private double v;
Complex (double x, double y) {
u=x;
v=y;
}
public double Real () {
return u;
}
public double Imaginary () {
return v;
}
public double Magnitude () {
return Math.sqrt(u*u + v*v);
}
public double Arg () {
// Need to watch out for zero
return Math.atan(v/u);
}
// Add z to w; i.e. w += z
public Complex Plus (Complex z) {
return new Complex(u + z.u, v + z.v);
}
// Subtract z from w
public Complex Minus (Complex z) {
return new Complex(u - z.u, v - z.v);
}
public Complex Times (Complex z) {
return new Complex(u*z.u - v*z.v, u*z.v + v*z.u);
}
// divide w by z
public Complex DivideBy (Complex z) {
double rz = z.Magnitude();
return new Complex((u * z.u + v * z.v)/(rz*rz),(v * z.u - u * z.v)/(rz*rz));
}
}