R help - Feb 2008 - help with oop in R - class structure and syntex

Hi,

I read section 5, oop, of the R lang doc, and I am still not sure I
understand how to build a class in R for oop. I thought that since I
understand the oop syntex of Java and VB, I am wondering if the R programmig
experts could help me out by comparing and contrasting the oop syntex in R
with that of Java. For example, the basic class structure in Java is like
this:

public class Bicycle {

    // *the Bicycle class has three fields*
    public int cadence;
    public int gear;
    public int speed;

    // *the Bicycle class has one constructor*
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }

    // *the Bicycle class has four methods*
    public void setCadence(int newValue) {
        cadence = newValue;
    }

    public void setGear(int newValue) {
        gear = newValue;
    }

    public void applyBrake(int decrement) {
        speed -= decrement;
    }

    public void speedUp(int increment) {
        speed += increment;
    }

}

Could one of the R experts please illustrate the R class syntex for writing
the R equivalent of the Java Bicycle class above?

Also, in Java, inheritance is done like this:

public class MountainBike extends Bicycle {

    // *the MountainBike subclass has one field*
    public int seatHeight;

    // *the MountainBike subclass has one constructor*
    public MountainBike(int startHeight, int startCadence, int startSpeed,
int startGear) {
        super(startCadence, startSpeed, startGear);
        seatHeight = startHeight;
    }

    // *the MountainBike subclass has one method*
    public void setHeight(int newValue) {
        seatHeight = newValue;
    }

}

What would be the R oop syntex for inheritance in the case of the
MontainBike class?

Thanks!

-- 
Tom

	[[alternative HTML version deleted]]

On 2/5/2008 8:21 AM, tom soyer wrote:
> Hi,
> 
> I read section 5, oop, of the R lang doc, and I am still not sure I
> understand how to build a class in R for oop. I thought that since I
> understand the oop syntex of Java and VB, I am wondering if the R
programmig
> experts could help me out by comparing and contrasting the oop syntex in R
> with that of Java. For example, the basic class structure in Java is like
> this:
> 
> public class Bicycle {
> 
>     // *the Bicycle class has three fields*
>     public int cadence;
>     public int gear;
>     public int speed;
> 
>     // *the Bicycle class has one constructor*
>     public Bicycle(int startCadence, int startSpeed, int startGear) {
>         gear = startGear;
>         cadence = startCadence;
>         speed = startSpeed;
>     }
> 
>     // *the Bicycle class has four methods*
>     public void setCadence(int newValue) {
>         cadence = newValue;
>     }
> 
>     public void setGear(int newValue) {
>         gear = newValue;
>     }
> 
>     public void applyBrake(int decrement) {
>         speed -= decrement;
>     }
> 
>     public void speedUp(int increment) {
>         speed += increment;
>     }
> 
> }
> 
> Could one of the R experts please illustrate the R class syntex for writing
> the R equivalent of the Java Bicycle class above?
The class system in standard R has no equivalent of that.  It's based on 
a different idea:  the generic function owns methods, classes don't.

Another problem is that there are two different class systems in R: 
sometimes calls S3 and S4 (because of the versions of S where they were 
introduced).  You were reading about S3.

Duncan Murdoch

> 
> Also, in Java, inheritance is done like this:
> 
> public class MountainBike extends Bicycle {
> 
>     // *the MountainBike subclass has one field*
>     public int seatHeight;
> 
>     // *the MountainBike subclass has one constructor*
>     public MountainBike(int startHeight, int startCadence, int startSpeed,
> int startGear) {
>         super(startCadence, startSpeed, startGear);
>         seatHeight = startHeight;
>     }
> 
>     // *the MountainBike subclass has one method*
>     public void setHeight(int newValue) {
>         seatHeight = newValue;
>     }
> 
> }
> 
> What would be the R oop syntex for inheritance in the case of the
> MontainBike class?
> 
> Thanks!
>

This illustration uses S3.  Note that functions do not modify their arguments
so to modify an object we have to pass it to the method and then pass the
object back.  There is also another system called S4 which involves typing
of arguments and there are packages proto and R.oo which provide different
OO models.


# define constructors for bicycle and mountainBike classes
Bicycle <- function(cadence, gear, speed) structure(list(cadence cadence,
gear = gear, speed = speed), class = "bicycle")
MountainBike <- function(cadence, gear, speed, seatHeight) {
   x <- Bicycle(cadence, gear, speed)
   x$seatHeight <- seatHeight
   class(x) <- c(class(x), "mountainBike")
   x
}

# define generic setCadence and then methods for each class

setCadence <- function(x, cadence) UseMethod("setCadence")
setCadence.bicycle <- function(x, cadence) { x$cadence <- cadence; x }

# mountBike's setCadence method overrides bicycle's setCadence method
setCadence.mountBike <- function(x, cadence) { x$cadence <- cadence + 1; x
}

# list the setCadence methods avialable
methods(setCadence)

# define a generic applyBrake and a "bicycle" method
# mountainBike will inherit the bicycle method by default
applyBrake <- function(x, decrement) UseMethod("applyBrake")
applyBrake.bicycle <- function(x, decrement) { x$speed <- x$speed -
decrement }

# list the applyBrake methods available
methods(applyBrake)

b <- Bicycle(1, 2, 3)
m <- MountainBike(4, 5, 6, 7)
m <- applyBrake(m, 1)


On Feb 5, 2008 8:21 AM, tom soyer <tom.soyer at gmail.com>
wrote:
> Hi,
>
> I read section 5, oop, of the R lang doc, and I am still not sure I
> understand how to build a class in R for oop. I thought that since I
> understand the oop syntex of Java and VB, I am wondering if the R
programmig
> experts could help me out by comparing and contrasting the oop syntex in R
> with that of Java. For example, the basic class structure in Java is like
> this:
>
> public class Bicycle {
>
>    // *the Bicycle class has three fields*
>    public int cadence;
>    public int gear;
>    public int speed;
>
>    // *the Bicycle class has one constructor*
>    public Bicycle(int startCadence, int startSpeed, int startGear) {
>        gear = startGear;
>        cadence = startCadence;
>        speed = startSpeed;
>    }
>
>    // *the Bicycle class has four methods*
>    public void setCadence(int newValue) {
>        cadence = newValue;
>    }
>
>    public void setGear(int newValue) {
>        gear = newValue;
>    }
>
>    public void applyBrake(int decrement) {
>        speed -= decrement;
>    }
>
>    public void speedUp(int increment) {
>        speed += increment;
>    }
>
> }
>
> Could one of the R experts please illustrate the R class syntex for writing
> the R equivalent of the Java Bicycle class above?
>
> Also, in Java, inheritance is done like this:
>
> public class MountainBike extends Bicycle {
>
>    // *the MountainBike subclass has one field*
>    public int seatHeight;
>
>    // *the MountainBike subclass has one constructor*
>    public MountainBike(int startHeight, int startCadence, int startSpeed,
> int startGear) {
>        super(startCadence, startSpeed, startGear);
>        seatHeight = startHeight;
>    }
>
>    // *the MountainBike subclass has one method*
>    public void setHeight(int newValue) {
>        seatHeight = newValue;
>    }
>
> }
>
> What would be the R oop syntex for inheritance in the case of the
> MontainBike class?
>
> Thanks!
>
> --
> Tom
>
>        [[alternative HTML version deleted]]
>
> ______________________________________________
> R-help at r-project.org mailing list
> https://stat.ethz.ch/mailman/listinfo/r-help
> PLEASE do read the posting guide
http://www.R-project.org/posting-guide.html
> and provide commented, minimal, self-contained, reproducible code.
>