In a nutshell protected means - 

• Protected: Protected members are accessible from its derived classes or any classes in the package where it is declared.

so if there is a subclass in a different package, you the subclass can access protected members within its own class.

AND

protected members can be access by any classes in the package where it is declared.

default access and child classes (subclasses). Protected access means that parent members are accessible to child subclasses.

NOTE: Keep in mind - although subclasses in different packages can access protected members of the parent, other classes in the same package are the ONLY ones allowed to access protected members due to protected access which includes default access. Classes in other packages, that are NOT SUBCLASSES, CANNOT access protected members, even when accessing the protected member from the class or its subclasses!

EXAMPLE1: Say you have 4 classes, in 2 different packages;

Let's look at a collection of classes and see how access levels affect visibility. The following figure shows the four classes in this example and how they are related.

The following table shows where the members of the Alpha class are visible for each of the access modifiers that can be applied to them.

EXAMPLE2: Say you have a Bird class, and a Goose class, and they are in different packages.

Bird is in animal.bird package.

Goose is in animal.goose package. Goose imports animal.Bird and extends from Bird see below;

public Goose extends Bird{ }

Bird has a protected method - "protected void fly();"

Within the goose class you can access the fly() method directly by just calling "fly();"

public void gooseFly(){

     fly(); // CAN CALL FLY DIRECTLY, DUE TO INHERITANCE

}

Because Goose is a subclass, and fly is inherited, this is ok. Also,

You can create a Goose instance with a Goose reference, and you can call "fly():" on it because you are going through a goose reference and it is a subclass of Bird, although in a different package;

public void gooseFlyHigher(){

     Goose goose = new Goose();

     goose.fly(); // THIS IS OK BECAUSE THE REFERENCE IS GOOSE BECAUSE ITS STILL USING INHERITANCE

}

HOWEVER, if you are in the Goose class, even though you imported the Bird class, and the object you are referencing is a Goose, you still CANNOT use a Bird reference to call the "fly();" method;

public void gooseFlyEvenHigher(){

     Bird bird = new Goose();

     bird.fly(); // THIS DOES NOT COMPILE

}

THIS DOES NOT COMPILE SINCE YOU ARE ACCESSING THE PROTECTED fly() METHOD WITH A BIRD REFERENCE, IT DOESN'T MATTER THAT THE OBJECT BEING REFERENCE IS A GOOSE, THIS WILL STILL FAIL

Also, what if you were in another class that was not a subclass of the class having the protected method, and not in the same package, but you imported the subclass and tried to call a method on it?

Package animal.goosewatcher;

import animal.goose;

public GooseWatcher{

      Goose goose = new Goose();

    goose.fly(); // DOES NOT COMPILE - YOU CAN ONLY CALL THIS FROM WITHIN THE ACTUAL SUBCLASS OR FROM ANOTHER CLASS IN THE SAME PACKAGE, NOT FROM CALLERS OF THE SUBCLASS

}

Can you call a static member from an instance variable?

public Test{

     public static String str = "";

     P public static void main(String[] args){

          Test t = new Test();

           System.out.println(t.str); // WILL THIS COMPILE?

     }

}

How about when the instance is set to null?

public Test{

     public static String str = "";

     P public static void main(String[] args){

          Test t = null;

           System.out.println(t.str); // WILL THIS COMPILE?

     }

}

1. Yes

2. Yes - Java knows via the static optional modifier that this member is part of the class, and will reference it that way even when it's being called by an reference variable.

What do we call "static final" variables?

How are they typically named in Java?

1. Constants

2. Using all caps and underscores to separate words;

public static String THIS_IS_A_CONSTANT = "constant";

True or false - you cannot update static final reference variables, i.e.;

public static final List list = new ArrayList();

public static void main(String[] args){

     list.add("one"); // WILL THIS COMPILE?

}

False - you CAN update static final reference variables, by calling methods on them! When marking them as final, all the compiler can do is make sure you are not reassigning them to another object, i.e.;

public static final List list = new ArrayList();

public static void main(String[] args){

     list.add("one"); // THIS WILL COMPILE

     list = new ArrayList(); // THIS WILL NOT COMPILE!

}

static {

}

import static java.util.Arrays.asList;

OR

import static java.util.Arrays.*;

They are only used for the static members of a class, not the class itself.

Also in your code it is not ok to preface the static reference call with the class name when you use a static import;

Arrays.asList("one"); // WILL NOT COMPILE

asList("one"); // THIS WILL COMPILE

True or false - statically importing two static members with the same name from different classes will compile;

static import com.text.B.Type;

static import com.text.A.Type; // WILL THIS COMPILE?

True or false - when passing a primitive parameter in a method, variable reassignment will affect the original value.

i.e.

int nine = 9; // WHAT WILL THE VALUE OF THIS BE AFTER THE METHOD CALL

change(nine);

void change(int nine){

     nine = 8;

}

Assigning a new primitive or reference to to a parameter inside a method body DOES/DOESN'T change the caller (or the original value of the parameter).

If you call methods on a parameter that is referencing an object inside of a method call, this DOES/DOESN'T affect the caller (or the original value of the parameter). 

1. DOESN'T

2. DOES

Will the following code compile, and why or why not?

public void fly(int[] intses){}

public void fly(int... intses){}

True or false - varargs arguments give you the flexibility to pass in an array OR standalone parameters;

public void addNums(int... Nums){}

// can call with either?

addNums(new int[]{1,2,3});

addNums(1,2,3);

