inheritance of java...basics of java in ppt

Classes and Objects in Java
and
Inheritance in Java
1
Basics of Classes in Java Recap

Contents
 Introduction to classes and objects in Java.
 Understand how some of the OO concepts learnt
so far are supported in Java.
 Understand important feature inheritance in
Java classes.
2

Introduction
 Java is a true OO language and therefore the underlying
structure of all Java programs is classes.
 Anything we wish to represent in Java must be encapsulated
in a class that defines the “state” and “behavior” of the basic
program components known as objects.
 Classes create objects and objects use methods to
communicate between them. They provide a convenient
method for packaging a group of logically related data items
and functions that work on them.
 A class essentially serves as a template for an object and
behaves like a basic data type “int”. It is therefore important
to understand how the fields and methods are defined in a
class and how they are used to build a Java program that
incorporates the basic OO concepts such as encapsulation,
inheritance, and polymorphism.
3

Classes
 A class is a collection of fields (data) and methods
(procedure or function) that operate on that data.
4
Circle
centre
radius
circumference()
area()

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:
 Bare bone class – no fields, no methods
5
public class Circle {
// my circle class
}
class ClassName
{
[fields declaration]
[methods declaration]
}

Adding Fields: Class Circle with fields
 Add fields
 The fields (data) are also called the instance
varaibles.
6
public double x, y; // centre coordinate
public double r; // radius of the circle
}

Adding Methods
 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 form of a method declaration is:
7
type MethodName (parameter-list)
{
Method-body;
}

8
public double x, y; // centre of the circle
public double r; // radius of circle
r = 2;
//Methods to return circumference and area
public double circumference() {
return 2*3.14*r;
}
public double area() {
return 3.14 * r * r;
}
}
Method Body

Data Abstraction
Can define variables (objects) of that type:
Circle aCircle;
Circle bCircle;
Circle aCircle = new aCircle();
Circle bCircle=new bCircle():
9
Data abstraction is the
reduction of a particular body
of data to a simplified
representation of the whole

Class of Circle cont.
 aCircle, bCircle simply refers to a Circle object,
not an object itself.
10
aCircle
Points to nothing (Null Reference)
bCircle
Points to nothing (Null Reference)
null null

11
Creating objects of a class
aCircle = new Circle();
bCircle = new Circle() ;
bCircle = aCircle;

 Objects are created dynamically using the new
keyword.
 aCircle and bCircle refer to Circle objects
 Circle aCircle;
12
aCircle = new Circle() ;

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

Automatic garbage collection
 The object 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.
14

Accessing Object/Circle Data
 Similar to C syntax for accessing data defined in
a structure.
15
Circle aCircle = new Circle();
aCircle.x = 2.0 // initialize center and radius
aCircle.y = 2.0
aCircle.r = 1.0
ObjectName.VariableName
ObjectName.MethodName(parameter-list)

Executing Methods in Object/Circle
 Using Object Methods:
16
Circle aCircle = new Circle();
double area;
aCircle.r = 1.0;
area = aCircle.area();
sent ‘message’ to aCircle

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);
}
}
17
java MyMain
Radius=5.0 Area=78.5
Radius=5.0 Circumference =31.400000000000002
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;
}
public double area() {
return 3.14 * r * r;
}
}

Inheritance in Java
 It is the mechanism in java by which one class is
allow to inherit the features(fields and methods)
of another class.
class ClassName [extends SuperClassName]
{
[fields declaration]
[methods declaration]
}
18

Important terminology:
 Super Class: The class whose features are inherited is
known as super class(or a base class or a parent class).
 Sub Class: The class that inherits the other class is known
as sub class(or a derived class, extended class, or child
class). The subclass can add its own fields and methods in
addition to the superclass fields and methods.
 Reusability: Inheritance supports the concept of
“reusability”, i.e. when we want to create a new class and
there is already a class that includes some of the code that
we want, we can derive our new class from the existing
class. By doing this, we are reusing the fields and methods
of the existing class.
19

 The keyword used for inheritance is extends.
Syntax :
 class derived-class extends base-class { //methods
and fields }
21

Types of Inheritance in Java
 Single Inheritance :
