Misconceptions

AbstractClassMustImplementAbstractMethod

Java

DRAFT

An abstract class must implement all abstract methods defined in its superclass

Java

DRAFT

An abstract class cannot contain implemented methods

Java

Set of class members can change at runtime

All classes automatically get a no-argument constructor

Any class can be an exception class

Java

Addition has higher precedence than string concatenation

Java

DRAFT

Parenthesis are used to access an element in an array

Arrays are created without the new keyword

The number of brackets in an array type or an array initializer corresponds to the length of the array

The type of a multi-dimensional array is written as T[] T[] T[]

Java

DRAFT

Elements of arrays are untyped

Java

To get the length of an array, one needs to call its length method

Array initializers list the elements in square brackets

Java

DRAFT

An array cannot have a length of 0 elements

The length of an array is part of its type

Java

ArrayLists are arrays

Array rank and array length are the same thing

The rank of an array is not part of its type

Java

Arrays can grow dynamically

Java

= compares two values

Java

Assignment copies the object

Java

An assignment a=b is not an expression

Java

DRAFT

Recursive computations do not necessarily need a base case

The base case of a structural recursion consists of a recursive self-call

Passing null to a wrapper class constructor creates an object representing the absence of a value

Java

A method invocation on a reference of a type that does not have that method won't compile

One can invoke a method on primitive values

One needs a variable to invoke a method

A method invocation does not necessarily allocate a stack frame

Stack frame of caller includes variables for callee's formal parameters

Java

Member accesses cannot be chained together

Java

Method calls or field accesses cannot be chained to a constructor invocation

Catch blocks always get executed

Only the necessary part of a catch block executes

Java

DRAFT

Chained methods are all called on the object at the beginning of the chain

Java

Char is not a numeric type

Java

To test whether an expression is true or false, one must compare it to true or to false

Expressions that consist of multiple parts have no type

A concrete class needs to implement all methods declared in its abstract superclasses

A concrete class only needs to implement those abstract methods it inherits from abstract superclasses

A concrete class only needs to implement abstract methods declared in its direct supertypes

A concrete class only needs to implement those abstract methods it inherits from interfaces

A condition node in a control-flow graph can have a single outgoing edge

Java

If-else is equivalent to sequence of two ifs

Java

The constructor allocates the object

Formal constructor parameters are equivalent to instance variables

Java

Constructors need to return objects

One can write the constructor name, without new, to instantiate a class

Java

One can control access to local variables using access modifiers

Java

A return statement in the middle of a method doesn't return immediately

There is an elsif keyword for multi-way conditional statements

Java

DRAFT

The else branch of an if-else statement always executes

Java

o==p compares the objects referred to by variables o and p

Java

o.equals(p) compares the references stored in the variables o and p

Evaluating an expression means outputting its result

Exception is the top-most exception class

Java

DRAFT

An expression that reads a variable also updates its value after the evaluation

One has to evaluate an expression to determine its type

Java

An object referred to by a final variable is an immutable object

Java

DRAFT

An enhanced for loop iterates over the indices of an array or a collection

For-each loops know how to traverse any recursive data structure

One can assign to the variable of an enhanced for statement to store a value in the corresponding array or collection element

The body of a for statement executes at most once

The scope of variables declared in a for loop header extends beyond the loop

A stack frame is the same as an instance of a class

Java

The body of an if statement executes repeatedly, as long as the condition holds

Every if statement requires an else

Immutable classes need final constructor/method parameters

Java implicitly produces implementations of any methods a class inherits from the interfaces it implements

The expression tree of an expression involving a call inlines the call's computation of the returned value

The expression tree of an expression involving a variable inlines the variable's definition

Dividing two integers can produce a rational number

An interface can extend a class

In an intra-procedural control-flow graph, method call nodes point to the called method

Java

Large integer numbers have type long

A literal is not an expression

When passing a literal string as argument to a method, no quotes are needed

Java

Local variables are automatically initialized

Lifetime of variables declared in a loop body extends across all loop iterations

Java

DRAFT

For and while loops end when the condition becomes true

Maps can store multiple values for a given key

Map.put with an existing key does nothing

Java

To map a boolean expression to a boolean, a conditional operator is necessary

Java

To map a boolean expression to a boolean, an if statement is necessary

Each object contains its own special fields for all of its methods

A method declaration does not need to include a return type

Methods can be defined outside a class

A reference variable can point to multiple objects

A variable can contain more than one value

A multi-dimensional array is one thing

A class can have multiple superclasses

Java

Constructors must assign values to all fields

To instantiate a generic type, one needs to specify type parameter names as well as types

If objects are part of a containment hierarchy, their classes are nested, too

