Core Java - Unit 1 2 3

1) A Simple Class :
/* A program that uses the Box class.

Call this file BoxDemo.java
*/
class Box {
double width;
double height;
double depth;
}
// This class declares an object of type Box.
class BoxDemo {
public static void main(String args[]) {
Box mybox = new Box();
double vol;
// assign values to mybox's instance variables
mybox.width = 10;
mybox.height = 20;
mybox.depth = 15;
// compute volume of box
vol = mybox.width * mybox.height * mybox.depth;
System.out.println("Volume is " + vol);
}
}
Output:
Volume is 3000.0
2)
// This program declares two Box objects.
class Box {
double width;
double height;
double depth;
}
class BoxDemo2 {
Box mybox1 = new Box();
double vol;
// assign values to mybox1's instance variables
mybox1.width = 10;
mybox1.height = 20;
mybox1.depth = 15;
// assign different values to mybox2's instance variables
mybox2.width = 3;
mybox2.height = 6;
mybox2.depth = 9;
// compute volume of first box
vol = mybox1.width * mybox1.height * mybox1.depth;
// compute volume of second box
vol = mybox2.width * mybox2.height * mybox2.depth;
}
}
Output :
Volume is 3000.0
Volume is 162.0
CORE JAVA EXAMPLES PGK

3) Adding a Method to the Box Class :
// This program includes a method inside the box class.
class Box {
double width;
double height;
double depth;
// display volume of a box
void volume() {
System.out.print("Volume is ");
System.out.println(width * height * depth);
}
}
class BoxDemo3 {
mybox1.width = 10;
mybox1.height = 20;
mybox1.depth = 15;
/* assign different values to mybox2's
instance variables */
mybox2.width = 3;
mybox2.height = 6;
mybox2.depth = 9;
// display volume of first box
mybox1.volume();
// display volume of second box
mybox2.volume();
}
}
Output:
Volume is 3000.0
Volume is 162.0
4) Returning a Value :
// Now, volume() returns the volume of a box.
class Box {
double width;
double height;
double depth;
// compute and return volume
double volume() {
return width * height * depth;
}
}
class BoxDemo4 {
double vol;
mybox1.width = 10;
mybox1.height = 20;
mybox1.depth = 15;
/* assign different values to mybox2's
instance variables */
mybox2.width = 3;
mybox2.height = 6;
mybox2.depth = 9;
// get volume of first box
vol = mybox1.volume();
// get volume of second box
}
}
5) Adding a Method That Takes Parameters :
// This program uses a parameterized method.
class Box {
double width;
double height;
double depth;

double volume() {
}
// sets dimensions of box

void setDim(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
}
class BoxDemo5 {
double vol;
// initialize each box
mybox1.setDim(10, 20, 15);
mybox2.setDim(3, 6, 9);
}
}
6) Constructors :
/* Here, Box uses a constructor to initialize the

dimensions of a box. */
class Box {
double width;
double height;
double depth;
// This is the constructor for Box.

Box() {

System.out.println("Constructing Box");
width = 10;
height = 10;
depth = 10;
}

double volume() {
}
}
class BoxDemo6 {
// declare, allocate, and initialize Box objects
double vol;
}
}
Output:
Constructing Box
Constructing Box
Volume is 1000.0
Volume is 1000.0
7) Parameterized Constructors :
/* Here, Box uses a parameterized constructor to
initialize the dimensions of a box.*/
class Box {
double width;
double height;
double depth;
// This is the constructor for Box.
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
double volume() {
}
}
class BoxDemo7 {
// declare, allocate, and initialize Box objects
Box mybox1 = new Box(10, 20, 15);
double vol;
}
}
Output:
Volume is 3000.0
Volume is 162.0
8) The this Keyword :
// A redundant use of this.

this.width = w;
this.height = h;
this.depth = d;
}
// Use this to resolve name-space collisions.

Box(double width, double height, double depth) {
this.width = width;
this.height = height;
this.depth = depth;
}
9) Overloading Methods :
// Demonstrate method overloading.
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for one integer parameter.

void test(int a) {
System.out.println("a: " + a);
}
// Overload test for two integer parameters.

void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}
// Overload test for a double parameter

