Test 1

Question 1

platform dependent

Answer 1

Executable files created from most high-level language source code files are platform dependent. Since such executables are actually machine language files, each can be run only on a certain kind of computer with a particular operating system.

Question 2

Java bytecode

Answer 2

Java compilers do not create machine language files. Instead, they create files of Java bytecode.

Question 3

Java Virtual Machine

Answer 3

To run a Java program, you must translate the Java bytecode into machine language through a program called the Java Virtual Machine (or Java VM for short). The Java VM is an interpreter, taking the Java bytecode and executing it directly as it translates it into the machine language of the execution platform.

Question 4

portable.

Answer 4

Java bytecode is the same on all computers. Bytecode produced by a Java compiler on a Mac can be run on UNIX or Windows systems, and vice versa! That means Java programs are portable. As long as a machine has a Java VM, it can run Java bytecode produced on a completely different kind of system.

Question 5

Java API

Answer 5

The Java language comes with a large library of code

Question 6

packages

Answer 6

The Java API is organized into packages. Each Java API package consists of related classes that provide all sorts of things from graphical user interface components to code for handling security
The name of each package in the Java API is in the form

java. or javax.

Question 7

JRE

Answer 7

Java runtime environment. You must have a copy of the JRE on your system to run Java applications and applets. The JRE contains the JavaVM and the runtime libraries required to execute java programs.

Question 8

JDK

Answer 8

Java Development Kit (formerly known as the SDK). To develop Java applications and applets, you need the JDK, which includes the JRE.

Question 9

applets

Answer 9

Java applets are special applications that must be run through a web browser or a special “applet viewer.” When a web page with an embedded applet is downloaded, the local Java VM executes the applet.

Question 10

servlets

Answer 10

Java servlets are special applications that run on the server side of a client/server architecture. They are often part of interactive Web programs.

Question 11

Control flow diagrams

Answer 11

Control flow diagrams are graphs that use the following notations:

Rectangles represent statements (the statement goes inside the rectangle).
Diamonds represent decisions, including loops (the condition goes inside the diamond).
The connections between rectangles and diamonds, rectangles and rectangles, and diamonds and diamonds indicate the flow of control of execution.

Question 12

Software metrics

Answer 12

Metrics are quantitative measures (applying a metric gives an actual number). They are supposed to be objective, consistent, and reproducible. There are ongoing attempts to make them relevant to management of software projects. Numerous software metrics cover a variety of properties from lines of code to number of lines of customer requirements!

Question 13

Cyclomatic complexity

Answer 13

(also called conditional complexity) is a software metric that measures the number of execution paths through a method. Cyclomatic complexity was developed in 1976 by Thomas McCabe.

Cyclomatic complexity has a formula:

Cyclomatic complexity = #decisions + 1

Question 14

Code coverage

Answer 14

Code coverage is a software testing metric. It measures how much of a program’s source code has been tested.
Method coverage. Did you execute each method?
Statement coverage. Did you execute each statement?
Condition/Decision coverage. Was each part of each condition tested with true values and false ones?

Question 15

Static analysis

Answer 15

means analyzing your code without executing it.

Static analysis includes:

Code inspections and walkthroughs
Identification of code that is likely to cause errors

Question 16

version control system (VCS)

Answer 16

is a software application that enables users to collaborate on authoring and files.
The VCS does version tracking by automatically recording changes to each file in the repository. The record of changes is called the revision history.

Question 17

Index (or Staging area)

Answer 17

A file that keeps information on which files will be committed as part of your next revision.

Question 18

Working directory

Answer 18

The folder that holds the actual files that you do your work on. This is your workspace.

Question 19

HEAD

Answer 19

A file that points to the most recent versions of the files.

Question 20

interface

Answer 20

An interface spells out the services that classes must provide by declaring methods but not defining them. Any concrete class that implements an interface defines all of the methods that the interface declares. An interface is essentially a development contract. It ensures that a particular object provides a given set of methods.

Question 21

characteristics of interfaces

Answer 21

