OOP Using Java Unit 1

DEPT & SEM : CSE & I SEM
SUBJECT NAME: OBJECT ORIENTED PROGRAMMING

THROUGH JAVA
COURSE CODE : 20A05302T
UNIT : I
PREPARED BY : P LAKSHMI
CONCEPTS:
• Introduction to Object Oriented Programming
• The History and Evolution of Java
• Introduction to Classes
• Objects, Methods
• Constructors, this keyword, Garbage Collection
• Data Types, Variables,
• Type Conversion and Casting , Arrays
• Operators, Control Statements,
• Method Overloading, Constructor Overloading
• Parameter Passing, Recursion,
• String Class and String handling methods.
COURSE: OOPJ UNIT: 1 Pg. 2

OBJECT ORIENTED PROGRAMMING
 What is Java ?
• Java is a “Programming Language”.
 What is a programming Language?
Programming
Spoken
Languages
Languages
Fig . 1.1:Person to person communication Fig . 1.2:person to system communication
 A programming language is set of instructions , used to establish communication

between human and a system

JAVA’S LINEAGE
 Java is related to C++, which is a direct descendant of C.

 Much of the character of Java is inherited from these two languages.
 From C, Java derives its syntax. Many of Java’s object oriented features were influenced
by C++.
Earlier languages (cobal, pascal,etc..)
C Language (Procedure oriented)
C++ Language (Object oriented, platform dependent)
Java Language (Object oriented, platform independent)

There are four main OOP concepts in Java. These are:

 Abstraction. Abstraction means using simple things to represent complexity. We all
know how to turn the TV on, but we don’t need to know how it works in order to
enjoy it. In Java, abstraction means simple things like objects, classes,
and variables represent more complex underlying code and data. This is important
because it lets avoid repeating the same work multiple times.
 Encapsulation. This is the practice of keeping fields within a class private, then
providing access to them via public methods. It’s a protective barrier that keeps the
data and code safe within the class itself. This way, we can re-use objects like code
components or variables without allowing open access to the data system-wide.

 Inheritance. This is a special feature of Object Oriented Programming in Java. It lets

programmers create new classes that share some of the attributes of existing
classes. This lets us build on previous work without reinventing the wheel.
 Polymorphism. This Java OOP concept lets programmers use the same word to
mean different things in different contexts. One form of polymorphism in Java
is method overloading. That’s when different meanings are implied by the code
itself. The other form is method overriding. That’s when the different meanings are
implied by the values of the supplied variables.

THE HISTORY AND EVOLUTION OF JAVA
 Java was developed by James Gosling and his
team at Sun Microsystems, Inc. in 1991.
 This language was initially called “Oak,” but was
renamed “Java” in 1995.
 But the history of Java starts with the Green
project .
 Java team members (also known as Green Team) Fig . 1.3 : James Gosling
 Initiated this project to develop a software for
digital devices such as set-top boxes, televisions,
etc. However, it was suited for internet
programming.
 Green Team thought choose c or c++ language
to develop project, but they face problem with
that languages is both languages are platform
dependent.
 Green Team started a new project to develop a
new language that should be platform Fig . 1.4 : James Gosling and his team
independent.
JAVA’S MAGIC: THE BYTECODE
 Java bytecode is the instruction set for the Java Virtual Machine.
 Java byte code is the combination of object code and assembly code .
 When we write a program in Java, firstly, the compiler compiles that program and a
bytecode (class file) is generated for that piece of code.
 When we wish to run this .class file is executed by JVM and generate matching
code.
Fig . 1.5: java Architecture

JAVA BUZZWORDS
1.Simple
->(easy to learn and write)
2.Secure
(provides data security through encapsulation )

3.Portable
(they can be executed on any kind OS)

4.Object-Oriented
(it is complete object oriented programming)