double test(double a) {
System.out.println("double a: " + a);
return a*a;
}
}
class Overload {
OverloadDemo ob = new OverloadDemo();
double result;
// call all versions of test()
ob.test();
ob.test(10);
ob.test(10, 20);
result = ob.test(123.25);

System.out.println("Result of ob.test(123.25): " + result);
}
}
Output:
No parameters
a: 10
a and b: 10 20
double a: 123.25
Result of ob.test(123.25): 15190.5625
10) Overloading Constructors :
/* Here, Box defines three constructors to initialize

the dimensions of a box various ways. */
class Box {
double width;
double height;
double depth;
// constructor used when all dimensions specified
width = w;
height = h;
depth = d;
}
// constructor used when no dimensions specified
Box() {
width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box
}
// constructor used when cube is created
Box(double len) {
width = height = depth = len;
}
double volume() {
}
}
class OverloadCons {
// create boxes using the various constructors
Box mycube = new Box(7);
double vol;
System.out.println("Volume of mybox1 is " + vol);
// get volume of cube
vol = mycube.volume();
System.out.println("Volume of mycube is " + vol);
}
}
Output:
Volume of mybox1 is 3000.0
Volume of mybox2 is -1.0
Volume of mycube is 343.0
11) Using Objects as Parameters :
// Objects may be passed to methods.

class Test {
int a, b;
Test(int i, int j) {
a = i;
b = j;
}
// return true if o is equal to the invoking object
boolean equalTo(Test o) {
if(o.a == a && o.b == b)
return true;
else
return false;
}
}
class PassOb {
Test ob1 = new Test(100, 22);
Test ob2 = new Test(100, 22);
Test ob3 = new Test(-1, -1);
System.out.println("ob1 == ob2: " + ob1.equalTo(ob2));
System.out.println("ob1 == ob3: " + ob1.equalTo(ob3));
}
}
Output:
ob1 == ob2: true
ob1 == ob3: false
12) Box Objects as Parameters :

// Here, Box allows one object to initialize another.
class Box {
double width;
double height;
double depth;
// Notice this constructor. It takes an object of type Box.
Box(Box ob) { // pass object to constructor
width = ob.width;
height = ob.height;
depth = ob.depth;
}
width = w;
height = h;
depth = d;
}
Box() {
depth = -1; // box

}
Box(double len) {
}
double volume() {
}
}
class OverloadCons2 {
// create boxes using the various constructors
Box mycube = new Box(7);
Box myclone = new Box(mybox1); // create copy of mybox1
double vol;
// get volume of cube
System.out.println("Volume of cube is " + vol);
// get volume of clone
vol = myclone.volume();
System.out.println("Volume of clone is " + vol);
}
}
13) Static :
// Demonstrate static variables, methods, and blocks.

class UseStatic {
static int a = 3;
static int b;
static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
static {
System.out.println("Static block initialized.");
b = a * 4;
}
meth(42);
}
}
Output:
Static block initialized.
x = 42
a=3
b = 12

14) Static :
class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {

System.out.println("a = " + a);
}
}
class StaticByName {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);
}
}
Output:
a = 42
b = 99
15) Nested and Inner Classes :

// Demonstrate an inner class.
class Outer {
int outer_x = 100;
void test() {
Inner inner = new Inner();
inner.display();
}
// this is an inner class

class Inner {
void display() {
System.out.println("display: outer_x = " + outer_x);
}
}
}
class InnerClassDemo {
Outer outer = new Outer();
outer.test();
}
}
Output:
display: outer_x = 100
16)
// This program will not compile.
class Outer {
int outer_x = 100;
void test() {
Inner inner = new Inner();
inner.display();
}
// this is an inner class
class Inner {

int y = 10; // y is local to Inner
void display() {
System.out.println("display: outer_x = " + outer_x);
}
}
void showy() {
System.out.println(y); // error, y not known here!
}
}
class InnerClassDemo {
Outer outer = new Outer();
outer.test();
}
}
17) String Class :
// Demonstrating Strings.
class StringDemo {
String strOb1 = "First String";
String strOb2 = "Second String";
String strOb3 = strOb1 + " and " + strOb2;
System.out.println(strOb1);
}
}
Output:
First String
Second String
First String and Second String
18)
// Demonstrating some String methods.
class StringDemo2 {
String strOb1 = "First String";
String strOb2 = "Second String";
String strOb3 = strOb1;
System.out.println("Length of strOb1: " +
strOb1.length());
System.out.println("Char at index 3 in strOb1: " +
strOb1.charAt(3));
if(strOb1.equals(strOb2))
System.out.println("strOb1 == strOb2");
else
System.out.println("strOb1 != strOb2");
if(strOb1.equals(strOb3))
System.out.println("strOb1 == strOb3");
else
System.out.println("strOb1 != strOb3");
}
}
Output:
Length of strOb1: 12