In single inheritance, subclasses inherit the features of
one superclass. In image below, the class A serves as
a base class for the derived class B.
22

Example
//Java program to illustrate the
// concept of single inheritance
import java.util.*;
import java.lang.*;
import java.io.*;
class one
{
public void print_geek()
{
System.out.println("Geeks");
}
}
class two extends one
{
public void print_for()
{
System.out.println("for");
}
}
// Driver class
public class Main
{
public static void main(String[] args)
{
two g = new two();
g.print_geek();
g.print_for();
g.print_geek();
}
}
23

Multilevel Inheritance
 In Multilevel Inheritance, a derived class will be inheriting a
base class and as well as the derived class also act as the base
class to other class. In below image, the class A serves as a base
class for the derived class B, which in turn serves as a base class
for the derived class C. In Java, a class cannot directly access the
grandparent’s members.
24

Example for multilevel Inheritance
import java.util.*;
import java.lang.*;
import java.io.*;
class one
{
{
}
}
{
{
}
}
class three extends two
{
{
}
}
// Drived class
public class Main
{
public static void main(String[]
args)
{
three g = new three();
g.print_geek();
g.print_for();
g.print_geek();
}
}
26

Hierarchical Inheritance :
 In Hierarchical Inheritance, one class serves as a superclass (base
class) for more than one sub class.In below image, the class A
serves as a base class for the derived class B,C and D.
27

// Java program to illustrate the
// concept of Hierarchical inheritance
import java.util.*;
import java.lang.*;
import java.io.*;
class one
{
{
}
}
{
{
}
}
class three extends one
{
/*............*/
}
// Drived class
public class Main
{
{
three g = new three();
g.print_geek();
two t = new two();
t.print_for();
g.print_geek();
}
}
28

Multiple Inheritance (Through
Interfaces)
 In Multiple inheritance ,one class can have more than one superclass and
inherit features from all parent classes. Please note that Java does not
support multiple inheritance with classes. In java, we can achieve multiple
inheritance only through Interfaces. In image below, Class C is derived from
interface A and B.
29

Multiple Inheritance (Through
Interfaces)
30

Example of Multiple Inheritance
// Java program to illustrate the
// concept of Multiple inheritance
import java.util.*;
import java.lang.*;
import java.io.*;
interface one
{
public void print_geek();
}
interface two
{
public void print_for();
}
interface three extends one,two
{
public void print_geek();
}
class child implements three
{
@Override
public void print_geek() {
}
{
}
}
// Drived class
public class Main
{
{
child c = new child();
c.print_geek();
c.print_for();
c.print_geek();
}
}
31

Hybrid Inheritance(Through
Interfaces)
 It is a mix of two or more of the above types of
inheritance. Since java doesn’t support multiple
inheritance with classes, the hybrid inheritance
is also not possible with classes. In java, we can
achieve hybrid inheritance only through
Interfaces.
32

Hybrid Inheritance(Through
Interfaces)
33

Advantages of Inheritance
 Reusability -- facility to use public methods of base class
without rewriting the same
 Extensibility -- extending the base class logic as per business
logic of the derived class
 Data hiding -- base class can decide to keep some data private so
that it cannot be altered by the derived class
 Overriding -- With inheritance, we will be able to override the
methods of the base class so that meaningful implementation
of the base class method can be designed in the derived class.
34

Method Overloading
 If a class has multiple methods having same
name but different in parameters, it is known
as Method Overloading.
 It is also known as Compile-Time Polymorphism
35

Overloading
 If we have to perform only one operation, having
same name of the methods increases the
readability of the program
36

Overloading
 Different ways to overload the method
There are two ways to overload the method in java
 By changing number of arguments
 By changing the data type
37

Overloading
 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));
}}
38

Overloading
 2) Method Overloading: changing data type of
arguments
class Adder{
int add(int a, int b){return a+b;}
double add(double a, double b){return a+b;}
}
class TestOverloading2{
Adder ob1= new Adder();
Ob1.add(11,11);
Ob1.add(11,12.6);
//System.out.println(Adder.add(11,11));
//System.out.println(Adder.add(12.3,12.6));
}}
39

Method Overriding
 If subclass (child class) has the same method as