5.Robust
(it is very strong with type checking

6.Multithreaded
( java support Multithreading)


7.Architecture neutral
 (java is platform independent)
8.Interpreted
 (java maintain both compiler and interpreter)
9.High Performance
 (java maintain JIT compiler)
10.Distributed
 (Java supports distributed computation using Remote Method Invocation (RMI)
concept. )
11.Dynamic
(Libraries are dynamically linked during runtime


CLASSES
 A class is a collection of Objects. Objects may be fields (data) and methods

(procedure or function) that operate on that data.
(Or)
 A class is a blueprint or template from which individual objects are created.
Circle (Class name)
Centre (Variables)
radius
circumference()
area()
Fig . 1.6: Class Structure

CLASSES
 A class is a collection of fields (data) and methods (procedure or function) that

operate on that data.
The basic syntax for a class definition:
class ClassName [extends SuperClassName]

{
[fields declaration]
[methods declaration]
}
 Bare bone class – no fields, no methods
public class Circle

{
// my circle class
}

ADDING FIELDS: CLASS CIRCLE WITH FIELDS
 Add fields
public class Circle
{
public double x, y; // centre coordinate
public double r; // radius of the circle
}
 The fields (data) are also called the instance varaibles.

 A class with only data fields has no life. Objects created by such a class cannot
respond to any messages.
 Methods are declared inside the body of the class but immediately after the
declaration of data fields.
 The general
typeform of a method
MethodName declaration is:
(parameter-list)
{
Method-body;
}
ADDING METHODS TO CLASS CIRCLE
public class Circle {
public double x, y; // centre of the circle

public double r; // radius of circle
//Methods to return circumference and area

public double circumference()
{
return 2*3.14*r;
} Method Body
public double area()
{
return 3.14 * r * r;
}
}

VARIABLE TYPES
A class can contain any of the following variable types.

 Local variables − Variables defined inside methods, constructors or blocks are called
local variables. The variable will be declared and initialized within the method and
the variable will be destroyed when the method has completed.
 Instance variables − Instance variables are variables within a class but outside any
method. These variables are initialized when the class is instantiated. Instance
variables can be accessed from inside any method, constructor or blocks of that
particular class.
 Class variables − Class variables are variables declared within a class, outside any
method, with the static keyword(can be used to refer the common property of all
objects.)

Exp:
public class Dog { void hungry()
static String animal_type; // Class variable {
String breed; // instance variable String foodtype; //Local variable
int age; }
String color; void sleeping()
void barking() {
{ }
}

CREATING OBJECTS OF A CLASS:
 Objects are created dynamically using the new keyword.

 aCircle and bCircle refer to Circle objects
aCircle = new Circle();
bCircle = new Circle();
bCircle = aCircle;
aCircle bCircle

aCircle = new Circle();
bCircle = new Circle() ;
bCircle = aCircle;
Before Assignment After Assignment
aCircle bCircle aCircle bCircle
P Q P Q

AUTOMATIC GARBAGE COLLECTION
 The object Q does not have a reference and cannot be used in future.
 The object becomes a candidate for automatic garbage collection.
 Java automatically collects garbage periodically and releases the memory used to be
used in the future.
ACCESSING OBJECT/CIRCLE DATA:
Syntax for accessing data defined in a structure.
ObjectName . VariableName
ObjectName .MethodName(parameter-list)
Circle aCircle = new Circle();

aCircle.x = 2.0 // initialize center and radius
aCircle.y = 2.0
aCircle.r = 1.0

USING CIRCLE CLASS:
// Circle.java: Contains both Circle class and its user class
//Add Circle class code here
class MyMain
{
public static void main(String args[])
{
Circle aCircle; // creating reference
aCircle = new Circle(); // creating object
aCircle.x = 10; // assigning value to data field
aCircle.y = 20;
aCircle.r = 5;
double area = aCircle.area(); // invoking method
double circumf = aCircle.circumference();
System.out.println("Radius="+aCircle.r+" Area="+area);
System.out.println("Radius="+aCircle.r+" Circumference ="+circumf);
}
}
OUT PUT :
Radius=5.0 Area=78.5
Radius=5.0 Circumference =31.400000000000002
CONSTRUCTOR
 Constructor in java is a special type of method that is used to initialize the object.
 Java constructor is invoked at the time of object creation. It constructs the values i.e.
provides data for the object that is why it is known as constructor.
RULES FOR CREATING JAVA CONSTRUCTOR:
There are basically two rules defined for the constructor.
1.Constructor name must be same as its class name
2.Constructor must have no explicit return type
TYPES OF JAVA CONSTRUCTORS
There are two types of constructors:
1. Default constructor (no-arg constructor)
2. Parameterized constructor

EXAMPLE OF DEFAULT CONSTRUCTOR
class Bike1
{
Bike1(){System.out.println("Bike is created");}
public static void main(String args[]){
Bike1 b=new Bike1();
}
}
Output:
Bike is created

EXAMPLE OF PARAMETERIZED CONSTRUCTOR
class Student4
{
int id;
String name;
Student4(int i,String n){
id = i;
name = n;
}
void display(){System.out.println(id+" "+name);}
public static void main(String args[]){
Student4 s1 = new Student4(111,"Karan");
Student4 s2 = new Student4(222,"Aryan");
s1.display();
s2.display();
}
}
Output:
111 Karan
222 Aryan
this KEYWORD
 this is a reference variable that refers to the current object in java.

 It is a keyword in java language represents current class object.
 this is always a reference to the object on which the method was invoked.
 It can be used in side of method or constructor.
USAGE OF THIS KEYWORD
 It can be used to refer current class instance variable. { this.x }
 this() can be used to invoke current class constructor from another method or constructor.
{ this(); }
 It can be used to invoke current class method (implicitly)
{ this.add() }
 It can be passed as an argument in the method call.
{ add(this);}
 It can be passed as argument in the constructor call.
 It can also be used to return the current class instance.
{ return this; }

WHY USE THIS KEYWORD IN JAVA ?
 The main purpose of using this keyword is to differentiate the formal parameter and
data members of class.
 whenever the formal parameter and data members of the class are similar then jvm
get ambiguity (no clarity between formal parameter and member of the class)
 To differentiate between formal parameter and data member of the class, the data
member of the class must be preceded by "this".

EXAMPLE WITHOUT USING THIS KEYWORD
class Employee
{ int id; String name;
Employee(int id,String name)
{ id = id;
name = name;
}
void show()
{ System.out.println(id+" "+name); }
{ Employee e1 = new Employee(111,"Harry");
Employee e2 = new Employee(112,"Jacy");
e1.show(); e2.show();
}
}
Output
0 null 0 null

EXAMPLE WITH USING THIS KEYWORD
class Employee
{ int id; String name;
Employee(int id,String name)
{ this. id = id;
this. name = name;
}
void show()
{ System.out.println(id+" "+name); }
{ Employee e1 = new Employee(111,"Harry");
Employee e2 = new Employee(112,"Jacy");
e1.show(); e2.show();
}
}
Output
111 Harry 112 Jacy

GARBAGE COLLECTION:
 In java, garbage means unreferenced objects created by new operator dynamically.
 Garbage Collection is process of reclaiming the runtime unused memory automatically. In
other words, it is a way to destroy the unused objects.
 To do so, we were using free() function in C language and delete() in C++. But, in java it is
performed automatically. So, java provides better memory management.
ADVANTAGE OF GARBAGE COLLECTION
 It makes java memory efficient because garbage collector removes the unreferenced
objects from heap memory.
 It is automatically done by the garbage collector(a part of JVM) so we don't need to
make extra efforts.
 If you want to make your object eligible for Garbage Collection, assign its reference
variable to null.
 Primitive types are not objects. They cannot be assigned null.

DATA TYPES :
Data Type Size Description
byte 1 byte Stores whole numbers from -128 to 127
short 2 bytes Stores whole numbers from -32,768 to 32,767
int 4 bytes Stores whole numbers from -2,147,483,648 to

2,147,483,647
long 8 bytes Stores whole numbers from -
9,223,372,036,854,775,808 to
9,223,372,036,854,775,807
float 4 bytes Stores fractional numbers. Sufficient for storing
6 to 7 decimal digits
double 8 bytes Stores fractional numbers. Sufficient for storing
15 decimal digits
boolean 1 bit Stores true or false values
char 2 bytes Stores a single character/letter or ASCII values

VARIABLES:
 Variables are containers for storing data values

DECLARING (CREATING) VARIABLES:
 To create a variable, you must specify the type and assign it a value:
Syntax: type variable = value;
 Where type is one of Java's types (such as int or String), and variable is the name of
the variable (such as x or name). The equal sign is used to assign values to the
variable.
 To create a variable that should store text, look at the following Example
 Create a variable called name of type String and assign it the value "John":
String name = "John";

System.out.println(name);

TYPE CONVERSION AND CASTING
 Java provides various datatypes to store various data values.
 Converting one primitive datatype into another is known as type casting (type
conversion) in Java.
 Widening − Converting a lower datatype to a higher datatype is known as widening.
In this case the casting/conversion is done automatically therefore, it is known as
implicit type casting. In this case both datatypes should be compatible with each
other.
Fig . 1.7 : Winding type

 Narrowing − Converting a higher datatype to a lower datatype is known as
narrowing. In this case the casting/conversion is not done automatically, you need
to convert explicitly using the cast operator “( )” explicitly. Therefore, it is known as
explicit type casting. In this case both datatypes need not be compatible with each
other.
Fig . 1.8:Narrowing type

ARRAYS
DECLARING AND CREATING AN ARRAY VARIABLE:
 Do not have to create an array while declaring array variable
<type> [] variable_name;
<type> variable_name[];
Ex:
int [] prime;
int prime[];
 Above both syntaxes are equivalent
 No memory allocation at this point
 In Java we allocate memory for array variables with the help of “new” keyword.
 Define an array as follows:
variable_name=new <type>[N];
Ex: primes=new int[10];
 Declaring and defining in the same statement:
int[] primes=new int[10];
 In JAVA, int is of 4 bytes, total space 4*10=40 bytes

DEFAULT INITIALIZATION:
 When array is created, array elements are initialized default as
• Numeric values (int, double, etc.) to 0
• Boolean values to false
• Char values to ‘\u0000’ (unicode for blank character)
• Class types to null
TWO-DIMENSIONAL ARRAYS
float[][] temperature=new float[10][365];
• 10 arrays each having 365 elements
• First index: specifies array (row)
• Second Index: specifies element in that array (column)
•I n JAVA float is 4 bytes, total Size=4*10*365=14,600 bytes
THREE-DIMENSIONAL ARRAY:
long[][][] beans=new long[5][10][30];
OPERATORS:
GROUP OF OPERATORS:
 Arithmetic Operators(+,-,*,/ ,%)
• Assignment Operator(=)
• Order of Precedence
• Increment/Decrement Operators(++,--)
 Relational Operators(<,>,<=,>=,==,!=)
 Logical Operators(&&,||,!)
 Bitwise Operators(~,&,|,^)
 Shift Operators(>>,>>>,>>)
 Ternary Operator(?)

OPERATORS PRECEDENCE
Parentheses (), inside-out

Increment/decrement ++, --, from left to right
Multiplicative *, /, %, from left to right
Additive +, -, from left to right
Relational <, >, <=, >=, from left to right
Equality ==, !=, from left to right
Logical AND &&
Logical OR ||
Assignment =, +=, -=, *=, /=, %=

SHIFT OPERATORS :
 Shift Left (<<) Fill with Zeros

 Shift Right (>>) Based on Sign
 Shift Right (>>>) Fill with Zeros
int a = 3; // ...00000011 = 3
int b = -4; // ...11111100 = -4
a 00000000000000000000000000000011 3
a << 2 00000000000000000000000000001100 12
<<
Left
b 11111111111111111111111111111100 -4
b << 2 11111111111111111111111111110000 -16
a 00000000000000000000000000000011 3
a >> 2 00000000000000000000000000000000 0
>>
Left
b 11111111111111111111111111111100 -4
b >> 2 11111111111111111111111111111111 -1

SHIFT OPERATOR >>>:
int a = 3; // ...00000011 = 3
int b = -4; // ...11111100 = -4
a 00000000000000000000000000000011 3
a >>> 2 00000000000000000000000000000000 0
>>>
Right 0
b 11111111111111111111111111111100 -4
b >>> 2 00111111111111111111111111111111 +big

SHIFT OPERATOR EXAMPLES
public class Example

{
public static void main(String[] args)
{
int a = 3; // ...00000011 = 3
int b = -4; // ...11111100 = -4
System.out.println("a<<2 = " + (a<<2));

System.out.println("b<<2 = " + (b<<2));
System.out.println("a>>2 = " + (a>>2));
System.out.println("b>>2 = " + (b>>2)); > java Example
a<<2 = 12
System.out.println("a>>>2 = " + (a>>>2)); b<<2 = -16
System.out.println("b>>>2 = " + (b>>>2)); a>>2 = 0
b>>2 = -1
} a>>>2 = 0
} b>>>2 = 1073741823
>
THE ?(TERNARY) OPERATOR
 Java includes a special ternary operator that can replace certain types of if – then -
else statements. This operator is ?.
The syntax is:
expression1?expression2:expression3;
Hear expression1 returns boolean value.
 If expression1 returns true then expression2 is executed, if expression1 return
false then expression3 is exicuted.
EXAMPLE :
class CheckEvenNumber
{
public static void main( String args[] ) {
int number = 3;
String msg = (number % 2 == 0) ? " The number is even!" : " The number is odd!";
System. out. println(msg);
} }

CONTROL STATEMENTS
Fig . 1.9 Fig . 1.10

Fig . 1.11

Fig . 1.12

Fig . 1.13

LEXICAL ISSUES
There are many atomic elements of Java.

 Java programs are a collection of
• whitespace,
• identifiers,
• comments,
• literals,
• operators,
• Separators
• keywords.

METHOD/CONSTRUCTOR OVERLOADING
 In Java, it is possible to define two or more methods within the same class that share the
same name, as long as their parameter declarations are different.
 If a class has multiple methods having same name but different in parameters, it is
known as Method Overloading.
 Method overloading is one of the ways that Java supports polymorphism.
ADVANTAGE OF METHOD OVERLOADING:
 Method overloading increases the readability of the program.
DIFFERENT WAYS TO OVERLOAD THE METHOD:
There are two ways to overload the method in java
1. By changing number of arguments
2. By changing the data type

1. METHOD OVERLOADING: CHANGING NO. OF ARGUMENTS
class Adder
{
static int add(int a,int b)
{return a+b;}
static int add(int a,int b,int c)
{return a+b+c;}
}
class TestOverloading1{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(11,11,11));
}
}
Out put:
22
33
2) METHOD OVERLOADING: CHANGING DATA TYPE OF ARGUMENTS
class Adder
{
static int add(int a, int b)
{return a+b;}
static double add(double a, double b)
{return a+b;}
}
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(12.3,12.6));
}
}
Out put:
22
24.9
Note:
 In java, method overloading is not possible by changing the return type of the method