Char at index 3 in strOb1: s
strOb1 != strOb2
strOb1 == strOb3
19)
// Demonstrate String arrays.
class StringDemo3 {
String str[] = { "one", "two", "three" };
for(int i=0; i<str.length; i++)
System.out.println("str[" + i + "]: " +
str[i]);
}
}
Output:
str[0]: one
str[1]: two
str[2]: three
20) Inheritance :
// A simple example of inheritance.

// Create a superclass.
class A {
int i, j;
void showij() {
System.out.println("i and j: " + i + " " + j);
}
}
// Create a subclass by extending class A.

class B extends A {
int k;
void showk() {
System.out.println("k: " + k);
}
void sum() {
System.out.println("i+j+k: " + (i+j+k));
}
}
class SimpleInheritance {
public static void main(String args []) {
A superOb = new A();
B subOb = new B();
// The superclass may be used by itself.
superOb.i = 10;
superOb.j = 20;
System.out.println("Contents of superOb: ");
superOb.showij();
System.out.println();
/* The subclass has access to all public members of
its superclass. */
subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Contents of subOb: ");
subOb.showij();
subOb.showk();

System.out.println("Sum of i, j and k in subOb:");
subOb.sum();
}
}
Output:
Contents of superOb:
i and j: 10 20
Contents of subOb:
i and j: 7 8
k: 9
Sum of i, j and k in subOb:
i+j+k: 24
21) Member Access and Inheritance :

/* In a class hierarchy, private members remain
private to their class.
This program contains an error and will not
compile.
*/
// Create a superclass.
class A {
int i; // public by default
private int j; // private to A
void setij(int x, int y) {

i = x;
j = y;
}
}
// A's j is not accessible here.

class B extends A {
int total;
void sum() {
total = i + j; // ERROR, j is not accessible here
}
}
class Access {
B subOb = new B();
subOb.setij(10, 12);
subOb.sum();
System.out.println("Total is " + subOb.total);
}
}
22)
// This program uses inheritance to extend Box.

class Box {
double width;
double height;
double depth;
// construct clone of an object
width = ob.width;
height = ob.height;

depth = ob.depth;
}
width = w;
height = h;
depth = d;
}
Box() {
depth = -1; // box
}
Box(double len) {
}
double volume() {
}
}
// Here, Box is extended to include weight.

class BoxWeight extends Box {
double weight; // weight of box
// constructor for BoxWeight
BoxWeight(double w, double h, double d, double m) {
width = w;
height = h;
depth = d;
weight = m;
}
}
class DemoBoxWeight {
BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);
double vol;
System.out.println("Weight of mybox1 is " + mybox1.weight);
}
}
Output:
Weight of mybox1 is 34.3
23) A Superclass Variable Can Reference a Subclass Object :
Writing Test class for the same Example :

class RefDemo {
BoxWeight weightbox = new BoxWeight(3, 5, 7, 8.37);
Box plainbox = new Box();
double vol;
vol = weightbox.volume();
System.out.println("Volume of weightbox is " + vol);
System.out.println("Weight of weightbox is " +
weightbox.weight);
// assign BoxWeight reference to Box reference
plainbox = weightbox;
vol = plainbox.volume(); // OK, volume() defined in Box
System.out.println("Volume of plainbox is " + vol);
/* The following statement is invalid because plainbox
does not define a weight member. */
// System.out.println("Weight of plainbox is " + plainbox.weight);
}
}
24) Using super to Call Superclass Constructors :
// A complete implementation of BoxWeight.

class Box {
private double width;
private double height;
private double depth;
width = ob.width;
height = ob.height;
depth = ob.depth;
}
width = w;
height = h;
depth = d;
}
Box() {
depth = -1; // box
}
Box(double len) {
}
double volume() {
}
}
// BoxWeight now fully implements all constructors.