Packages can contain other packages

Java

Expressions must consist of more than one piece

One cannot invoke methods on String literals

If a variable is at least as big (bit-width) as a value, then no cast is needed to a assign the value to the variable

\ is a normal character in char and String literals

Java

A constructor must do something

An object contains only the fields declared in its class

Objects without instance variables can't exist

Java

There are no float literals

Java

DRAFT

Smaller types are never automatically converted into bigger ones without an explicit cast

Java

DRAFT

It is foirbidden to call other methods on the same object while inside its constructor

Multi-dimensional arrays have a rectangular shape

There are no local variables

Java

There are no long literals

Java

DRAFT

Subclasses inherit fields but not methods

Java

Every sequence of letters and digits starting with a letter can be used as an identifier

Java

&& and || always evaluate both operands

Java

& is only a bitwise AND

One cannot invoke toString() on a String

Java

null is an object

Java

DRAFT

NullPointerExceptions are detected at compile time

Numeric types can be coerced to boolean

In stack and heap diagrams, an object on the heap is labeled like a stack frame of a constructor call

In stack and heap diagrams, an object on the heap is labeled with the name of the variable that refers to it

Java

A variable is needed to instantiate an object

Only the elements of the innermost array of a multi-dimensional array are accessible

Only the creators of the JDK can create packages

Out-of-bounds array elements are null

Java

Nested method calls are invoked outside in

Java

() are optional for method calls without arguments

Pre-increment in update part of for loop means increment before loop body

Primitive values are heap objects

Type parameters of generic types can be assigned primitive types

The type of a primitive variable depends on its value

println(...) starts a new line and then prints

Java

DRAFT

Private members of a superclass are accessible from a subclass

A class where all fields are private is immutable

Java

An object cannot access private members of other objects of the same class

Java

Static methods cannot access private members of instances of same class

A private field cannot be changed

Rational fractions are literals

Java

Recursive calls of a method share a stack frame

Tail-recursive call sites have no continuation

Java

A class with a recursive method represents part of a recursive data structure

Java

A recursive method needs to contain an if-else statement

References can point into the stack

In stack and heap diagrams, reference variables are labeled with the types of the objects they refer to

Every reference type can be coerced to boolean

One can cast between references and ints

Java

References can point to variables

A class referring to a recursive data structure is (indirectly) part of that recursion as well

Java

Return statements need () around the return value

In a control-flow graph, a return statement has no outgoing edge

Java

A return statement can unwind multiple call stack frames

Java

Chained accesses are invoked from right to left

RuntimeExceptions are checked exceptions

Two pieces of code with the same observable behavior have to be implemented in the same way

Setter methods are static

String literals can be in single quotes

A stack trace is the sequence of previously called methods

A non-condition node in a control-flow graph can have multiple outgoing edges

A static method call is dispatched polymorphically at runtime based on the argument types

Java

DRAFT

The method to be called is determined by the static type

Stack frame of static method calls lives in the global memory area

Java

DRAFT

One can know the length of a String object by accessing its length field

Java

One needs to call the String constructor to get a String object from a literal

Java

String concatenation stringifies non-String operand expressions

Java

DRAFT

The multiplication operator can repeat a String a number of times

Java

DRAFT

A variable of a subtype can reference an object of a supertype

Java

DRAFT

To call a method on a superclass, parentheses are needed after the keyword super

Java

DRAFT

super() can be called anywhere in the constructor of a subclass

Java

DRAFT

When instantiating an object of a subclass, an object of a superclass is also allocated

Java

DRAFT

A variable of a supertype cannot reference an object of a subtype

The type of a numerical expression depends on the type expected by the surrounding context

this is a special field in the object

Java

One can assign to this

Java

this can be null

Instance method or constructor call nodes in expression trees have a child labeled "this"

Java

this is a local variable, also in static methods

In a constructor, this is null

Java

The name this is not an expression

Invoking toString() prints something

If code could throw an exception, you must surround that code with a try/catch block

Exceptions get thrown at the end of the try block

Variables don't need to be declared

The unqualified names of different classes must be different

Variable declarations don't need a type

If a class has a method that has a local variable, parameter, or return value with the class as its type, the class is a recursive type

Java

= stores an expression in a variable

Java

A variable of a reference type contains a whole object

A method with void return type can't be recursive

A method with void return type can return a value

In integer numbers, decimal digits with value `0` take less storage than decimal digits with other values

A control-flow graph node (other than the entry node) can have zero incoming edges

A control-flow graph node (other than the exit node) can have zero outgoing edges

Misconceptions

Find Misconceptions by...

About

Stay up-to-date