OCAJP/OCPJP Resources

Which of the given options if put at //1 will correctly instantiate objects of various classes defined in the following code?


public class TestClass
{
   public class A{
   }
   public static class B {
   }
   public static void main(String args[]){
      class C{
      }
      //1
   }
}

1. new TestClass().new A();
2. new TestClass().new B();
3. new TestClass.A();
   A is not static. So no outer instance of TestClass is necessary.
4. new C();
5. new TestClass.C();

What will the following code print when compiled and run?

public class TestClass{
    
    public static int operate(IntUnaryOperator iuo){
        return iuo.applyAsInt(5);
    }
    
    public static void main(String[] args) {
        
        IntFunction<IntUnaryOperator> fo = a->b->a-b;  //1
        
        var x = operate(fo.apply(20)); //2
        System.out.println(x);
    }
}

1. Compilation error at //1
2. Compilation error at //2
3. 15
4. -15
5. 20
6. Exception at run time

Given:

public class Student {

    public static enum Grade{ A, B , C, D, F}   

    private String name;
    private Grade grade;
    public Student(String name, Grade grade){
        this.name = name;
        this.grade = grade;
    }
    public String toString(){
        return name+":"+grade;
    }
    //getters and setters not shown
}

What can be inserted in the code below so that it will print:
{C=[S3], A=[S1, S2]}


List<Student> ls = Arrays.asList(new Student("S1", Student.Grade.A), new Student("S2", Student.Grade.A), new Student("S3", Student.Grade.C));
//INSERT CODE HERE
System.out.println(grouping);

1. Map<Student.Grade, List<Student>> grouping = ls.stream().collect(
           Collectors.groupingBy(Student::getGrade),
           Collectors.groupingBy(Student::getName, Collectors.toList())));
   
   Invalid arguments to the collect method.
   
   Remember that Stream has only two overloaded collect methods - one that takes a Collector as an argument and another one that takes a Supplier, BiConsumer, and BiConsumer. In this option, it is trying to pass two Collectors to the collect method. Therefore, it will not compile.
   
   1. public <R,A> R collect(Collector<? super T,A,R> collector)
   Performs a mutable reduction operation on the elements of this stream using a Collector. A Collector encapsulates the functions used as arguments to Stream.collect(Supplier, BiConsumer, BiConsumer), allowing for reuse of collection strategies and composition of collect operations such as multiple-level grouping or partitioning.
   
   2.public <R> R collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)
   Performs a mutable reduction operation on the elements of this stream. A mutable reduction is one in which the reduced value is a mutable result container, such as an ArrayList, and elements are incorporated by updating the state of the result rather than by replacing the result.
2. Map<Student.Grade, List<String>> grouping = ls.stream().collect(
           Collectors.groupingBy(Student::getGrade,
               Collectors.groupingBy(Student::getName, Collectors.toList())));
   
   The right hand side of = is actually okay from a compilation perspective. It is trying to group the elements of the stream by Grade and then it is again trying to groups the elements of each grade by name. So technically, the return type of this expression would be:
   Map<Student.Grade, Map<String, List<Student>>> grouping = ...
   
   Even if you change the left hand side declaration as described, it will only print {C={S3=[S3:C]}, A={S1=[S1:A], S2=[S2:A]}}, which is not what is required by the question.
3. Map<Student.Grade, List<String>> grouping = ls.stream().collect(
       Collectors.groupingBy(Student::getGrade,
       Collectors.mapping(Student::getName, Collectors.toList())));
   This code illustrates how to cascade Collectors.
   Here, you are first grouping the elements by Grade and then collecting each element of a particular grade into a list after mapping it to a String. This will produce the required output.
4. Map<Student.Grade, List<String>> grouping = ls.stream().collect(
                   Collectors.groupingBy(Student::getGrade,
                   Collectors.mapping(Student::getName)));
   Collectors.mapping method requires two arguments - the first argument must be a Function that maps one element type into another (here, you are mapping Student to String, which is good), and the second argument must be an appropriate Collector in which you can hold the result (here, this argument is missing). Therefore, it will not compile.

