Vocabulary

The following is a list of vocabulary words and general concepts that I think any student completing this course should be able to define/discuss. As the semester goes on and you start to hear these terms used and defined you should consider updating this page to include a definition/discussion regarding these terms. If I end up using a term/concept not already on this page, please feel free to add it in.

Note from Dr. Schafer - (4/16/09) In response to the forum conversation between JC and Larry I will make another pass down this list and give you my opinion of the quality of things. If I mark it as weak or incomplete or wrong then you should feel free to update the definition. Having said that, I wouldn't just rush out and copy and paste a definition from Google (heck some of the bad ones here appear to maybe come from Google as they aren't wrong but aren't proper in the context of this course). If you update a definition that I marked in some way you might simply add "updated" after my tag so others know that it has been changed since I interpreted it as "weak" or incomplete"

  • abstract class - A class that contains at least one abstract method that each class that extends it must provide. In concept, a abstract class is a class and interface combined together. Unlike classes however, Abstract classes can not be instantiated and unlike interfaces a abstract class provided implementation on all non abstract methods. (changed from previous)-[A BIT incomplete. More detail would be needed on a test answer]
  • abstract method - A method that has no implementation.
  • access method - returns information from the class (returns its state)
  • access modifier - keyword that defines the accessibility scope of a specific class, variable, method. example of access modifiers: public, private, static, abstract [WRONG. It's semantics, but this is wrong].
  • accessor - a method that allows a user to get information from an object without changing the state of the object.
  • adaptor (design pattern) - Allows a programmer to use an interface but cheat by not having to write all of the implemented methods. Usually is extended rather than implemented. Like plugging a 3 prong cord into a 2 prong outlet.
  • API - (Application Programming Interface) - set of classes and methods, defined in libraries, that are used to implement an application. Shows us how to use a class or interface without going into detail on how its implemented. (changed from previous)-[Right and wrong at the same time. Not quite how I would define it]
  • array - a list of elements which in Java has to be of the same type, stored one after the other in the memory
  • ArrayList - an array that is like a hash map that extends its memory only when it needs more spaces and elements are added to the end. [Mostly]
  • assertion - A boolean condition at a given location within a program that should be true when the program executes it.
  • AWT - Stands for Abstract Windows Toolkit. It is a core package in java that allows basic support for building GUI's.
  • behavior - how an object reacts to changes is state. i.e. methods.
  • black box testing - Is when you don't know how the code works, so every possible outcome or input must be tested.
  • boundary case - this is used in testing where both sides of upper and lower limits if they exist are tested. i.e. if an upper limit is applied than test the value just below and the value just above.
  • * byte code - "Compiled" version of code that the java virtual machine can read and execute
  • canonical form of a class - includes these elements: No-arg constructor, Object equality, String representation, Cloning, Serialization.
  • casting - The process of converting one type to another
  • child class - a class that extends another class to use its methods provided and or extend behavior and or add new behavior over the preexisting super class (changed from previous)-[Probably correct when this was written, but now only partially correct given what we learned about the six forms of inheritance]
  • class - a description of relations between instances of objects. Contains methods for implementation of behavior. (changed from previous)-[Correct, but sort of missing the point]
  • class diagram - a graphical representation of the class. it contains information about the members and/or methods that the class contains
  • class header - the first line in a class definition. it contains the name of the class and access modifiers
  • cloning - Creating a copy of an object. Must implement cloneable interface and override the clone() method.
  • cohesion - a measure of how class entities are related within a module or how well defined a class is and it's actions.
  • combination (form of inheritance) - inheriting two or more classes (multiple inheritance) java uses extends and implementing interfaces to do this.
  • composition- Not extending a class but adding it as an instance variable for use in the new class.
  • construction - initializing an object using the constructor method
  • construction (form of inheritance) - calls its parent with the super command and then initializes any extra objects. - Bad no substitution.
  • constructor - creates and initializes a new instance of an object and sets all initial values for instance variables.
  • content equivalent - the equivalency of the instance variables in two objects without having to have the same name. [or memory location. Remember that two names can refer to the same object in memory]
  • coupling - a measure of interdependency among modules.i.e. does a change in one class make it neccessary to make changes in other classes.
  • crc cards (Component Responsibility Collaborators) - a class designing methods that allows the designer to concentrate on what the class is and what it will do without caring about ----how to implement it
  • debug- is finding and fixing errors in code.
  • declaration - defining a variable name and it's type(and possibly value)— [Declaration does not include assigning a value. That is called initialization. While they may be done in one line of code, the declaration itself does not involve any assignment of a value]
  • decorator (design pattern) -
  • default constructor - a constructor with no parameters that creates a default object with a default set of variable values. For example 0 for numbers, an empty string for strings.
  • design pattern - schematic description of reusable designs. Each pattern describes a recurring problem and the core of the solution to that problem
  • destructor - removes objects and frees resources
  • duplicate code - Is when you see two or more statements of code in different areas (or methods) of a class(es). Like IF/ELSE statements.
  • encapsulation - a type of coding design that allows the programmer to code in different ways but doesn't change the way the user interacts with the program. Hence, the user can interact with program without knowing how it is coded.
  • event driven programming - A style in which a program is not ran in a sequential order but based off of events. This is achieved through listeners and threads. [Correct but weak]
  • event handler - when an event is triggered in event driven programming a event handler is called and the code within it is executed. This code controls what the program should do for each type of event. (changed from previous)- ["The actual code from an event"???? ]
  • exception handling - A block of code that will let your program recover from operations that causes an error. Implemented trough the use of try/catch blocks. It is common that any operation in java that can produce an error, reading from a file, requires a try/catch block to compile.
  • extend a class - to make this class a child of the Super class or the one being extended - the child can be subsitituted for the parent
  • extend a method - Whenever you extend a class in essence you are also extending the methods (or the behavior) of the class that you are extending.[There should be a definition here at this point. The difference between this and the previous term is small but important. They are related but different]
  • extends (key word) - makes the current class a child of the extended class and sets up inheritance.
  • extension (form of inheritance) - to extend a class and create a subclass that uses most of the methods of the super class and but adds new behaviors and methods.
  • factory method (design pattern) - design pattern that defines an interface of creating an object but lets the subclasses decide which class to instantiate and how.
  • field - variables, class variables or local variables.
  • final (key word) - a field or class that is not allowed to be changed i.e a constant.
  • framework - Used in GUI programming where the graphical code is held in the frame and inherits features from parents. [There is so much more to this idea and you guys should know it by now]
  • garbage collection - a property of certain programming languages like java, that removes information from memory at intervals when it is no longer needed
  • graphical user interface - Graphical part of an application used to exchange data with the user
  • GUI - stand for Graphical User Interface
  • helper method - method use as a step in a more complex method. For example: if you had to make a method that draws a table, you could use two helper methods: one that draws the surface and one that draws the legs. Usually used to eliminate duplicate code. Also, is set to "private" because it is helping you not any one else.
  • identifier - name of a variable(object)
  • identity - ways to distinguish objects from one another.
  • immutable - you cannot change the object [Give me the crucial immutable object in Java…]
  • implementation - the code within a method that defines how the behavior should be "implemented" (changed from previous)- [WEAK]
  • implementing an interface - Every method outlined in the interface must be provided by the implementing class. The class itself provides the functionallity of the methods(implementation). (changed from previous)-[I Agree. Add more here. This is weak]
  • implements (key word) - a keyword included in the class declaration to specify any interfaces that are implemented by the current class.
  • inheritance - Creating a subclass (child) that extends the original (superclass) class's behavior and state.
  • inner class - A class within another class. Used in some cases for listeners that only need to be used locally. (changed from previous)-[ok, when do we use it and why?]
  • instance - variable(object) of a class type
  • instance variable - variable defined in a class or what an object knows about itself.
  • instantiation - assigns a value to a variable after it has been declared. Can be done on the same line as declaration or on a separate line.
  • interaction diagram - a table of objects with arrows showing how they interact with each other. If one class creates an object from another class this would be interaction. (changed from previous)- ["connected"???]
  • interface (concept) - is like a class with no functionality. It has a list of what needs to be provided (the contract).
  • interface (key word) - Tells java that the class your working on will only include stub methods and when implemented requires all methods to be coded in the implementing program.
  • layout manager - An object which handles the size and position of visual objects inside a container.
  • limitation (form of inheritance) - A subclass that overrides inherited methods so they can't be uses i.e set from an Array list, Bad don't use this because you lose Substitution.
  • listener - a interface where the event handling is done dynamically. As soon as an event takes place the program focuses on it, which gets rid of the hold and wait functionality.
  • local variable - a variable constructed and used only in the method and then is garbage after the method terminates.
  • main class - the class that represents the entry point of the specific application(the class that holds the method "main").
  • main method - a method that contains the code that will be run during the application
  • method - creates object behavior or what an object can do.
  • method header - a comment block that describes the behavior of a given method
  • model-view-controller (design pattern) - a design pattern where there are at least three different classes where all output, all input and all interactions are separated from each other making it easy to change one without changing the other.
  • Mouse Adapter - A class that implements The MouseListener interface and provides stub methods to cover all required methods from the interface. This allows the client code to extend the MouseAdapter and override only the methods needed.
  • Mouse Listener - An interface that deals with the events of a mouse.
  • mutable - the object can be changed
  • mutator method - changes information in a class (changes its state)
  • name equivalent - SKBN [Wow, no one has filled this in yet or asked about it in class… Might make a good test question for the next exam…]
  • Object (with a capital O) - root of the class hierarchy. Every class has Object as a superclass. All objects, including arrays, implement the methods of this class [Updated]
  • object (with a lower case O) - Anything in the real world that can be distinctly identified.
  • object code - the byte code the compiler creates when the .java files are compiled.
  • object recursion - [We are actually skipping this topic this semester, but I will leave it here as a stub for some other semester when I might cover it]
  • overload a method - Is when you have two or more methods with the same name but they take in different parameters.
  • override a method - Is when the child or subclass disregards the parent or super's method and implements its own method.
  • package (key word) - ??? default constructor, everything in the same director is a package ??? you can have different packages to split up into object oriented programming ??? [BAD!]
  • parameter - a variable that is passed as a argument to a method from another place in code whether from another class or from another method. The recieving method then uses this parameter. (changed from previous) -[What this person means is true, but it is a pretty weak definition]
  • parent class - a class that has another class that extends it
  • polymorphic variable - A variable that can be substitutiable for its parent class.
  • polymorphism - The capability of an action or method to do different things based upon the object it's acting upon.
  • primitive data type - holds one value, one of boolean, byte, short, int, long, char, float, and double.
  • private (key word) - access modifier - making data types or objects only available to the class or method.
  • protected (key word) - access modifier - allows only the class itself and classes extending it to access the class/method
  • public (key word) - access modifier - making class or object available to everyone.
  • refactoring - "Changing a program in a way that does not change its functionality. "
  • referential data type - stores a memory location of where the state and behavior is stored. [More to it than this, although it is correct]
  • return type - type of object being returned from a class…i.e. int, boolean or String
  • scope - a spot in the program compared to the levels in the overall program, i.e (local variables in a for loop inside a method which is inside a class)
  • specification (form of inheritance) - Super class that provides responablity but no behavior (contract), common use is Interface i.e PinBallTargets
  • state - information the object needs to know about itself.
  • static (key word) - a method or field that is accessed from the class only and not from instances of the class.
  • strategy (design pattern) -
  • style - going beyond syntax and creating code that looks and runs a certain way.
  • sub class - a class that extends another class
  • substitutability - the ability for a subclass to be able to take the place of a superclass but not the other way around
  • substring - a part of a string. Could be anything from nothing to the whole string
  • super (key word) - Allows the child class to call public/protected methods and variables of its parent. As someone stated earlier "calling the parent and initalizing from the child," this is actually super(); and not super.method or variable
  • super class - the parent of the subclass
  • Swing - An extension of the AWT that helps you build sophisticated, high quality GUI's.
  • synchronized (key word) - a mechanism that helps make sure that two threads don't take up the same resources at the same time.
  • syntax - rules that defines how a Java program is written
  • test case - methods of a class (Junit) that automate testing and are computer scoreable i.e passed all 7 tests.
  • this (key word) - a reference to the current object
  • thread - Concurrently running processes that allow multiple parts of a program to be ran 'simultaneously'. Used heavily in GUI programing. [Actually, I strongly disagree with the GUI statement]
  • UML (Unified Modeling Language) - a way to describe a class's instance variables and methods in a list to lay out the behavior of the class.
  • Vector - A data structure that is like an array but can grow or shrink as needed and is optimized for threading.
  • white box testing - a method of testing where the tester know what the code looks like and tests it based on what it should do.
  • wrapper class - referential data types of the eight primitive data types to allow more functionality.
  • yo-yo effect - Is when a class calls a method, and the class is a subclass, and it does whatever it has to do for that method inside of the class. If that method makes a call to another method and the current class doesn't know anything about the method then it goes up to the parent class to see if it knows anything about the method, and if it does then it finishes the method. Then it goes back down to the subclass and finishes the current method. e.g. Like the method repaint in JFrame. It is called in a class and then goes up to JFrame and does whatever it is that it needs to do. In the JFrame repaint method makes a call to paint, and then the class goes down to the current class to see if it has a method called paint. A methodology used by java that allows the caller to use its variables and methods before using its parent/supper variables and methods. [This would get virtually no points on an exam question about this term. Missing the key point(s)] [UPDATED]
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License