Final Exam: Java Apprentice - access and update protected and private fields
- access and update values of fields
- access public, private, and protected methods
- access the constructors in a class using reflection
- annotate test case methods for unit testing
- compare and contrast lambda statements and expressions
- compare and contrast the usage of parameterized and non-parameterized lists
- compare and contrast upper-bounded wildcards and bounded type parameters
- constrain types using bounded type parameters
- create a custom pom.xml file and build an executable JAR with Maven
- create a Maven project which can then be packaged into a JAR file
- create and add data to arrays of different types
- create and execute a basic Java archive using a manifest file
- create and set up a basic IntelliJ project to write java code
- create Predicate, Consumer, Function, and Supplier interfaces
- define and use anonymous classes
- define and use inner classes
- define and use lambda expressions
- define and use local classes
- define new classes and instantiate objects of these classes
- examine the fixed-length enforcement of arrays
- execute and view the contents of a Java archive built with Maven
- execute test cases using a custom test harness
- explore the basic characteristics of the 'set' data structure
- explore the disadvantages of using reflection with generics
- extract and recognize the contents of a Java archive (JAR)
- given code, identify the exception
- identify anonymous, local, member classes, and interfaces using reflection
- identify enums, arrays, and primitives using reflection
- identify types of exceptions encountered by compilers
- identify what generic information about type parameters is available using reflection
- implement a class with generics for type safety and compile-time checks
- implement a dynamic proxy to create a dynamic object implementing an interface
- install and configure Maven to create Java archives
- instantiate and use static nested classes
- iterate over the values in arrays using for loops
- list the advantages of writing generic code over non-generic code
- outline the automatic generation of manifests and the fields contained in them
- outline the hierarchy of Exception classes in Java and recall specific exception types
- recall how different types of sets are ordered
- recall how functional interface instances are objects
- recall how hash sets identify duplicates
- recall how Java infers data types using wildcard capture
- recall how nested static classes work
- recall that anonymous instances are objects
- recall the disadvantages of unbounded type parameters
- recall the limitations of static nested classes
- recall the limitations of using raw objects rather than generic types
- recall the limitations on code reuse in non-generic classes
- recall the special operations that can be performed on sorted maps
- recall when and how you would use unbounded wildcards
- recognize different type of map implementations
- recognize how the throwing of exceptions influences the flow of a Java program
- use an integrated development environment (IDE) to create the main class for a Java project
- use class handles accessed via reflection to explore properties of classes
- use multiple catch blocks to handle different types of exceptions in your code
- use public, private, and protected methods
- 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
- view and edit data stored in arrays
- work with list operations
|