only because of ambiguity.
 We can also overload java main() method. You can write any number of main methods in
a class by method overloading. But JVM calls main() method which receives string array as
arguments only. Let's see the simple example:
 If there are matching type(int & long) arguments in the method, type promotion is not
performed.
 We can also overload constructor methods
Exp:
public static void main(String[] args){System.out.println("main with String[]");}
public static void main(String args){System.out.println("main with String");}
public static void main(){System.out.println("main without args");}
} Out put: main with String[] COURSE: OOPJ UNIT: 1 Pg. 48
PARAMETER PASSING
 In general, there are two ways that a computer language can pass an argument.
1. call-by-value(pass values).
2. call-by-reference(pass object).
 Java also use above two ways to pass an argument.
 When you pass a primitive type to a method, it is passed by value
 When you pass an object to a method, it is call-by-reference

// PRIMITIVE TYPES ARE PASSED BY VALUE.(CALL BY VALUE)
class Test {
void meth(int i, int j)
{
i *= 2;
j /= 2;
}
}
class CallByValue {
public static void main(String args[]) {
Test ob = new Test();
int a = 15, b = 20;
System.out.println("a and b before call: " + a + " " + b);
ob.meth(a, b);
System.out.println("a and b after call: " + a + " " + b);
} }
The output from this program is shown here:
a and b before call: 15 20
a and b after call: 15 20

