**1. Overview**

In this quick tutorial, we'll show **how to find the point of intersection of two lines defined by the linear functions** in the slope-intercept form.

Any straight line (except vertical) on a plane can be defined by the linear function:

`y = mx + b`

where *m* is the slope and *b* is the y-intercept.

For a vertical line, *m* would be equal to infinity, that's why we're excluding it. If two lines are parallel, they have the same slope, that is the same value of *m*.

Let's say we have two lines. The first function defines the first line:

`y = m1x + b1`

And the second function defines the second line:

`y = m2x + b2`

We want to find the point of intersection of these lines. Obviously, the equation is true for the point of intersection:

`y1 = y2`

Let's substitute *y-*variables:

`m1x + b1 = m2x + b2`

**From the above equation we can find the ***x-*coordinate:

```
x(m1 - m2) = b2 - b1
x = (b2 - b1) / (m1 - m2)
```

**Finally, we can find y-coordinate of the point of intersection:**

`y = m1x + b1`

Let's now move on to the implementation part.

**3. Java Implementation**

Firstly, we have four input variables – *m1, b1* for the first line, and *m2, b2* for the second line.

Secondly, we'll convert the calculated point of intersection into the object of *java.awt.Point* type.

Finally, lines may be parallel, hence let's make the returned value *Optional<Point>*:

```
public Optional<Point> calculateIntersectionPoint(
double m1,
double b1,
double m2,
double b2) {
if (m1 == m2) {
return Optional.empty();
}
double x = (b2 - b1) / (m1 - m2);
double y = m1 * x + b1;
Point point = new Point();
point.setLocation(x, y);
return Optional.of(point);
}
```

Now let's choose some values and test the method for parallel and non-parallel lines.

For example, let's take the *x*-axis (*y = 0*) as the first line, and the line defined by *y = x – 1 *as the second line.

For the second line, the slope *m* is equal to *1* which means *45* degrees, and the* y*-intercept is equal to *-1 *which means that the line intercepts the *y*-axis in the point (0, -1).

It's intuitively clear that the point of intersection of the second line with the *x*-axis must be *(1,0*):

Let's check it.

Firstly, let's make sure that a *Point* is present, as the lines aren't parallel, and then check the values of *x* and *y*:

```
@Test
public void givenNotParallelLines_whenCalculatePoint_thenPresent() {
double m1 = 0;
double b1 = 0;
double m2 = 1;
double b2 = -1;
Optional<Point> point = service.calculateIntersectionPoint(m1, b1, m2, b2);
assertTrue(point.isPresent());
assertEquals(point.get().getX(), 1, 0.001);
assertEquals(point.get().getY(), 0, 0.001);
}
```

Lastly, let's take two parallel lines and make sure that the returned value is empty:

```
@Test
public void givenParallelLines_whenCalculatePoint_thenEmpty() {
double m1 = 1;
double b1 = 0;
double m2 = 1;
double b2 = -1;
Optional<Point> point = service.calculateIntersectionPoint(m1, b1, m2, b2);
assertFalse(point.isPresent());
}
```

**4. Conclusion**

In this tutorial, we've shown how to calculate the point of intersection of two lines.

As usual, the complete source code is available over on GitHub.

res – REST with Spring (eBook) (everywhere)