this keyword. 2 bmi class public class bmi { private string name; private int age; private double...
TRANSCRIPT
2
BMI Class
BMI
-name: String
-age: int
-weight: double
-height: double
+BMI(name: String, age: int, weight: double, height: double)
+BMI(name: String, weight: double, height: double)
+getBMI(): double
+getStatus(): String
The name of the person.
The age of the person.
The weight of the person in pounds.
The height of the person in inches.
Creates a BMI object with the specified name, age, weight, and height.
Creates a BMI object with the specified name, weight, height, and a default age 20.
Returns the BMI
Returns the BMI status (e.g., normal, overweight, etc.)
The get methods for these data fields are provided in the class, but omitted in the UML diagram for brevity.
public class BMI { private String name; private int age; private double weight; // in pounds private double height; // in inches public static final double KILOGRAMS_PER_POUND = 0.45; public static final double METERS_PER_INCH = 0.0254; public BMI(String name, int age, double weight, double height) { this.name = name; this.age = age; this.weight = weight; this.height = height; }
this keyword refers to an object itself. One common use of the this keyword is reference a class’s
hidden data fields.
public BMI(String name, double weight, double height) { this(name, 20, weight, height); }
Another common use of the this keyword to enable a constructor to invoke another constructor of the same class.
public double getBMI() { double bmi = weight * KILOGRAMS_PER_POUND / ((height * METERS_PER_INCH) * (height * METERS_PER_INCH)); return Math.round(bmi * 100) / 100.0; }
public String getStatus() { double bmi = getBMI(); if (bmi < 16) return "seriously underweight"; else if (bmi < 18) return "underweight"; else if (bmi < 24) return "normal weight"; else if (bmi < 29) return "over weight"; else if (bmi < 35) return "seriously over weight"; else return "gravely over weight"; }
Abstract Class and Abstract Methods
An abstract class is declared with keyword abstract. An abstract class normally contains one or more
abstract methods. ABSTRACT CLASSES MAY NOT BE INSTANTIATED using
the new operator.
public abstract void draw(); // abstract methodAbstract methods do not provide implementations. A class that contains any abstract methods must be
explicitly declared abstract even if that class contains some concrete methods.
Abstract Class and Abstract MethodsEach concrete subclass of an abstract superclass also
must provide concrete implementations of each of the superclass’s abstract methods.
Constructors and static methods cannot be declared abstract.Constructors are not inherited, so an abstract constructor
could never be implemented. Though non-private static methods are inherited, they
cannot be overridden. Since abstract methods are meant to be overridden so
that they can process objects based on their types, it would not make sense to declare a static method as
abstract.
Software Engineering Observation
An abstract class declares common attributes and behaviors (both abstract and concrete) of the various classes in a class hierarchy.
An abstract class typically contains one or more abstract methods that subclasses must override if they are to be concrete.
The instance variables and concrete methods of an abstract class are subject to the normal rules of inheritance.
Q1)Design a class named Triangle that extends GeometricObject.
class GeometricObject { ………… } class Triangle extends GeometricObject { ………….. }
The class contains: Q2)Three double data fields named side1, side2, and side3 with default values 1.0 to denote three sides of the triangle.
class Triangle extends GeometricObject { private double side1 = 1.0, side2 = 1.0, side3 = 1.0;
Q3)A no-argument constructor that creates a default triangle. public Triangle() { }
Q4) A constructor that creates a triangle with the specified side1, side2, and side3.
public Triangle(double side1, double side2, double side3) { this.side1 = side1; this.side2 = side2; this.side3 = side3; }
Q5)The accessor methods for all three data fields. // Override abstract getArea() method in GeometricObject public double getArea() { // returns the area of triangle double s = (side1 + side2 + side3) / 2; return Math.sqrt(s * (s - side1) * (s - side2) * (s - side3)); }/*Override abstract getPerimeter () method in GeometricObject*/public double getPerimeter() {return side1 + side2 + side3; //returns perimeter of triangle. }
// Override the toString method public String toString() {//returns string description for thetriangle.
// Implement it to return the three sides return "Triangle: side1 = " + side1 + " side2 = " + side2 + " side3 = " + side3; } }
public abstract class GeometricObject { private String color = "white"; private boolean filled; private java.util.Date dateCreated;
An abstract class’s purpose is to provide an appropriate superclass from which other classes can inherit and thus share a common design
Classes that can be used to instantiate objects are called concrete classes.
abstract class continued
/** Construct a default geometric object */ protected GeometricObject() { dateCreated = new java.util.Date(); }
/** Construct a geometric object with color and filled value */protected GeometricObject(String color, boolean filled) { dateCreated = new java.util.Date(); this.color = color; this.filled = filled; }
abstract class continued
/** Return color */ public String getColor() { return color; }
public void setColor(String color) {/** Set a new color */ this.color = color; }
/*Return filled. Since filled is boolean, the get method is named isFilled */ public boolean isFilled() { return filled; }
/** Set a new filled */ public void setFilled(boolean filled) { this.filled = filled; } /** Get dateCreated */ public java.util.Date getDateCreated() { return dateCreated; }
abstract class continued@Override public String toString() { return "created on " + dateCreated + "\ncolor: " + color + " and filled: " + filled; }
/** Abstract method getArea */ public abstract double getArea();
/** Abstract method getPerimeter */ public abstract double getPerimeter();}
Association relationships between classes&
Aggregation relationships between classes&
Composition relationships between classes
Association
Association represents a general binary relationship that describes an activity between two classes.
20
Student * 5..60 Take Teach 0..3 1
Teacher Faculty Course
public class Student {
/** Data fields */ private Course[]
courseList;
/** Constructors */
/** Methods */
}
public class Course {
/** Data fields */ private Student[]
classList;
private Faculty faculty;
/** Constructors */
/** Methods */
}
public class Faculty {
/** Data fields */
private Course[]
courseList;
/** Constructors */
/** Methods */
}
An association is usually represented as a data field in the class.
Translation is not Unique for Association
If you don’t need to know the courses a student takes or a faculty teaches, the data field courseList in Student or Faculty can be omitted.
21
AssociationBetween Same Class
Association (also aggregation) may exist between objects of the same class.
For example, a person may have a supervisor.
22
Person Supervisor
1
1
public class Person {
// The type for the data is the class itself
private Person supervisor;
...
}
23
Aggregation Between Same ClassWhat happens if a person has several supervisors?
Person Supervisor
1
m
public class Person { ... private Person[] supervisors; }
24
Object Composition
Composition is actually a special case of the aggregation relationship.
Aggregation models has-a relationships and represents an ownership relationship between two objects.
The owner object is called an aggregating object and its class an aggregating class.
The subject object is called an aggregated object and its class an aggregated class.
25
Class RepresentationAn aggregation relationship is usually represented as a
data field in the aggregating class. For example, the relationship in Figure 10.6 can be represented as follows:
public class Name {
...
}
public class Student {
private Name name;
private Address address;
...
}
public class Address {
...
}
Aggregated class Aggregating class Aggregated class
Aggregation and CompositionAggregation: special form of association
Represents ownership relationship Aggregation models the has-a relationship.
Composition: special form of aggregationobject exclusively owned by aggregated object
26
Name Address Person
Composition Aggregation
class Person { private Heart heart; private List<Hand> hands;}
class City { private List<Tree> trees; private List<Car> cars}
In composition (Person, Heart, Hand), "sub objects" (Heart, Hand) will be destroyed as soon as Person is destroyed.
In aggregation (City, Tree, Car) "sub objects" (Tree, Car) will NOT be destroyed when City is destroyed
class StereoSystem { private boolean state ;
StereoSystem() {} StereoSystem(boolean state) { this.state = state ; }System.out.println("Stereo System State: " + (state == true ? "On!" : "Off!")) ; } }
class Car { private StereoSystem s ; Car() {} Car(String name, StereoSystem s) { this.s = s ; } public static void main(String[] args) { StereoSystem ss = new StereoSystem(true) ; // true(System is ON.) or false (System is OFF) Car c = new Car("BMW", ss) ; 7 } }
Aggregation and Composition
Both aggregation and composition represent a whole-part (has-a/part-of) association.
The main differentiator between aggregation and composition is the lifecycle dependence between whole and part.
In aggregation, the part may have an independent lifecycle, it can exist independently.
When the whole is destroyed the part may continue to exist.
For example, a car has many parts. A part can be removed from one car and installed
into a different car. If we consider a business, before a car is destroyed,
they remove all saleable parts. Those parts will continue to exist after the car is
destroyed.
Composition is a stronger form of aggregation.The lifecycle of the part is strongly dependent
on the lifecycle of the whole. When the whole is destroyed, the part is
destroyed too. For example, a building has rooms.
A room can exist only as part of a building. The room cannot be removed from one building
and attached to a different one.
DesignWhen we decide between aggregation and
composition we need to answer the following question:
can the part exist independently? For example The car-part relationship mentioned above is an
aggregation, but if the business requirements state that
“no part of a vehicle can be used for resale or as spare part; at the end of the amortization period the vehicle is destroyed”
Then this will suggest a composition relationship between car and its parts.
Java Implementation Objects do not need to be destroyed explicitly; An object is automatically “destroyed” when it is
garbage collected. An object is garbage collected when it is not
referenced by any other object. Regardless of the type of relationship –
aggregation or composition – the part is referenced by the whole. If the whole is destroyed (garbage collected), then the
part is no longer referenced by the whole. If there is no other object referencing the part then
the part is destroyed too.
The Difference Between Aggregation and Composition
Is the variable that holds the part object accessible to objects other than the whole?
If the answer is yes, then we have aggregation,If the answer is no then we have composition.
public class Car {private String make;private int year;private Engine engine;
public Car(String make, int year, Engine engine) {this.make = make;this.year = year;
this.engine = engine; }public String getMake() { return make; }public int getYear() { return year; }
public Engine getEngine() { return engine; }}
public class Engine {private int engineCapacity;private int engineSerialNumber;public Engine(int engineCapacity, int
engineSerialNumber) {
this.engineCapacity = engineCapacity;this.engineSerialNumber = engineSerialNumber;
}public int getEngineCapacity() {
return engineCapacity;}public int getEngineSerialNumber() {
return engineSerialNumber;}
}
Aggregation Explanation
The engine object is created outside and is passed as argument to Car constructor
When this Car object is destroyed, the engine is still available to objects other than Car
If the instance of Car is garbage collected the associated instance of Engine may not be garbage collected (if it is still referenced by other objects)
public class Car {private String make;private int year;private Engine engine;
public Car(String make, int year, int engineCapacity, int engineSerialNumber) { this.make=make;
this.year=year;engine = new Engine(engineCapacity, engineSerialNumber); }
we create the engine using parameters passed in Car constructor only the Car instance has access to the engine instance
when Car instance is garbage collected, the engine instance is garbage collected too*/