OCA Java SE 8 Exam Chapter 4 Methods Encapsulation

OCA EXAM 8
CHAPTER 4 – Methods & Encapsulation
By İbrahim Kürce
Brief of OCA: Oracle Certified Associate Java SE 8 Programmer I Study Guide: Exam 1Z0-808
Jeanne Boyarsky, Scott Selikoff

Methods & Encapsulation
 In this chapter, we'll explore methods and constructors in depth and cover
everything you need to know about them for the OCA exam.
 Every interesting Java program we've seen has had a main() method. We
can write other methods, too.
 This is called a method declaration, which specifies all the information
needed to call the method.

Access Modifiers
 Public The method can be called from any class.
 Private The method can only be called from within the same class.
 Protected The method can only be called from classes in the same
package or subclasses. You'll learn about subclasses in Chapter 5.
 Default (Package Private) Access The method can only be called from
classes in the same package. This one is tricky because there is no keyword
for default access. You simply omit the access modifier.
 Note: There's a default keyword in Java. You saw it in the switch statement.
It's not used for access control.
 The exam creators like to trick you by putting method elements in the
wrong order or using incorrect values.

Access Modifiers
 Pay attention to the access modifiers

Optional Specifiers
 There are a number of optional specifiers, but most of them aren't on the exam.
Unlike with access modifiers, you can have multiple specifiers in the same
method (although not all combinations are legal).
 Static Covered later in this chapter. Used for class methods.
 Abstract Covered in Chapter 5. Used when not providing a method body.
 Final Covered in Chapter 5. Used when a method is not allowed to be
overridden by a subclass.
 Synchronized On the OCP but not the OCA exam.
 Native Not on the OCA or OCP exam. Used when interacting with code written
in another language such as C + +.
 Strictfp Not on the OCA or OCP exam. Used for making floating-point
calculations portable.

Optional Specifiers
 Focus on syntax

Return Type
 The return type might be an actual Java type such as String or int. If there is
no return type, the void keyword is used.
 This special return type comes from the English language: void means
without contents.

Method Name
 Method names follow the same rules as we practiced with variable names.
 To review, an identifier may only contain letters, numbers, $, or _.
 Also, the first character is not allowed to be a number, and reserved words
are not allowed.
 By convention, methods begin with a lowercase letter but are not required
to.

Parameter List
 Although the parameter list is required, it doesn't have to contain any
parameters. This means you can just have an empty pair of parentheses
after the method name, such as void nap(){}.

Optional Exception List
 In Java, code can indicate that something went wrong by throwing an
exception.
 For now, you just need to know that it is optional and where in the method
signature it goes if present.
 You can list as many types of exceptions as you want in this clause
separated by commas.

Method Body
 The final part of a method declaration is the method body (except for
abstract methods and interfaces)
 A method body is simply a code block.
 It has braces that contain zero or more Java statements.

Working with Varargs
 A method may use a vararg parameter (variable argument) as if it is an array.
 A vararg parameter must be the last element in a method's parameter list. This
implies you are only allowed to have one vararg parameter per method.
 When calling a method with a vararg parameter, you have a choice. You can
pass in an array, or you can list the elements of the array and let Java create it
for you.

 You can even omit the vararg values in the method call and Java will create an
array of length zero for you.
 You've seen that Java will create an empty array if no parameters are passed
for a vararg. However, it is still possible to pass null explicitly:
 walk(1, null); // throws a NullPointerException

 Since null isn't an int, Java treats it as an array reference that happens to
be null. It just passes on the null array object to walk.
 Accessing a vararg parameter is also just like accessing an array.

Applying Access Modifiers
 There are four access modifiers: public, private, protected, and default
access.
 private: Only accessible within the same class
 default (package private) access: private and other classes in the same
package
 protected: default access and child classes
 public: protected and classes in the other packages

Private Access
 Only code in the same class can call private methods or access private
fields.

Default (Package Private) Access
 When there is no access modifier, Java uses the default, which is package
private access.
 This means that the member is “private” to classes in the same package. In
other words, only classes in the package may access it.

Default (Package Private) Access
 MotherDuck only allows lessons to other ducks by restricting access to the
pond.duck package.
 Remember that when there is no access modifier, only classes in the same
package can access it.

