Scribd Logo
Upload

Welcome to Scribd!

  • 51 views

    Unit 2 Programs Java

    Uploaded by

    Moon Nila
    1. Inheritance allows classes to inherit attributes and behaviors from a parent class. The document defines a Book class and subclasses ReferenceBook and Magazine that inherit from Book and override its display method to add additional subclass-specific fields. 2. The document defines an Interest interface with simpleInterest and compoundInterest methods and an InterestCalculator class that implements the interface's methods. 3. An abstract Reservation class is created with a Reserve abstract method. Subclasses ReserveTrain and ReserveBus implement Reserve for reserving train and bus tickets.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd

    Unit 2 Programs Java

    Uploaded by

    Moon Nila
    51 views8 pages
    1. Inheritance allows classes to inherit attributes and behaviors from a parent class. The document defines a Book class and subclasses ReferenceBook and Magazine that inherit from Book and override its display method to add additional subclass-specific fields. 2. The document defines an Interest interface with simpleInterest and compoundInterest methods and an InterestCalculator class that implements the interface's methods. 3. An abstract Reservation class is created with a Reserve abstract method. Subclasses ReserveTrain and ReserveBus implement Reserve for reserving train and bus tickets.

    Original Title

    UNIT 2 PROGRAMS JAVA

    Copyright

    © © All Rights Reserved

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    1. Inheritance allows classes to inherit attributes and behaviors from a parent class. The document defines a Book class and subclasses ReferenceBook and Magazine that inherit from Book and override its display method to add additional subclass-specific fields. 2. The document defines an Interest interface with simpleInterest and compoundInterest methods and an InterestCalculator class that implements the interface's methods. 3. An abstract Reservation class is created with a Reserve abstract method. Subclasses ReserveTrain and ReserveBus implement Reserve for reserving train and bus tickets.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    51 views8 pages

    Unit 2 Programs Java

    Uploaded by

    Moon Nila
    1. Inheritance allows classes to inherit attributes and behaviors from a parent class. The document defines a Book class and subclasses ReferenceBook and Magazine that inherit from Book and override its display method to add additional subclass-specific fields. 2. The document defines an Interest interface with simpleInterest and compoundInterest methods and an InterestCalculator class that implements the interface's methods. 3. An abstract Reservation class is created with a Reserve abstract method. Subclasses ReserveTrain and ReserveBus implement Reserve for reserving train and bus tickets.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    of 8

    UNIT-II

    PART-C
    2. What is inheritance? How inheritance is implemented in java? Create a class
    Book and define display method to display book information. Inherit
    Reference_Book and Magazine classes from Book class and override display
    method of Book class in Reference_Book and Magazine classes.
    Make necessary assumptions required.(
    // Base class: Book
    class Book {
    private String title;
    private String author;
    private String publisher;
    private int publicationYear;

    public Book(String title, String author, String publisher, int publicationYear) {


    this.title = title;
    this.author = author;
    this.publisher = publisher;
    this.publicationYear = publicationYear;
    }

    public void display() {


    System.out.println("Title: " + title);
    System.out.println("Author: " + author);
    System.out.println("Publisher: " + publisher);
    System.out.println("Publication Year: " + publicationYear);
    }
    }

    // Subclass 1: Reference_Book
    class Reference_Book extends Book {
    private int edition;

    public Reference_Book(String title, String author, String publisher, int publicationYear, int
    edition) {
    super(title, author, publisher, publicationYear);
    this.edition = edition;
    }

    // Override the display method to include edition


    @Override
    public void display() {
    super.display(); // Call the parent class display method
    System.out.println("Edition: " + edition);
    }
    }

    // Subclass 2: Magazine
    class Magazine extends Book {
    private int issueNumber;
    public Magazine(String title, String author, String publisher, int publicationYear, int
    issueNumber) {
    super(title, author, publisher, publicationYear);
    this.issueNumber = issueNumber;
    }

    // Override the display method to include issue number


    @Override
    public void display() {
    super.display(); // Call the parent class display method
    System.out.println("Issue Number: " + issueNumber);
    }
    }

    public class Main {


    public static void main(String[] args) {
    Book book = new Book("The Great Gatsby", "F. Scott Fitzgerald", "Scribner", 1925);
    System.out.println("Book Information:");
    book.display();
    System.out.println();

    Reference_Book referenceBook = new Reference_Book("Java: The Complete


    Reference", "Herbert Schildt", "McGraw-Hill Education", 2017, 10);
    System.out.println("Reference Book Information:");
    referenceBook.display();
    System.out.println();

    Magazine magazine = new Magazine("National Geographic", "Various", "National


    Geographic Partners", 2023, 10);
    System.out.println("Magazine Information:");
    magazine.display();
    }
    }

    OUTPUT:
    Book Information:
    Title: The Great Gatsby
    Author: F. Scott Fitzgerald
    Publisher: Scribner
    Publication Year: 1925

    Reference Book Information:


    Title: Java: The Complete Reference
    Author: Herbert Schildt
    Publisher: McGraw-Hill Education
    Publication Year: 2017
    Edition: 10
    Magazine Information:
    Title: National Geographic
    Author: Various
    Publisher: National Geographic Partners
    Publication Year: 2023
    Issue Number: 10
    3. Develop an Interest interface which containssimpleInterest and compInterest
    methods and static final field of Rate 25%. Write a class toimplement those
    methods.
    // Define an interface for interest calculations
    interface Interest {
    double simpleInterest(double principal, double rate, double time);
    double compoundInterest(double principal, double rate, double time);
    }

    // Create a class that calculates interest based on the interface


    class InterestCalculator implements Interest {
    @Override
    public double simpleInterest(double p, double r, double t) {
    // Simple Interest formula: SI = P * R * T / 100
    return (p * r * t) / 100.0;
    }

    @Override
    public double compoundInterest(double p, double r, double t) {
    // Compound Interest formula: CI = P * (1 + R/100)^T - P
    return p * (Math.pow(1 + r / 100, t)) - p;
    }
    }

    public class Main {


    public static void main(String[] args) {
    // Create an instance of the InterestCalculator class
    InterestCalculator calc = new InterestCalculator();

    // Set initial amount, annual interest rate (in percentage), and time period (in years)
    double principal = 1000.0;
    double rate = 5.0;
    double time = 2.5;

    // Calculate and display simple interest


    double simple = calc.simpleInterest(principal, rate, time);
    System.out.println("Simple Interest: " + simple);

    // Calculate and display compound interest


    double compound = calc.compoundInterest(principal, rate, time);
    System.out.println("Compound Interest: " + compound);
    }
    }
    OUTPUT:
    Simple Interest: 125.0
    Compound Interest: 128.015625
    4. Create an abstract Reservation class which has Reserve() abstract
    method. Implement the sub-classes like ReserveTrain and ReserveBus
    classes and implement the same. Use necessary variables, methods for
    reserving tickets
    abstract class Reservation {
    abstract void Reserve();
    }

    class ReserveTrain extends Reservation {


    String trainName;
    int numberOfSeats;

    public ReserveTrain(String trainName, int numberOfSeats) {


    this.trainName = trainName;
    this.numberOfSeats = numberOfSeats;
    }

    @Override
    void Reserve() {
    System.out.println(numberOfSeats + " seats reserved in " + trainName + " train.");
    }
    }

    class ReserveBus extends Reservation {


    String busName;
    int numberOfSeats;

    public ReserveBus(String busName, int numberOfSeats) {


    this.busName = busName;
    this.numberOfSeats = numberOfSeats;
    }

    @Override
    void Reserve() {
    System.out.println(numberOfSeats + " seats reserved in " + busName + " bus.");
    }
    }

    public class Main {


    public static void main(String[] args) {
    Reservation trainReservation = new ReserveTrain("Rajdhani Express", 2);
    trainReservation.Reserve();

    Reservation busReservation = new ReserveBus("Volvo", 4);


    busReservation.Reserve();
    }
    }
    OUTPUT:
    2 seats reserved in Rajdhani Express train.
    4 seats reserved in Volvo bus.

    PART-B
    17. Declare an abstract class to represent a bank account with data members
    name, account number, address and abstract methods withdraw and
    deposit. Method display() is needed to show balance. Derive a subclass
    Savings Account and add the following details: return on investment and
    the method calcAmt() to show the amount in the account after 1
    year.Create instance of Savings Account and show the use of withdraw
    and deposit abstract methods

    abstract class BankAccount {


    String name;
    String accountNumber;
    String address;
    double balance;

    public BankAccount(String name, String accountNumber, String address, double balance)


    {
    this.name = name;
    this.accountNumber = accountNumber;
    this.address = address;
    this.balance = balance;
    }

    abstract void withdraw(double amount);


    abstract void deposit(double amount);

    public void display() {


    System.out.println("Balance: " + balance);
    }
    }

    class SavingsAccount extends BankAccount {


    double returnOnInvestment;

    public SavingsAccount(String name, String accountNumber, String address, double


    balance, double returnOnInvestment) {
    super(name, accountNumber, address, balance);
    this.returnOnInvestment = returnOnInvestment;
    }

    public void calcAmt() {


    double interest = balance * returnOnInvestment;
    balance += interest;
    System.out.println("Amount after 1 year: " + balance);
    }

    @Override
    void withdraw(double amount) {
    balance -= amount;
    }

    @Override
    void deposit(double amount) {
    balance += amount;
    }
    }

    public class Main {


    public static void main(String[] args) {
    SavingsAccount savingsAccount = new SavingsAccount("John Doe", "123456789",
    "123 Main St", 1000, 0.05);
    savingsAccount.deposit(500);
    savingsAccount.withdraw(200);
    savingsAccount.display();
    savingsAccount.calcAmt();
    }
    }

    OUTPUT:
    Balance: 1300.0
    Amount after 1 year: 1365.0
    UNIT-II
    PART-B
    12.

    class Calculator {
    int num1, num2;

    Calculator(int a, int b) {
    num1 = a;
    num2 = b;
    }
    void add() {
    System.out.println("Addition result: " + (num1 + num2));
    }
    }

    class SubtractionCalculator extends Calculator {


    SubtractionCalculator(int a, int b) {
    super(a, b);
    }

    void subtract() {
    System.out.println("Subtraction result: " + (num1 - num2));
    }
    }

    class MultiplicationCalculator extends SubtractionCalculator {


    MultiplicationCalculator(int a, int b) {
    super(a, b);
    }

    void multiply() {
    System.out.println("Multiplication result: " + (num1 * num2));
    }
    }

    public class Main {


    public static void main(String[] args) {
    MultiplicationCalculator calculator = new MultiplicationCalculator(10, 5);
    calculator.add();
    calculator.subtract();
    calculator.multiply();
    }
    }
    OUTPUT:
    Addition result: 15
    Subtraction result: 5
    Multiplication result: 50

    You might also like