Final Exam: Java Apprentice

WHAT YOU WILL LEARN

• 

  Identify types of exceptions encountered by compilers
  

  outline the hierarchy of exception classes in java and recall specific exception types
  

  recognize how the throwing of exceptions influences the flow of a java program
  

  given code, identify the exception
  

  view and edit data stored in arrays
  

  identify what generic information about type parameters is available using reflection
  

  execute test cases using a custom test harness
  

  annotate test case methods for unit testing
  

  implement a dynamic proxy to create a dynamic object implementing an interface
  

  use an integrated development environment (ide) to create the main class for a java project
  

  create and execute a basic java archive using a manifest file
  

  extract and recognize the contents of a java archive (jar)
  

  use multiple catch blocks to handle different types of exceptions in your code
  

  use the throw keyword in java to explicitly throw an exception when the state of the program does not match your own set of valid conditions
  

  create and add data to arrays of different types
  

  examine the fixed-length enforcement of arrays
  

  iterate over the values in arrays using for loops
  

  work with list operations
  

  compare and contrast the usage of parameterized and non-parameterized lists
  

  explore the basic characteristics of the 'set' data structure
  

  recall how hash sets identify duplicates
  

  recall how different types of sets are ordered
  

  recognize different type of map implementations
  

  recall the special operations that can be performed on sorted maps
  

  list the advantages of writing generic code over non-generic code
  

  recall the limitations on code reuse in non-generic classes
  

  recall the limitations of using raw objects rather than generic types
  

  implement a class with generics for type safety and compile-time checks
  

  recall the disadvantages of unbounded type parameters
  

  recall when and how you would use unbounded wildcards
• 

  constrain types using bounded type parameters
  

  compare and contrast upper-bounded wildcards and bounded type parameters
  

  recall how java infers data types using wildcard capture
  

  recall how nested static classes work
  

  recall the limitations of static nested classes
  

  define and use local classes
  

  define and use inner classes
  

  instantiate and use static nested classes
  

  define and use anonymous classes
  

  recall that anonymous instances are objects
  

  recall how functional interface instances are objects
  

  define and use lambda expressions
  

  compare and contrast lambda statements and expressions
  

  create predicate, consumer, function, and supplier interfaces
  

  create and set up a basic intellij project to write java code
  

  define new classes and instantiate objects of these classes
  

  use class handles accessed via reflection to explore properties of classes
  

  identify enums, arrays, and primitives using reflection
  

  identify anonymous, local, member classes, and interfaces using reflection
  

  use public, private, and protected methods
  

  access public, private, and protected methods
  

  access the constructors in a class using reflection
  

  access and update values of fields
  

  access and update protected and private fields
  

  explore the disadvantages of using reflection with generics
  

  outline the automatic generation of manifests and the fields contained in them
  

  install and configure maven to create java archives
  

  create a maven project which can then be packaged into a jar file
  

  create a custom pom.xml file and build an executable jar with maven
  

  execute and view the contents of a java archive built with maven