Also, what languages partially or fully utalize OOP?

[This message has been edited by Wacko4X (edited February 07, 2005).]

There are generally three characteristics of an object oriented language. These words are big, but their concepts are simple:

- Encapsulation - data and actions are grouped together, rather than having the data and actions separate. You can "encapsulate" (isolate and protect) an object's data and internal algorithms, and only provide an interface (the public member functions) that are the only way to manipulate the object. Like a CD player, the speed of the CD, the position of the laser lense, the layout of the transitors and resistors on the circuit board, etc., are all encapsulated away from the user, and the interface is simply the play/stop/skip buttons and the volume control.

- Inheritance - the definition of one object can be extended, or "inherited", into another. For example, you might have a class called "Creature" which encapsulates "age", "numberoflegs", "weight", etc. You could create another class that "inherits" the Creature class and automatically receives all of a Creature's member data and member functions. E.g. a "Dog" class derived from "Creature" would contain all the above data and any member functions, plus you could add more, like "owner", "breed". You could further derive a class "Poodle" from "Dog", which would inherit all the member data and functions from both Dog and Creature, and you could add more, like "poofiness" and "yappiness".

- PolyMorphism - allows you to treat different kinds of objects as if they were the same. For example, you could have a base class "Shape" with a member function "Draw". Derived from Shape, you could have "Circle", "Square", and "Triangle" classes, each overriding the "Draw" member function. You could create a "Shape" pointer, and point it at a Square object, a Triangle object, or the Circle object:

Circle c;
Triangle t;
Square s;
Shape *pShape;

pShape = &c; // point to the circle
pShape->Draw(); // calls Circle:: Draw
pShape = &t; // point to the triangle
pShape->Draw(); // calls Triangle:: Draw
pShape = &s; // point to the square
pShape->Draw(); // calls Square:: Draw

Note all calls to draw ("pShape->Draw();") are the same. That's polymorphism in action.

------------------
Brian

[This message has been edited by BrianT (edited February 08, 2005).]

------------------
"The very idea of freedom presupposes some objective moral law which overarches rulers and ruled alike." -- C. S. Lewis (1898 - 1963), "The Poison of Subjectivism" (from Christian Reflections; p. 108)

Switch Mayhem now available! Get it here
Codename: Roler - hoping to get more done over the holidays . . .

Any online tutorials or books that you would recommend for really getting into the nitty-gritty of OOP?

Wacko

------------------
Soterion Studios

I'm reluctant to move to Java simply because I don't want to give up pointers! I can't imagine working without them. Pointers are my Secret Power (tm).

------------------
Brian

quote:

---

I'm reluctant to move to Java simply because I don't want to give up pointers!

---

the one thing I don't like about java is that it runs slower and less powerful, having to go through the JVM and all. it is cross-platform, tho...

basically, OOP is a programming style modeled after the real world by use of objects.
like, things happen in the real world by certain objects doing things with other objects,etc. well, OOP takes that concept.
------------------
Soterion Studios

[This message has been edited by ArchAngel (edited February 09, 2005).]

quote:

---

Originally posted by ArchAngel:
are you serious? lol

---

Well, not really, but I do like pointers.

------------------
Brian

quote:

---

I'm reluctant to move to Java simply because I don't want to give up pointers! I can't imagine working without them. Pointers are my Secret Power (tm).

---

I used to think that way also . But you pretty much do the same stuff in Java as you do C++. Whenever you do something like pass an object to a function or whatnot, you're actually passing its reference. All Java objects pretty much act like pointers.

When you say:
Shape A = new Shape();
A is now a reference to a new instance of Shape

When you say:

Shape B;
B = A;

Now B is also a reference to the same shape. If you change Shape B, you also change shape A, because they are both "pointers" to the same shape.

quote:

---

the one thing I don't like about java is that it runs slower and less powerful, having to go through the JVM and all.

---

Sun's latest JVMs' are very fast, and ever since JIT came out, they actually do compile your code to native code. The HotSpot compiler also further optimizes often-used sections of code while the code is running - often used loops will become as fast as (some even claim faster than) C++.

------------------
"The very idea of freedom presupposes some objective moral law which overarches rulers and ruled alike." -- C. S. Lewis (1898 - 1963), "The Poison of Subjectivism" (from Christian Reflections; p. 108)