BoxWeight(BoxWeight ob) { // pass object to constructor
super(ob);
weight = ob.weight;
}
// constructor when all parameters are specified
super(w, h, d); // call superclass constructor
weight = m;
}
// default constructor
BoxWeight() {
super();
weight = -1;
}
BoxWeight(double len, double m) {
super(len);
weight = m;
}
}
class DemoSuper {
BoxWeight mybox3 = new BoxWeight(); // default
BoxWeight mycube = new BoxWeight(3, 2);
BoxWeight myclone = new BoxWeight(mybox1);
double vol;
vol = mybox2.olume();
vol = myclone. volume();
System.out.println("Volume of myclone is " + vol);
System.out.println("Weight of myclone is " + myclone.weight);
System.out.println("Volume of mycube is " + vol);
System.out.println("Weight of mycube is " + mycube.weight);
}
}
Output:
Volume of mybox3 is -1.0
Weight of mybox3 is -1.0
Volume of myclone is 3000.0
Weight of myclone is 34.3
Volume of mycube is 27.0
Weight of mycube is 2.0
25) A Second Use for super :
// Using super to overcome name hiding.

class A {
int i;
}
class B extends A {
int i; // this i hides the i in A
B(int a, int b) {
super.i = a; // i in A
i = b; // i in B
}
void show() {
System.out.println("i in superclass: " + super.i);
System.out.println("i in subclass: " + i);
}
}
class UseSuper {
B subOb = new B(1, 2);
subOb.show();
}
}
Output:
i in superclass: 1
i in subclass: 2
26) Creating a Multilevel Hierarchy :
// Extend BoxWeight to include shipping costs.

// Start with Box.
class Box {
private double width;
private double height;
private double depth;
width = ob.width;
height = ob.height;
depth = ob.depth;
}
width = w;
height = h;
depth = d;
}
Box() {

depth = -1; // box
}
Box(double len) {
}
double volume() {
}
}
// Add weight.
BoxWeight(BoxWeight ob) { // pass object to constructor
super(ob);
weight = ob.weight;
}
super(w, h, d); // call superclass constructor
weight = m;
}
BoxWeight() {
super();
weight = -1;
}
BoxWeight(double len, double m) {
super(len);
weight = m;
}
}
// Add shipping costs.
class Shipment extends BoxWeight {
double cost;
Shipment(Shipment ob) { // pass object to constructor
super(ob);
cost = ob.cost;
}
Shipment(double w, double h, double d,
double m, double c) {
super(w, h, d, m); // call superclass constructor
cost = c;
}
Shipment() {
super();
cost = -1;
}
Shipment(double len, double m, double c) {
super(len, m);
cost = c;
}
}
class DemoShipment {
Shipment shipment1 =
new Shipment(10, 20, 15, 10, 3.41);
Shipment shipment2 =
new Shipment(2, 3, 4, 0.76, 1.28);
double vol;
vol = shipment1.volume();
System.out.println("Volume of shipment1 is " + vol);
System.out.println("Weight of shipment1 is "+ shipment1.weight);
System.out.println("Shipping cost: $" + shipment1.cost);
vol = shipment2.volume();
System.out.println("Volume of shipment2 is " + vol);
System.out.println("Weight of shipment2 is "+ shipment2.weight);
System.out.println("Shipping cost: $" + shipment2.cost);
}
}
Output:
Volume of shipment1 is 3000.0
Weight of shipment1 is 10.0
Shipping cost: $3.41
Volume of shipment2 is 24.0
Weight of shipment2 is 0.76
Shipping cost: $1.28
27) Order of Execution of Constructors :
// Demonstrate when constructors are executed.

// Create a super class.
class A {
A() {
System.out.println("Inside A's constructor.");
}
}
class B extends A {
B() {
System.out.println("Inside B's constructor.");
}
}
// Create another subclass by extending B.

class C extends B {
C() {
System.out.println("Inside C's constructor.");
}
}
class CallingCons {
C c = new C();
}
}
Output:
Inside A's constructor
Inside B's constructor
Inside C's constructor
28) Method Overriding :
// Method overriding.
class A {
int i, j;
A(int a, int b) {
i = a;
j = b;
}
// display i and j
void show() {
System.out.println("i and j: " + i + " " + j);
}
}
class B extends A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}
// display k – this overrides show() in A
void show() {
}
}
class Override {
B subOb = new B(1, 2, 3);
subOb.show(); // this calls show() in B
}
}
Output:
k: 3
29)
class B extends A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}
void show() {
super.show(); // this calls A's show()
}
}
Output:
i and j: 1 2
k: 3
30) Dynamic Method Dispatch :
// Dynamic Method Dispatch

