Thread: Java Vocabulary Help

Haha, there's so many terms to know.

Here's a few of the more important ones (mostly CS terms, but some have a Java twist to them). Sorry for the ordering, I just put them here in what ever order they came to my mind

Abstract: Basically taking away the details. You can think of this as the "magical black-box" analogy. You can put stuff in to it, it will give you something out, but you don't know (and don't care) how it does. However, it must tell you that for something you put in, what you should expect out. Methods are commonly used to "abstract away" details (see below).

Polymorphism: Being able to look at an object in multiple ways. The simplest example is this: Take a Fararri Enzo. It is a Farrari Enzo (by default ). However, if needed, it can be looked at as a car, also, which can be looked at as an automobile. However, this only goes one way. You can't say that you're car is a Fararri Enzo (unless it really is, in which case you are lucky!).

Encapsulation: This is restricting access to components of an object. An example is the steering: You don't have direct access to turn the wheels anyway you want. Some of these limitations are physical, but some of them were put there by the manufacturer via the steering wheel This lets the maker of the object decide how that object can be used, and how it can not be used.

Method: A method is known by several names: function, sub-routine, and maybe a few others. Basically, it's the black box I talked about in abstraction. It should tell you what to put in, then given what you put in should give you an output of some kind.

Side-Effect: Pertaining to methods, side-effects are other things methods might do. In classical computer science, methods can only have 1 output. Side effects may be changes that are made to the object, text or pictures drawn to the screen, or anything else the method does that has a lasting effect when the method is done running.

Variable: Variables can be thought of as buckets. They hold stuff, in particular, information. Variables have 4 things: A value, a lifetime, scope, and a name. A variable's value and name seem like fairly self-explanatory terms, so I won't delve into what they are unless you want me to. Lifetime is when the variable actually physically exists in memory. Scope is when the variable can be used. This may be confusing to think of, but here's an example: pretend your program is a person writing stuff on a piece of paper. Then, he gets out a second separate sheet of paper to do other calculations. Everything on that first sheet is still physically available, but is not in scope (not usable) of the second sheet. However, if you throw away that first sheet, the variables on the first sheet have "died", and their lifetime is over.

Recursion: Recursion is anything that either directly or indirectly refers to itself. A good example in mathematics is the Fibonacci Sequence: the nth term is simply the sum of the 2 previous terms, with the first 2 terms being 1.

Loop: A loop is any code that repeats itself. You can think of this as a race track, where the cars are executing a certain command depending on where they are on the track, and when they get back to the beginning, they execute the same code again, though it may have different effects each time through (like drivers may adjust how they drive each lap).

Object: An object is... an object. It's basically any idea or physical thing you can represent in any way that you deem necessary.

Class: A class defines what an object would be. A good analogy is social class. Within each social class (rich, poor, politicians, clergy, etc.), there can be different objects (people). However, there is an over-all definition of which each class each object belongs to. Classes can contain fields and methods, both static and non-static.

Field: A variable inside a class.

Static: In java, static is a modifier added to a field or a method that denotes it as not belonging to any one object, but to the class as a whole. An example of this is tax rate: Regardless of which person you are, you have to pay a certain tax rate (well, not completely true, but let's assume this is true).

Non-static, or instance: Basically the opposite of static. It's any field that applies specifically to a certain object in a class, or any method that acts on a certain object in a class. An example of this is a person's name: Not everyone has the same name. However, people's names don't necessarily have to be different.

I think those are the main ones I deal with on a daily basis, let me know if there are any others you want me to define

Here a few others I thought of:

Algorithm: Any combination of steps/actions to accomplish something. An analogy is a recipe for making cake. You follow a certain list of instructions, with given inputs (ingredients). At the end of the recipe, you're left with some output (yummy cake).

Getters/Setters: Fancy names for methods that get the value of or set the value of a field.

Data structure: Any specification to how data is stored, and how that data is viewed. Some common types of data structures are: collection, set, list, linked list, array, heap, hash table, trees, and maps. Data structure is also commonly referred to as an Abstract Data Type, or ADT.

Collection: A data structure that contains stuff. This has also been known as a bag, since the order doesn't matter, and you can have similar things inside that bag (say 2 red marbles, a blue one, and 5 yellow ones).

Set: A collection that only contains one of anything inside of it.

List: A collection where order does matter.

Linked List: A type of list that in the implementation, each item's position is determined relative to where the next and/or previous item is. Example: The first item (also called the head) of a list of cars I like is the Ariel Atom. I like the Porshe 911 less than the ariel atom, and I like the Honda Civic less than the Porshe 911.

Array: A type of list that in the implementation, each item's position is determined absolutely in that list. Example: My #1 favorite car is the Ariel Atom. My #2 favorite car is the Porshe 911. My #3 favorite car is the Honda Civic. (note the subtle differences between linked lists). Is also commonly referred to as an Array List.

Array index: The array index is the location in an array that a certain element exists. In java, this index starts counting from 0, so the first element's index is 0, the second element's index is 1, etc.

Queue: Any list that has FIFO access. An example are queues for getting food, or waiting in line at an amusement park.

FIFO: First in, first out.

Stack: Any list that has a LIFO access. An example is a stack of cards: pretend you can only add cards to the top, and you can only take cards from the top. Then, the last card you put on is the first card you will take off.

LIFO: Last in, first out.

Heap: A heap is a tree that has been implemented as an array. To calculate the "parent" of a node, divide the array index by 2. The value of each parent must be less than that of both of it's children, so the top element of a heap is the minimum value of that heap. Note: determining if an object is less than another object is completely arbitrary. It also can be greater than, but for a certain heap you MUST stick with only one (either all less than, or all greater than).

Hash table: A hash table is a table that stores elements fairly arbitrarily based on some characteristic of the element (arbitrary), but has some method of retrieving back a specific item.

Hash key: This is the key computed to retrieve the specific item back. This key is computed via a hash function.

Hash function: A function that computes hash keys. Note that this function must always compute the same key given a specific object, and is used both to add items to a hash table and to remove them. The quality of a hash function is determined by how "randomly" it can distribute items in a hash table.

Tree: Any data structure where elements have "children". It's easy to think of a real life tree: suppose the top element is the trunk. Then, coming out of the trunk are some large branches. From these branches are other branches, and maybe even more branches from the next level of branches. Eventually, you reach a leaf node, and there are no more branches/leaves you can go further with.

Map: Probably the most difficult to explain, A map is a set of nodes and a set of links between nodes. An example is a real life-map: The nodes are the cities/locations, and the links are the roads. Links can have "weights", or how much it costs to travel between to nodes via that link.

Map path: Any set of links in a map that must be traversed to get from one node to another node.

*Note: for the ADT's, I've only provided a short overview of what they are. I'd strongly suggest you read more about these on google/wikipedia or some programming books as they give much more details concerning ADT's (and any of these terms).

Nice posts helloworld.

Maybe we could add a Java vocabulary section to the forums.