The developer of a method that accesses the file system wants to ensure that the caller has appropriate permissions. She has written the following code:


public class FileOps {
     public static void doOps() {
                return AccessController.doPrivileged(
                    new PrivilegedAction<String>() {
                        public String run() {
                            //do File operations here
                        }
                    }, AccessController.getContext()
                );
            }
}


What, if anything, is wrong with this code from a security perspective?

1. This code does not really check the permissions of the caller.
   The second argument to doPrivileged (for which AccessController.getContext() in being passed here), returns the caller's permissions.
2. This code violates secure coding guidelines because it does not check the return value of AccessController.getContext() for null.
   AccessController.getContext() never returns null.
   Null check is required when an AccessControlContext object is received an argument. Since null implies no restrictions, you must check it for null before performing sensitive operations:
   
   public static void doOps(AccessControlContext ctx){
           if (ctx == null) {
               throw new SecurityException("Missing AccessControlContext");
           }
           AccessController.doPrivileged(new PrivilegedAction<Void>() {
                   public Void run() {
                       ...
                   }
               }, ctx);
   }
3. This code is fine and does not violate secure coding guidelines.
4. It should use AccessController.getParentContext() instead of AccessController.getContext() as the second argument to doPrivileged.
   There is no getParentContext method.
   The getContext method takes a "snapshot" of the current calling context, and places it in an AccessControlContext object, which it returns.

What will the following code print if file test1.txt exists but test2.txt doesn't exist?
public class FileCopier {
    
    public static void copy1(Path p1, Path p2) throws Exception {
        Files.copy(p1, p2, StandardCopyOption.COPY_ATTRIBUTES, StandardCopyOption.REPLACE_EXISTING);
    }
    
    
    public static void main(String[] args) throws Exception {
        var p1 = Paths.get("c:\\temp\\test1.txt");
        var p2  = Paths.get("c:\\temp\\test2.txt");
        copy1(p1, p2);
        if(Files.isSameFile(p1, p2)){
            System.out.println("file copied");
        }else{
            System.out.println("unable to copy file");
        }
    }
}

1. An exception at run time if either of p1 or p1 is a symbolic link.
2. It will print file copied and test2.txt will contains the same data as test1.txt.
3. It will print file copied but test2.txt will NOT contain the same data as test1.txt.
4. It will print unable to copy file but test2.txt will contain the same data as test1.txt.
5. It will print unable to copy file and test2.txt will not be created.

Which of the following lines will cause the compilation to fail??

public enum EnumA{ A, AA, AAA};  //1

public class TestClass //2
{
   public enum EnumB{ B, BB, BBB }; //3
   public static enum EnumC{ C, CC, CCC }; //4
   public TestClass()
   {
       enum EnumD{ D, DD, DDD } //5    
   }

   public void methodX()
   {
      public enum EnumE{ E, EE, EEE } //6
   }

   public static void main(String[] args) //7
   {
       enum EnumF{ F, FF, FFF}; //8
   }
}

1. 1, 2, or both depending on the file name.
   Since both EnumA and TestClass are public, they must be defined in a file with a name of EnumA.java and TestClass.java respectively.
2. 3
   A public (or non-public) enum can be defined inside any class.
3. 4
   An enum can be defined as a static member of any class. You can also have multiple public enums with in the same class.
4. 5
   An enum cannot be defined inside any method or constructor.
5. 6
   An enum cannot be defined inside any method or constructor.
6. 7
   There is nothing wrong with this line.
7. 8
   An enum cannot be defined inside any method or constructor.

Given:
var qr = "insert into USERINFO values( ?, ?, ?)";
try(PreparedStatement ps =  c.prepareStatement(qr);)
{
    ps.setObject(1, 1, JDBCType.INTEGER);
    ps.setObject(2, "Ally A", JDBCType.VARCHAR);
    ps.setObject(3, "101 main str", JDBCType.VARCHAR);
    var i = ps.executeUpdate(); //1
    ps.setObject(1, 2, JDBCType.INTEGER);
    ps.setObject(2, "Bob B", JDBCType.VARCHAR);
    i = ps.executeUpdate(); //2
}