True or false - If there are two similar methods, but one with a primitive input param and one with Wrapper Object input param, Java will always use the most specific parameter list it finds, in this case the primitive version;

public void test(int num){

}

public void test(Integer number){

}

short s = 1;

test(s);

1. Exact match by type.

2. Larger primitive type.

3. Autoboxed type.

4. Varargs

1. Constructors

2.instantiation

3.new instance

4. New

5. Instantiate

default constructor OR default no-arg constructor.

Remember the compiler will only ever insert one if there are no other constructors in the class.

If the exam asks you "which of these classes has a default constructor?" And it shows you something like;

 class Bear{

     public Bear(){}

}

Does this class have a default constructor?

No.  You would not say this class has a default constructor, because the coder already provided one, and even if it is the same as the default the constructor would insert. If you saw;

class Bear{

}

This would imply that the coder did not supply any constructor at all, and the compiler will be inserting a default constructor at compile time.

1. Many

2. Same

3. Different

4. Must not

What happens in a constructor when you use new, is that it just creates another, different, object in memory, and has no effect on the instance and ignores the instance.

You must use either this() when referring to another constructor in the same class.

1. Once

2. Variable declaration

3. Constructor

1. Superclass

2. Static variable declarations and static blocks (initializers) in the order they appear.

3. Instance variable declarations and instance blocks (initializers) in the order they appear.

static blocks look like this;

static {

}

instance initialized blocks look like this;

{

}

It will initialize and print the static variable(s) first, then will call the static initiliazer block with the new Object() line which will first call the initializer var(s) and blocks then the print statement for the "constructor" in the Objects contructor, and then print statement in the main method "main", and it will look like this;

sVar

iVar

constructor

main

All properties (variables) are private. All getters and setters of the properties are public. Boolean getter method names begin with is. All other property type getter method names start with get. All setter method names begin with set. Method names begin with is/get/set and then the name of the property with the first letter of the property name capitalized;

public String strVar= "";

public Boolean safe;

public String getStrVar(){

     return this.strVar;

}

public void setStrVar(String strVar){

     this.strVar = strVar;

}

public Boolean isSafe(){

     return this.safe;

}

public void setSafe(Boolean safe){

     this.safe = safe;

}

If you have an immutable class, and a caller initializes the values on a variable through the constructor, how do we prevent a caller from modifying the variable via the get method by call methods on it by chaining them to the get method?

i.e.

ImmutableClass imute = new ImmutableClass(new StringBuilder("new"));

imute.getSb().append("modify the stringbuilder"); // THIS WILL CHANGE THE INTERNAL SB - how do we stop this?

Change the get method in the immutable class to not return a reference to the object, but a copy via a new object;

public StringBuilder getSb(){

     return new StringBuilder(this.sb);

     }

This way the caller can get and make changes to the copy, but the original immutable class, stays the same.

Provide single statement legal lambdas with a method called "print", with 1 and 2 String parameters, and calling the .startsWith() method on the string;

1 param

2 params

print(s -> s.startsWith("a"));

print((s,t) -> s.startsWith("a"));

print((String s) -> s.startsWith("a"));

print((String s, String t) -> startsWith("a"));

Provide lambdas with statements for String parameters, one with .startsWith, one with .endsWith for

2 parameters;

print((s,t) - > {

    if(s.startsWith("a"))

        System.out.println("ok");

    return (s.startsWith("a") && t.endsWith("s"));

});

print((String s, String t) -> {

    Return (s.startsWith("a") && t.startsWith("s"));

});

True or false - If you have a lambda with multiple parameters parenthesis are not required.

i.e.

print(s,t -> s.startsWith("a"));

OR

print(String s, String t - > s.startsWith("a"));

Both of these are legal?

True or false - you are allowed to redeclare variables in a lambda expression.

i.e.

print(s -> {

     String s = "d";

     return s.startsWith("d");

});

False. You are not allowed to redeclare or name a variable the same in a lambda expression is the same as an input parameter name.

in the example above you would just need to rename String s to something else;

String f = "d";

If you are declaring a static print method passing in params List<String> and Predicate<String>, what would the signature and the method look like, if you wanted to see if a List of Strings started with the "a" string?

What would the method call look like?

The signature would look like;

public static void print(List<String> l, Predicate<String> checker){

     for(String s: l){

          if(checker.test(s)){

               System.out.println("s ="+ s);

          }

     }

}

The method call would look like;

List strings...

print(strings, s -> s.startsWith("a"));

True or false - including public setters is required for encapsulation, And for immutability they must exist.

True or false - when using Predicates the following is required; 

i.e.

you have a print method that uses a Predicate<String> to check the values in a list, and you pass in the code for the predicate to run the test method on;

print (list, s - > s.equals("s"));

1) The Predicate is only expecting one parameter so if you see (s1, s2) ->..., this will not compile.

2) When sending the code, you must refer to the variable name in the code s -> s.equals("s"), or it will not compile.

3) Any time you use multiple statements, in sending the code, you need braces, and a return. 

True or false - 1) data encapsulation and immutability both require private variables.

2) Immutability does not allow setters.

3) Encapsulation and Immutability do not require that all instance variables be exposed.

True or false - the predicate method definition does not care about using interfaces as parameters or the objects implementing them.

public static Boolean checkList(List list, Predicate<List> p){

}

so you can call it using

checkList( new ArrayList(), (ArrayList al) -> al.isEmpty());

True or false - if a variable name is already used above a call to a predicate, in the same scope, you can still use that variable name in a call to the predicate method.

Data d = new Data(1);

filterData(al, d -> d.value%2 == 0);