One of the main challenges that programmers face while writing code is that, while writing lengthy code, the code becomes haphazard and unorganized. It becomes very difficult to debug and look for errors while checking them line by line. Here comes the concept of OOPs programming, which basically helps the programmer properly organize the program. However, we will learn about classes and objects in Java, polymorphism, inheritance, encapsulation, and abstraction in Java.<\/p>\n
OOPs stands for Object-Oriented Programming. As we all know, Java is an object-oriented programming language. OOPs programming language tries to map our code with real-world entities like objects, methods, inheritance, abstraction, etc, making the code short and easier to understand. OOPs also makes our programs easier to maintain and debug.<\/p>\n
Advantages of Using OOPs in Java:<\/strong><\/p>\n Main Principles of OOPs in Java<\/strong><\/p>\n OOPs mainly consists of 6 principles:<\/strong><\/p>\n There are a few other sub-principles of OOP that we will discuss at the end. They include:<\/p>\n Let Us Discuss Each Principle One by One:<\/strong><\/p>\n A Java class is a logical entity or blueprint from which objects can be created. A class can be described as a group of objects having common properties. Classes in Java contain: Fields, Methods, Constructors, Blocks, Nested Classes, and interfaces.<\/p>\n Syntax of a Class in Java:<\/strong><\/p>\n An object in Java is a real-life entity of a class. A class is a logical entity, whereas an object is a physical entity. A class is defined as a template or blueprint; it is only when an object is declared that memory is assigned to the program. An object has a proper state and behaviour. Objects are also known as instances of a class.<\/p>\n Syntax of a Java object:<\/strong><\/p>\n Let us understand the relationship between classes and objects with a real-world example:<\/p>\n Suppose a student is filling out an application form for an internship, he will fill out the form and send it to the company. Here, the application form is the class that contains fields like name, age, gender, etc., which are the contents of the class. After the student fills the form, the final application of the student is known as the object.<\/p>\n Program to understand objects and classes in Java:<\/strong><\/p>\n The output of the above Code:<\/strong><\/p>\n Abstraction is the process of hiding implementation details from the end-user. In a programming language, we use a predefined object or previously created objects in another program without caring what that object contains; we only care about what it does. This type of implementation is known as abstraction.<\/p>\n We use mobile phones or smartphones to perform various tasks in our day-to-day lives. Each application on the phone performs a specific task. We, as users, only care about what the application does, rather than focusing on how it does the task. This is known as abstraction.<\/p>\n In Java, we can achieve abstraction through two processes:<\/strong><\/p>\n Let us take a look at them individually:<\/p>\n A Java class with the keyword abstract in front of it is known as an abstract class. Th, it can have both abstract and non-abstract methods. It cannot be initiated like other methods. The abstract methods in Java need to be extended and implemented. We can achieve partial abstraction with abstract classes.<\/p>\n Program to illustrate Abstract Class in Java:<\/strong><\/p>\n The output of the above Program:<\/strong><\/p>\n As we know, a class is a blueprint of a program; similarly, the blueprint of a class is known as an interface. Unlike abstract classes, interfaces cannot have normal methods; they only have abstract methods. Thus, interfaces provide complete abstraction, unlike abstract classes.<\/p>\n Program to Illustrate Interface in Java:<\/strong><\/p>\n The output of the above Program:<\/strong><\/p>\n Inheritance, as the name suggests, is the act of inheriting properties of the previously declared class. The class from which the properties are inherited is known as the parent class or superclass, and the classes that derive from the main class are known as subclasses or child classes. Although Inheritance uses the DRY principle. Therefore, it is the act of deriving new things from previously existing things.<\/p>\n Phones were invented a long time ago, but they could only be used to communicate with others. In recent times, these phones have been replaced by smartphones, which inherited the properties of those phones and added new and improved features to them.<\/p>\n Program of Java Inheritance:<\/strong><\/p>\n The output of the above program:<\/strong><\/p>\n The wrapping up of data into a single entity, for example, a class, is known as encapsulation. However, it is the act of putting various entities together. Therefore, in Java, encapsulation helps to keep the sensitive data hidden from the users.<\/p>\n Let us consider the laptop to be a single entity. A laptop contains a speaker, Keyboard, Mouse(Trackpad), wifi, etc. Although we can say that all these components are encapsulated into a single device known as a laptop.<\/p>\n Encapsulation can be done by making all the data members of a class private. Thus, the class is then provided with a setter and getter method to set and get the data. Therefore, A Java Bean class is an example of an encapsulated class. As a result, Encapsulation provides control over data, data hiding, better unit testing, and easy and fast creation.<\/p>\n Program to Illustrate Encapsulation in Java:<\/strong><\/p>\n The output of the above program:<\/strong><\/p>\n Polymorphism means many forms. In Java, polymorphism can be achieved using method overloading and method overriding. When a method has the same name but differs in either return type or parameter list, they are known as an overloaded function and is an example of polymorphism.<\/p>\n Although there are two types of polymorphism in Java, namely, compile-time polymorphism and runtime polymorphism.<\/p>\n A smartphone can be used as a phone to make calls, and it can also be used as a calculator. Hence, we can see that the entity is the same, but the function differs; this is known as Polymorphism.<\/p>\n Program Illustrating Polymorphism in Java<\/strong><\/p>\n The output of the above program:<\/strong><\/p>\n A few of the other important terms included in the OOPs Principle are discussed below:<\/p>\n Coupling in Java refers to the access to information that one class has on the other. If a class can access all the information of another class, then the classes are known to be strongly coupled. However, there are access modifiers to modify the access to the information a class gives by adding public, private, or protected. For weaker coupling, interfaces can be used, as there is no proper implementation.<\/p>\n The level of an entity that performs a single well-defined task is known as cohesion. When an entity performs a single well-defined task on its own, the entity is said to be highly cohesive. Hence, weakly cohesive entities will split the task. The java.io package is highly cohesive, as it has I\/O related classes and interfaces only. The java.util package is an example of a weakly cohesive entity, as it has unrelated classes and interfaces.<\/p>\n Association is the relation between the objects and how they are mapped inside the program. Similar to, functions in mathematics, object mapping can also be done in four ways:<\/p>\n Association can be unidirectional as well as bidirectional.<\/p>\n Aggregation represents the weak relationship between two objects. It can be termed as a has-a relationship in Java, just like inheritance, which represents the is-a relationship. Therefore, Aggregation is basically another way to reuse objects. Therefore, aggregation is a way to achieve association.<\/p>\n Composition represents a strong relationship between the containing object and the dependent object. It is a process where the containing object does not have an independent existence. If the dependent object is deleted, the containing object will also be automatically deleted. It is also another way to achieve association.<\/p>\n Programmers have shifted to OOPs programming; there must be a reason behind that. Let us see why OOPs programming has a clear advantage over procedural programming languages.<\/p>\n 1. OOPs provide an organized way to access and debug a program, thus making maintaining the program easier. However, in procedural programming, each line has to be debugged separately to look for errors, which sometimes becomes too chaotic.<\/p>\n 2. It provides security and protection to our data by hiding data using abstraction, encapsulation, etc. Therefore, Procedural Programming doesn\u2019t have such provisions.<\/p>\n 3. OOPs can be used to simulate real-life problems and thus can help solve those problems through different algorithms. With Procedural language, this is impossible to achieve.<\/p>\n In this article, we saw why OOPs took over the programming world and helped us solve different issues. However, we discussed each and every terminology of OOPs with real-life examples to make it easier for everyone to understand the importance of OOPs.<\/p>\n","protected":false},"excerpt":{"rendered":" One of the main challenges that programmers face while writing code is that, while writing lengthy code, the code becomes haphazard and unorganized. It becomes very difficult to debug and look for errors while...<\/p>\n","protected":false},"author":7,"featured_media":108844,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[32],"tags":[720,22413,2806,2817,6836,7422,7423,15775,15776,15785],"class_list":["post-6263","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-anonymous-objects-in-java","tag-classes-and-objects-in-java","tag-components-of-class","tag-components-of-objects","tag-instantiating-a-class-in-java","tag-java-class-and-object-with-examples","tag-java-class-vs-object","tag-what-is-java-class","tag-what-is-java-class-and-object","tag-what-is-java-object"],"yoast_head":"\n\n
\n
\n
Classes in Java<\/h3>\n
class <class name>{\r\n\/\/Statements\r\n}\r\n<\/pre>\nObjects in Java<\/h3>\n
<Class name> <Object name>= new <class name>();\r\n<\/pre>\n
package com.DataFlair.OOPS;\r\npublic class Internshipform\r\n{\r\n String Name;\r\n int Age;\r\n String Gender;\r\n Internshipform(String name, int age,String gender) {\r\n this.Name = name;\r\n this.Age = age;\r\n this.Gender = gender;\r\n }\r\n public static void main(String args[]) {\r\n Internshipform obj1 = new Internshipform(\"Arka Ghosh\", 21, \"Male\");\r\n Internshipform obj2 = new Internshipform(\"Aradhya Sarkar\", 22, \"Female\");\r\n System.out.println(\"Name: \" + obj1.Name);\r\n System.out.println(\"Age: \" + obj1.Age);\r\n System.out.println(\"Gender: \"+obj1.Gender);\r\n System.out.println(\"Name: \" + obj2.Name);\r\n System.out.println(\"Age: \" + obj2.Age);\r\n System.out.println(\"Gender: \"+obj2.Gender);\r\n }\r\n}\r\n<\/pre>\n
\nAge: 21
\nGender: Male
\nName: Aradhya Sarkar
\nAge: 22
\nGender: Female<\/div>\nAbstraction in Java<\/h3>\n
Real-World Example of Java Abstraction<\/h4>\n
\n
Java Abstract Class<\/h4>\n
package com.DataFlair.OOPS;\r\nabstract class Internship\r\n{\r\n abstract void success(); \r\n} \r\npublic class Status extends Internship{ \r\nvoid success(){\r\n System.out.println(\"You Have Successfully Applied for the Internship!\");\r\n} \r\npublic static void main(String[] args){ \r\n Internship obj = new Status(); \r\n obj.success(); \r\n} \r\n}\r\n<\/pre>\nJava Interface<\/h4>\n
package com.DataFlair.OOPS;\r\ninterface Internship\r\n{\r\n void print();\r\n}\r\npublic class StatusofInternship implements Internship{ \r\npublic void print(){System.out.println(\"You Have Successfully Applied for the Internship!\");\r\n} \r\npublic static void main(String args[]){ \r\nStatusofInternship obj = new StatusofInternship(); \r\nobj.print(); \r\n } \r\n} \r\n<\/pre>\nInheritance in Java<\/h3>\n
Real-World Example of Java Inheritance<\/h4>\n
Types of Inheritance in Java<\/h4>\n
package com.DataFlair.OOPS;\r\npublic class Intern\r\n{ \r\n String name=\"Arka Ghosh\";\r\n}\r\npublic class Role extends Intern\r\n{\r\n String Job=\"Technical Writer\";\r\n String Lang=\"JAVA\";\r\n void main(String[] args)\r\n { \r\n Topic t=new Topic(); \r\n System.out.println(\"Intern Name: \"+t.name); \r\n System.out.println(\"Intern Role: \"+t.Job+\" in \"+t.Lang); \r\n }\r\n}\r\n<\/pre>\n
\nIntern Role: Technical Writer in JAVA<\/div>\nEncapsulation in Java<\/h3>\n
Real-world example of encapsulation in Java<\/h4>\n
Encapsulated Class:\r\npackage com.DataFlair.OOPS;\r\npublic class Interns\r\n{ \r\nprivate String name; \r\npublic String getName(){ \r\nreturn name; \r\n} \r\npublic void setName(String name){ \r\nthis.name=name;\r\n} \r\n}\r\nAccess Class:\r\npackage com.DataFlair.OOPS;\r\npublic class AssignIntern\r\n{\r\n public static void main(String[] args)\r\n { \r\n Interns I=new Interns(); \r\n I.setName(\"Arka Ghosh\"); \r\n System.out.println(I.getName()); \r\n} \r\n}\r\n<\/pre>\nPolymorphism in Java<\/h3>\n
Real-world example of Java Polymorphism<\/h4>\n
package com.DataFlair.OOPS;\r\npublic class Polymorphism\r\n{\r\n void area(int r)\r\n {\r\n double a=3.14*r*r;\r\n System.out.println(\"The area of the Circle is: \"+a);\r\n }\r\n void area(int l, int b)\r\n {\r\n int a= l*b;\r\n System.out.println(\"The area of the rectangle is: \"+a);\r\n }\r\n public static void main(String[] args)\r\n {\r\n Polymorphism a = new Polymorphism();\r\n a.area(5);\r\n a.area(2,3);\r\n }\r\n}\r\n<\/pre>\n
\nThe area of the rectangle is: 6<\/div>\nJava Coupling<\/h3>\n
Cohesion in Java<\/h3>\n
Association in Java<\/h3>\n
\n
Java Aggregation<\/h3>\n
Composition in Java<\/h3>\n
Advantages of OOPs over Procedural Programming Language<\/h3>\n
Conclusion<\/h3>\n