Switch Mayhem now available! Get it here
Codename: Roler - hoping to get more done over the holidays . . .

10 Print "i was a dummy"
20 goto 10

------------------
Karl /GODCENTRIC
Visionary Media
the creative submitted to the divine.
Husband of my amazing wife Aleshia
Klumsy@xtra.co.nz

quote:

---

Whenever you do something like pass an object to a function or whatnot, you're actually passing its reference. All Java objects pretty much act like pointers.

When you say:
Shape A = new Shape();
A is now a reference to a new instance of Shape

When you say:

Shape B;
B = A;

Now B is also a reference to the same shape. If you change Shape B, you also change shape A, because they are both "pointers" to the same shape.

---

That is very bizarre.

So how do you know you have a single object with two names, verses two objects?

Also, in the following code:

Shape B;
B = A;

I'm assuming there is a Shape object (and not just a pointer) created after the first line. If the second line makes B point to the same object as A is pointing to, what happens to the object created in the first line??? In C++, the second line would call B's operator=, so that the two objects are identical, but still to separate objects that can still change totally independent of each other. How would you do that in Java?

------------------
Brian

if you specify an object, it can hold a NULL,nothing value, which means there isn't an object in memory alocated to it (think of pointer to class)

so B at first points to nothing
then when you do
B = A
bother a and b point to the same physical object. so really such a thing is a pointer to an object, or a reference to an object..

when you do
B = A you are Not cloning the object.. unless you do something like
B = A.clone();

------------------
Karl /GODCENTRIC
Visionary Media
the creative submitted to the divine.
Husband of my amazing wife Aleshia
Klumsy@xtra.co.nz

quote:

---

So how do you know you have a single object with two names, verses two objects?

---

Compare them, just like comparing pointers.

if(A==B)
{ System.out.println("A and B are the same object");
} else
{ System.out.println("A and B are two different objects");
}

quote:

---

Shape B;
B = A;

I'm assuming there is a Shape object (and not just a pointer) created after the first line.

---

You assume wrong. An object must specifically be created with the "new" statement. B contains null after the first line, and contains A (whatever that is) after the second line.

quote:

---

If the second line makes B point to the same object as A is pointing to, what happens to the object created in the first line???

---

I'm assuming you're thinking of a more complete example:

Shape A = new Shape();
Shape B = new Shape();
B=A;

And wondering what happens to the object that used to be in B created in the second line?

That depends on whether there are any more references to it. If there's a C pointing to it somewhere, nothing happens. But if it loses all references pointing to it, it then gets put into Java's garbage collector.

quote:

---

In C++, the second line would call B's operator=, so that the two objects are identical, but still to separate objects that can still change totally independent of each other. How would you do that in Java?

---

Good question - how does one make a copy of a class?

Well, the makers of Java were intelligent to take care of that. You see, the class Object is implicitly inherited by all objects. There are two finctions (called "methods" in Java) that Object has, that all objects inherit - clone() and equals().

clone() creates a seperate object, but with the same data.

B = A.clone(); // is what you are looking for

equals() compares the data inside the objects (remember that a direct comprison just tels whether the pointers point to the same object)

if(A==B) { System.out.println("A and B are the same object"); } else if(A.equals(B)) { System.out.println("A and B are two different objects with the same data"); } else { System.out.println("A and B are two different objects with the different data"); }

------------------
"The very idea of freedom presupposes some objective moral law which overarches rulers and ruled alike." -- C. S. Lewis (1898 - 1963), "The Poison of Subjectivism" (from Christian Reflections; p. 108)

Switch Mayhem now available! Get it here
Codename: Roler - hoping to get more done over the holidays . . .

say, you make an object out of the class Person:

Person fool = new Person();

fool is a reference variable, pointing to an object you made, which exists somewhere in your memory. you access that object through the reference variable. it's kinda a gateway.
if you go.