Protected Access
Protected access allows everything that default
(package private) access allows and more.
The protected access modifier adds the ability to
access members of a parent class.
Gosling: kaz yavrusu
Goose: kaz
Swan: kuğu

Protected Access
 We create a Bird class and give protected access to its members:

Protected Access
 Next we create a subclass:
 This is a very simple subclass. It extends the Bird class. Extending means
creating a subclass that has access to any protected or public members of
the parent class.

Protected Access
 Remember that protected also gives us access to everything that default
access does. This means that a class in the same package as Bird can
access its protected members.
 Subclasses and classes in the same package are the only ones allowed to
Access.

Protected Access
 Swan is not in the same package as Bird, but does extend it— which implies it
has access to the protected members of Bird since it is a subclass. And it does.
Lines 5 and 6 refer to protected members via inheriting them.
 Lines 10 and 11 also successfully use protected members of Bird. This is allowed
because these lines refer to a Swan object. Swan inherits from Bird so this is
okay. It is sort of a two-phase check. The Swan class is allowed to use protected
members of Bird and we are referring to a Swan object. Granted, it is a Swan
object created on line 9 rather than an inherited one, but it is still a Swan object.
 Lines 15 and 16 do not compile. Wait a minute. They are almost exactly the
same as lines 10 and 11! There's one key difference. This time a Bird reference is
used. It is created on line 14. Bird is in a different package, and this code isn't
inheriting from Bird, so it doesn't get to use protected members.

Protected Access
 A member is used without referring to a variable. This is the case on lines 5
and 6. In this case, we are taking advantage of inheritance and protected
access is allowed.
 A member is used through a variable. This is the case on lines 10, 11, 15, and
16. In this case, the rules for the reference type of the variable are what
matter. If it is a subclass, protected access is allowed. This works for
references to the same class or a subclass.
 OrnekProje yi göster.

Public Access
 public means anyone can access the member from anywhere.

Designing Static Methods and Fields
 Static methods don't require an instance of the class. They are shared
among all users of the class.
 Note: Each class has a copy of the instance variables. There is only one
copy of the code for the instance methods. Each instance of the class can
call it as many times as it would like. However, each call of an instance
method (or any method) gets space on the stack for method parameters
and local variables.
 In addition to main() methods, static methods have two main purposes:
 For utility or helper methods that don't require any object state.
 For state that is shared by all instances of a class, like a counter.

Calling a Static Variable or Method
 You just put the classname before the method or variable and you are
done.
 There is one rule that is trickier. You can use an instance of the object to call
a static method.

Static vs. Instance.
 A static member cannot call an instance member.

Static vs. Instance.
 A common use for static variables is counting the number of instances:
 This example relies on the fact that static (and instance) variables are
automatically initialized to the default value for that type, which is 0 for int.

Static Variables
 Some static variables are meant to change as the program runs.
 Other static variables are meant to never change during the program. This
type of variable is known as a constant. It uses the final modifier to ensure
the variable never changes.
 It actually does compile. values is a reference variable. We are allowed to
call methods on reference variables. All the compiler can do is check that
we don't try to reassign the final values to point to a different object.

Static Initialization
 In Chapter 1, we covered instance initializers that looked like unnamed
methods. Just code inside braces.
 Static initializers look similar. They add the static keyword.
 There is something interesting about this example. We just got through saying
that final variables aren't allowed to be reassigned. The key here is that the
static initializer is the first assignment. And since it occurs up front, it is okay.

Static Imports
 Static imports are for importing static members of classes.
 Note: In a large program, static imports can be overused. When importing
from too many places, it can be hard to remember where each static
member comes from.
 Rewriting the code to use a static import yields the following:

Static Imports
 An interesting case is what would happen if we created an asList method in
our StaticImports class.
 Remember that static imports are only for importing static members.
 Line 6 is sneaky. We imported the asList method on line 2. However, we did