declared in the parent class, it is known
as method overriding in Java.
 In other words, If a subclass provides the specific
implementation of the method that has been
declared by one of its parent class, it is known as
method overriding.
40

Overriding
 Overriding is a feature that allows a subclass or
child class to provide a specific implementation
of a method that is already provided by one of its
super-classes or parent classes.
41

Overriding
 When a method in a subclass has the same name,
same parameters or signature, and same return
type(or sub-type) as a method in its super-class,
then the method in the subclass is said to
override the method in the super-class.
42

Usage of Java Method Overriding
 Method overriding is used to provide the specific
implementation of a method which is already
provided by its superclass.
 Method overriding is used for runtime
polymorphism
44

 Rules for Java Method Overriding
 The method must have the same name as in the
parent class
 The method must have the same parameter as in the
parent class.
 There must be an IS-A relationship (inheritance).
45

Overriding
class Vehicle{
//defining a method
void run(){System.out.println("Vehicle is running");}
}
//Creating a child class
class Bike2 extends Vehicle{
//defining the same method as in the parent class
void run(){System.out.println("Bike is running safely");}
public static void main(String args[]){
Bike2 obj = new Bike2();//creating object
obj.run();//calling method
}
}
Output:
Bike is running safely 46

Scope of the Variable
Method Scope
Variables declared directly inside a method are
available anywhere in the method following the
line of code in which they were declared.
47

Scope of Variables in Java
 Scope is that area of the program where the variable
is visible to a program and can be used (accessible).
 i.e. the scope of variable determines its accessibility
for other parts of program.
 Java allows declaring variables within any block. A
block defines scope that starts with an opening curly
brace and ends with a closing curly brace.
 There are three types of variables in java,
depending on their scope: local variables, instance
variables, and class variables (static variables).
48

Scope of Variables in Java
 1. Scope of Local Variables in Java
 2. Scope of Instance variables in Java
 3. Scope of Static variables
49

Scope of the method
public class MyClass {
public static void main(String[] args) {
// Code here cannot use x
int x = 100;
// Code here can use x
System.out.println(x);
}
}
50

Block Scope
 A block of code refers to all of the code between
curly braces {}
 Variables declared inside blocks of code are
only accessible by the code between the curly
braces which follows the line in which the
variable was declared.
 A block of code may exist on its own or it may
belong to an if, while or for statement. In the
case of for statements, variables declared in the
statement itself are also available inside the
block's scope.
51

Example Program
public class MyClass {
// Code here CANNOT use x
{ // This is a block
int x = 100;
// Code here CAN use x
System.out.println(x);
} // The block ends here
}
}
52

Java Modifiers
Modifiers divided into two groups:
Access Modifiers - controls the access level
Non-Access Modifiers - do not control access level,
but provides other functionality
53

The four primary access modifiers
in Java are:
 Default access modifier
 Protected access modifier
 Public access modifier
 Private access modifier
54

Access Modifiers
For classes, we can use either public or default
public :The class is accessible by any other class
default :The class is only accessible by classes in the
same package. This is used when you don't specify a
modifier.
//You will learn more about packages in the Packages
chapter
55

Access Modifiers
For attributes, methods and constructors, you can
use one of the following:
public :The code is accessible for all classes
private :The code is only accessible within the declared
class
default :The code is only accessible in the same package.
This is used when you don't specify a modifier. You will
learn more about packages in the Packages chapter
protected :The code is accessible in the same package and
subclasses. You will learn more about subclasses and
superclasses in the Inheritance chapter
56

Non-Access Modifiers
For classes, we can use either final or abstract:
final:The class cannot be inherited by other classes
abstract :The class cannot be used to create objects (To
access an abstract class, it must be inherited from
another class. You will learn more about inheritance
and abstraction in the Inheritance and Abstraction
chapters)
57

Non Access Modifiers
final Attributes and methods cannot be overridden/modified
static Attributes and methods belongs to the class, rather than an object
abstract
Can only be used in an abstract class, and can only be used on methods.
The method does not have a body, for example abstract void run();. The
body is provided by the subclass (inherited from). You will learn more
about inheritance and abstraction in the Inheritance and Abstraction
chapters
transient
Attributes and methods are skipped when serializing the object
containing them
synchronize
d
Methods can only be accessed by one thread at a time
volatile
The value of an attribute is not cached thread-locally, and is always read
from the "main memory" 58

