Project
Scientific Calculator with object-oriented programming (OOP) concept .
Introduction
Object-Oriented Programming and define terminology like abstraction, encapsulation, inheritance, and polymorphism. To begin, OOP is a programming style that needs programmers to construct objects and use them throughout the program in functions that demand the use of such objects. The OOPs concepts with Scientific Calculator.
OOPs is very useful in nearly every programming language like in Java , C++
In today’s technology-driven environment, computer programming skills are in high demand. When it comes to designing and managing software programs, understanding object-oriented programming (OOP) can be extremely useful. In this report, we’ll go through the fundamentals of OOP and illustrate them with simple examples. OOPs and its concepts with Scientific Calculator of object-oriented programming easily.
What Is OOPS?
Object-Oriented Computers, or OOPs concepts, refer to programming languages that make use of objects. Inheritance, hiding, polymorphism, and other real-world concepts are all part of object-oriented programming. The basic goal of OOPs concepts with real time examples is to connect data and the functions that operate on it so that no other part of the code may access it except that function.
In object-oriented programming, a group of data properties is combined with functions or methods to form an “object.” OOP languages are often class-based, which implies that a class defines the data characteristics and functions that are used to create objects, which are instances of the class. Java, Python, and C++ are examples of popular class-based OOP languages. Multiple independent objects can be instantiated—or represented—from the same class, and they can interact in a variety of ways. Data structures are also one of the important topics in OOPs languages like C.
A class is call as “MAIN” ,that represents a person is a simple example. The person class would have characteristics that represented data like the objects , and all functions and operators. And print option.
EX:
Class: public class calculationHistory {
A family could be created by creating individual person objects from the class for each family member. Because each person is different, each person’s object would have different data attributes.
EX:
Objects: File file11=new File("hello.txt");
Attribute: double a;, double b,, int c = 0;
This programming approach may be found in several prominent programming languages, including Java, C++, Python, JavaScript, and C#. Classes can be arranged into modules by defining sets of classes that represent and encapsulate objects in a program. This improves the structure and organization of software applications. As a result, developers frequently use OOP as a tool when creating large programs since classes and their relationships are easier to reason about.
Many gets confused between OOPs and POPs, so here we have listed difference between OOPs and POPs. POP is a step-by-step approach to decompose a task into a set of variables and routines (or subroutines) using a set of instructions. Each step is completed in a methodical way so that a computer can understand what has to be done.
Note : With OOP and POP you also should know about the Structure and Union in C
Lets now try to understand OOPS with real time examples.
OOPs Concepts With Calculator Examples
Class
One of the fundamental notions in OOPs concepts with real time examples is the class, which is a collection of comparable entities. It is a mental component rather than a physical thing. Let’s take an example of one of the OOPs concepts with real time examples: If you had a class called “CALCULATOR,” it could contain objects like calculator, scientific calculator one of its attributes (data).techniques can be used with these calculator.
Instead of writing a program, you create classes with OOP. Data and functions are both contained in a class. You construct an object, which is an instance of that class, when you want to save something in memory. As an example, you can create a Customer class that contains customer-related data and functions. You must then build a new Customer class object if you want your program to generate a customer in memory.
OOPs concepts with Examples :In Calculator Class. There may be many Calculator with different names and brands, but they will all have some basic characteristics, such as four add, sub , multi , divide. The class is Calculator, and the attributes int, double, string .
- A Class is a data type with data members and member functions that is defined by the user.
- Data members are data variables, and member functions are functions that manipulate these variables; these data members and member functions together define the properties and behavior of the objects in a Class.
Object
An object is a real-life entity that is defined as an instance of a class. The objects of a class called calculator for example, will be a ADD,SUB,DIVIDE,MULTIPLY AND OTHER OPERATORS. Each object has its own identity, attribute, and behavior. The code below shows how to utilize class, object, and method in the Java programming language.
Objects, like records in Pascal or structures or unions in C, take up memory and have an associated address. When a programme is run, the objects communicate with one another by sending messages.
Each object contains data as well as code for manipulating it. Objects can interact without knowing anything about each other’s data or code; all they need to know is the type of message they take and the sort of response they provide.
Composition
Composition is a type of Aggregation that is more specific. It’s sometimes referred to as a “death” connection. Because child objects lack a lifecycle, when the parent object is deleted, all child objects are automatically deleted as well. Let’s use the example of a house and its rooms as an example. A house can have a number of rooms. It’s impossible for a single room to be a part of two different homes. As a result, deleting the homeroom will also delete the house room.
Access Modifiers
Access modifiers are used to perform Data Hiding, an important feature of Object-Oriented Programming.
Access modifiers are keywords that specify a class’s (or type’s) and its members’ accessibility. These modifications can be used from within or outside of the current application’s code. In.NET, access modifiers are used to control the accessibility of each of a type’s members from various code sections. This can be done either inside or outside the current assembly. An assembly is a logical unit of functionality that is made up of types and resources that are stored in one or more files.
OOPs concepts with Examples: The Research and Analysis Wing (R&AW), which comprises ten core members, has obtained critical confidential national security material. These core components can now be linked to data members or member functions of a class, which can then be linked to the R&A wing.
These ten members have direct access to confidential information from their wing (the class), but anyone other than these ten members does not have direct access to confidential information from their wing (the class), i.e. outside functions other than those prevalent in the class do not have direct access to information that is not entitled to them, unless they have been assigned privileges or have access to one of these ten members who has direct access to the confidential information.
Aggregation
Every item in this methodology has its own lifecycle. There is, however, ownership, and a child object cannot be owned by another parent object. Consider the department of class/objects and the calculator. A single calculator cannot belong to more than one function, but the calculator object will never be deleted, even if the function is deleted.
Association
A relationship between two objects is known as association. It is one of the OOPs concepts with examples(in Java) that specifies the diversity of objects. There is no owner in this OOP approach, and each object has its own lifecycle. Many objects, for example, can be associated with a single class, whereas one class can be associated with multiple objects & functions.
4 Major Pillars Of OOPs Concepts Examples:-
Encapsulation, abstraction, inheritance, and polymorphism are the four essential concepts of object-oriented programming. Even if these notions appear to be quite complicated, understanding the broad structure in which they operate can aid you in comprehending the fundamentals of an OOP computer programme. We’ll go through these four fundamental principles of OOPs concepts with real time examples and what they encompass in more detail below:
The word “encapsulate” refers to the act of enclosing something. Encapsulation works in OOP in a similar fashion to how a pill “encapsulates” or contains the medication under its coating: by building a protective barrier around the information contained within a class from the rest of the cod
In our topic of OOPs concepts with real time examples, we encapsulate data and methods that operate on it by combining them into a single unit, the class. We can hide private information of a class from the outside world and only disclose functionality that is needed to interact with it this way. We say a class is properly enclosed when it prevents calling code from accessing its private data directly.
OOPs Concepts with Real Time Examples: Extending the person class example from before, the class may contain private data, such as “socialSecurityNumber,” that should not be disclosed to other program objects. Outside programmes would not have direct access to this data member because it was encapsulated as a private variable in the class, and it would remain safe within that person’s object.
If a method called “private key word” is implemented , that function might then access the “socialSecurityNumber” variable as needed. Such a class would effectively encapsulate a person’s personal information.
When you can isolate the interface of a class from its implementation and focus on the interface, it’s often easier to reason and create a program. This is similar to seeing a system as a “black box,” where understanding the nitty-gritty inner workings isn’t required to reap the benefits of using it.
Because we are abstracting away the gory implementation details of a class and just exposing a clean and easy-to-use interface via the class’ member methods, this process is called “abstraction” in OOPs concepts with real time examples. When utilized correctly, abstraction isolates the impact of code changes, ensuring that if something goes wrong, the change only affects the implementation details of a class and not the outside code.
- Abstraction using Classes:
We may use classes to implement Abstraction in C++. Using the available access specifiers, the class assists us in grouping data members and member functions. A Class has the ability to control which data members are visible to the outside world and which are not.
- Abstraction in Header files:
Header files are another sort of abstraction that can be used in C++. Consider the pow() method in the math.h header file, for example. We just call the function pow() in the math.h header file whenever we need to calculate the power of a number and supply the numbers as arguments, without knowing the underlying algorithm through which the function calculates the power of numbers.
Example: Consider a stereo system as an object with a sophisticated logic board on the inside. It features buttons on the outside that allow it to be interacted with. Because you can’t see what occurs on the inside when you press any of the buttons, you don’t think about it. Even if you can’t see the logic board conducting these activities as a result of hitting a button, it is doing so behind your back.
In our blog of OOPs concepts with real time examples, this concept of abstraction, which is extremely valuable in all fields of engineering and can also be seen in action in object-oriented programming.
OOPs concepts with Real Time Examples:
The calculator only knows that add provides adding numbers and sub provides subtraction operators using lops and class . This is the definition of abstraction.
The OOPs concepts with real time examples of “inheritance” are almost always supported by object-oriented languages that offer classes. Classes can be grouped into hierarchies, with each parent or child class having one or more children. If a class has a parent class, it is said to be derived or inherited from it, and it represents an “IS-A” relationship. That is, the parent class’s child class has the “IS-A” type.
As a result, if a class inherits from another class, it inherits a lot of the same functionality and properties, and it can be modified to contain different code and data. Because the functionalities of a parent class do not need to be re-defined in any of its child classes, inheritance generally leads to good code reuse.
Consider two classes, one of which is the superclass (or parent), and the other is the subclass (or child). The parent class’s properties will be passed down to the child class, which may be modified or extended. Programmers that use the inheritance approach group these classes into what is known as a “IS-A” connection.
Real Time Example: An insect could be represented by an Insect superclass in the calculator. Insects scientific calculator have cos, tan ,sip like , subclasses could be created. They inherently share all bug features because they inherit or are derived from the Insect class.
In our topic of OOPs concepts with real time examples, Polymorphism is an OOP feature that allows classes in a hierarchy to be treated the same way. As a result, calling code only needs to handle objects from the hierarchy’s root, and each object instantiated by any child class is treated the same way.
Because derived objects and their parents have the same interface, the caller code can utilize any function in that class’ interface. Depending on the type of object supplied, the appropriate function will be invoked at run-time, resulting in potentially various behavior.
OOPs, Concepts With Examples: calculator class with two child classes named “normal calculator” and “scientific calculator function that is inherited by the subclasses “Calculator” and “scientific calculator” to be “add”, ”sub ” and “other operators,” respectively if the calculator class contains a way to create a named “calculator” Then, another function may be built that takes any Animal object as a parameter and calls the “scientific calculator” member function on it. Depending on the type of calculator object that was supplied to the function, the noise will be either a “add” or a sub.”
Advantages Of OOPs
Here are the advantages of OOPs concepts with real time examples:-
Here are a few of OOPs main Advantages:
Inheritance allows for code reusability
Assume that, in addition to your Car object, one of your colleagues needs a RaceCar object, while another requires a Limousine. Everyone constructs their items in their own unique way, but they all share commonalities. Each object is, in fact, a different type of Car. This is when the inheritance method comes in handy: Create one generic class (Car), then describe the subclasses that will inherit the generic class’s traits (RaceCar and Limousine).
Of course, each Limousine and RaceCar has its own set of characteristics and functions. If the RaceCar object requires a “fireAfterBurners” method and the Limousine object requires a Chauffeur, each class could implement its own functions. Because both classes inherit crucial characteristics from the Car class, such as the “drive” and “fillUpGas” methods, your inheriting classes can reuse existing code rather than rewriting these functions.
What if you wish to change the appearance of all Car objects, independent of their type? Another benefit of the OOPs concepts with real time examples. If you modify the code in your Car class, all car objects will inherit the new code.
Modularity makes troubleshooting easier
When using object-oriented programming languages, you always know where to look if something goes wrong. “Oh, the automobile object malfunctioned?” “It’s got to be in the Car class!” You don’t have to go over all of your code lines by line.
Encapsulation’s beauty is in its simplicity. Objects are self-contained, and each piece of functionality operates independently of the others. Additionally, modularity allows an IT team to operate on different items at the same time while reducing the risk of one individual duplicating the functionality of another.
Polymorphism provides flexibility
Using these OOPs concepts with real time examples as an example, you’ll just need a few drivers or functions, such as “driveCar,” “driveRaceCar,” and “DriveLimousine.” Some characteristics are shared by RaceCarDrivers and LimousineDrivers, but others, such as RaceHelmets and BeverageSponsorships, are distinct.
Polymorphism, a feature of object-oriented programming, comes into play here. Because a single function may adapt to the class it’s in, you might make a single function in the parent Car class called “drive” — not “driveCar” or “driveRaceCar,” just “drive.” This single-function would be compatible with RaceCarDriver, LimousineDriver, and other such drivers. In reality, “raceCar.drive(myRaceCarDriver)” or “limo.drive(myChauffeur)” might be used.
Effective problem solving
Many people are hesitant to learn OOPs Concepts with real time examples because it appears to have a higher learning curve than top-down programming. However, if you take the time to learn OOPs concepts with real time examples, you’ll find that it’s the easier, more intuitive way to construct large applications.
Object-oriented programming is all about breaking down a large problem into manageable bits. You create a class for each mini-problem that fulfills your requirements. Then, best of all, you can reuse those classes, making the next challenge even easier to tackle.
This isn’t to argue that object-oriented programming (OOP) is the only way to develop software. But there’s a reason why C++, C#, and Java are the languages of choice for serious software development.
Disadvantages Of OOPs
Here are the disadvantages of OOPs concepts with real time examples:-
It can be Inefficient
Object-oriented programming consumes more CPU than other programming methods. When there are technical limits owing to the size that it can wind up being, this can make it an inefficient decision. First-time coding can also be more comprehensive than other options due to the redundancy involved.
It can cause duplication
Designing OOP projects is usually easier than implementing them. This is due to the fact that modular classes can be used in a variety of ways. You may be able to get new projects up and running faster, but this comes at the cost of projects that feel cloned at times.
Although object-oriented programming has a steep learning curve, it might be a good investment for future projects. The initial expense can be assessed against future gains to see if it is the best route to take by weighing the pros and drawbacks.
It can be too scalable
If OOP is allowed to go amok, it can result in a tremendous amount of bloated, unneeded code. When this happens, overhead rises, making it difficult to keep expenses low.
Steep learning curve
For some people, the mental process involved in object-oriented programming is not natural, and it can take some time to adjust. Creating programmes based on object interaction is difficult. Some of the most important programming methods, such as inheritance and polymorphism, can be difficult to grasp at first.
Opps concepct software.
Talented software developers with experience using C# and Java is in high demand right now. Employers prefer OOP programmers who have additional credentials, such as Certified Information Security Manager (CISM) or AWS-Certified Cloud Practitioner.
The following industries have the most need for OOP developers:
- Services in the financial sector
- Healthcare
- technologically sophisticated
- Services provided by professionals
- Investing in real estate
- E-commerce and retail
Conclusion
To summarize it all, we’ve covered the fundamentals of OOPs in this blog of OOPs concepts with real time examples. These ideas are widely applied in industry and other settings. These ideas must be understood thoroughly in order to become a competent programmer. After reading the blog we all know that OOPs concepts with real time examples are so crucial to learn. With the Object Oriented Programming you must know about the Database Management System,
Object-oriented programming of an object, which encapsulates data and action acting on the data, is central to object-oriented programming. An object’s services are delivered via a well-defined interface. This interface defines “what” the object provides while abstracting “how” it does so (actual implementation). OOPs concepts with real time examples can help anyone to learn effectively and efficiently through real-world examples provided.
Calculator program : opps concepts by java.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class calculationHistory {
public static void main(String[] args)
{
double a;
double b;
int c = 0;
int monthlyRate = 0;
int months;
double futureValue;
Scanner sc = new Scanner(System.in);
File file11=new File("hello.txt");
System.out.println("1. Normal calculator, 2.Scientific calculator");
System.out.println("Enter the choice : ");
double choice = sc.nextDouble();
String usertype;
while(true) {
if(choice==1) {
usertype="normal calculator";
sc.nextLine();
System.out.println("1. add");
System.out.println("2. sub");
System.out.println("3. multiply");
System.out.println("4. divid");
System.out.println("enter ur choice ");
choice= sc.nextInt();
if(choice==1) {
System.out.println("enter 2 num for addition");
a = sc.nextDouble();
b= sc.nextDouble();
System.out.println(a+b);
break;
}
else if(choice==2) {
System.out.println("enter 2 num for sub");
a=sc.nextDouble();
b=sc.nextDouble();
System.out.println(a-b);
break;
}
else if(choice==3) {
System.out.println("enter 2 num for sub");
a=sc.nextDouble();
b=sc.nextDouble();
System.out.println(a*b);
break;
}
else if(choice==4) {
System.out.println("enter 2 num for sub");
a=sc.nextDouble();
b=sc.nextDouble();
System.out.println(a/b);
break;
}
}
if(choice==2) {
usertype="Scientific calculator";
// sc.nextLine();
System.out.println("1. ^-power");
System.out.println("2. sqrt");
System.out.println("3. log");
System.out.println("4. sin");
System.out.println("5. asin");
System.out.println("6. cos");
System.out.println("7. acos");
System.out.println("8.tan");
System.out.println("9.atan");
System.out.println("10. store ");
System.out.println("11. recall");
System.out.println("12. D2B");
System.out.println("13. B2D");
System.out.println("14.sip");
System.out.println("enter ur choice ");
choice= sc.nextInt();
if(choice==1) {
System.out.println("enter 2 num for power");
a = sc.nextDouble();
b= sc.nextDouble();
System.out.println(Math.pow(a, b));
break;
}
else if(choice==2) {
System.out.println("enter num sqrt");
a = sc.nextDouble();
System.out.println(Math.sqrt(a));
break;
}
else if(choice==3) {
System.out.println("enter num for log");
a = sc.nextDouble();
System.out.println(Math.log(a ));
break;
}
else if(choice==4) {
System.out.println("enter num for sin");
a = sc.nextDouble();
b =Math.toRadians(a);
System.out.println(Math.sin(b));
break;
}
else if(choice==5) {
System.out.println("enter num for asin");
a = sc.nextDouble();
System.out.println(Math.asin(a));
break;
}
else if(choice==6) {
System.out.println("enter num for cos");
a = sc.nextDouble();
System.out.println(Math.cos(a));
break;
}
else if(choice==7) {
System.out.println("enter num for inverse cos");
a = sc.nextDouble();
System.out.println(Math.acos(a));
break;
}
else if(choice==8) {
System.out.println("enter num for tan");
a = sc.nextDouble();
System.out.println(Math.tan(a));
break;
}
else if(choice==9) {
System.out.println("enter num for inverse tan");
a = sc.nextDouble();
System.out.println(Math.atan(a));
break;
}
else if(choice==10) {
try {
BufferedWriter bw=new BufferedWriter(new FileWriter(file11,true));
System.out.println("Enter array size");
int size=sc.nextInt();
int numbers[]= new int[size];
System.out.println("Enter data in array");
for (int i=0; i<size; i++){
numbers[i]=sc.nextInt();
}
System.out.println("file stored suddfully");
bw.close();
} catch (IOException e) {
System.out.println("file unsussfully");
e.printStackTrace();
}
}
else if(choice==11) {
try {
BufferedReader br=new BufferedReader(new FileReader(file11));;
String contents;
while((contents=br.readLine())!=null)
System.out.println(contents);
br.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
else if(choice==12) {
System.out.println(" enter the num: ");
c=sc.nextInt();
System.out.println(Integer.toBinaryString(c));
}
else if(choice==13) {
Scanner dd= new Scanner(System.in);
System.out.println(" enter the binary num: ");
String binaryString = dd.nextLine();
System.out.println("output: "+Integer.parseInt(binaryString, 2));
}
else if(choice==14) {
System.out.println("Enter investment rate: ");
double investment = sc.nextInt();
System.out.println("enter annual rate: ");
double annualRate1=sc.nextInt();
// monthlyRate=annualRate1/12/100;
System.out.println("enter num of year:");
double years=sc.nextInt();
futureValue=investment*Math.pow((1+annualRate1/100),years);
System.out.println(futureValue);
}
}
else
System.out.println("ivalid input try again");
Break;
}
}
}