// OBJECTS ARE PASSED THROUGH THEIR REFERENCES (CALL BY REFERENCE).
class Test {
int a, b;
Test(int i, int j) {
a = i;
b = j;
}
// pass an object
void meth(Test o) {
o.a *= 2;
o.b /= 2;
} }
class PassObjRef {
public static void main(String args[]) {
Test ob = new Test(15, 20);
System.out.println("ob.a and ob.b before call: " + ob.a + “ " + ob.b);
ob.meth(ob);
System.out.println("ob.a and ob.b after call: " + ob.a + " " + ob.b);
} }
This program generates the following output:
ob.a and ob.b before call: 15 20
ob.a and ob.b after call: 30 10

RECURSION:
 Java supports recursion.
 Recursion is the process of defining something in terms of itself
 Java programming, recursion is the attribute that allows a method to call itself.
 A method that calls itself is said to be recursive.
EXAMPLE FOR RECURTION:
class Factorial {
// this is a recursive method
int fact(int n) {
int result;
if(n==1) return 1;
result = fact(n-1) * n;
//fact(3-1)*3->fact(2-1)*2*3->1*2*3
return result;
}
}
class Recursion {
public static void main(String args[]) { The output from this program is shown
Factorial f = new Factorial(); here:
System.out.println("Factorial of 3 is " + f.fact(3));
System.out.println("Factorial of 4 is " + f.fact(4)); Factorial of 3 is 6
System.out.println("Factorial of 5 is " + f.fact(5)); Factorial of 4 is 24
} } Factorial of 5 is 120

EXPLORING THE STRING CLASS
 Java does not support String type, it is not a simple type .
 String is an array of characters. It is under the package java.lang.*;
 In java String is an “Object”.
 Strings in java are immutable
 Once created they cannot be altered and hence any alterations will lead to creation of
new string object
 String is thread safe. It can not be used by two threads simultaneously
 Note: Object is the super class for all classes in java
String s1 = “Example”
String s2 = new String(“Example”)
String s3 = “Example”
 The difference between the three statements is that, s1 and s3 are pointing to the same
memory location i.e. the string pool . s2 is pointing to a memory location on the heap.
 Using a new operator creates a memory location on the heap.
 Concatenating s1 and s3 leads to creation of a new string in the pool.
STRING METHODS
Method Description Return
Type
charAt() Returns the character at the specified index (position) char
codePointAt() Returns the Unicode of the character at the specified index int
codePointBefore() Returns the Unicode of the character before the specified index int
codePointCount() Returns the Unicode in the specified text range of this String int
compareTo() Compares two strings lexicographically int
compareToIgnoreCase() Compares two strings lexicographically, ignoring case differences int
concat() Appends a string to the end of another string String
contains() Checks whether a string contains a sequence of characters boolean
contentEquals() Checks whether a string contains the exact same sequence of boolean
characters of the specified CharSequence or StringBuffer
copyValueOf() Returns a String that represents the characters of the character array String
endsWith() Checks whether a string ends with the specified character(s) boolean
equals() Compares two strings. Returns true if the strings are equal, and false if boolean
not
CONTENT BEYOND SYLLABUS
JAVA VERSIONS:
Version - Release date Version - Release date
• JDK Beta - 1995 • Java SE 8 - March 2014
• JDK 1.0 - January 1996 • Java SE 9 - September 2017
• JDK 1.1 - February 1997 • Java SE 10 - March 2018
• J2SE 1.2 - December 1998 • Java SE 11 - September 2018
• J2SE 1.3 - May 2000 • Java SE 12 - March 2019
• J2SE 1.4 - February 2002 • Java SE 13 - September 2019
• J2SE 5.0 - September 2004 • Java SE 14 - March 2020
• Java SE 6 - December 2006 • Java SE 15 - September 2020
• Java SE 7 - July 2011

CONTENT BEYOND SYLLABUS
STRUCTURE OF JAVA PROGRAMMING
Fig . 1.14
UNIT OUTCOMES:
Student should be able to
 Understand the syntax, semantics and features of Java Programming Language.
 Learn object oriented features and understanding type conversion and casting.
 Understand different types of string handling functions and its usage.

DIGITAL RESOURCES
 Lecture Notes - Lecture Notes
 Video Lectures - Video Lecture
 E-Book - Java The Complete Reference Ninth Edition
 Model Papers - JNTUA Question Papers

THANK YOU

OOP Using Java Unit 1

Uploaded by

Copyright:

Available Formats

OOP Using Java Unit 1

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

OOP Using Java Unit 1

Uploaded by

Copyright:

Available Formats

DEPT & SEM : CSE & I SEM

SUBJECT NAME: OBJECT ORIENTED PROGRAMMING

COURSE CODE : 20A05302T

COURSE: OOPJ UNIT: 1 Pg. 2

Fig . 1.1:Person to person communication Fig . 1.2:person to system communication