not import the Arrays class anywhere. This makes it okay to write asList("
one"); but not Arrays.asList(“ one”);

Static Imports
 The compiler will complain if you try to explicitly do a static import of two
methods with the same name or two static variables with the same name.

Passing Data Among Methods
 Java is a “pass-by-value” language. This means that a copy of the variable
is made and the method receives that copy.
 The correct answer is Webby.
 A copy is made of the primitive or reference and returned from the
method. Most of the time, this returned value is used.

Overloading Methods
 Method overloading occurs when there are different method signatures
with the same name but different type parameters.
 Everything other than the method signature can vary for overloaded
methods. This means there can be different access modifiers, specifiers (like
static), return types, and exception lists. Overloaded methods;
 public void fly( int numMiles) { }
 public void fly( short numFeet) { }
 public boolean fly() { return false; }
 void fly( int numMiles, short numFeet) { }
 public void fly( short numFeet, int numMiles) throws Exception { }

Overloading Methods
 That is not valid overloading:
 This method doesn't compile because it only differs from the original by
return type.

Overloading and Varargs
 Which method do you think is called if we pass an int[]?
 Remember that Java treats varargs as if they were an array.

Autoboxing
 What happens if we have both a primitive and an integer version?
 This means calling fly( 3);
 Java will match the int numMiles version. Java tries to use the most specific
parameter list it can find. When the primitive int version isn't present, it will
autobox.

Reference Types
 Given the rule about Java picking the most specific version of a method
that it can.
 The first call is a String and finds a direct match. There's no reason to use the
Object version.
 The second call Object one.

Primitives
 The answer is int long. If we comment out the overloaded method with the
int parameter list, the output becomes long long.
 Note that Java can only accept wider types. An int can be passed to a
method taking a long parameter.

Creating Constructors
 As you learned in Chapter 1, a constructor is a special method that
matches the name of the class and has no return type.
 Constructors are used when creating a new object. This process is called
instantiation because it creates a new instance of the class. A constructor is
called when we write new followed by the name of the class we want to
instantiate.
 new Bunny()
 When Java sees the new keyword, it allocates memory for the new object.

Creating Constructors
 The this keyword tells Java you want to reference an instance variable.
Most of the time, this is optional. The problem is that sometimes there are
two variables with the same name.
 Some examples that aren't common but that you might see on the exam:

Default Constructor
 Every class in Java has a constructor whether you code one or not. If you
don't include any constructors in the class, Java will create one for you
without any parameters. This Java-created constructor is called the default
constructor.
 Remember that a default constructor is only supplied if there are no
constructors present. Only Rabbit1 gets a default no-argument constructor.

Default Constructor
 Rabbit4 made the constructor private so that other classes could not call it.
 This is useful when a class only has static methods or the class wants to
control all calls to create new instances of itself.

Overloading Constructors
 You can have multiple constructors in the same class as long as they have
different method signatures.
 Constructors must have different parameters in order to be overloaded.
 There is a problem here, though. There is a bit of duplication.

Overloading Constructors
 this() has one special rule you need to know. If you choose to call it, the
this() call must be the first noncommented statement in the constructor.

Constructor Chaining
 Overloaded constructors often call each other. One common technique is
to have each constructor add one parameter until getting to the
constructor that does all the work. This approach is called constructor
chaining.

Final Fields
 final instance variables must be assigned a value exactly once.
 There is one more location this assignment can be done: in the constructor.
 The constructor is part of the initialization process, so it is allowed to assign
final instance variables in it. By the time the constructor completes, all final
instance variables must have been set.

Order of Initialization
 You do have to memorize this list.
 If there is a superclass, initialize it first (we'll cover this rule in the next chapter. For
now, just say “no superclass” and go on to the next rule.)
 Static variable declarations and static initializers in the order they appear in the
file.
 Instance variable declarations and instance initializers in the order they appear in
the file.
 The constructor.

 The output is: 0, 10, Torchie, constructor

 The output looks like this: 0, read to construct, Torchie, 1, constructor

Encapsulating Data
 Encapsulation means we set up the class so only methods in the class with
the variables can refer to the instance variables. Callers are required to use
these methods.
 For encapsulation, remember that data (an instance variable) is private
and getters/ setters are public.

Encapsulating Data
 Java defines a naming convention that is used in JavaBeans. JavaBeans
are reusable software components. JavaBeans call an instance variable a
property.

Creating Immutable Classes
 Encapsulating data is helpful because it prevents callers from making
uncontrolled changes to your class. Another common technique is making
classes immutable so they cannot be changed at all.
 Immutable classes are helpful because you know they will always be the
same. You can pass them around your application with a guarantee that
the caller didn't change anything.
 One step in making a class immutable is to omit the setters.

Writing Simple Lambdas
 Java is an object-oriented language at heart.
 In Java 8, the language added the ability to write code using another style.
 Functional programming is a way of writing code more declaratively. You
focus more on expressions than loops.
 Functional programming uses lambda expressions to write code. A lambda
expression is a block of code that gets passed around. You can think of a
lambda expression as an anonymous method.
 It has parameters and a body just like full-fledged methods do, but it
doesn't have a name like a real method.
 Lambda expressions are often referred to as lambdas for short.
 You might also know them as closures in other languages.

Lambdas
 Only the simplest lambda expressions are on the OCA exam. You'll see
lambdas again on the OCP exam.
 Our goal is to print out all the animals in a list according to some criteria.
 We plan to write a lot of different checks, so we want an interface.

Lambdas
 The first thing we want to check is whether the Animal can hop.
 Now we have everything that we need to write our code to find the Animals that hop:

Lambdas
 Now what happens if we want to print the Animals that swim? Sigh. We
need to write another class CheckIfSwims.
 Turns out that we can with lambda expressions. We could repeat that
whole class here and make you find the one line that changed.
 How about Animals that cannot swim?
 This code uses a concept called deferred execution. Deferred execution
means that code is specified now but will run later. In this case, later is
when the print() method calls it.

Lambda Syntax
 a -> a.canHop();
 This means that Java should call a method with an Animal parameter that
returns a boolean value that's the result of a.canHop().
 We are passing this lambda as the second parameter of the print()
method. That method expects a CheckTrait as the second parameter.
Since we are passing a lambda instead, Java tries to map our lambda to
that interface:
 boolean test( Animal a);
 Since that interface's method takes an Animal, that means the lambda
parameter has to be an Animal. And since that interface's method returns
a boolean, we know the lambda returns a boolean.

Lambda Syntax
 The syntax of lambdas is tricky because many parts are optional. These two
lines do the exact same thing:
 Specify a single parameter with the name a
 The arrow operator to separate the parameter and body
 A body that calls a single method and returns the result of that method

Lambda Syntax
 Specify a single parameter with the name a and stating the type is Animal
 The arrow operator to separate the parameter and body
 A body that has one or more lines of code, including a semicolon and a
return statement
 The parentheses can only be omitted if there is a single parameter and its
type is not explicitly stated.

Lambda Syntax
 Some examples of valid lambdas.
 The first line needs parentheses around the parameter list. Remember that the
parentheses are only optional when there is one parameter and it doesn't have
a type declared. The second line is missing the return keyword. The last line is
missing the semicolon.
 You might have noticed all of our lambdas return a boolean. That is because
the scope for the OCA exam limits what you need to learn.

Lambda Syntax
 There is one more issue you might see with lambdas. We've been defining
an argument list in our lambda expressions. Since Java doesn't allow us to
redeclare a local variable,
 http://kodcu.com/2014/03/java-8-lambda-expression-nedir-nasil-kullanirim/

Predicates
 Lambdas work with interfaces that have only one method.
 These are called functional interfaces— interfaces that can be used with
functional programming.
 You can imagine that we'd have to create lots of interfaces like this to use
lambdas. We want to test Animals and Strings and Plants and anything else
that we come across.
 Luckily, Java recognizes that this is a common problem and provides such
an interface for us. It's in the package java.util.function and the gist of it is
as follows:

Predicates
 Java 8 even integrated the Predicate interface into some existing classes.
There is only one you need to know for the exam. ArrayList declares a
removeIf() method that takes a Predicate.
 Line 8 takes care of everything for us. It defines a predicate that takes a
String and returns a boolean. The removeIf() method does the rest.

Predicates
 For the OCA exam, you only need to know how to implement lambda
expressions that use the Predicate interface. Remember the one method in
the interface called test()?
 It takes any one reference type parameter and returns a boolean.
 Functional programming is a large topic and just the basics are covered.
On the OCP exam, you'll learn how to get rid of the loop entirely for more
than just removeIf().
 You'll also learn the rules for implementing your own functional interface.

OCA Java SE 8 Exam Chapter 4 Methods Encapsulation

More Related Content

What's hot (20)

Viewers also liked (14)

Similar to OCA Java SE 8 Exam Chapter 4 Methods Encapsulation (20)

More from İbrahim Kürce (6)

Recently uploaded (20)

OCA Java SE 8 Exam Chapter 4 Methods Encapsulation