What will be the result?

1. An exception will be thrown at //1
2. An exception will be thrown at //2
3. Two rows with the following values will be inserted in the USERINFO table:
   1, Ally A, 101 main str
   2, Bob B, null
4. Two rows with the following values will be inserted in the USERINFO table:
   1, Ally A, 101 main str
   2, Bob B, 101 main str
5. One row with the following values will be inserted in the USERINFO table:
   1, Ally A, 101 main str
   and an exception will be thrown at //2.

Given the following module-info:

module book{
   requires org.pdf;
   uses org.pdf.Print;
}

Which of the following statements are correct?

1. book module can be compiled without requiring any module that provides Print service.
   book module depends only on the module that defines Print service. It does not depend on any module that implements Print service.
   
   A module providing an implementation of the Print interface will need to be available at run time on the module-path only if the book module tries to locate and use a Print service using ServiceLoader. Even at run time, if no print service is found, there will not be any exception thrown by the JVM on its own. ServiceLoader.load(Print.class) will simply return an Iterator with zero elements in that case.
   
2. At least one implementation of Print service must be available on module-source-path for book module to compile.
3. At least one implementation of Print service must be available for book module to execute without an exception.
   This is not really necessary because it depends on what the book module does. For example, if a class in book module does the following:
   
      ServiceLoader<Print> pLoader = ServiceLoader.load(Print.class); // note that ServiceLoader implements Iterable interface
      for (Print p : pLoader){
            p.print("Hello");
       }
   
   
   There will be no exception even if there is no module that provides Print implementation because ServiceLoader.load will return a ServiceLoader with no elements.
4. At least one implementation of Print service must be available for book module to load successfully at run time.
   The JVM does not check whether a service implementation is present or not while loading a module.
5. The requires org.pdf; clause in the given module-info is redundant.
   This clause is actually required because org.pdf is the module that contains org.pdf.Print interface. Coincidently, org.pdf is also the package to which Print belongs but that is irrelevant here because requires clause contains the module name, not the package name.

Consider the classes shown below:

class A{
   public A() { }
   public A(int i) {   System.out.println(i );    }
}
class B{
   static A s1 = new A(1);
   A a = new A(2);
   public static void main(String[] args){
      var b = new B();
      var a = new A(3);
   }
   static A s2 = new A(4);
}

1. 1 ,2 ,3 4.
2. 1 ,4, 2 ,3
3. 3, 1, 2, 4
4. 2, 1, 4, 3
5. 2, 3, 1, 4

Given the following class:

class Person{
  private String name;
  private java.time.LocalDate dob;
  
  public Person(String name, java.time.LocalDate dob){
     this.name = name;
     this.dob = dob;
  }
  //public getters and setters for name and dob

}


and the following method appearing in some other class:

public List<Person> getEligiblePersons(List<Person> people){
    var pl = new ArrayList<Person>();
    for(var p : people){
        if(p.getDob().isBefore(cutoff)){
            pl.add(p);
        }
    }
    return pl;
}

1. There is no issue with the given code.
2. A copy of dob parameter should be made and that copy should be assigned to the dob field.
   This is not required because LocalDate is immutable.
3. getEligiblePersons should create a deep copy of the people list before processing the elements.
   Observe that Person class is mutable (due the the presence of setter methods). Therefore, it is possible that a Person object's dob field is changed by another code while the method is processing Person objects. ( Guideline 6-3 / MUTABLE-3: Create safe copies of mutable and subclassable input values )
   
   Ideally, Person class should provide a copy constructor or some other means to create a copy of a Person instance. (Guideline 6-4 / MUTABLE-4: Support copy functionality for a mutable class.)
4. Person class should provide a copy constructor.
   Since Person class is mutable, it should provide a way for users to create a copy of a Person instance which can be used independently without the threat of getting modified by some other code.
   
   Something like:
   public Person copy(){
      return new Person(this.getName(), this.getDob());
   }
   
   Guideline 6-4 / MUTABLE-4: Support copy functionality for a mutable class
5. Person class should be made final.

Given :

