More specifically, I need to be able to differentiate between C programming language and the Java programming languageHey, what's the difference between object oriented programming language and function(al) programming? thanks!!?
Reusability of code
Polymorphism
Inheritance
encapsulation
also: java doesnt allow you to mess with memory adresses directly. (thank god)Hey, what's the difference between object oriented programming language and function(al) programming? thanks!!?
An object oriented language is a language that expresses things as ';objects'; which contain data and the code that acts on that data. OO languages support concepts like encapsulation, polymorphism, and inheritance.
In functional languages each function is completely self contained. You pass data in and the function passes results out with not side effects outside the function.
Neither C (or c++) nor Java are functional languages. Plain C (not C++) is not object oriented, but Java is object oriented.
Ok here we go:
Differences between functional and objected oriented programming can
be summed up as follows:
In object oriented programming everything (or almost everything) is
treated as an object that can be modified and that can perform tasks,
or in OOP speak one might say objects have state and behavior. What it
buys you (among other more advanced things) is: modularity,and data
hiding.
Here is an example: You might have an object that models a ball, from
above the ball can be modified (i.e. you can change its state) for
example you may be able to change the color of the ball. It can also
perform tasks (i.e. it also has behavior) for example the ball can
roll, or be thrown. As an object it is bundled neatly in a package
that provides methods to change the state of the ball, and to make the
ball perform actions. This package is usually called a module, in
addition to the methods used to change state, and perform actions, the
module also has data that is used to store any state information
needed.
Because this module is a complete package that models your object
competely, the module can easily be reused in many different
applications. Once it is wirtten and working anyone should be able to
use the module without fully understanding internals. For examplea all
one needs to know is that they want a red ball to throw. :)
Here is a good resource on OOP:
';Object-Oriented programming concepts';
http://java.sun.com/docs/books/tutorial/鈥?/a>
In functional programming what you have basically are a set of
functions each of which performs a task. Selectively executing these
function results in the solution to the problem at hand.
For example you might have a function that takes the coords. of a
square computes the area, and you may have another function that
computes the area of a triangle. By executing the square function 6
times you could compute the area of a cube. Or by executing a
combination of the square and triangle functions you could compute the
area of a rhomboid. As you can see you can build quite complex systems
based on simple functions.
Technically choosing OOP of FOP (or vice versa) you can always
accomplish the same results in either paradigm, however what may be
very easy to do with an OOP approach may prove to be very difficult in
FOP, and the converse may also be true depending on the problem.
Which leads to: Why has the whole world moved from FOP to OOP...
Welp this one is simple, it hasn't (in my opinion). Much of the world
is moving to OOP, and OOP is getting all the press of late. But there
is still a TON of work going on in the FOP world. But I digress, that
is a different debate.
I think the examples above may have already shed some light on this
question, but simply put OOP makes it easier to conceive very large
complex systems. Because it gives the developers the ability to break
the system down to small tangible.. uhh.. objects... :) which can be
designed, developed, and tested independently.
In a functional paradigm what invariably happens as a large system
grows: it becomes a huge pile of functions. All of which are
interconnected, and dependent on each other. Which means if you change
one function you break 10 others, it becomes impossible to manage. A
*good* large program written in a functional language is usually
designed with OOP principles in mind. (i.e. it is designed as a set of
modules that are not inter-dependent on other modules)