Java Package
 A java package is a group of similar types of
classes, interfaces and sub-packages.
 Package in java can be categorized in two form,
built-in package and user-defined package.
61

Java Packages
 There are many built-in packages such as java,
lang, awt, javax, swing, net, io, util, sql etc.
Advantage of Java Package
 Java package is used to categorize the classes and
interfaces so that they can be easily maintained.
 Java package provides access protection.
 Java package removes naming collision.
62

Syntax to create packages
package nameOfPackage;
64

Java Packages
Consider the following package program in Java:
package pack;
public class A
{ public void msg()
{System.out.println("Hello");
}
}
65

Java Packages
package mypack;
import pack.*;
class B{
public static void main(String args[])
{ A obj = new A();
obj.msg();
}
}
67

Default access modifiers
 The default access modifier is accessible to any
package by default. The programmers need not
specify any keyword to use the default access
modifier.
 It means that the programmer doesn’t need to specify
a class, method, or constructor default explicitly.
 A class or method is, by default, accessible from any
other “class” that exists in the same package. We
usually don’t define variables and methods with any
access modifier.
70

Example Code
class Def {
int num = 175;
void print() {
System.out.println("Default class " + num);
}
}
public class Test {
public static void main(String args[]) {
Def def = new Def();
def.print();
}
}
Output:
Default class 175
71

Private access modifiers
 As the name suggests, the private access modifier limits
access to the defining “class” only. With the help of the
“private” keyword, we can implement the real concept
of Data Encapsulation. It means to hide the private
members form the outside world.
 The functions labeled as private are accessible within
the class only.
 You can’t declare a top-level class or interface as
private. Also, if so, then it would be useless as no one
could access it.
 The programmer must define a getter or setter to
access private methods or variables.
72

The example below will help you visualize a getter for the private
method:
class Priv {
private void PRINT() {
System.out.println("Private access");
}
public void getPrint() {
PRINT();
}
}
public class Test {
Private priv = new Priv();
priv.PRINT();
}
}
Output:Private access
73

Public access modifiers
 The public modifiers are the most common
in Java applications. They mean that any
public class, method, variable, interface, or
constructor is accessible throughout the
package.
 Before using a public class in another
package, you must first import it.
 If you inherit a public class, then the
subclass will have all its methods and
variables by default.
74

Example Code For Public access
modifier
public class First {
public void print() {
System.out.println("Hello");
}
public class Test extends First {
First first = new First();
first.print();
}
}
Output:Hello
75

Protected access modifiers
 Objects or methods having protected access are
visible to the package and subclasses only.
 The following are a few points to elaborate on the
exact behavior:
 These methods, variables, or constructors are
accessible within the package only and also
available to all the subclasses.
 The protected keyword doesn’t apply to any class or
interface.
 Interface methods or variables can’t have protected
access.
76

Example Code for Protected Access:
public class First {
protected static int count;
public void update(){
System.out.println(++count);
}
public class Test extends First {
First out = new First();
out.update();
}
}
}Output:1
77

Non-access modifiers
 Static – It means something is directly related to a
class.
 Final – It indicates that the object is immutable.
 Abstract – It means you need to subclass for creating
objects.
 Synchronized – It indicates that only one thread can
execute a method at a time.
 Transient – It means to exclude something during
serialization.
 Volatile – It indicates that different threads can modify
a variable’s value.
 Native – It shows that the method is available in the
native code using JNI or JNA.
78

Static Modifier
 Static Modifier is used for creating a static
variable and static method.
 The reserved keyword for a static modifier is
static, which is used before the data type of the
variable or method.
 A static method or variable exists independently
of any class object.
 It means a static variable or static method can
be called using the class name without creating
an instance or object of this class.
79

Static Modifier
 Car.java
public class Car{
public static String msg; //String type static
variable is declared
public static void create(){
System.out.print(msg); //Variable msg is passed as
argument to print.
}
}
80

