Java Basics

(Fundamentals)
By
Mahesh Kumar G P
Agenda
 Java Ws…?
 Parameter passing
 Packages
 Encapsulation
 Getter methods returning objects
 Assignments
Java Ws

 The below list answers some of the questions like,

what is java ? Why java ? Etc..
 Simple:
Don’t believe me…?
What if I say ,java doesn’t have pointers.
 Secure and Portable :
 Applications written using Java are portable, in the sense that they can be executed on
any kind of computer containing any CPU or any operating system.
 When an application written in Java is compiled, it generates an intermediate code file
called as “bytecode”.
 Bytecode helps Java to achieve portability.
 This bytecode can be taken to any computer and executed directly.
 Object-Oriented and functional:
supports all the features of object oriented model like:
 Encapsulation
 Inheritance
 Polymorphism
 Abstraction

Supports functional programming through lambdas

 Multithreaded
Parameter passing

public static void main(String... args)

{
int a = 10;
int b = 20;
S.O.P.(a, b); // 10, 20
swap(a, b);
S.O.P.(a, b); // 20, 10
}
Parameter passing

public static void swap(int x, int y)

{
int temp = x;
x = y;
y = temp;
}
Parameter passing ? stack view

Y(20)

X(10)

B(20)

A(10)
Parameter passing

public static void main(String... args)

{
Integer a = 10;
Integer b = 20;
S.O.P.(a, b); // 10, 20
swap(a, b);
S.O.P.(a, b); // 20, 10
}
Parameter passing

public static void swap(Integer x, Integer y)

{
Integer temp = x;
x = y;
y = temp;
}
Parameter passing

20
X

B
10
A
Parameter passing

Java parameter passing is always

“pass by value”
Packages: WHY?

 Class name conflicts

 Act as name spaces

 Logical grouping of classes

 ease of maintainence
Encapsulation

public class MyInt

{
private int value;
public void setValue(int value)
{
this.value = value;
}
public int getVaule()
{
return value;
}
}
Why encapsulation

 Enforcing constraints

 Hiding implementation

 Synchronization
Encapsulation ? reference leaking

public class Employee

{
private Date joiningDate;
public Date getJoiningDate()
{
return joiningDate;
}

}
Encapsulation ? reference leaking

 Returning references to
 private/protected
 mutable
 objects

 How to rectify?
 cloning!
What is inheritance

Person

Employee Student
What is inheritance

 To inherit: to derive or acquire from ancestors

 In an OO world, what can be acquired?

 data
 code

 In an OO world, who are the

ancestors/descendants?
 classes
What is inheritance

 In an OO world when a class acquires

 data
 methods
 or both
 from another class

it is inheritance
Why inheritance

 Code reuse
 Less code to maintain
 Creation of frameworks
 parent classes perform common tasks
 children classes provide specific details

 Loose coupling/pluggability
Polymorphism

 Polymorphism
 poly: many
 morph: form
 when a class reference takes many forms

class Parent...
class Child1 extends Parent...
class Child2 extends Parent...
Parent p = new Child1(); //or Child2() or Parent()
Method overriding: dynamic
polymorphism
public class Foo
{
public void foo(){S.O.P.(?in parent foo()?);}
}

public class FooChild extends Foo

{
public void foo(){S.O.P.(?in child foo()?);}
}

Foo f = new Foo(); f.foo(); // in parent foo()

Foo f = new FooChild(); f.foo(); // in child foo()
Dynamic polymorphism

Dynamic polymorphism because

which method to call
is decided at runtime
Static Polymorphism

public class Foo

{
public void foo(int x){S.O.P.(?int: ? + x);}
public void foo(long x){S.O.P.(?long: ? + x);}
}
int i = 10;
long j = 20;
Foo f = new Foo();
f.foo(i);
f.foo(j);
Static polymorphism

Static polymorphism because

which method to call
is decided at compile time
Method access modifier overridings

class Foo
{
public void foo()...
}

class FooChild extends Foo

{
protected void foo()...
}

What is wrong in this?

Method access modifier overridings

 No clear way to resolve the ambiguity of restricted

access modifier overriding

 Hence it's not allowed by the compiler

Method access modifier overridings

class Foo
{
protected void foo()...
}

class FooChild extends Foo

{
public void foo()...
}

What is wrong in this?

Method access modifier overridings

 Nothing wrong in it!

 The contract of allowing subclasses or package

classes to access 'foo()' will always be honoured

 Hence it's allowed by the compiler

A simple way to remember this

 Liskov Substitution Principle (LSP)

 Sub classes should be able to replace their base

classes
 public -> protected can not
 protected -> public can
Member variable overriding

class Foo
{
protected int x = 10;
public void foo(){S.O.P.(x)}
}
class FooChild extends Foo
{
protected int x = 20;
}

Foo f = new FooChild();

f.foo(); // what will this print?
Member variable overriding

 This will print 10

 Java has no concept of member varibale overriding

Static method overriding

class Foo
{
public static void foo(){S.O.P.(?in parent?)}
}
class FooChild extends Foo
{
public static void foo(){S.O.P.(?in child?)}
}

Foo f = new FooChild();

 f.foo(); // what will this print?
Static method overriding

 “in parent”

 Static methods belong to classes

 Their calls resolved at compile time

 Hence they can not be polymorphically overridden

Static method overriding

class Foo
{
public static void foo(){S.O.P.(“in parent”)}
}
class FooChild extends Foo
{
public static void foo(){S.O.P.(“in child”)}
}

FooChild f = new FooChild();

f.foo(); // what will this print?
Static member inheritance

class Foo
{
protected static int x = 10;
public static void printX(){S.O.P.(x);}
}
class FooChild extends Foo
{
public static void setX(int val){x = val;}
}

FooChild.setX(100);
Foo.printX(); // what will this print?
Static member inheritance

 This will print 100

 Static members are shared, not copied

Assignment

 Write a simple Java program to prove that method

overloading is static polymorphism

i.e., a call to one of these methods is resolved at

compile time
public class Example {
void method(int n) {
System.out.println("Number: " + n);
}
}

public class ExampleWithString extends Example {

void method(String s) {
System.out.println("Text: " + s);
}

public static void main(String[] args) {

Example e = new ExampleWithString();

e.method(23);
e.method("Hello"); // Error. Even though instance has method.
}
}