//1
public class TestClass {
//2
   public static void main(String[] args) throws Exception{
        var al = new ArrayList<Integer>();
        printElements(al);
   }

//3
    static void printElements(List<Integer>... la) {
       for(List<Integer> l : la){
           System.out.println(l);
       }
    }
}

Which option(s) will get rid of compilation warning(s) for the above code?

1. Apply @SuppressWarnings("all") at //1
   Although you can pass any string value to the SuppressWarnings annotation (unrecognized values are ignored), the Java specification mandates only three values - unchecked, deprecation, and removal. Different compilers and IDEs may support other values in addition to these three.
   
   In this particular case, "all" is not a valid argument for @SuppressWarnings. @SuppressWarnings("unchecked") will work.
   
   Applying @SuppressWarnings("unchecked") on the class suppresses all unchecked warnings from that class. Note that the set of warnings suppressed in a given element is a superset of the warnings suppressed in all containing elements. For example, if you annotate a class to suppress one warning and annotate a method to suppress another, both warnings will be suppressed in the method. However, note that if a warning is suppressed in a module-info file, the suppression applies to elements within the file and not to types contained within the module.
   
   As a matter of style, programmers should always use this annotation on the most deeply nested element where it is effective. If you want to suppress a warning in a particular method, you should annotate that method rather than its class.
   
2. Apply @SuppressWarnings("unchecked") at //2
3. Apply @SuppressWarnings("rawtypes") at //2
4. Apply @SuppressWarnings("rawtypes") at //3
   The "rawtypes" warning is issued when you use a parameterized class without a type parameter. For example, List al = new ArrayList();. Here, List and ArrayList are parameterized classes and you should specify the type parameter in the declaration and instantiation i.e. List<String> al = new ArrayList<>();
   
   The "unchecked" warning is issued where a compiler is not able to check the type safety of the operation. For example:
   
   List al = new ArrayList(); //rawtypes warning here
   al.add(""); //unchecked warning here
   
5. Apply @SuppressWarnings("unchecked") at //2 as well as //3.
   Any time you invoke a method or declare a method that uses varargs with a generic type, you will get an "unchecked" warning. Thus, @SuppressWarnings("unchecked') would be issued because of the call to printElements(al) in main and the declaration of the printElements method.
6. Apply @SuppressWarnings("rawtypes") at //2 as well as //3.

Which of the following statements are correct regarding abstract classes and interfaces?

1. An abstract class can have private as well as static methods while an interface can not have static methods.
   Interfaces can have static methods (public as well as private). Interfaces cannot have protected methods. It cannot have non-public fields and instance fields.
2. An abstract class cannot implement multiple interfaces while an interface can extend multiple interfaces.
   An abstract class (or any class for that matter) can implement any number of interfaces.
3. Abstract classes can have abstract methods but interface cannot.
   Both abstract classes and interfaces can have abstract as well as non-abstract methods. The difference is that by default (i.e. when no modifier is specified), the methods of an abstract class have "default" access and are non-abstract (i.e. they must have a body), while the methods of an interface are public and abstract.
4. Abstract classes can have instance fields but interfaces can't.
   Fields of an interface are always public, static, and final.
5. An abstract class can have final methods but an interface cannot.

Given:

//assume appropriate imports
public class Calculator{
    public static void main(String[] args) {
        double principle = 100;
        int interestrate = 5;
        double amount = compute(principle, x->x*interestrate);
    }
    
    INSERT CODE HERE
}

Which of the following methods can be inserted in the above code so that it will compile and run without any error/exception?

1. public static double compute(double base, Function<Integer, Integer > func){
       return func.apply((int)base);
   }
2. public static double compute(double base, Function<Integer, Double> func){
       return func.apply((int)base);
   }
   The method definition is fine. But the usage of this method i.e. compute(principle, x->x*interestrate); will not compile because the type of the expression that makes up the body of the function i.e. x*interestrate is int, while the expected return type of the Function is Double. int cannot be boxed to a Double.
   You could do this though: double amount = compute(principle, x->new Double(x*interestrate));
3. public static double compute(double base, Function<Double, Integer> func){
       return func.apply(base);
   }
   Function<Double, Integer> implies that your argument type is Double and return type is Integer. However, the return type of the lambda expression x->x*interestrate is Double because you are passing base, which is a double, as the argument to this function..
4. public static double compute(double base, Function<Double, Double> func){
       return func.apply(base);
   }
5. public static double compute(double base, Function<Integer, Double> func){
       return func.apply(base);
   }
   Function<Integer, Double> implies that your argument type is Integer and return type is Double. However, you are passing base, which is double, to this function. You cannot pass a double where an int or Integer is required without explicit cast due to potential loss of precision.

Consider the following code:

class Account{
    private String id; private double balance;

    ReentrantLock lock = new ReentrantLock();
    
    public void withdraw(double amt){
        try{
            lock.lock();
            if(balance > amt) balance = balance - amt;
        }finally{
            lock.unlock();
        }
    }
}

What can be done to make the above code thread safe?

1. Change new ReentrantLock() to new ReentrantLock(true).
   ReentrantLock has two constructors - the no-args one and the boolean one. The boolean constructor allows you to specify whether you want to apply fairness policy or not.
   In this case, either of the constructors is fine. There is no need to change.
   
2. Move the call to lock.lock(); to before the try block.
   Although valid, this change is not required.
3. Declare lock variable as private and final.
   Unless lock is private and final, it can be changed to point to some other object by another thread. In that case, the whole point of locking the critical section of the code using the same lock will be lost.
4. Make the lock variable private, final, and static.
   Making it static will cause all Account object to use the same lock. This means only one Account object can be used at any time, which will drastically reduce performance and is not desired.
5. Make the lock variable static.
6. No change is required.

Your application uses one modular jar (a.jar), which, in turn, uses one non-modular jar (b.jar). Which of the following commands will cause jdeps to include the non-modular jar in its analysis?

1. jdeps -module-path lib\a.jar; -classpath lib\b.jar
   This is an invalid usage of jdeps. After specifying options, you must specify the target file that you want to analyze.
   
   Usage: jdeps <options> <path ...>]
   <path> can be a pathname to a .class file, a directory, a JAR file.
   
