0% found this document useful (0 votes)
10 views9 pages

Practice Programs - Inheritance2

Notes useful and detailed

Uploaded by

inboxinsta0987
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
10 views9 pages

Practice Programs - Inheritance2

Notes useful and detailed

Uploaded by

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

Program1:Inheritance

//Base class
class Vehicle {
void start() {
System.out.println("The vehicle is starting.");
}
}

//Derived class
class Car extends Vehicle {
void honk() {
System.out.println("The car is honking.");
}
}

//Main class to test the inheritance


public class inherit3 {
public static void main(String[] args) {
Car myCar = new Car();
myCar.start(); // Inherited method from Vehicle
myCar.honk(); // Method from Car
}
}

Output:
The vehicle is starting.
The car is honking.

Program2: :Inheritance

//Base class
class Animal {
void eat() {
System.out.println("This animal eats food.");
}
}
//Derived class
class Dog extends Animal {
void bark() {
System.out.println("The dog barks.");
}
}

//Main class to test the inheritance


public class inherit2 {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.eat(); // Inherited method from Animal
myDog.bark(); // Method from Dog
}
}

Output:
This animal eats food.
The dog barks.

Program 3: Inheritance with constructor


//Base class
class Person {
Person() {
System.out.println("Person constructor called.");
}
}

//Derived class
class Student extends Person {
Student() {
System.out.println("Student constructor called.");
}
}

//Main class to test the inheritance


public class inherit4 {
public static void main(String[] args) {
Student myStudent = new Student();
}
}

Program 4:Inheritance

class Bank{
double GetInterestRate(){
return 0.0;
}
}
class SBI extends Bank{
double GetInterestRate(){
return 5.5;
}
}
class ICIC extends Bank{
double GetInterestRate(){
return 6.0;
}
}

public class ij{


public static void main(String[] args){
SBI s= new SBI();
System.out.println("rate of interest of sbi is :"
+s.GetInterestRate());
ICIC i= new ICIC ();
System.out.println("rate of interest of icic is :" +
i.GetInterestRate());
Bank b= new SBI();
System.out.println("rate of interest of sbi is :" +
b.GetInterestRate());
}
}

Output:
rate of interest of sbi is :5.5
rate of interest of icic is :6.0
rate of interest of sbi is :5.5
Program 4:Private members

class Car {
// Private member variable
private String model;

// Getter method for 'model'


public String getModel() {
return model;
}

// Setter method for 'model'


public void setModel(String model) {
this.model = model;
}
}

public class Main {


public static void main(String[] args) {
// Creating an instance of Car
Car myCar = new Car();

// Setting the private member using the setter


myCar.setModel("Tesla Model S");

// Accessing the private member using the getter


System.out.println("Car model: " + myCar.getModel());
}
}

Program 5:

public class privateerror {


public static void main(String[] args) {
B b =new B();
b.sum();
}
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
}
}

Program 6:

//BankAccount.java
class BankAccount {
protected double balance;

public BankAccount(double initialBalance) {


if (initialBalance >= 0) {
this.balance = initialBalance;
} else {
this.balance = 0;
System.out.println("Initial balance can't be negative. Set to 0.");
}
}

// Method to deposit money


public void deposit(double amount) {
if (amount > 0) {
balance += amount;
System.out.println("Deposit successful. New balance: $" + balance);
} else {
System.out.println("Deposit amount must be positive.");
}
}

// Method to withdraw money


public void withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
System.out.println("Withdrawal successful. New balance: $" +
balance);
} else {
System.out.println("Invalid withdrawal amount. Current balance: $" +
balance);
}
}

// Method to check the balance


public double getBalance() {
return balance;
}
}

//SavingsAccount.java
class SavingsAccount extends BankAccount {

public SavingsAccount(double initialBalance) {


super(initialBalance);
}

// Override the withdraw method to prevent balance from going below 100
@Override
public void withdraw(double amount) {
if (amount > 0 && (balance - amount) >= 100) {
balance -= amount;
System.out.println("Withdrawal successful. New balance: $" +
balance);
} else {
System.out.println("Withdrawal failed. Minimum balance of $100
required. Current balance: $" + balance);
}
}
}

//Main.java
public class Main {
public static void main(String[] args) {
// Create a regular bank account
BankAccount myAccount = new BankAccount(500);
myAccount.deposit(100);
myAccount.withdraw(200);
myAccount.withdraw(600); // Invalid withdrawal

// Create a savings account


SavingsAccount mySavings = new SavingsAccount(500);
mySavings.deposit(150);
mySavings.withdraw(400); // Should succeed
mySavings.withdraw(200); // Should fail due to minimum balance
}
}

Program 7: Multilevel

//Base class (Grandparent)


class Animal {
public void eat() {
System.out.println("This animal eats food.");
}
}

//Derived class (Parent) that inherits from Animal


class Mammal extends Animal {
public void breathe() {
System.out.println("This mammal breathes air.");
}
}

//Derived class (Child) that inherits from Mammal


class Dog extends Mammal {
public void bark() {
System.out.println("The dog barks.");
}
}

public class Multilevel {


public static void main(String[] args) {
// Creating an instance of Dog
Dog myDog = new Dog();

// Calling methods from all levels of the hierarchy


myDog.eat(); // From Animal class
myDog.breathe(); // From Mammal class
myDog.bark(); // From Dog class
}
}
Program 8: Hierarchical

/// Parent class


class Vehicle {
public void start() {
System.out.println("Vehicle is starting.");
}
}

// Child class 1
class Cars extends Vehicle {
public void drive() {
System.out.println("Car is driving.");
}
}

// Child class 2
class Bike extends Vehicle {
public void ride() {
System.out.println("Bike is riding.");
}
}

public class Hierarchical {


public static void main(String[] args) {
// Creating an instance of Car
Cars myCar = new Cars();
myCar.start(); // Inherited from Vehicle
myCar.drive(); // Specific to Car

// Creating an instance of Bike


Bike myBike = new Bike();
myBike.start(); // Inherited from Vehicle
myBike.ride(); // Specific to Bike
}
}
Program 8: SuperConst

//Superclass
class Animals {
String name;

// Constructor of Superclass
public Animals(String name) {
this.name = name;
System.out.println("Animal constructor called");
}
}

//Subclass
class Dogs extends Animals {
String breed;

// Constructor of Subclass
public Dogs(String name, String breed) {
// Calling the superclass constructor using super()
super(name);
this.breed = breed;
//this.name=name;
//this.name=name;
System.out.println("Dog constructor called");
}

public void display() {


System.out.println("Name: " + name);
System.out.println("Breed: " + breed);
}}

public class SuperConst {


public static void main(String[] args) {
// Creating an instance of Dog
Dogs myDog = new Dogs("Buddy", "Golden Retriever");

// Displaying the values


myDog.display();
}}

You might also like