class A {
void callme() {
System.out.println("Inside A's callme method");
}
}
class B extends A {
// override callme()
void callme() {
System.out.println("Inside B's callme method");
}
}
class C extends A {
// override callme()
void callme() {
System.out.println("Inside C's callme method");
}
}
class Dispatch {
A a = new A(); // object of type A
B b = new B(); // object of type B
C c = new C(); // object of type C
A r; // obtain a reference of type A
r = a; // r refers to an A object
r.callme(); // calls A's version of callme
r = b; // r refers to a B object
r.callme(); // calls B's version of callme
r = c; // r refers to a C object
r.callme(); // calls C's version of callme
}
}
Output:
Inside A's callme method
Inside B's callme method
Inside C's callme method
31) Applying Method Overriding :
// Using run-time polymorphism.

class Figure {
double dim1;
double dim2;
Figure(double a, double b) {
dim1 = a;
dim2 = b;
}
double area() {
System.out.println("Area for Figure is undefined.");
return 0;
}
}
class Rectangle extends Figure {

Rectangle(double a, double b) {
super(a, b);
}
// override area for rectangle
double area() {
System.out.println("Inside Area for Rectangle.");
return dim1 * dim2;
}
}
class Triangle extends Figure {

Triangle(double a, double b) {
super(a, b);
}
// override area for right triangle
double area() {
System.out.println("Inside Area for Triangle.");
return dim1 * dim2 / 2;
}
}
class FindAreas {
Figure f = new Figure(10, 10);
Rectangle r = new Rectangle(9, 5);
Triangle t = new Triangle(10, 8);
Figure figref;
figref = r;
System.out.println("Area is " + figref.area());
figref = t;
figref = f;
}
}
Output:
Inside Area for Rectangle.
Area is 45
Inside Area for Triangle.
Area is 40
Area for Figure is undefined.
Area is 0

Core Java - Unit 1 2 3

Uploaded by

Copyright:

Available Formats

Core Java - Unit 1 2 3

Uploaded by

Document Information

Original Description:

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

Core Java - Unit 1 2 3

Uploaded by

Copyright:

Available Formats

1) A Simple Class :

/* A program that uses the Box class.

CORE JAVA EXAMPLES PGK

// This program uses a parameterized method.

// compute and return volume

// sets dimensions of box

/* Here, Box uses a constructor to initialize the

// This is the constructor for Box.

CORE JAVA EXAMPLES PGK

// compute and return volume

8) The this Keyword :

// A redundant use of this.

// Use this to resolve name-space collisions.

// Overload test for one integer parameter.

// Overload test for two integer parameters.

// Overload test for a double parameter

CORE JAVA EXAMPLES PGK

10) Overloading Constructors :

/* Here, Box defines three constructors to initialize

11) Using Objects as Parameters :

// Objects may be passed to methods.

12) Box Objects as Parameters :

CORE JAVA EXAMPLES PGK

// Demonstrate static variables, methods, and blocks.

CORE JAVA EXAMPLES PGK

static void callme() {

15) Nested and Inner Classes :

// this is an inner class

CORE JAVA EXAMPLES PGK

17) String Class :

CORE JAVA EXAMPLES PGK

// A simple example of inheritance.

// Create a subclass by extending class A.

CORE JAVA EXAMPLES PGK

21) Member Access and Inheritance :

void setij(int x, int y) {

// A's j is not accessible here.

// This program uses inheritance to extend Box.

CORE JAVA EXAMPLES PGK

// Here, Box is extended to include weight.

23) A Superclass Variable Can Reference a Subclass Object :

Writing Test class for the same Example :

CORE JAVA EXAMPLES PGK

24) Using super to Call Superclass Constructors :

// A complete implementation of BoxWeight.

// BoxWeight now fully implements all constructors.

25) A Second Use for super :

// Using super to overcome name hiding.

26) Creating a Multilevel Hierarchy :

// Extend BoxWeight to include shipping costs.

CORE JAVA EXAMPLES PGK

27) Order of Execution of Constructors :

// Demonstrate when constructors are executed.

// Create another subclass by extending B.

28) Method Overriding :

30) Dynamic Method Dispatch :

// Dynamic Method Dispatch

CORE JAVA EXAMPLES PGK

31) Applying Method Overriding :