companion object as factory in scala - scala

Question

I am just starting out with Scala, and working on some tutorials. I came across companion object, and using them as factory. I tried several things out. However I am not getting the following to work properly. Cant get my head around it..
import math._
abstract class Point{
// ...
}
object Point{
private class PointInt(val x:Int,val y:Int) extends Point{
def +(that:PointInt) = new PointInt(this.x + that.x, this.y + that.y)
def distance(that:PointInt) =
sqrt(pow((this.x - that.x), 2) + pow((this.y - that.y), 2))
}
private class PointDouble(val x:Double,val y:Double) extends Point{
def +(that:PointDouble) = new PointDouble(this.x + that.x, this.y + that.y)
def distance(that:PointDouble) =
sqrt(pow((this.x - that.x), 2) + pow((this.y - that.y), 2))
}
def apply(x:Int,y:Int):Point = new PointInt(x,y)
def apply(x:Double,y:Double):Point = new PointDouble(x,y)
}
val a = Point(1,2)
val b = Point(3,4)
val c = a+b // does not work...
Just trying to add up two integer Points, like I defined it in the methods... Does anyone know what I am doing wrong??
EDIT: I was was trying to wrap the following (working) class in an Factory.
class Point(val x:Int,val y:Int){
def +(that:Point) = new Point(this.x + that.x, this.y + that.y)
def distance(that:Point) = sqrt(pow((this.x - that.x),2) + pow((this.y - that.y),2))
}
val a = new Point(1,2) //> a : week1.OU2.Point = week1.OU2$Point#73e48fa7
val b = new Point(3,4) //> b : week1.OU2.Point = week1.OU2$Point#677bb8fe
val c = a+b //> c : week1.OU2.Point = week1.OU2$Point#6bae60c5
c.x //> res0: Int = 4
c.y //> res1: Int = 6

Answer 1

I am not quite sure which constraints are actually imposed on you, for example, which classes should/must be private, but using F-bounded polymorphism might be a stepping stone to your desired solution.
/* Simplified interface (adding sqrt is straight-forward) */
abstract class Point[P <: Point[P]] {
def +(that: P): P
}
/* Two implementations */
class PointInt(val x:Int,val y:Int) extends Point[PointInt] {
def +(that:PointInt) = new PointInt(this.x + that.x, this.y + that.y)
}
class PointDouble(val x:Double,val y:Double) extends Point[PointDouble] {
def +(that:PointDouble) = new PointDouble(this.x + that.x, this.y + that.y)
}
/* Companion object */
object Point {
def apply(x:Int,y:Int) = new PointInt(x,y)
def apply(x:Double,y:Double) = new PointDouble(x,y)
}
/* Use cases */
val a = Point(1,2)
val b = Point(3,4)
val c = a+b // ok
val d = Point(1.0, 2.5)
val e = c+d // error: type mismatch
Notice, however, that this won't help you in case you want to hide your implementations, i.e., make them private and declare public interfaces using the generic Point only - as others pointed out already.