 A programming language is set of instructions , used to establish communication

COURSE: OOPJ UNIT: 1 Pg. 3

 Java is related to C++, which is a direct descendant of C.

C Language (Procedure oriented)

C++ Language (Object oriented, platform dependent)

Java Language (Object oriented, platform independent)

COURSE: OOPJ UNIT: 1 Pg. 4

There are four main OOP concepts in Java. These are:

COURSE: OOPJ UNIT: 1 Pg. 5

 Inheritance. This is a special feature of Object Oriented Programming in Java. It lets

COURSE: OOPJ UNIT: 1 Pg. 6

Fig . 1.5: java Architecture

COURSE: OOPJ UNIT: 1 Pg. 9

COURSE: OOPJ UNIT: 1 Pg. 10

 A class is a collection of Objects. Objects may be fields (data) and methods

Circle (Class name)

Fig . 1.6: Class Structure

COURSE: OOPJ UNIT: 1 Pg. 11

 A class is a collection of fields (data) and methods (procedure or function) that

class ClassName [extends SuperClassName]

 Bare bone class – no fields, no methods

public class Circle

COURSE: OOPJ UNIT: 1 Pg. 12

 The fields (data) are also called the instance varaibles.

public class Circle {

public double x, y; // centre of the circle

//Methods to return circumference and area

COURSE: OOPJ UNIT: 1 Pg. 14

A class can contain any of the following variable types.

COURSE: OOPJ UNIT: 1 Pg. 15

static String animal_type; // Class variable {

String breed; // instance variable String foodtype; //Local variable

String color; void sleeping()

COURSE: OOPJ UNIT: 1 Pg. 16

 Objects are created dynamically using the new keyword.

COURSE: OOPJ UNIT: 1 Pg. 17

Before Assignment After Assignment

aCircle bCircle aCircle bCircle

COURSE: OOPJ UNIT: 1 Pg. 18

Circle aCircle = new Circle();

COURSE: OOPJ UNIT: 1 Pg. 19

COURSE: OOPJ UNIT: 1 Pg. 21

COURSE: OOPJ UNIT: 1 Pg. 22

 this is a reference variable that refers to the current object in java.

COURSE: OOPJ UNIT: 1 Pg. 24

COURSE: OOPJ UNIT: 1 Pg. 25

COURSE: OOPJ UNIT: 1 Pg. 26

COURSE: OOPJ UNIT: 1 Pg. 27

COURSE: OOPJ UNIT: 1 Pg. 28

byte 1 byte Stores whole numbers from -128 to 127

short 2 bytes Stores whole numbers from -32,768 to 32,767

int 4 bytes Stores whole numbers from -2,147,483,648 to

char 2 bytes Stores a single character/letter or ASCII values

COURSE: OOPJ UNIT: 1 Pg. 29