Static Modifier
Main.java
public class Main
{ //initialization of class
{
//value is stored in static variable
Car.msg = "A new car has been created";
// static method in class Car is invoked
Car.create();
}
}
81

Final Modifier
 In Java, variable, method, and class can have a final
non-access modifier. The reserved keyword for a
final non-access modifier is final. This keyword is
used to make any class, method, or variable final.
 Once a final variable is initialized, you cannot change
its value again. A final variable that is uninitialized is
called a blankfinal variable that can be initialized
only in the constructor of a class. To make a class
variable, sometimes, we use the static keyword
with final. If a static final variable is not initialized,
we can initialize it in a static block.
82

Final Modifier
public class Main{ //initialization of class
//declare a final variable of int data type
public final int number = 1;
//non-static method to print number value
public void print(){
System.out.print(number); //print number
number = 2; //change value of number
System.out.print(number); //print new value
}
// main method
//object of class Main to access non-static methods
Main p = new Main();
//print method invoked
p.print();
}
} //end of class 83

If we remove code at line 11, the modified code would be executed without
any error.
Code Example for Final Variable:
//declare a final variable of int data type
public final int number = 1;
//non-static method to print number value
System.out.print("Output is "+number); //print number
}
// main method
//object of class Main to access non-static methods
Main p = new Main();
//print method invoked
p.print();
}
} //end of class
84

 Code Example for Static Final Variable:
//declare a static final variable of int data type
public static final int number = 1;
// main method
System.out.print("Output is "+number); //print number
}
} //end of class
 A method that we cannot override is called final method. It can be
inherited in any other class.
85

Code Example for Final Method:
Car.java
public class Car{
//final method
public final void create(){
System.out.print("I'm final method to create a car.");
}
}
Main.java
//initialization of class
public class Main extends Car{
//non-static method to access non-static methods in Car.java
public void makeCar(){
create(); //method invoked
}
// main method
Main m = new Main(); //object of Main class
m.makeCar(); //call to makeCar method
} //end of main method
} //end of class
86

A class that we cannot extend is called final class. It means a final class cannot be inherited by any
other class.
 Code Example for Final Class:
Car.java
public final class Car{
//void method
//method body
}
}
Main.java
} //end of class
87

Abstract Modifier
 A class or method can be declared as abstract. Reserved keyword abstract is
used for the abstract modifier.
 An abstract class or method cannot be final because an abstract class is made
with the purpose of extending it in other classes and an abstract method is
made for the sole purpose of overriding the method body. To make a class
abstract, at least one abstract method should be defined in a class. If we have to
declare abstract methods in a class, a class must be an abstract class.
 An abstract method is just a declaration; it does not contain an implementation
or method body. You will have to define its implementation by overriding this
method in a class, which has extended the abstract class. When a class extends
an abstract class, all the abstract methods defined in the abstract class must be
overridden in a subclass.
88

Example Code: Abstact Modifier
Car.java
public abstract class Car{
public abstract void create();
System.out.print("I'm not abstract
method.");
}
}
89
Main.java
// overriding method defined in Car
class
//as create is only abstract method in
Car class
//overriding it is compulsory
//otherwise error will occur
@Override
public void create(){
System.out.println("I'm overridden
method.");
}
// main method
Main m = new Main(); //object of Main
class
m.create(); //invoking overridden
method
m.print();
} //end of class

Volatile Modifier
 This modifier is applied only to private or object type
instance field or variable. Reserved keyword for this
modifier is volatile.
 It indicates to the JVM to merge a thread’s own copy
of field with the master copy of field available in
memory. When we access a volatile variable, it
synchronizes all the available cached copies of
variables in memory.
90

Volatile Modifier
public class Salary implements Runnable {
private volatile int salary;
public void run() {
salary = 5000; //assigning value to salary
do{
//loop body
}
while (salary <= 5000); // while loop definition
}
public void stop() {
salary = 5001; // new value assignment to salary
}
}
91

Transient Modifier
 When we use a transient modifier in an instance
variable declaration, the JVM will skip this
variable or field while serializing the object
containing that variable. Reserved keyword
is transient.
92

Transient Modifier
//instance variable with transient modifier
public transient int number = 22114;
}
93