2. jdeps --module-path lib\a.jar; lib\b.jar
   If you put a.jar on module-path, then jdeps will try to build its module graph. It will look for module b (because it is given in the problem statement that a.jar uses b.jar). But b.jar is not on the module-path, so jdeps will given an error saying a required module b is not found.
3. jdeps --class-path lib\a.jar; lib\b.jar
   Ideally, since a.jar is a module, it should be put on the module-path. However, if b.jar does not refer to classes from a.jar, this will work and will do the analysis for b.jar.
   
   --class-path lib\a.jar; is of no use in this case.
   
   BTW, -cp -classpath and --class-path are equivalent.
4. jdeps -cp lib\b.jar lib\a.jar
   Note that the problem statement says that a.jar uses b.jar. Since a.jar is a modular jar, it cannot access classes from b.jar if b.jar is put on classpath.  b.jar must be put on the module-path so that it can be converted into an automatic module and be accessible from a.jar.
   Thus, while analyzing a.jar, jdeps will generate an error saying a required module b is not found.
5. jdeps -cp lib\b.jar;lib\a.jar
   A target path is required.

Consider the following piece of code:

        Locale.setDefault(new Locale("fr", "CA")); //Set default to French Canada
        Locale l = new Locale("jp", "JP");
        ResourceBundle rb = ResourceBundle.getBundle("appmessages", l);
        String msg = rb.getString("greetings");
        System.out.println(msg);

You have created two resource bundle files with the following contents:

#In appmessages.properties:
greetings=Hello

#In appmessages_fr_FR.properties:
greetings=bonjour

Given that this code is run on machines all over the world. Which of the following statements are correct?

1. It will throw an exception when the default locale of the machine where it is run is different from fr/FR and fr/CA.
2. It will throw an exception where ever it is run.
3. It will throw an exception when the default locale of the machine is fr/CA.
4. It will throw an exception when the default locale of the machine is jp/JP.
5. It will run without any exception all over the world.