Menu
▾
▴
Java_Fundamentals
There is a newer version of this page. You can find it here.
A comprehensive overview of fundamental computer science terms and Java programming concepts. External links are provided in case of special interest in a particular topic. With specific programming definitions/keywords, please note that this article explains the fundamentals of Java, and many of the external links point to Wikipedia, which will usually be generalizing on behalf of all languages.
Programming Tools
AWT: A collection of graphical user interface (GUI) components that were implemented using native-platform versions of the components. These components provide that subset of functionality which is common to all native platforms. Largely supplanted by the Project Swing component set.
GUI: Graphical User Interface. Refers to the techniques involved in using graphics, along with a keyboard and a mouse, to provide an easy-to-use interface to some program.
Swing: The most recent java GUI toolset available.
http://en.wikipedia.org/wiki/Rich_client_platform... Rich Client Platform (RCP): A platform that provides a framework, so developers can build applications faster.
General Computer Science Terms
Assign: To throw away the old value of a variable and replace it with a new one.
Casting:
Class: The blueprint for an object to be instantiated from containing attributes, data structures, and methods.
- Upcasting: Permits an object of a subclass type to be treated as an object of any superclass type.
- Downcasting: Permits an object of a superclass type to be treated as an object of any subclass type.
Creational: Involved with the process of creating objects.
Composition: Creates an object of another class to use. (A “has a” relationship.)
Encapsulation: Keeps data hidden and allows for adaptability through organization / code reuse.
Inheritance: Creates a derived subclass as an extension of a superclass. (An “is a” relationship)
Initialize: A special kind of assignment: the first. Before initialization objects have null value and primitive types have default values such as 0 or false. Can be done in conjunction with declaration.
Instantiate: To create a new instance of an object, i.e. to realize it.
Polymorphism: The ability to create a variable, a function, or an object that has more than one form.
Object (or Instance): An encapsulated entity based on a class blueprint.
Overriding: Providing a different implementation of a method in a subclass of the class that originally defined the method.
Abstract class: This is a base class that passes general shared methods with no implementation down to other classes.
Interface: An implicitly abstract type that classes must implement, used to define a contract for how classes interact with an object.
Proxy: A system that acts as an intermediary for requests between clients and servers. Also a class functioning as an interface to something else.
Sort: Using an algorithm to organize data.
Search: Using an algorithm find data.
Refactoring: Altering a body of code's internal structure without changing its external behavior. Most commonly used in reference to renaming a plugin, package, class, or variable.
Inner (or Nested) Class: Class whose only application is within the scope of its parents class.
Enumerations: Identifiers that behave as constants in the language.
Performance Optimization
Recursion: The act of calling back the same process once that process is fully executed. This stores overhead and stacks very inefficiently, and will lead to crash or system failure. This can easily be replaced by iteration in the form of pointers or while loops.
- tail: Calling back from the end of the method.
- head/body: Calling back from the beginning/middle of a method.
- mutual: Calling between two methods that are defined in terms of one another.
Iteration: Has the same effect of recursion, except that because iteration uses loops and pointers, it leads to amuch better use of memory. The overhead does not have to handle ______. Also the stack does not have to continuously grow with each cycle from re-initializing all the variables, returns, etc. Overall, iteration uses less memory and is faster because it does not have to waste time storing variables within its block.
Resource Contention: A contention event occurs when a function in a thread is forced to wait for access to the resource because a function in another thread has acquired exclusive access to the resource.
Profiler: Used to determine hot spots (areas of heavy computational load) are located in the code. Once located, these allow for performance optimization tweaks or bug fixes.
Benchmarking: Comparing two or more operations' performance (memory, speed, etc.)
Memory leak: Simply allocated memory that was not released when it was supposed to be, leading to continuously raising levels of memory consumed. Normal behavior is for the memory to be allocated (raise in consumption level), then to fall again when the memory is released.
User Interface
The user interface is the part of your program that is visible to the user, and with which the user may interact.
Event Handling: The process of a program reacting to external events, such as the user clicking the mouse or typing something. Objects called Listeners react to events.
MVC: Model View Controller.
- Model: The data management center, can have any number of V/C's
- View: The presentation (UI [User Interface] which can be GUI [Graphical UI], audio turning on air conditioning,etc.)
- Controller: Gathers input from the world and tells model what it needs to change.
Layering: Having several components that make up the UI. This is necessary if user interactions must take place.
Use Case: A single task, performed by the end user of a system, that has some useful outcome.
Z-Order: This determines the order in which windows appear on the screen--how they overlap.
Parts of the Computer
OS: Operating System. The software that supports a computer core functionality.
CPU: Central Processing Unit. Performs basic arithmetical, logical, I/O, on a large scale. This does not process small amount efficiently, rather the large chunks of data is its specialty.
RAM: Random Access Memory. Integrated circuits that allow stored data to be accessed in any order with a worst case performance of constant time.
JVM: Java Virtual Machine. A virtual machine is a software implementation of a machine that will execute a program like a machine. The JVM will specifically be for executing Java bytecode. This is an essential part of Java, because it makes it a “run anywhere” program rather than a “compile anywhere” program.
Hard disk drive: For storing and retrieving digital information, a RAM device.
NiCE Team Terms
NiCE: An integrated computing environment for nuclear simulation, providing features that allow for large simulations to render on a separate server while providing all GUI elements on a local client with universal web access (using Visit by default to handle the data processing for the images). It works across any standard OS, many machines (including android), and provides a unified set of frameworks to make data simulations across the scientific community easily sharable.
VisIt: A visualization software that can process very large sets of data.
Maven: Software to “easily” build projects with their own Ant builds and JARs.
JAXBY /JAXRS: Java architecture for XML bindings.
Hashing: Any algorithm or subroutine that maps large data sets, called keys, to smaller data sets.
Reference: A variable data type in which the variable's value is an address.
Miscellaneous Vocabulary
Expensive: Heavy loads of computational work.
JavaSun: Oracle's java support website, an excellent resource for tutorials and definitions.
Compiler: A program to translate source code into code to be executed by a computer. The Java compiler translates source code written in the Java programming language into bytecode for the Java virtual machine.
SQL: Structured Query Language. The standardized relational database language for defining database objects and manipulating data.
API: Application Programming Interface. The specification of how a programmer writing an application accesses the behavior and state of classes and objects.
instanceof: A two-argument Java keyword that tests whether the runtime type of its first argument is assignment compatible with its second argument.
Reflection: The operation to access private methods and fields.
JavaDocs: A documentation generator from Sun Microsystems for generating API documentation in HTML format from Java source code.
Logging: Using or controlling the process of a computer to collecting data through sensors, analyzing the data, and saving and outputting the results of the collection and analysis.
Databases: A structured set of data held in a computer, esp. one that is accessible in various ways.
- Connectors: Java database connectivity (JDBC) is an industry standard for database-independent connectivity between the Java platform and a wide range of databases. The JDBC provides a call-level API for SQL-based database access.
- Access: Connect to a data source. Send queries and update statements to the database. Retrieve and process the results received from the database in answer to your query.
System Calls: A mechanism to execute command line commands from an application.
Pipes: Common source or destination of data, providing the ability for two threads running in the same JVM to communicate.
Processors (XML Parsers): Analyzes the markup and passes structured information to an application.
- DOM: Document Object Model, parses an entire XML document and load it into memory, modeling it with Object for easy nodel traversal. DOM Parser is slow and consume a lot memory if it load a XML document which contains a lot of data.
- SAX: Simple API for XML, does not load any XML document into memory, the SAX parser uses a callback function to inform clients of the XML document structure.
SWT: An open source widget toolkit for Java designed to provide efficient, portable access to the user-interface facilities of the operating systems on which it is implemented.
JFace: A UI toolkit that provides helper classes for developing UI features that can be tedious to implement, operating above the level of a raw widget system.
JSP: JavaServer Pages technology provides a simplified, fast way to create dynamic web content.
System calls: Provide the interface between a process and the operating system. This may include hardware related services, creating and executing new processes, and communicating with integral kernel services.
Basic Coding
Parts of Code
Access Control Modifier: The umbrella term for keywords that determines the visibility of the class--as the following chart explains:
Class Package Subclass World
Public
Y
Y
Y
Y
Protected
Y
Y
Y
N
Package
Y
Y
N
N
Private
Y
N
N
N
Classpath: An environmental variable which tells the Java virtual machine and Java technology-based applications where to find the class libraries, including user-defined class libraries.
Constructor: Initializes the already constructed (created) object, called right after memory is allocated for the object. Has no return (not even void) and has same name as the class.
Fields: A data member of a class. A field is not static by default
Library: A set of dynamically loadable libraries that Java applications can call at runtime.
Main(): A method in the controlling class used to initialize the program.
Method: A piece of a class, used to implement actual pieces of code
Method Signatures: Collection of information about the method including name, visibility, type(static or not), its arguments, and return type
Package: A group of types (class or interface), and are declared with the package keyword.
Keywords
A complete list of Java's (currently) 50 keywords can be found here, but here
Declare: A declaration states the type of a variable, along with its name. A variable can be declared only once. It is used by the compiler to help programmers avoid mistakes such as assigning string values to integer variables. Before reading or assigning a variable, that variable must have been declared.
final: This modifier commits you to defining an entity exactly once. You cannot change it or derive from it later. More specifically: a final class cannot be subclassed, a final method cannot be overridden, and a final variable cannot change from its initialized value.
New: creates a object, reference, primitive, etc., and adds it to the memory.
Static: This keyword can modify methods or classes, and designates them as having only one instance. Static members belong to the class rather than to a specific instance.
this: A keyword that can be used to represent an instance of the class in which it appears; "this" can be used to access class variables and methods.
Method Overloading: Using one identifier to refer to multiple items in the same scope. In the Java programming language, you can overload methods, but not variables or operators.
Casting: Explicit conversion from one data type to another.
Argument: A data item specified in a method call. An argument can be a literal value, a variable, or an expression.
Block: A sequence of statements, local class declarations and local variable declaration statements within braces.
Variables
Local Variable: A variable that is given local scope and is accessible only from the function or block in which it is declared.
Global Variable: Unlike a local variable, a global variables is accessible everywhere in the project. These are not good to use, because they can lead to shadowing and other confusion, as well as continuously allocating memory, which is wasteful.
A [http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html Primitive Type is a variable, or data type, is primitive when variable's value is of the appropriate size and format for its described type. That is, the name of the type will be entirely self-explanatory. Primitive types are built-in to programming languages, often remaining consistent across many languages. Here are the most common ones:
boolean: Booleans can only have two values: true or false. This data type is mostly used to track conditions for logic statements (such as if...then...).
int: An integer number value. There are also a few subcategories:
- byte: The byte data type has the most limited range, with a minimum value of -128 and a maximum value of 127 (inclusive). However, if an integer in your code should always be within that range, then using bytes is a great way to save memory.
- short: A short integer is at least 16 bits. It must be kept within a smaller range compared to a standard integer on the same machine, but it takes up less storage, so it's convenient to use if memory capacity is an issue.
- long: A long integer is at least 32 bits. Predictably, it is the short integer's opposite. It takes up more memory, but accommodates a wider numerical range.
double: Doubles are the default choice for decimal numbers, but shouldn't be used for values that need to be precise, like currency.
float: Used for non-integer numbers, but its range us less precise than a double's.
String: Strings are used for characters (most often words, phrases, etc.).
char: Chars each use one character, but you can use an array of chars (char[]) to form a String. Not all languages use char variables, as a String will often suffice. The essential difference is that arrays of chars must be micromanaged and is often used to represent code units, while a String is much easier to work with and frequently used for labeling.
Common Data Structures
Data structures are the main mode of organizing and storing data in Java.
ArrayList: Implementation of the List interface used to hold data linearly.
Hash Table A record of key-value pairs.
LinkedList: Implementation of the List interface where each piece within the list recognizes the directly surrounding pieces. The LinkedList is efficiently used with binary algorithms for sets of data that only need to be walked through once.
Vector: Synchronized implementation of the List interface.
Tree: A data structure that emulates a hierarchical tree structure with a set of linked nodes.
Node: A record consisting of one or more fields that are links to other nodes; used to build linked, often hierarchical, data structures such as linked lists and trees.
Error Handling
catch: A Java keyword used to declare a block of statements to be executed in the event that a Java exception, or run time error, occurs in a preceding try block.
try: A Java keyword that defines a block of statements that may throw a Java language exception. If an exception is thrown, an optional catch block can handle specific exceptions thrown within the try block. Also, an optional finally block will be executed regardless of whether an exception is thrown or not.
finally: A Java keyword that executes a block of statements regardless of whether a Java Exception, or run time error, occurred in a block defined previously by the try keyword.
Exception: The customary way in Java to indicate to a calling method that an abnormal condition has occurred. In Java, exceptions are objects.
Exception Handler: A block of code that reacts to a specific type of exception. If the exception is for an error that the program can recover from, the program can resume executing after the exception handler has executed.
Exception Hierarchy: Only objects descending from the Throwable class may be thrown. Two direct descendants of this class are Exception and Error.
Global Exception Handling: Rather than sprinkling try/catch blocks throughout your applications they can all be managed at one location. The first step is to define your own UncaughtExceptionHandler implementation class. The second step is to set the default uncaught exception handler.
Controlling Flow
loop: Repeats a specified section in the code according to a state or predefined number set by the programmer.
if-else: An operation used to say if A happen then this happens, otherwise that happens.
for: A loop that has a set number of iterations set by the programmer.
while: A loop that continues to iterate over a section while a certain state or property exists.
do: A while loop based on a boolean condition.
switch: a certain kind of if statement that allows many choices to be chosen from rather than just two (if or else)
Equality
Equality: One way for primitives, four for objects
a==b, a!=b: Will only be true if two references point to the same underlying object.
equals(): Will return true if two objects have the same value.
compare(): For comparing values.
compareTo(): Compares values returning int less than, equal, or greater than.
Equivalence: When !(a