Person idiot = fool; your not making a new object equal to fool. you do that by:
Person idiot = fool.clone(); (but that's a different story. and you need to define the clone method.)

the statement " Person idiot = fool" is pretty just making a new gateway to the object which fool is pointing too.

I'm finished repeating what Cobra and Klumsy already said.

------------------
Soterion Studios

------------------
Brian

------------------
Karl /GODCENTRIC
Visionary Media
the creative submitted to the divine.
Husband of my amazing wife Aleshia
Klumsy@xtra.co.nz

// ( name, age, IQ)
Person JimBob = new fool("JimBob," 23, 45 );

------------------
Soterion Studios

------------------
Keep the holy day sacred.......halllllllukan

------------------
Soterion Studios

------------------
Keep the holy day sacred.......halllllllukan

------------------
Brian

------------------
Soterion Studios

------------------
Keep the holy day sacred.......halllllllukan

archangel, - though jimbob may sue for defamation.

------------------
Karl /GODCENTRIC
Visionary Media
the creative submitted to the divine.
Husband of my amazing wife Aleshia
Klumsy@xtra.co.nz

I never defined him with any phone-using method.
------------------
Soterion Studios

[This message has been edited by ArchAngel (edited February 13, 2005).]

[vb]
if confused = true then
msgbox("Confused = very yes!")
end if
[/vb]

------------------
~~~boogie woogie woogie~~~

quote:

---

Originally posted by bwoogie:
i don't know c++ or java... what's a pointer exactly? i'm guessing its creating a new variable and setting a value to it? but if so, how can you not have them? i mean, every program has variables. uhg.. im confused...

---

Simply, a pointer is a type of variable whose value is a memory address. The address can be anywhere in memory, but normally you want to set it to something useful, such as another variable, allocated memory, or even a function.

For example:

int fred; // an integer variable
int wilma; // an integer variable
int *mypointer; // a pointer (to an int) variable

mypointer = &fred; // set mypointer to the address of fred ("&fred")
fred = 10; // *mypointer ("the value contained at where mypointer points to") is 10
wilma = 20;
mypointer = &wilma; // set mypointer to the address of wilma, *mypointer is now 20.

I can provide more complex examples if you want more info.

Brian

------------------
Brian

------------------
~~~boogie woogie woogie~~~

well a pointer is like a link, to the real box.. if you act this out in real life it should be easy.. grab a pen to use as a pointer and some cd cases, and throw a peice of paper in each. where you can write something on..

so lets start

int var1 ; //this is your first CD case
int var2 ; //this is your second CD case
int var3 ;//this is the third cd case
int *pointer1 ; // this is a pen used as a pointer.
int *pointer2 ; // this is a pen used as a pointer.

//pointer one is not pointing at anything in particular now.. lets start

var1 = 10 ; //now you are being the computer, go write 10 on the peice of paper in the first cd case
var2 = 20 ; //as above

pointer1 = &var1 ; //now POINT the pen towards the first CD case

//so now the pointer is pointing to the first CD case.. if we try to find out the value of pointer, we will just get its direction, (or computer address) where it is pointing at.. so if we want to get the value of WHAT IT IS POINTING at we use *

var3 = *pointer1 ; //so here we see what pointer1 (the pen) is pointing at.. its pointing at the first CD case, so we open it up.. look and see that it has 10 on it.. then we write that in var3, the third cd case..

pointer1 = &var2 ; //now we changing the direction of where the pointer (PEN ) is pointing. so now it is pointing at the second Cd case.. so now if we do the same line of code as above.

var3 = *pointer1 ; //now the pen is pointing at the 2nd cd case, so we look inside and it has 20 in then, so we go write that in var3 (actually var3 already got 10, so we OVERWRITE that value.. so now var3 has 20 written

var2 = var2 + 20; //now we go to the 2nd cd case.. see that it already has 20 on it, we add 20... which equals 40 and write that..

var3 = *pointer1 ; //now we do this again.. the pointer is still pointing at the 2nd cd case, but when we look inside, the value has changed.. now it is 40, so we get that number and write it in the third cd case..

if you don't get this by reading it, then act it out..

you can see that pointers can change where they are pointing, and also you can have more than one pointer pointing at the same thing (i.e 2 or 3 pens pointing at hte same cd case.. so when you change what is in the CD case, it seems that all these pointers values have changed, but really they are just pointers.. to see what value something is.. you follow the pointer and look inside the variable/ CD case to see what is there)

Karl

int fred; // an integer variable
int wilma; // an integer variable
int *mypointer; // a pointer (to an int) variable

mypointer = &fred; // set mypointer to the address of fred ("&fred")
fred = 10; // *mypointer ("the value contained at where mypointer points to") is 10
wilma = 20;
mypointer = &wilma; // set mypointer to the address of wilma, *mypointer is now 20.

grab 3 cd

------------------
Karl /GODCENTRIC
Visionary Media
the creative submitted to the divine.
Husband of my amazing wife Aleshia
Klumsy@xtra.co.nz

quote:

---

Originally posted by bwoogie:
so, even though you didnt change the value of mypointer, by setting fred to 10, mypointer automatically changes to 10 also?

---

Sort of. mypointer is "pointing to" fred: i.e. the value of mypointer is the address in memory of where fred lives. So by setting fred to a value, the value of mypointer does not change (it still contains the memory address of where fred lives), but the value it "points to" (i.e. fred's value) does (i.e. fred changes). E.g.

mypointer = &fred; // mypointer is set to the "address of" ("&") fred fred = 10; // fred, and thus the value that mypointer points to, = 10 *mypointer = 20; // what mypointer points to ("*"), and thus fred, = 20

Here's another example;

char color[] = "purple"; char *cp = NULL; // a pointer to a character, currently pointing to NULL (memory addess 0) cp = color; // these two lines are essentially the same. cp is set to cp = &(color[0]); // the address of the first character in the char array // i.e. cp == the memory address of the first character // and *cp == the first character itself ('p') cp++; // increment cp, i.e. add one to its value (which is an // address). cp now equals the memory address of the // second character, and *cp equals the second // character itself ('u') *cp = toupper(*cp); // pass what cp points to ('u') to the toupper // function, and store the result ('U') in what cp // points to. After this call, the color string will // be "pUrple". cp += 2; // add 2 to cp's value (i.e. add 2 to the address), // cp now points to the fourth character, *cp equals 'p' *cp = 'g'; // the color string is now "pUrgle"

quote:

---

so instead of setting fred and fredjr to 10, just use a pointer to use less code or something?

---

Not necessarily less code (although sometimes), but a more efficient way of dealing with memory. One area this happens is when passing data to/from functions. With small variables like ints, you usually don't gain much, but with larger variables the efficiency really adds up. For example, in C/C++, you can pass variables to functions "by value" or "by reference". "By value" means you pass the entire value of the variable (not the variable itself, but a COPY of its value), "by reference" means you pass the address of the variable itself. Let's say you had a large structure like this:

struct MyStruct { int val; float x, y, z; char name[100]; };

To pass it "by value", you would do this:

MyStruct myStruct; myStruct.val = 100; VerifyVal(myStruct); // passing by value

That would create a copy of the entire large myStruct variable on the stack (and calls constructors, etc., if compiling in C++) accessible by the VerifyVal function. VerifyVal could modify it's copy all it wants, and when it returns, myStruct.val would still = 100, untouched. However, if we passed it by reference:

MyStruct myStruct; myStruct.val = 100; VerifyVal(&myStruct); // passing by reference

We're not really passing "myStruct" to VerifyVal, but instead we're passing the "address of" ("&") myStruct. I.e. we're passing a pointer to myStruct. 4 bytes are created on the stack (instead of sizeof(MyStruct)) to hold the pointer (and thus already more efficient), but also no constructors or anything are called if compiled in C++ (because a new object is not being created, we're just referring to an existing object). Also, VerifyVal now operates on the original variable, NOT a copy, so when it returns, myStruct.val will be equal to whatever VerifyVal set it to. This behavior of allowing functions to modify variables is not possible without pointers. In other languages (like Java, I think) passing "by value" (passing a copy of the value) is not possible and passing "by reference" happens automatically behind the scenes. In C/C++ you have to be explicit about which you desire.

Here is a pretty good explanation and short tutorial on pointers:
http://www.cplusplus.com/doc/tutorial/tut3-3.html

There's tons more if you google.

------------------
Brian

[This message has been edited by BrianT (edited March 13, 2005).]

------------------
~~~boogie woogie woogie~~~

------------------
Brian

[This message has been edited by BrianT (edited March 14, 2005).]

------------------
~~~boogie woogie woogie~~~