Help
Options
Didn't know it?
click below
click below
Knew it?
click below
click below
Don't Know
Remaining cards (0)
Know
retry
shuffle
restart
0:00
Embed Code - If you would like this activity on your web page, copy the script below and paste it into your web page.
Normal Size Small Size show me how
Normal Size Small Size show me how
M250
Java terms and definition
| Term | Definition |
|---|---|
| absolute pathname | A full path to a file beginning from the name of the storage device. |
| abstract class | A class that defines a common message protocol and common set of instance variables for its subclasses. Cannot be instantiated in Java. |
| abstract method | Methods with no body. Must be implemented in any concrete subclasses of the class in which they are specified. Interfaces also specify ... methods, which must be implemented by classes implementing the interface. |
| access level | The scope for access that exists for a software component such as a method. Four scopes of access in Java: public, private, protected and default. The default level occurs when nothing is specified. |
| access modifier | One of three Java keywords (public, private, protected) which specify the visibility of variables and methods. |
| accessibility = | visibility = |
| accessor message | Another name for a getter message. |
| accessor method | Another name for a getter method. |
| actual argument | A value used in a message that is copied to a formal argument for use inside the corresponding method. Must be of a compatible type with their corresponding formal arguments. |
| annotation | A piece of code in a source file that indicates a programmer’s intention to the compiler. The only one used in M250 is @Override. All annotations begin with the character @ in Java. |
| application domain = | problem domain = |
| array | An indexable, fixed-size collection whose elements are all of the same type. |
| array initialiser | An expression that can be used to initialise an array using assignment, a shortcut way of initialising array elements. |
| assert | The keyword in a Java assertion statement used to indicate a condition that should be true in order for the code to be correct, particularly used in private methods. |
| assertion | A statement in the Java language that enables you to test your assumptions about your program; a condition that a programmer believes should be true. |
| assignment | Process that results in the variable on the left-hand side of the ... operator receiving a copy of the value on the right-hand side. The value may be a primitive value or a reference to an object. |
| assignment operator | An operator (=) used to copy the value on the right-hand side to the the variable on the left-hand side in an ... statement. |
| assignment statement | A statement that copies a particular value to a variable. |
| attribute | Some property or characteristic of an object that can be accessed using a getter method. Generally implemented by instance variables. Examples are position and colour for Frog objects, and balance and holder for Account objects. |
| attribute value | The current value of an ..., often the same as an instance variable value, but possibly computed using instance variables. |
| auto-boxing | The automatic process of wrapping primitive values when called for by the context of usage in a Java program. |
| auto-unboxing | The automatic process of unwrapping primitive values when called for by the context of usage in a Java program. |
| automatic type conversion | Java compiler automatically converts a value of some type to another type. Occurs in certain contexts, such as in an assignment statement when a compatible type on the right-hand assignment is converted to the type of the variable on the left-hand side. |
| behaviour | A term used to describe the way in which an object acts in response to the messages in its protocol. |
| binary digit | Either 0 or 1. Used for the internal representation of numbers, characters and instructions in computers. Smallest unit of storage. |
| binary operator | An operator that has two operands. |
| bit | An abbreviation of binary digit. |
| body | Another word for a (statement) block; for example, the body of a while loop is a (statement) block. |
| Boolean condition | Expression used to control the conditional execution of a statement block. |
| Boolean expression | An expression that evaluates to either true or false. |
| Boolean operator | A operator used to combine simple ... expressions to form more complex ... expressions, which in turn can be combined with other ... expressions. |
| Boolean operator = | Logical operators = |
| bucket | A data structure that can contain zero or more unsorted elements. A HashSet uses it to implement a set. |
| buffer | Could refer to either an area used for temporary storage as data is transferred between a data source and a data sink, or a sequence of unfilled components that allows a StringBuilder object to grow. |
| bug | The cause of a run-time error. |
| bulk operations | Operations that act on an entire collection without requiring the programmer to focus on individual elements. |
| bytecode | Intermediate code produced by the Java compiler. Files have the extension *.class. The file is portable because each computer that can run Java programs has a JVM that understands and converts it into machine code required for that particular computer. |
| call stack | A representation of the order of methods called at some point during the execution of a program, with the first called method on the bottom and the last called method on the top. |
| capacity | The number of characters a StringBuilder object can hold. |
| casting | The prefixing of a value with the name of a type in parentheses in order to convert a copy of that value into a different type. For example, (int) 99.0 ... the value 99.0 into an int value. |
| catch | The process of catching an exception, and the keyword introducing the clause in a try-catch statement that handles an exception. |
| chaining | ... constructors meanins that when an object is created, the constructors of all its superclasses are also called, either explicitly or implicitly. |
| checked exception | An exception that the compiler requires the programmer to explicitly handle or declare may be thrown in a method header using a throws clause. A programmer may reasonably be expected to catch these or should be made aware of. |
| class | A blueprint for the creation of objects. Ensures that all its instances have the same instance variables and behave in response to messages in an identical manner. |
| class header | The line in a class definition which gives its access modifier, name and,optionally, the name of a class it extends and the name(s) of any interface(s) it implements. Example usage: public class WeatherFrog extends Frog implements WeatherClient |
| class method | Method declared with the keyword static and associated with a class and not with its instances. The expression this (classes are no objects) or the keyword super can't be used. Invoked directly on the name of the class; no polymorphism. |
| class variable | A variable declared with the keyword static. Associated with a class rather than with any of its instances, although each instance of this class can access them. A class only ever has one copy of them. |
| client (class) | An object that uses a service provided by some other (server) class. |
| collaboration | The achievement of a software solution using two or more communicating objects. |
| collection * | Consists of a number of, possibly zero, objects (strictly object references) or primitives. The objects or primitives within it are referred to as elements. |
| comma-delimited file | A file whose items of data (tokens) are separated by commas. |
| comment | Piece of text in program code to assist human readers in understanding the code, and which the compiler ignores. Multi-line: delimited by /* and */. End-of-line: begin with two forward slashes (//) Javadoc: placed between /** and */ |
| common message protocol | A set of messages shared by a number of classes. Often used to describe the set of messages specified by an abstract class for its concrete subclasses. |
| Comparable | An interface that allows an element type to be sorted. It contains a single method: compareTo(). |
| comparison operators | Used for comparing values of expressions, including ==, > and < . |
| compilation[-time] error | An error detected by a compiler when code is compiled. No bytecode is generated. |
| compiler | Software which checks that text written in a high-level language is correctly formed and that it is meaningful source code for the language. |
| component (of an array) | The memory location at which an element (or a reference to it) of an array is stored. |
| component type | Determines the types of the object or primitive value that can be stored in the array. |
| compound expression | An expression built up using other sub-expressions. For example: (3 + 2) * (6 - 3). |
| concatenation | The joining of two strings. In Java the operator is + (the plus sign). For example, "Milton " + "Keynes" evaluates to "Milton Keynes". |
| concrete class | A class which is not abstract; a class for which instances can be created. |
| conditional selection | The use of if statements to select and execute alternative statement blocks based upon the value of a Boolean condition. |
| constant | A variable whose value is fixed and unchangeable. Normally the keyword final is used. Typically declared as static when only a single value is needed for a class. not static: each instance of a class has its own different value, e.g. a serial number |
| constant instance variable | Usually declared as final static variables. However, sometimes it makes more sense to define a constant as a final instance variable. See constant for more information. |
| constructor | A programming construct, similar to a method, used to initialise a newly created object. |
| constructor chaining | The process whereby constructors use super() to invoke constructors higher up their inheritance hierarchy. |
| convention | A commonly followed rule for implementing some feature of a software system that is not enforced by the language used, compiler, or platform on which the software is used. |
| 'object referenced by x belongs to class A' = (synonymous phrase) | 'x refers to an instance of class A' = (synonymous phrase) |
| class members | - instance methods - instance variables - class methods - class variables - (no constructors, though!!!) They are involved into inheritance and their accessibility is controlled by access modifiers. |
| (data) fields | - instance variables - class variables - constants (can be looked at a special form of variable with static content) but not variables in - a method or code block -> local variables - method declarations -> parameters, or formal arguments |
| instance methods | methods associated with instances of a class (objects) and invoked as a result of the corresponding message-send -> all together sum up to an instance's protocol |
| instance variables | common to all instances of a class with values specific to each instance -> all together sum up an instance's state -> instances of the same class (objects) can have different states |
| class methods | associated with the class itself and not with its individual instances (objects). -> declared by the keyword static -> the keyword "this" can't be used with class methods |
| class variables | associated with the class itself and not with its individual instances a class has only one copy of its class variables -> all instances of a class (objects) see the same variable values |
| local variables | variables in a method or code block |
| parameters = | formal arguments = |
| parameters / formal arguments | variables in method declarations |
| subclass | Any class which extends (inherits from) and specialises another class. In Java all classes except Object are subclasses of some other classes. - direct (no intervening classes in the class hierarchy) -> keyword extends in the message header - indirect |
Created by:
gabimuc
Popular Computers sets