Java: A Beginner’s Guide (8th Edition)

  1. Java Fundamentals
    • The History and Philosophy of Java
      • created at Sun Microsystems to be a platform-independent language
      • originally targeted for embedded consumer electronics
      • blew up due to the world wide web
      • internet populated with many types of computers, operating systems, and CPUs
      • adopted syntax from C and object model from C++
      • Java simplified internet programming and addressed portability and security
      • security by confining application to Java execution environment preventing it from accessing other parts of the computer
      • a key part is the bytecode which is executed by the JVM (Java Virtual Machine) which is part of the JRE (Java Runtime Environment)
      • All JREs understand the same Java bytecode
      • While Java was designed as an interpreted language, supports on-to-fly compilation of bytecode to native code
      • java has been moving to a quicker time-based (6-months) release cycle
    • Object-Oriented Programming
      • OOP is central to language
      • OOP grew as a way to help programmers manage complexity
      • organize programs around data “data controlling access to code”
      • encapsulation
        • binds code and data (black box)
        • the basic unit is a class in Java
        • typically public parts which provide a controlled interface
      • polymorphism
        • allows one interface to access a general class of actions
        • “one interface multiple methods”
      • inheritance
        • allows an object to acquire properties of another object
        • hierarchical classification
        • without using hierarchies, each object would have to explicitly define all of its characteristics
    • Handling Syntax Errors
      • highlighted by compiler
      • the error may not always reflect the actual cause of the problem
    • Another Data Type
      • int represents whole numbers
      • also can use float or double (more common) to represent partial numbers
      • different types allow for efficient programs
      • by choosing different types, Java allows you to make best use of system resources
    • Two Control Statements
      • if statement helps determine program execution “if(condition) statement”
      • for loops allows for repeated execution of code “for(initialization; condition; iteration) statement”
    • Create Blocks of Code
      • enclosed by opening and closing braces “{}”
      • statements inside a block form a logical unit
    • Semicolons and Positioning
      • semicolons act as separators
      • Java does not recognize the end of the line as a terminator
    • Indentation Practices
      • java is free-form so indentation is not required, but is recommended to do so for readability
    • The Java Keywords
      • There are 61 keywords which are reserved
    • Identifies in Java
      • names of methods, variables, or other user-defined items
      • can not start with digits
    • The Java Class Libraries
      • Java is the language itself plus the standard classes
      • part of becoming a Java programmer is learning how to use them
  2. Introducing Data Types and Operators
    • Why Data Types are Important
      • strong type checking helps prevent errors and enhances readability
    • Java’s Primitive Types
      • data types
        • boolean: true/false
        • byte: 8-bit int
        • char: Character
        • double: double-precision floating point
        • float: single-precision floating point
        • int: Integer (32-bits)
        • long: long integer (64-bits)
        • short: short integer (16-bits)
      • java specifies strict ranges which all JVMs must support
      • allows programs to be fully portable
    • Integers
      • byte, short, int, long
      • no unsigned ints in java
    • Floating-Point Types
      • floats are 32 bits and doubles are 64 bits
      • double more commonly used
    • Characters
      • 16-bit type unicode
      • can increment or add like ints
    • Boolean
    • Literals
      • fixed values that are represented in their human-readable form
      • char are single quotes e.g. ‘C’
      • ints are numbers without fractional components. e.g. 3
        • 3L for long
      • floating-point has decimal points e.g. 3.3 (defaults to double)
      • floating-point with float type 3.3F
      • underscores allowed for numbers (e.g. 444_444) which can be useful for part numbers, customer ids, etc
    • Hexadecimal, Octal, and Binary
      • hexadecimal: 0X prefix
      • octal begins with zero
      • binary begins with 0B
    • Character escape sequences
      • can embed in strings e.g. “A\nB”
    • A Closer Look at Variables
      • variable types cannot change during its lifetime
      • all variables must be declared prior to use
    • The Scope and Lifetime of Variables
      • variables can be declared within any block
      • a block defines a scope
      • variables defined inside scope not visible outside it
      • variables are created when the scope is entered and destroyed when left
      • no variable declared within an inner scope can have the same name as a variable declared by an enclosing scope
    • Operators
      • perform specific mathematical or logical manipulation
      • careful when using ints e.g. divide will truncate the remainder
      • prefix increment applies increment and returns value while postfix returns value first then increments
    • Relational and Logical Operators
      • ==, !=, >, <, >=, <=
      • &, |, ^, || (short-circuit), && (short-circuit), !
    • Assignment Operator
      • yields value on the right-hand
      • allows “x = y = z = 100” to work
    • Shorthand Assignments
      • e.g. x += 10;
      • can be used with arithmetic and logical operators
    • Type Conversion in Assignments
      • when compatible types are mixed the right side is automatically converted to the type on the left
      • types must be compatible and the destination type must be larger than the source type
      • e.g. assigning int to a float type
    • Casting Incompatible Types
      • form of “(target-type) expression”
      • when casting involves a narrowing conversion, information might be lost e.g. going from long to short
    • Expressions
      • can mix different data types
      • different types can be converted to the same type
      • char, byte, and short are promoted to int
      • if one operand is a long, the whole expression is promoted to a long
      • if one operand is a float, the whole expression promoted to a float
      • if any operand is a double, whole expression promoted to a double
      • can result in unexpected results e.g. operating on two bytes can result in an int type
    • Spacing and Parentheses
      • use spaces to help with readability
      • parentheses can be used to increase the precedence of operations
  3. Program Control Statements
    • Input Characters from Keyboard
      • read character from System.in.read()
      • by default input is line-buffered
      • helps make our program more dynamic
    • if statement
      • for nested ifs, else statement always refers to the nearest if statement that is within the same block
    • if-else-if ladders are evaluated top-down and execute when there is a match
    • switch statements
      • provides multiway branch
      • needs to break after each case or else will run other cases
      • can nest switches and use the same case constants
    • for loops
      • can increment multiple variables
      • can leave out initialization, condition or iteration sections
      • can declare control variables inside the loop e.g. for(int i = 0;;) to keep it only in that scope
    • while loops keep running until a condition is false
    • do-while loop: when needs to execute at least once
    • break
      • can be used to exit the most immediate loop
      • can add labels to specify which block to exit but must be the label associated with enclosing block
    • continue
      • goes to the next iteration of the for loop
      • can also use labels here
    • can nest for loops
  4. Introducing Classes, Objects, and Methods
    • Class Fundamentals
      • class is a template that defines the form of an object
      • specifies data and code that will operate on that data
      • objects are physical instances of the class
      • methods and variables called members
      • data members are called instance variables
      • a class should group logically connected information
      • objects have their own copy of the instance variables
    • How objects are Created
      • variables for objects hold a reference to them
      • new operator dynamically allocates memory for an object and returns the reference
    • Reference Variables and Assignment
      • for primitive types, variables receive a copy of the value
      • for objects, they receive a reference
    • Methods
      • can use instance variable names without dot operator
      • this is implicit
      • return to exit if void return a value otherwise
    • parameters
      • pass in arguments
      • passed in arguments are parameters of the method
    • Constructors
      • default exists for all classes, sets instance variables to null, false, 0
      • define by using name of class and can pass in parameters to initialize instance variables
    • new operator
      • can fail if not able to allocate memory
    • garbage collection
      • recovers free memory
      • does it when there is no reference to an object and there is a reason to recycle
    • this keyword
      • refers to the object
      • is implicit by default
      • maybe useful to use if the method parameter has the same name as an instance variable
      • by default, the local name hides the instance variable
      • can unhide by using this
  5. More Data Types and Operators
    • Arrays
      • can have more than one dimensions
      • easily manipulated
      • arrays are objects
      • multidimensional arrays represented with additional brackets e.g. int[][] or int[][][]
      • nested arrays can have different lengths for inner arrays
      • “int counter[]” and “int counter[]” are both valid and common
    • For-Each Style Loop
      • can cycle through the array with “for (num: nums)” syntax
      • don’t need to initialize, increment, track termination or boundaries
      • can exit with break
      • can not change contents of the array by assigning the iteration variable a new value
    • Strings
      • array of characters
      • Strings are also objects
      • string literals created and reused
      • contents of strings are immutable
      • can be used in switch statements after java 7
    • Command-Line Arguments
      • args of the main method
    • Type Inference with Local Variables
      • can only be used for local variables not instance variables, parameters, return type
      • don’t have to specify type if the variable is initialized
      • var avg = 10;
      • useful for user-defined classes
      • can use in for loop “for (var x: arr)”
      • only one can be declared at a time and cannot use null as the initializer
      • only available after Java 10
      • be careful about reducing readability
    • Bitwise Operators
      • &, |, ^, >>, <<, >>>, ~
      • can be used on long, int, short, char, or byte
      • useful for bit manipulation, masks, etc
    • The ? Operator
      • ternary
      • condition? if-true : if-false
  6. A Closer Look at Methods and Classes
    • Controlling Access to Class Members
      • default access is public
      • prepend members with “private” to make only accessible in within class
      • “protected” used in inheritance
      • helps with encapsulation and keeping internals hidden
      • can force invariants with access methods
    • Pass Objects to Methods
      • primitive types passed by value
      • objects types passed via reference
    • Method overloading
      • name methods the same, but must have different parameters
      • cannot overload changing only the return type
      • helps with polymorphism
      • will try implicit conversions if an explicit method that can handle doesn’t exist
      • don’t overload names of unrelated methods
      • can also overload the constructor
    • static
      • when you want to define member independent of an object
      • can be used without reference to the object
      • can act as a global variable for the class
      • all instances of the class share the same static variable
      • do not have a this reference
    • static blocks
      • executed when class is first loaded
      • can be used when certain actions must occur before object initialization
    • nested and inner classes
      • classes defined within a class are bound by the outer class
      • inner classes can access members of the outer class
    • varargs
      • methods can have variable length parameters
      • “(int … v)” format
      • acts as an array
      • must be last parameter
      • cannot have more than one type of varargs
      • can overload
      • may have errors if there is potential ambiguity e.g. can’t tell type of passing with no args and overloaded method
  7. Inheritance
    • Basics
      • use extends keyword in class
      • can only specify one superclass
    • Member Access
      • inheriting does not overrule the private access restriction
      • usually not an issue because Java programmers tend to provide setters and getters
    • Constructors
      • the constructor of the superclass constructs the superclass portion and the constructor of the subclass constructs the subclass part
      • user super(parameter-list) in the subclass constructor
      • super must always be executed first
      • constructors are executed top-down (superclass must run first)
    • super to access superclass members
      • can access with super.member
      • most applicable when the member name of a subclass hides members of the superclass of the same name
    • Superclass References and Subclass Objects
      • a reference variable of a superclass can be assigned a reference to any object derived from that superclass
      • but the object will only have access to members available on the superclass
    • Method Overriding
      • can override own specific version of the method in the subclass
      • signatures must be identical
      • dynamic method dispatch is the mechanism by which overridden method is resolved at runtime
      • Java determines which method to execute based on the object type
      • allows different versions of the method to be executed
      • allows a general class to specify methods that will be common to all of its derivatives
      • subclasses can define own specific implementation
      • adds flexibility while enforcing a consistent interface
    • Abstract Classes
      • defines only the generalized form
      • abstract classes have at least one abstract member
      • can only be used on instance methods
      • all methods must be implemented for it to not be an abstract class
      • can contain concrete methods as well
    • Using final
      • can be used on class and members
      • prevents subclassing or overriding
      • useful for constants
    • The Object Class
      • implicit superclass of all other classes
  8. Packages and Interfaces
    • Packages
      • provides a way to name a collection of classes
      • helps avoid name collisions by partitioning namespaces
      • defined with package keyword
      • organized in same structure as directories
      • java run-time uses current working directory, but classpath can be specified as well
    • Packages and Member Access
      • public is accessible by all
      • protected is acessible within the package and outside package if its in a subclass
      • default members only accessible within the package
      • private member only accessible in class
    • Importing
      • can use fully qualified name
      • can also import package
      • use * to get all in namespace
    • Java Class library
      • java.lang automatically imported
      • others that need to be imported: java.io, java.net, java.util, java.awt
    • Interfaces
      • similar to abstract classes
      • defines what class must do but not how
      • can be implemented by numerous classes
      • a class can implement multiple interfaces
      • can add default implementations, static methods, and private methods
      • public interfaces must be in file of same name
      • methods are implicitly public
      • variables are public, final, static (essentially constants)
      • methods implementing an interface must be public and type signatures must be the same
      • like a reference variable can be assigned a subclass, you can assign classes that implement an interface
      • interfaces can be extended by other interfaces
    • Default Interface Methods
      • must use keyword default
      • helps prevent breaking changes to popular interfaces
      • allows implementation in some cases
    • Multiple Inheritance
      • if class implements method that takes precedence
      • if multiple default implementations from two interfaces, error
      • if an interface extends another interface, will default to the inheriting interface e.g. Beta extends Alpha, Beta’s version will take precedence
  9. Exeception Handling
    • Exception Hierarchy
      • all exception classes derived from Throwable
      • two direct subclasses are Error and Exception
      • Errors are related to errors in the JVM and not in program, usually beyond your control and not dealt with
      • Exceptions are the result of program activity
      • RuntimeException important subclass of Exception to represent various common runtime errors
    • Fundamentals
      • try, catch, throw, throws, finally
      • exceptions are monitored in try block
      • catch handles errors in try block based on specified exception types
      • can manually throw with throw
      • checked exceptions must be specified with throws in signature
      • finally executed after try/catch block
    • uncaught exceptions
      • displays stack trace, error and terminates execution by default
    • can catch multiple exception types
    • put subclass exceptions first since superclass can catch subclass exceptions
    • nested try blocks allow specific handling of different cases
    • Throwing an Exception
      • needs to throw an exception object
      • can rethrow in catch block
    • Throws
      • methods that throw errors that aren’t RuntimeException or Error must specify throws in signature
      • error must be handled by caller
    • Additional features
      • try-with-resource statement
      • catch two or more types in catch using “|”
      • final rethrow (more precise rethrow)
    • chained exceptions can point to underlying cause
      • use cause exception in constructor of new exception
    • define your own exception subclasses
  10. Using I/O
    • Streams
      • java I/O is performed throug streams
      • produces or consumes information
      • modern versions have byte streams (original) and character streams
    • Byte stream
      • top abstract classes are InputStream and OutputStream
    • Character stream
      • top abstract classes are Reader and Writer
      • operate on unicode characters
    • Predefined Streams
      • System.in, System.out, System.err
      • they are byte streams since that was original Java specification
      • preferred method is to use character oriented streams in commercial code
    • Reading and Writing Files Using Byte Streams
      • to create byte stream linked to a file use FileInputStream or FileOutputStream
      • use “read()” to read file
      • call “close()” when done
      • common to call “close()” in finally block
      • catch IOExceptions
    • Automatically closing files
      • try(FileInputStream fin = new FileInputStream(filename)) {}
      • can specify multiple resources with semi-colon
    • Reading and Writing Binary Data
      • can use DataInputStream and DataOutputStream to write and read primitives
    • Random-Access Files
      • use “RandomAccessFile”
      • implements DataInput and DatOutput methods
      • can use seek to set file pointer
    • Character Based Streams
      • Can wrap byte stream in Reader
      • Buffered Reader br = new BufferedReader(new InputStreamReader(System.in));
      • read method reads single unicode character
      • can use PrintWriter to output to console
    • File I/O Using Character Streams
      • Use FileWriter and FileReader
    • Java’s Type Wrappers to Convert Numeric Strings
      • Double, Float, Long, Integer, Short, Byte
      • wrap primitive types
      • act as objects and give you parsing methods
  11. Multithreading Programming
    • Fundamentals
      • lets you utilize idle time that is present in most programs
    • Thread Class and Runnable Interface
      • to create a new thread either extend Thread class or implement Runnable interface
      • instantiate object Thread
      • need to define run method
      • call start on thread object
      • sleep lets you suspend execution for some period of time
      • can create thread in constructor and also static factor method to make easier
      • may want to extend class if you want to override any other thread methods otherwise implement Runnable
    • Determining When a Thread Ends
      • can check isAlive
      • another option is call join on thread which will cause calling thread to wait until over
    • can set priority which gives greater potential access to CPU
    • Synchronization
      • objects have monitor which locks access
      • object with synchronized method will prevent other threads from accessing at same time
      • if you can’t modify object, can use synchronized block to lock object
    • Thread Communication
      • if thread has monitor for an object and is blocked, can release lock by using wait
      • the sleeping thread can be awakened when some other thread enters the same monitor and calls notify or notifyAll
      • possible for sleeping thread to be awakened due to spurious wake up so good to place in loop that checks the condition thread is waiting on
    • Suspending, Resuming and Stopping Threads
      • originally ahd suspend, resume, and stop methods, but deprecated due to deadlock issues
      • can design run method to check if thread should suspend, resume or stop
      • while(suspended) {wait()}; if (stopped) break;
  12. Enumerations, AutoBoxing, Static Import, and Annotations
    • Enumerations
      • list of named constants
      • can use in switch
      • they are class types can have instance variables, constructors, methods, etc
      • values(): all members
      • valuesOf(): takes string and returns member
      • enumeration constant is an object with the enumeration type
      • enumerations can’t inherit or be inherited
    • Autoboxing
      • implicit conversions from primitive to type wrapper e.g. int to Int
      • can use with variable references, parameter passing, return values, etc.
      • e.g. Double val = 123.0;
      • primitive types more efficient only use if type wrapper is necessary
    • Static Import
      • can import static method
      • e.g. import static java.lang.Math.sqrt;
      • good if plan on using multiple times not a few
      • brining in too many can cause name conflicts
    • Annotations
      • used to embed information to source file
      • used by tools
      • based on interface
      • does not change the actions of the program
      • can annotate any declarations
  13. Generics
    • Fundamentals
      • parameterized types
      • many algorithms logically the same
      • allows better code reuse, type safety, and error reduction
      • previously done with using Object reference and casting
      • class Gen<T>
      • generic type doesn’t exist at runtime
      • compiler removes all generic types and substitutes with necessary casts
      • only works with reference types
    • Bounded Types
      • allow only certain types
      • <T extends superclass>
      • can keep types compatible
    • Wildcard Arguments
      • sometimes not flexible enough
      • e.g. NumericFns<Integer> comparing NumericFns<Double> wouldn’t work if arg type is NumericFns<T>
      • can use wildcard args e.g. NumericFns<?> or NumericFns<? extends superclass>
      • can also set lowerbound with <? super subclass>
      • can define generic methods, constructors, interfaces
    • Type Inference with Diamond Operator
      • can reduce some of the verbosity
      • TwoGen<Integer, String> tbOb = new TwoGen<>(42, “testing”)
      • var tbOb = new TwoGen<Integer, String>(42, “testing”)
    • Erasure
      • type information is removed when code is compiled
      • i.e. type parameter replaced with Object type if no explicit bound set
      • no type parameters exist at runtime
      • can cause issues with overloaded methods
    • Restrictions
      • can’t create instance of type parameter
      • no static member can use type parameter declared by enclosing class
      • can’t instantiate array whose elemnt type is a type parameter e.g. vals = new T[10];
      • can’t create an array of type-specific generic references e.g. Gen<Integer> gens[] = new Gen<Integer>[10];
  14. Lambda Expressions and Method References
    • Introduction
      • anonymous methods
      • lambda expressions also refered to as closures
      • defined with arrow operatore e.g. () -> 3
      • can be single expression or block
      • functional interface must have one and only one abstract method
      • lambda forms the implementation of the abstract method of the functional interface
      • works with generics
      • can use local variables in enclosing scope, but cannot modify
      • can use and modify instance variables
    • Method References
      • can pass method reference of static method with “ClassName::methodName”
      • pass method reference for specific instance with “objRef::methodName”
      • can pass instance method without specifying specific instance with “ClassName::instanceMethodName”
      • the first parameter of the functional interface must match the invoking object and second parameters matches parameters of the method
      • constructor references passed with classname::new
    • Predefined Functional Interfaces
      • UnaryOperator<T>: applies to obejct of type T and returns type T
      • Binary Operator<T>: applies to two objects of type T and returns type T
      • Consumer<T>: apply operation on object of type T
      • Supplier<T>: return an object of type T
      • Function<T,R>: apply operation on object of type T and return type R
      • Predicate<T>: determine if object fulfills some criteria and return boolean

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s