Scribd
Upload
77 views3 pages

Lab2 PDF

This document provides instructions for Lab Exercise 2 on object-oriented programming, including how to create classes with properties, methods, constructors, inheritance, polymorphism, abstract classes, and interfaces; students are tasked with creating a class hierarchy with abstract classes and subclasses that demonstrate these concepts and writing a program to instantiate objects, access properties, call methods, and loop through an array of objects.

Uploaded by

rrbuatag
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
77 views3 pages

Lab2 PDF

This document provides instructions for Lab Exercise 2 on object-oriented programming, including how to create classes with properties, methods, constructors, inheritance, polymorphism, abstract classes, and interfaces; students are tasked with creating a class hierarchy with abstract classes and subclasses that demonstrate these concepts and writing a program to instantiate objects, access properties, call methods, and loop through an array of objects.

Uploaded by

rrbuatag
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

CMSC 123 LAB EXERCISE 2 Total: 30 points

Object-Oriented Programming

What you need to know:


● Creating classes
public class ​Person{
String ​name; // attributes / properties
int ​age;
boolean ​isCool;

public void ​talk( ){


System.out.println(“Hello, my name is “ + name); // method
}
}
● Creating objects
Person john = ​new ​Person( );
● Accessing properties
john.name = “John”;
john.age = 20;
john.isCool = false;
● Calling object methods
john.talk( );
● Static methods​ → no need to create an object of that class to use the method
public ​static ​void main(​String​[ ] args) { …. }
● Constructors
public ​Person(​String​ name, ​int ​age){
this​.name = name; // this → refers to object being created
this​.age = age;
}
● Private properties
private ​String name; // inaccessible outside the class
// Accessing john.name results in an error
● Getters ​and ​Setters
// Allows you to encapsulate your data
// Gives you better control of how properties are accessed
public String ​getName( ){
return ​name;
}
public void ​setName(​String​ newName){
if​(newName != “”){
name = newName;
}
}
● Inheritance
// Superclasses allow its subclasses to inherit their properties and methods
// Good for code reuse
class ​Animal​{ // Superclass
String ​name;
public ​Animal(​String​ name){
this.name = name;
}
void ​walk( ){
System.out.println(name + “ is walking..”);
}
}
class Dog ​extends ​Animal{ // Subclass of Animal
public ​Dog(​String​ name){
super​(name); ​ // calls the superclass’ constructor
}
void ​bark( ){
System.out.println(name + “ says arf! arf! “);
}
}
class Cat ​extends ​Animal{ // Subclass of Animal
public ​Cat(​String​ name){
super​(name);
}
void ​meow( ){
System.out.println(name + “ says meow! meow! “);
}
}

Dog bantay = ​new ​Dog(“Bantay”);


Cat miming = ​new ​Cat(“Miming”);
bantay.bark( );
miming.meow( );
bantay.walk( );
miming.walk( );
● Polymorphism
// Arrays in Java are homogeneous → array elements must be of one type
// You can put a Dog and Cat object together in one array, since both are Animal objects
Animal ​pets[ ] = ​new ​Animal[3]; // creating an empty Animal array of size 3
pets[0] = ​new ​Animal(“Bugsy”);
pets[1] = ​new ​Dog(“Bantay”);
pets[2] = ​new ​Cat(“Miming”);
● Abstract classes
abstract class ​Animal { … } // Animal class can only function as a superclass
// Cannot create Animal objects
// Can only create Animal subclass objects (e.g. Dog, Cat)

Animal bugsy = ​new ​Animal(“Bugsy”); ​// results in an error → Animal is an abstract class
Animal bantay = ​new ​Dog(“Bantay”); ​// this is OK
● Interfaces
interface ​Printable {
void ​print( );
}
interface ​Displayable {
void ​display( );
}
class ​WebDocument ​implements ​Printable, Displayable{
void ​print( ){
System.out.println(“Printing web document..”);
}
void ​display( ){
System.out.println(“Displaying web document..”);
}
}
class ​MobileDocument ​implements ​Displayable{
void ​display( ){
System.out.println(“Displaying mobile document..”);
}
}

What you need to do:


1. (​10 pts​) Create 5 classes - A, B, C, D, E (create your own scenario / topic), where:
a. Class A is ​abstract
b. Class B and C ​extends ​class A
c. Class D and E ​extends ​class B
d. Each class has their ​constructor ​defined
2. (​10 pts​) Each class should have at least ​2 properties​, and at least ​1 method​, where:
a. Some properties are ​private
b. Some methods are ​getters ​/ ​setters
c. Some methods are ​static
3. (​10 pts​) Create a program that will do the ff:
a. Create new class B, C, D, and E ​objects
b. Access / modify some object’s ​properties
c. Call an object’s ​own​ ​method
d. Call an object’s ​method ​inherited from its ​superclass
e. Create a class A ​array​, and put different types of objects (class B, C, D, E) in the array
f. Loop through the array elements and access a property / call a method that is common to
all (inherited from class A)

You might also like