An interface is declared with the keyword interface.
Interface methods can be abstract (not defined), default (must be called by an instance of a class that implements the interface), or static (must be called by the interface name).
Interface methods that are abstract, static, or default are automatically public.
Methods canot be defined in the interface (no method body) unless they are declared as static, default, or private.
Static interface methods are defined, and they must be invoked via the interface name rather than via any implementing class.
If an interface declares a data member, it is automatically public, static, and final.
Interfaces do not have constructors.
Interfaces are documented exactly like classes.

Question 22

Implementing interface without defining methods

Answer 22

If a class implements an interface without defining all of the methods declared in the interface, then the class must be abstract.

Question 23

declaring interface

Answer 23

You can declare a variable as an interface type.
ForSale x; // declaration

But you cannot instantiate it with the interface.
   x = new ForSale(); // DOES NOT WORK

You can instantiate it with a concrete implementing class.
    x = new AirplaneTicket("LHR", "RDU", 988.0);

You can call any of the interface methods on it directly.
if (x.isExpensive()) …

You must cast to its runtime class type before using methods not declared in the interface.
    System.out.println(((AirlineTicket)x).print());

Question 24

Static and default interface members

Answer 24

Static interface methods are defined in the interface itself. That is, a static interface method has a body that defines its actions. These methods are called without an instance. They are public.
Default interface methods are also defined in the interface. These methods are also public and they provide a default implementation that the implementing classes can optionally override.
You should call static interface methods with the interface name.

Question 25

base class

Answer 25

In program design, a base class enables you to factor out what is common and customize what is different among objects with related shapes and behaviors.

Question 26

child

Answer 26

create a new base class, then extend that base class to create other classes. A class that extends the base class is called a child of the base.

Question 27

Null constructors in parents

Answer 27

If you do not declare any constructor in a class, Java provides a default null constructor.
If you declare a non-null constructor in a parent class but no null constructor, then constructors of its children must make explicit calls to super.

Question 28

class hierarchy

Answer 28

A class hierarchy consists of a superclass and its descendants.

Question 29

Everything is an Object

Answer 29

Every Java class that does not extend another class is considered to be a child of Object, which is a class in the java.lang package. Every class is part of the Object class hierarchy.

Question 30

overloaded

Answer 30

When two methods in the same class have the same name, then the method is said to be overloaded. There are several examples of overloading in the Vehicle class hierarchy:

Question 31

overrides

Answer 31

When one method in a child class has the same signature (the same name and formal parameter list) as a method in the base class, then the child class method overrides the base class.
There are some restrictions on overriding.

Static. If a method is declared static in the base, only another static method can override it.
If a method is declared static in the child, any method it overrides must be declared static.

Access control. A method that overrides a base class method cannot have more restrictive access than what was declared in the base.

Question 32

hidden

Answer 32

If a subclass declares a field (data member) with the same name as one declared in the base, the base class data member is said to be hidden.

Question 33

substitution principle

Answer 33

Inheritance in Java follows the substitution principle – whenever a base class type is expected, a child (or descendent) will suffice.

Question 34

downcasting

Answer 34

