objects
If an objects does not need to be referenced later can create without explicitly assigning it to a variable. For instance new Circle(); This is called an _
Anonymous object
The variable myCircle can reference a Circle object. The next statement creates an object and assigns its redeems to myCircle
MyCircle = new Circle();
Constructors are invoked used the _ when an object is created
New operator
Runtime error that occurs when you invoke a method on a reference variable with a null value
NullPointerException
To prevent direct modifications of data fields, you should declare the data fields private, using the private modifier. This is known as _.
data field encapsulation
If a class is defined without the package statement, it is said to be placed in the __
default package
The program contains two classes. The first of these, TestSimpleCircle, is the main class. Its sole purpose is to test the second class, SimpleCircle. Such a program that uses the class is often referred to as _ of the class. When you run the program, the Java runtime system invokes the main method in the main class.
a client
To enable a private data field to be updated, provide a setter method to set a new value. A getter method is also referred to as an _ and a setter to a _.
accessor, mutator
Constants in a class are shared by all objects of the class. Thus, constants should be declared as __. For example, the constant PI in the Math class is defined as: _ double PI = 3.14159265358979323846;
final static
after the assignment statement c1 = c2, c1 points to the same object referenced by c2. The object previously referenced by c1 is no longer usefuland therefore is now known as garbage. Garbage occupies memory space, so the Java runtime system detects garbage and automatically reclaims the space it occupies. This process is called _.
garbage collection
A private data field cannot be accessed by an object from outside the class that defines the private field. However, a client often needs to retrieve and modify a data field. To make a private data field accessible, provide a __ to return its value.
getter method
TestPoint2D.java program start: import java.util.Scanner; _ public class TestPoint2D {
import javafx.geometry.Point2D;
Java supports static methods as well as static variables. Static methods can be called without creating an _of the class.
instance
Constructs a Date object for the current time.
+Date()
Constructs a Date object for a given time in milliseconds elapsed since January 1, 1970,GMT.
+Date(elapseTime: long)
Constructs a Point2D object with the specified x- and y-coordinates.
+Point2D(x: double, y: double)
Constructs a Random object with the current time as its seed.
+Random()
Constructs a Random object with a specified seed.
+Random(seed: long)
Returns the distance between this point and the specified point p.
+distance(p: Point2D): double (p1.distance(p2));)
Returns the distance between this point and the specified point (x, y).
+distance(x: double, y: double): double
Returns the number of milliseconds since January 1, 1970 GMT
+getTime(): long System.out.println("The elapsed time since Jan 1, 1970 is " + date.getTime() + " milliseconds");
Returns the x-coordinate from this point.
+getX(): double
Returns the y-coordinate from this point
+getY(): double
Returns a random boolean value
+nextBoolean(): boolean
Returns a random double value between 0.0 and 1.0 (excluding 1.0).
+nextDouble(): double
Returns a random float value between 0.0F and 1.0F (excluding 1.0F).
+nextFloat(): float
Returns a random int value.
+nextInt(): int
Returns a random int value between 0 and n (excluding n).
+nextInt(n: int): int
Returns a random long value
+nextLong(): long
Sets a new elapse time in the object.
+setTime(elapseTime: long): void
Returns a string representation for the point.
+toString(): String
Returns a string representing the date and time.
+toString(): String (System.out.println(date.toString());)
create a point2d object called p1
Point2D p1 = new Point2D(x1, y1);
A class is essentially a _, it is a _ which means that a variable of the class type can reference an instance of the class
Programmer defined type, reference type
Objects are accesses via the objects _ which contains reference to the objects
Reference variable
Constructors do not have a _ not even _
Return type, void
Constructor must have the _ as the _ itself
Same name, class
All method in the math class (Math.pow(3, 2.5) are _ defined using the _ keyword. getArea is an _ method and thus _
Static methods, static, instance, non static
for object p1 print string representation for the point
System.out.println(p1.toString());
The illustration of class templates and objects in Figure 9.2 can be standardized using Unified Modeling Language (UML) notation. This notation, as shown in Figure 9.4, is called a _ class diagram, or simply a _diagram.
UML, class
__ can be used to specify the visibility of a class and its members.
Visibility modifiers
It is a common mistake to put the _ in front of a constructor. But that makes it a method not a constructor.
Void keyword
The data field radius in the circle class is known as an __ which is tied to a specific instance of the class; it is not shared among objects of the same class. For example, suppose that you create the following objects: Circle circle1 = new Circle(); Circle circle2 = new Circle(5); The radius in circle1 is independent of the radius in circle2 and is stored in a different memory location.
instance variable (Changes made to circle1's radius do not affect circle2's radius, and vice versa.)
An object is an instance of a class. You can create many instances of a class. Creating an instance is referred to as _. The terms object and instance are often interchangeable.
instantiation
A visibility modifier specifies how data fields and methods in a class can be accessed from outside the class. There is no restriction on accessing data fields and methods from inside the class. An object can access its private members if it is defined in _.
its own class
The private modifier makes methods and data fields accessible only from within __
its own class
Java provides a system-independent encapsulation of date and time in the
java.util.Date class
You have used Math.random() to obtain a random double value between 0.0 and 1.0 (excluding 1.0). Another way to generate random numbers is to use the__, as shown in Figure 9.11, which can generate a random int, long, double, float, and boolean value.
java.util.Random class
To enable a private data field to be updated, provide a __ to set a new value. A getter method is also referred to as an accessor and a setter to a mutator.
setter method
The _ of an object (also known as its properties or attributes) is represented by data fields with their current values. A circle object, for example, has a data field radius, which is the property that characterizes a circle.
state
All the methods in the Math class are _. The main method is _, too
static
An instance method can invoke an instance or static method and access an instance or static data field. A static method can invoke a static method and access a static data field. However, a _ method cannot invoke an instance method or access an instance data field, since _ methods and data fields don't belong to a particular object
static
c1.numberOfObjects (line 27) and c2.numberOfObjects (line 30) are better replaced by CircleWithStaticMembers.numberOfObjects. This improves readability, because other programmers can easily recognize the _ variable.
static (Use ClassName.methodName(arguments) to invoke a static method and ClassName.staticVariable to access a static variable. This improves readability, because this makes the static method and data easy to spot.)
define static method numberOfObjects
static int getNumberObjects() {
/** Return numberOfObjects */ create method
static int getNumberOfObjects() { return numberOfObjects; }
static variable for /** The number of objects created */ syntax
static int numberOfObjects = 0;
declare static variable numberOfObjects
static int numberOfObjects;
If you want all the instances of a class to share data, use _ variables, also known as _ variables. Static variables store values for the variables in a common memory location. Because of this common location, if one object changes the value of a static variable, all objects of the same class are affected. Java
static, class
Note that static variables and methods are _ in the UML class diagram.
underlined
public class A { int i = 5; static int k = 2; public static void main(String[] args) { int j = i; // Wrong because i is an instance _ m1(); // Wrong because m1() is an instance __ } public void m1() { // Correct since instance and static variables and methods // can be used in an instance method ....
variable, method
Static variables and methods can be accessed _ creating objects.
without
True and false are _, null is a literal for a _.
Boolean literal, reference type
The object on which an instance method is invoked is called a _
Calling object
The following statement declares the variable myCircle to be of the Circle type
Circle myCircle;
Write s single statement to combine declaration of object reference variable, creation of object, & assigning of an object reference to the variable:
ClassName objectRefVar = new ClassName(); (Circle myCircle = new Circle();)
Declare reference variable syntax
ClassName objectRefVar;
A _ is invoked to crest an object using the _ operator
Constructor, new
A class may be defined without constructors. A public no-are constructor with an empty body is implicitly defined in the class. Called a _
Default constructor
An objects data and methods can be accessed through the _ operator via the objects _ variable
Dot, reference
Constructors play the role of _
Initialising objects
The method getArea is referred to as an _
Instance method (because it is dependent on a specific instance)
The data field radius is referred to as an _
Instance variable (because it is dependent on a specific instance)
_ variables belong to the instances and have memory storage independent of one another. _ variables are shared by all the instances of the same class.
Instance, static
The ___ contains a rich set of classes for developing Java programs
Java API
Null is a _ just like true or false
Literal
To construct an object from a class invoke a constructor of the class using the _
New operator
Constructor with no arguments
No-arg (or no argument constructor)
The data fields can be of reference types. If a data field of a reference type does not reference any object the data field holds a special Java value
Null
Object data can be accessed and its methods invoked using the dot operator also known as the __
Object member access operator
Objects of the same type are defined using a common class. A class is a template, blueprint, or _ that defines what an object's data fields and methods will be. An object is an _of a class.
contract, instance
A class is a template for _ objects
creating
A _ defines the properties and behaviors for objects.
class
When you compile TestCircleWithStaticMembers.java, the Java compiler automatically _ CircleWithStaticMembers.java if it has not been since the last change.
compiles
A Java class uses variables to define data fields and methods to define actions. Additionally, a class provides methods of a special type, known as _ , which are invoked to create a new object. They are designed to perform initializing actions, such as initializing the data fields of objects. Figure
constructors
Java API has a conveninent Point2D class in the _ package for representing a point in a two-dimensional plane
javafx.geometry
The behavior of an object (also known as its actions) is defined by _
methods
To declare a static variable or define a static method, put the _ in the variable or method declaration.
modifier static
Show constructor class creation syntax
new ClassName(arguments);
When you create a Random object, you have to specify a seed or use the default seed. A seed is a number used to initialize a random number generator. The _ constructor creates a Random object using the current elapsed time as its seed.
no-arg
/** Construct a circle with radius 1 & increase number of object by 1*/ CircleWithStaticMembers() { radius = 1; __
numberOfObjects++;
References a data field in the object. Syntax.
objectRefVar.dataField
Invokes a method on the object. Syntax.
objectRefVar.method(arguments)
The private modifier restricts access to its defining class, the default modifier restricts access to a _, and the public modifier enables unrestricted access.
package (If a class is not defined as public, it can be accessed only within the same package.)
Packages can be used to organize classes. To do so, you need to add the following line as the first noncomment and nonblank statement in the program:
package packageName;
You can use the public visibility modifier for classes, methods, and data fields to denote that they can be accessed from any other classes. If no visibility modifier is used, then by default the classes, methods, and data fields are accessible by any class in the same package. This is known as _ or _.
package-private, package-access
Every variable represents a memory location that holds a value. When you declare a variable, you are telling the compiler what type of value the variable can hold. For a variable of a _ type, the value is of the primitive type. For a variable of a _ type, the value is a reference to where an object is located.
primitive, reference
In most cases, the constructor should be public. However, if you want to prohibit the user from creating an instance of a class, use a private constructor. For example, there is no reason to create an instance from the Math class, because all of its data fields and methods are static. To prevent the user from creating objects from the Math class, the constructor in java.lang.Math is defined as follows:
private Math() {}
In addition to the public and default visibility modifiers, Java provides the _ and _modifiers for class members.
private, protected
The state of an object (also known as its _ or _) is represented by data fields with their current values
properties, attributes
A getter method has the following signature:
public returnType getPropertyName()