# N-body Simulations- Code Part 1

## Object-oriented programming

In general, programming languages have built in objects, such as integers, float point numbers, booleans, arrays, etc. that can be used very easily by the user. These allow programmers to code virtually whatever they need, but it is often easier to create objects that better suit the application that is being coded. The following examples are written in Java, so a small background would be useful. Even though the syntax may be slightly different, other programming languages such as C++ and Python can accomplish identical tasks.

It would be nice to declare a body, b, with the following parameters:
`Body b = new Body(double rx, double ry, double vx, double vy, double mass, Color color)`
This is accomplished, in Java, using the code below. Comments are prefaced by //.

```import java.awt.Color;

public class Body {
private static final double G = 6.673e-11;   // gravitational constant
private static final double solarmass=1.98892e30;

public double rx, ry;       // holds the cartesian positions
public double vx, vy;       // velocity components
public double fx, fy;       // force components
public double mass;         // mass
public Color color;         // color (for fun)

// create and initialize a new Body
public Body(double rx, double ry, double vx, double vy, double mass, Color color) {
this.rx    = rx;
this.ry    = ry;
this.vx    = vx;
this.vy    = vy;
this.mass  = mass;
this.color = color;
}

// update the velocity and position using a timestep dt
public void update(double dt) {
vx += dt * fx / mass;
vy += dt * fy / mass;
rx += dt * vx;
ry += dt * vy;
}

// returns the distance between two bodies
public double distanceTo(Body b) {
double dx = rx - b.rx;
double dy = ry - b.ry;
return Math.sqrt(dx*dx + dy*dy);
}

// set the force to 0 for the next iteration
public void resetForce() {
fx = 0.0;
fy = 0.0;
}

// compute the net force acting between the body a and b, and
// add to the net force acting on a
Body a = this;
double EPS = 3E4;      // softening parameter (just to avoid infinities)
double dx = b.rx - a.rx;
double dy = b.ry - a.ry;
double dist = Math.sqrt(dx*dx + dy*dy);
double F = (G * a.mass * b.mass) / (dist*dist + EPS*EPS);
a.fx += F * dx / dist;
a.fy += F * dy / dist;
}

// convert to string representation formatted nicely
public String toString() {
return "" + rx + ", "+ ry+ ", "+  vx+ ", "+ vy+ ", "+ mass;
}
}```

This defines the Body object that we will use to store information about bodies in our simulation. This file would be saved in a file Body.java and compiled into a class Body.class. The class file should reside in the same directory as all other class files.

On the next page we will create the main class that uses these methods to run the simulation.

Next