casting down a class hierarchy (from ancestor to descendent, and it is called downcasting.

Question 35

Polymorphism

Answer 35

means that objects respond to messages according to their actual types at runtime rather than their declared types. Polymorphism is also called runtime binding or late binding. That is because you cannot always tell what type of object a reference actually points to until the program is executing.
Note: Polymorphism occurs in the contexts of inheritance and interfaces.

Question 36

Polymorphism with interfaces

Answer 36

Interfaces are the primary feature of Java that supports polymorphism. With polymorphism, you don’t have to know how a class defines a particular operation, you simply need to know that it does provide it.

Interfaces cannot be instantiated. But you can declare a variable to be an interface type. That variable can reference an instance any class that implements the interface.

Question 37

Casting

Answer 37

Casting is required when you attempt to call a method for an object that is not declared in the object’s declared type. The first section of this lesson described casting in the context of an inheritance hierarchy. But it can also be used with interfaces. Again, you need to be careful. Attempts to cast to improper types generate ClassCastExceptions.

Question 38

abstract method.

Answer 38

A method that is declared but that does not have a body is an abstract method. You must declare such a method with the keyword abstract, like this:

public abstract String instructions();

Question 39

abstract class,

Answer 39

Any class with an abstract method is an abstract class, and it must be declared with the keyword abstract. Classes that are not abstract are sometimes referred to as concrete classes.
Names of abstract methods and classes in UML diagrams are typically in italics.
Any child class that does not define the abstract method instructions() must also be declared as an abstract class.
Here are the defining characteristics of an abstract class:

A class that contains abstract methods must be declared abstract .
It is not possible to create instances of an abstract class.
A class that does not contain abstract methods can also be declared abstract. This is done to make it impossible to create instances of a class.
Every concrete class that extends an abstract class must provide implementation for all abstract methods.

Question 40

Flexibility of interfaces

Answer 40

An interface simply specifies behaviors. It is the responsibility of the implementing class to define those behaviors.

Question 41

Object

Answer 41

Object defines 11 methods. Four of them are relevant to this course:
public boolean equals(Object o). Indicates whether two Objects are equal. If not overridden, this method returns true if and only if the two Objects have the same identity.
public Object clone() throws CloneNotSupportedException. Returns a duplicate (a clone -- a bitwise copy) of this object. The new Object has the same state as the original. A call to clone() works only if the class type implements Cloneable, else a CloneNotSupportedException is thrown.
public int hashcode(). Returns the hashcode that Java assigns to this object. Hashcodes are used by some code in the Java API for lookups and retrievals.
public String toString(). Returns a string representation of the object. If not overridden, this method returns the address of the object.`

Question 42

CLoning an object

Answer 42

public class Thermometer implements Cloneable {
   // ... rest of class definition       
   public Object clone() throws CloneNotSupportedException {
      try {
         return super.clone();
      } catch (CloneNotSupportedException e) {
         throw new CloneNotSupportedException();
      }
   }

Cast is required when calling
Here are some things you should note about the code:

Calls to clone() must take place inside a try/catch block.
If the class does not implement Cloneable, any attempts to call clone() for an instance of the class generated a CloneNotSupportedException.
If a class whose parent is Object does not override clone() to be public, then clone() for that class will not be visible outside the java.lang package.
The return type for clone() is Object. So you must cast to the class for which you are calling clone(). This is illustrated by the statement
Thermometer y = (Thermometer)x.clone();

Question 43

Shallow/deep copy

Answer 43

Unless you override clone(), it returns just a bitwise copy of an object. If the only data members of the object are primitive, this would likely suffice. However, if the instance that is cloned contains a reference to another object (a composition relationship), the clone would contain a reference to the same object. This is what is called a shallow copy. The alternative is for the resulting object to contain a clone of the shared object instead. That would be called a deep copy.

Question 44

Access levels

Answer 44

There are four access levels:

public. Visible to “the world,” which means to all other classes independent of their relationship to the class where the member is declared.
private. Visible only to the class in which it is declared.
protected. Visible only to child classes and classes in the same package. Child classes in different packages must access the member through super or this rather than through a local variable or instance variable.
default (also called package-private). Visible only to classes in the same package. These members are declared with no access modifier.

Question 45

problem domain

Answer 45

A software architect, who designs the solution, might start work by asking “What are the nouns that are important in modeling the problem?” The problem domain, which is the critical context in which the problem lives, suggests several noun

Question 46

three other kinds of classes: besides nouns

Answer 46

View classes. These provide the user interface (can be graphical or non-graphical).
Data consumer/generator classes. These could be used for reading/writing data from/to files, or for generating data from within the program itself.
Helper classes. Examples of helper classes include those that do computations or provide internal data structures.

Question 47

collaborators

Answer 47

These are its collaborators. Collaboration occurs when a class needs things that it does not have, and it uses other classes to help fulfill its responsibilities.

Question 48

CRC card

Answer 48

The class name is written at the top.
The responsibilities are listed on the left.
The collaborators are listed on the right.

Question 49

Limiting responsibilities

Answer 49

The reason designers limit themselves to 3 x 5 or 4 x 6 cards is to prevent them from putting too much into a single class. Classes that have too many responsibilities are notoriously difficult to implement correctly and impossible to maintain.

Question 50

Cohesion

Answer 50

When you design a class, the members of that class and the operations of that class ought to form a single, coherent unit. Cohesion is the degree to which the members of a class are related to the general purpose of the class. The various class elements should be as closely related as possible.

Question 51

dependency or coupling

Answer 51

Classes in a model can be connected in many ways. For example, a class can contain a member that is another class type, or a class can have an operation that requires another class to complete. Such a connection is called a dependency or coupling. If you change one class, then you may need to change the other. You can have dependencies among classes and among packages.

Question 52

Coupling vs cohesion:

Answer 52

Coupling and cohesion are usually considered in relation to each other. When you are designing, try to keep coupling low and cohesion high.

Question 53

Encapsulation

Answer 53

Encapsulation means gathering together into one package or class all aspects of the entity modeled by that package or class. A consequence of encapsulation is that class data members should be private so they cannot be directly manipulated outside the class. The concrete details of how a class works are hidden inside the class.

Question 54

Principle of Least Knowledge

Answer 54

Finally, there is the Principle of Least Knowledge, which is a design guideline for developing software invented 30+ years ago at Northeastern University. It remains solid as a best practice today. The Principle of Least Knowledge holds that each unit should have only limited knowledge of other units (to which is should be closely related). The fundamental notion is that a given object should assume as little as possible about the structure or properties of anything else, including its subcomponents!

Question 55

information hiding

Answer 55

The term information hiding means designing a class so that the implementation details for the class are hidden from other classes.

Question 56

class diagram

Answer 56

A class diagram of a system (or part of a system) shows its classes and the relationships between them. It is a “static” snapshot that shows how classes are related but not how they interact.

Question 57

associations.

Answer 57

The class at the beginning contains an instance (or static) variable of the type of the class at the end.

Question 58

Aggregate/Composition

Answer 58

These are kinds of associations. The class at the beginning has a variable (or collection of variables) of the class type at the end. For example, if class A has an array of objects of type class B, then an aggregate would connect A to B. Composition is a stronger form of aggregation, in which the contained object (type B, at the tail) cannot live in the absence of the containing object (type A, at the head).

Question 59

Generalization (Inheritance)

Answer 59

Used with inheritance. The class at the beginning of the link is derived from the class at the end.
Generalization links are solid lines with triangular arrowheads at the end (at the "generalization" end). Arrowheads are required.

Question 60

Realization (Implementation)

Answer 60

Used with interfaces. The class at the beginning defines all of the methods declared in the interface, which is at the end.

A realization link is dotted, and it has a triangular arrowhead at the end. Arrowheads are required.

Question 61

package

Answer 61

A package consists of one or more .class files that occupy a single directory. The Java source for each class must appear in a file that contains a package statement as its first statement, and the name of the package must be identical to its directory name. There is a dependency from package A to package B if changes in a class in B require changes in a class in A.

Question 62

namespaces

Answer 62

Programmers use packages to group related classes together and to create namespaces, which determine how a particular name is to be used in a particular context.

Question 63

sequence diagrams

Answer 63

Sequence diagrams show what happens when a single message is sent. While class diagrams reveal the architecture of the system, sequence diagrams reveal the actions. For that reason, sequence diagrams are often called dynamic diagrams.

Messages are method calls from one object to another. The top of a sequence diagram shows the objects that whose methods are called. Below each object is its lifeline, which is a dotted line in the diagram that represents the life of the object. The lifeline has a long rectangular bar that represents its activation record (when the call is on the runtime stack). An arrow from one bar to another represents a method call.

Question 64

exception

Answer 64

An exception is a signal that an unusual condition has happened, usually something has gone wrong. If the exception is not handled, the program might crash or (perhaps worse) work on corrupted data. In any case, the result of an unhandled exception is that the JVM prints a message showing the name of the exception and the call stack trace showing where it originated.

Question 65

The words try, catch, throw, throws, and finally are keywords:

Answer 65

try. Keyword before a block of code where a possible exception is anticipated.
catch. Keyword before a block of code that handles the exception.
throw. Keyword to indicate a new exception object.
throws. Keyword on a method declaration to indicate the method might throw an exception.
finally. Keyword to preface the wrapup code from trying code and catching exceptions.

Question 66

unchecked exceptions

Answer 66

These are RuntimeExceptions. Your code is not required to do anything about them. When an unhandled unchecked exception occurs, the JVM prints a stack trace. The program might or might not stop executing, depending in part on whether it is console based or GUI driven.

Question 67

checked exceptions

Answer 67

Your code must catch them or explicitly throw them back to the calling code to handle. Examples are FileNotFoundException and IllegalAddressException.

Question 68

Error

Answer 68

An Error, which is distinct from an Exception, is an indication of a very serious Java error. Examples include JVM errors and thread death errors. Error and Exception have a common super/parent class, Throwable. Java allows you to catch Errors, but you should not without a really, really compelling reason!

Question 69

catch (Exception e)

Answer 69

catch (Exception e) catches any exception. If you want to be able to catch any exception, put it in front of your last catch block.

You should always order your catch blocks from most specific to most general. For example, catch for NumberFormatException would come before catch for Exception.

Question 70

multi-catch exceptions

Answer 70

catch (ExceptionType1 | ExceptionType2 name) {
code to execute if either ExceptionType1 or ExceptionType2 occurs
}

Question 71

Finally blocks

Answer 71

A try block can have a corresponding finally block. If any code in the try block is executed, then the code in the finally block is guaranteed to be executed. This happens even if an exception occurs.

Question 72

library

Answer 72

A library is a built-in or 3rd party collection of code that can be used in mulitple programs. Libraries promote code reuse, offering tools to complete common tasks. Examples of libraries are almost endless, including familar ones such as core Java API and JUnit.
Java libraries are deployed as JAR files (Java ARchive).

Question 73

Application Programming Interface

Answer 73

An API, which stands for Application Programming Interface, is a specification for a library. Java APIs come as collections of web pages that describe:

The public classes, interfaces, and methods of the corresponding Java class libraries.
What functionality is available for you (the client) to use from these libraries.

Question 74

Javadoc

Answer 74

Javadoc is a tool for creating a type of documentation from Java source code. It is the standard doclet, which is a Java program that generates files of the documentation content that are formatted in a particular way.

Question 75

use case

Answer 75

A use case is a step-by-step, detailed description of how the software system provides a service to a user. For example, the set of use cases for an online banking system would include one that described exactly how a user could view an account balance. Use cases can be very complicated, depending on the amount of detail required for the developers.

Question 76

Waterfall software development

Answer 76

Waterfall software development is a traditional approach to software development. With waterfall, one phase is completed before the next begins. Go back to the previous phase only if necessary. Waterfall has its drawbacks:

It tends to be brittle, forcing delays in one phase when another drags on. For example, spending a long time analyzing requirements can mean too short a time for implementation.
Waterfall is called heavyweight because there is no flexibility in the order.
Waterfall promotes breaking teams into specialties – designers cannot do analyis or code, for example.
Waterfall makes revisions in requirements or any prior phase difficult to manage once a successive stage has begun.

Question 77

agile or lightweight

Answer 77

Agile methodologies place a heavy emphasis on collaboration with the customer throughout the development process. These methodologies allow (and welcome) changes in requirements, even when coding is well under way or even “completed.” Software developers recognize that requirements naturally evolve over time. It is almost impossible for the customers for a software project to spell out in detail all of the features and behaviors they want that software to provide. In effect, analysis occurs throughout the entire development.

Question 78

iterative development

Answer 78

Agile methodologies support iterative development with frequent production of working versions of the final system that have a subset of the required features. Each version brings new features.`

Question 79

Refactoring

Answer 79

means rewriting code without the intent of changing its logic. It includes:

Question 80

Finite State Machine

Answer 80

(FSM) is a computational model consisting of a finite number of states and the transitions between them.

States represent memory. They are the internal information of what has already occurred. FSM is in exactly one state at a time.
Transitions represent the reponse of the model to input. Each transition depends on the current state and input. Transitions can (and usually do) move the FSM from one state to another.

Question 81

transition table

Answer 81

You can also describe a finite state machine with a transition table. Each row in the table represents a state. Each column represents the input to the machine.

Question 82

State Design Pattern

Answer 82

The State Design Pattern describes an object-oriented approach to FSM problems. The different states are objects, which behave according to their actual types. These states are incorporated into a context, which is another object.

Question 83

design pattern

Answer 83

A design pattern is a template for a solution to a commonly occurring software modeling problem. You have already applied a modification of at least one well known design pattern, Model-View-Control. The State design pattern, which is also well known, was discussed in the FSM lesson.

Question 84

MVC is an acronym for the Model-View-Control

Answer 84

This formal design pattern is applied to create programs whose user interface is largely independent of the backend model. Java swing, which bundles the View and the Control part together, enables us to follow a modified version of MVC. (Technically, with MVC, the Model communicates with the Control only. The Control communicates with both the Model and the View.)

The important lesson of MVC is that the logic of the backend model is not incorporated into the view (the frames, buttons, labels, and everything else you can see). It is also not incorporated into the control (the actionPerformed or like methods). Instead, the backend logic can stand alone. You can use the identical backend model with different user interfaces.

Question 85

The GoF book organizes software patterns

Answer 85

Creational patterns, for creating objects
Structural patterns, for composing classes and objects to form larger structures
Behavioral patterns, for communication among objects

Question 86

s`ingleton design pattern

Answer 86

ensure a class has only one instance, and provide a global point of access to it. " *
There must be only one instance of the class.
The class must instantiate itself.
The instance must be accessible to client classes.
The class must maintain its own data.

Question 87

Adapter

Answer 87

“convert the interface of one class into another interface clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces. *

Question 88

aliases

Answer 88

The picture below shows two objects. The one on the left has two names, myBedsideClock and myAlarmClock. Those names are called aliases since they refer to the same object. A class is a description of a type of object. The objects in our figures are instances of the AlarmClock class.

Question 89

instance variables

Answer 89

They cannot be directly accessed from other classes – they can be used only in the Thermometer class methods. Data members such as these are called instance variables.

Question 90

pass-by-value

Answer 90

When a method is called, each actual parameter is evaluated, and the value is copied into the memory for the formal parameter. So the formal parameter becomes a new, initialized variable for the execution of the code.
If the formal parameter is a primitive type (such as int or bool), then it is completely independent of the actual parameter except for that initial value. During method execution, changes to the formal parameter have no impact on the actual parameter.
If the formal parameter is a class type that is initialized with a non-null reference to an object, then the formal parameter becomes an alias for that object. Any changes made to the object through the alias will remain after the method stops execution. 
Versus passed-by-reference: The object that the Thermometer parameter refers to is passed by reference

Question 91

Scope and Access

Answer 91

While it might seem that scope and access (public, private, etc.) are related, they are not. Public methods, which have class scope, can be accessed outside of the class using an object of the class type. But they cannot be referred to directly, without any object or class modifier (as in object.method as opposed to method).

Question 92

class methods

Answer 92

Methods such as main that are static are class methods. They are independent of any instance of the class (independent of any object). Variables that are static are not instance variables. Instead they are class variables – they are shared by the entire class.

Question 93

Static methods

Answer 93

Methods that are declared static can access only other members that are declared static.
It is illegal for a static method to access instance variables (non-static data members).
It is illegal for a static method to use the keyword this.
It is illegal to create a static variable that is local to a method. Static variables must be class members instead.

Question 94

namespaces

Answer 94

You can give two different classes the same name as long as they are in different packages. The packages provide namespaces so that the compiler can tell which class belongs to which name referred to in the code.

Question 95

package access

Answer 95

Classes or class members can have package access, which means any class in the same package can access them.
You can compress a package into a single JAR file (Java archive), which is convenient for deploying applications or downloading.

Question 96

package statement

Answer 96

To create a package, put a package statement as the first line in the source code file. Here are some examples:

package csc257;
package graphics;
package com.abc.textutils;
package edu.ncsu.csc216.project1;
Each class in the same package must have the same package statement. Any class that does not have a package statement is in the unnamed or default package.