OOP是 "面向对象的编程"，它由对象和类组成，因此在这里，编程是通过类和对象完成的。
OOP的概念
什么是 "类"？
OOP的A 类 在java中，一个蓝图包含了所有的方法、函数、主干，简单地说，整个代码都包含在类中，因此类是一个块，包含了所有的东西。
class class_name{
The code come here:
Methods/functions/main
}
什么是 "对象"？
它是一个现实世界的实体，如笔或椅子，用来调用类。所以任何类都可以在对象的帮助下被访问。
Class_Name Object_Name=new Class_Name();
This is the way to create an object of any class:
Object_Name.Method_Name();
This is how an object of a class access a method of that class:
继承（INHERITANCE
一个类获得其他类的所有属性的过程。因此，这个过程被称为 继承。
因此，继承属性的类被称为子类，其方法被继承的其他类被称为父类。
继承 的类型
在Java中，有多种类型的继承，基本上取决于各种条件，如：
单一的继承
在这种情况下，一个类扩展另一个类（只有一个类）。
单一继承
多重继承-
在 多重继承 一个类扩展了多个类。但Java不支持多重继承。
_多重继承_
多级继承
在_多级_继承中，一个类可以继承于一个派生类。因此，派生类成为新类的基类。
多级继承
分层继承
在这种情况下，一个类被许多子类所继承，因此父类被多个子类所继承。
分层继承
混合式继承
它是单继承和多继承的结合，因为它包含一个主父类和子多父类及多子类。
混合式继承
注意：
Java（不）支持混合/多重继承
继承代码的例子
class Employee{
float salary=40000;
}
class Programmer extends Employee{
int bonus=10000;
public static void main(String args[]){
Programmer p=new Programmer();
System.out.println("Programmer salary is:"+p.salary);
System.out.println("Bonus of Programmer is:"+p.bonus);
}
}
多态性
这是一个概念，在这个概念中，我们可以_以不同的方式_执行一个单一的任务 _，_所以它的名字表明了它的工作原理，它来源于两个希腊词：poly和morphs。
因此，"poly "意味着许多，"morphs "意味着形式。
显示多态性的图片
两种类型：
1.运行时（Runtime: 是一个过程，其中对重载方法的调用是在运行时解决的，而不是在编译时。
1.运行时：包含了方法重载的过程，在这个过程中，我们在子类中继承了同名的方法。
2.编译时：是一个过程，其中一个类可以包含两个具有不同参数或没有参数的同名方法。
所以编译时不需要运行时的条件。
例子代码
"class Animal {
public void animalSound() {
System.out.println("The animal makes a sound");
}
}
class Pig extends Animal {
public void animalSound() {
System.out.println("The pig says: wee wee");
}
}
class Dog extends Animal {
public void animalSound() {
System.out.println("The dog says: bow wow");
}
}
class Main {
public static void main(String[] args) {
Animal myAnimal = new Animal(); // Create a Animal object
Animal myPig = new Pig(); // Create a Pig object
Animal myDog = new Dog(); // Create a Dog object
myAnimal.animalSound();
myPig.animalSound();Here
myDog.animalSound();
}
}
ABSTRACTION
一个 抽象是一个隐藏实现细节的过程，只向用户展示功能
简单地说，它是一个过程，用户只看到他感兴趣的信息，而不是整个细节。
所以Ac是抽象的最好的例子，我们只想知道如何使用它，而不是它是如何工作的。
显示抽象的图片
代码的例子
// Abstract class
abstract class Animal {
// Abstract method (does not have a body)
public abstract void animalSound();
// Regular method
public void sleep() {
System.out.println("Zzz");
}
}
// Subclass (inherit from Animal)
class Pig extends Animal {
public void animalSound() {
// The body of animalSound() is provided here
System.out.println("The pig says: wee wee");
}
}
class Main {
public static void main(String[] args) {
Pig myPig = new Pig(); // Create a Pig object
myPig.animalSound();
myPig.sleep();
}
}
封装
这个 ，就是_把代码_ 和_数据包装成一个单元_的_过程_ ，比如说，一个混合了几种药物的胶囊。
图片显示封装
因此，通过只提供一个setter或getter方法，你可以使这个类成为只读或只写的。
换句话说，你可以跳过getter或setter方法。它为你提供了对数据的控制。假设你想设置id的值，它应该只大于100，你可以在setter方法中写下逻辑。
你可以在setter方法中写下不存储负数的逻辑。这是一种在Java中实现数据隐藏的方式 ，因为其他类将无法通过私有数据成员访问数据。
示例代码
class Account {
//private data members
private long acc_no;
private String name,email;
private float amount;
//public getter and setter methods
public long getAcc_no() {
return acc_no;
}
public void setAcc_no(long acc_no) {
this.acc_no = acc_no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public float getAmount() {
return amount;
}
public void setAmount(float amount) {
this.amount = amount;
} }
public class TestEncapsulation {
public static void main(String[] args) {
//creating instance of Account class
Account acc=new Account();
//setting values through setter methods
acc.setAcc_no(7560504000L);
acc.setName("Sonoo Jaiswal");
acc.setEmail("sonoojaiswal@javatpoint.com");
acc.setAmount(500000f);
//getting values through getter methods
System.out.println(acc.getAcc_no()+" "+acc.getName()+" "+acc.getEmail()+" "+acc.getAmount());
}
}
