Java Object-Oriented Programming Proficiency (Intermediate Level)

  • 30m
  • 30 questions
The Java Object-Oriented Programming Proficiency benchmark assesses your ability to work with files and directories in Java, architect a multilevel inheritance hierarchy in Java, and override methods using the @Override annotation. A learner who scores high on this benchmark demonstrates they have the skills to describe and implement advanced object-oriented features in Java.

Topics covered

  • access outer class variables from your anonymous inner class
  • construct two parallel base classes and derived classes for each of those base classes
  • create and define anonymous inner class objects
  • create and use final classes and final methods
  • create files using both the legacy as well as the modern java.nio namespaces
  • define and use static final member variables
  • implement a derived class that can both extend a base class and implement an interface
  • instantiate final arrays
  • perform operations such as copying and creating directories using the Files class in the java.nio namespace
  • perform operations such as copying files, checking for their existence, and deleting files using the Files class in the java.nio namespace
  • perform various casting operations
  • recognize how access works from one package into another
  • recognize how polymorphism works in the presence of a multilevel inheritance hierarchy
  • recognize how the instanceof operator works the same way with interfaces as with classes
  • recognize how to extend abstract classes and the implications of doing so
  • recognize how you can upcast multiple levels up and how downcasting is very dangerous
  • recognize situations where multiple inheritance is not allowed
  • recognize that a class can only be instantiated if it has implemented all abstract methods
  • recognize that compile-time polymorphism does not include type demotions
  • recognize the semantics of using default access modifiers inside the same package
  • recognize the semantics of using default access modifiers outside the current package
  • set up a class that implements some of the methods of an interface and then declares itself abstract
  • set up two inheritance hierarchies and combine these into a set of objects that implement both set of interfaces
  • use a combination of run-time and compile-time polymorphism
  • use compile-time polymorphism, including type promotions
  • use the instanceof operator to check that an object is an instance of every class in its inheritance hierarchy
  • use the methods of the Path interface to normalize, parse, and resolve paths
  • use the @Override annotation
  • use the protected access modifier
  • use the protected keyword across packages