Synchronized Modifier
 A modifier that is used to restrict a method to be
used by any other thread when it is under use of
one thread. Reserved keyword for this modifier
is synchronized.
 The synchronized modifier can be used with any
access modifier.
94

Synchronized Modifier
public synchronized make(){
//method body
}
}
95

Abstract Classes and Methods
 Data abstraction is the process of hiding certain
details and showing only essential information to
the user.
 Abstraction can be achieved with either abstract
classes or interfaces (which you will learn more
about in the next chapter).
96

Abstract Classes and Methods
 The abstract keyword is a non-access modifier, used
for classes and methods:
 Abstract class: is a restricted class that cannot be
used to create objects (to access it, it must be
inherited from another class).

Abstract method: can only be used in an abstract
class, and it does not have a body. The body is
provided by the subclass (inherited from).
97

Abstract Classes
 An abstract class can have both abstract and
regular methods:
abstract class Animal {
public abstract void animalSound();
public void sleep() {
System.out.println("Zzz");
}
}
98

Abstract Classes
 From the example above, it is not possible to
create an object of the Animal class:
Animal myObj = new Animal(); // will generate an
error
 To access the abstract class, it must be inherited
from another class
99

Abstract Classes
// Abstract class
abstract class Animal {
// Abstract method (does not have a
body)
public abstract void animalSound();
// Regular method
public void sleep() {
System.out.println("Zzz");
}
}
// Subclass (inherit from Animal)
class Pig extends Animal {
public void animalSound() {
// The body of animalSound() is
provided here
System.out.println("The pig says:
wee wee");
}
}
100
class MyMainClass {
Pig myPig = new Pig(); // Create a Pig
object
myPig.animalSound();
myPig.sleep();
}
}

JAVA Packages
 A java package is a group of similar types of
classes, interfaces and sub-packages.
 Package in java can be categorized in two form,
built-in package and user-defined package.
101

JAVA Packages
Advantage of Java Package
1) Java package is used to categorize the classes and
interfaces so that they can be easily maintained.
2) Java package provides access protection.
3) Java package removes naming collision.
102

Java Packages Categories
 Built-in Packages (packages from the Java API)
 User-defined Packages (create your own
packages)
104

Built-in Packages
 The Java API is a library of prewritten classes, that
are free to use, included in the Java D
 To use a class or a package from the library, you
need to use the import keyword:evelopment
Environment.
Syntax
 import package.name.Class; // Import a single class
import package.name.*; // Import the whole package
105

Built-in Packages
 If you find a class you want to use, for example,
the Scanner class, which is used to get user
input, write the following code:
Example
 import java.util.Scanner;
106

Example
import java.util.Scanner;
class MyClass
{ public static void main(String[] args)
{
Scanner myObj = new Scanner(System.in);
System.out.println("Enter username");
String userName = myObj.nextLine();
System.out.println("Username is: " + userName);
}
}
107

Import a Package
 To import a whole package, end the sentence
with an asterisk sign (*). The following example
will import ALL the classes in
the java.util package:
Example
import java.util.*;
108

User-defined Packages
 To create your own package, you need to
understand that Java uses a file system
directory to store them. Just like folders on your
computer:
 Example
└── root
└── mypack
└── MyPackageClass.java
109

MyPackageClass.java
 To create a package, use the package keyword:
package mypack;
class MyPackageClass
{ public static void main(String[] args)
{ System.out.println("This is my package!"); } }
110

Java Packages
 Save the file as MyPackageClass.java, and
compile it:
 C:UsersYour Name>javac MyPackageClass.java
 compile the package:
 C:UsersYour Name>javac -d .
MyPackageClass.java
111

Java Packages
To run the MyPackageClass.java file, write the
following:
C:UsersYour Name>java
mypack.MyPackageClass
The output will be:
This is my package!
112

Java Packages
 Simple example of java package
//save as Simple.java
package mypack;
public class Simple{
public static void main(String args[]){
System.out.println("Welcome to package");
}
}
113

inheritance of java...basics of java in ppt

More Related Content

Similar to inheritance of java...basics of java in ppt (20)

More from ssuserec53e73 (9)

Recently uploaded (20)

inheritance of java...basics of java in ppt