面向对象的编程（OOP）
oop是一种使用类和对象设计程序的方法或范式。通过提供以下一些构想，它简化了软件开发和主体利益：
班级
类是用户定义的数据类型，它定义其属性及其功能。
类是逻辑数据的表示。
例如，人类是班级。人类的身体部位是其属性，并且身体部位执行的动作被称为函数。
班级确实不占据任何内存空间 till the time an object is instantiated。
目的
对象是运行时实体。
这是类的实例。
一个物体可以代表一个人，地方或任何其他物品。对象可以在数据成员和成员功能上操作。
简而言之，类是蓝图，对象是使用该蓝图制造的实际产品
如果我们以大型工厂为例，他们花费数百万美元来创建汽车的蓝图，而 blueprint 我们可以称为 class ，并且使用该蓝图，它们创建了数百万辆汽车，这些汽车被称为对象。 以下是类和对象的示例 代码： 输出： 这种方法增强了代码可重复性并保持关注的明确分离。 注释：当使用新关键字创建对象时，将空间分配给 heap 中的变量，而开始地址存储在堆栈内存中。 构造函数是一种特殊的方法，在对象创建时会自动调用。它通常用于初始化新对象的数据成员。 构造函数具有与类或结构相同的名称。 构造函数没有返回类型。 （甚至都没有无效。） 构造函数仅在对象创建中称为一次。 有三种类型的构造函数。 具有 在创建对象时会调用它。如果我们不创建一个，则默认情况下由Java创建。 代码： 输出： 具有 它用于为不同的对象提供不同的值。 代码： 输出： 将当前对象作为参数传递给另一种方法 请参阅当前类实例变量 复制构造函数是一种超载构造函数，用于从另一个对象声明和初始化对象。 代码： Java有一个自动处理内存的垃圾收集器。 简单的词，poly表示'许多 - 态度表示形式。 这意味着可以用不同形式编写函数。 多态性允许将不同类别的对象视为普通超类的实例。 现在，有两种
class Car {
String brand = "Tesla";
int tires;
String series;
}
public class ClassObject {
public static void main(String[] args) {
Car carObj1 = new Car(); // Object 1
carObj1.series = "A";
carObj1.tires = 4;
System.out.println(carObj1.brand + " has " + carObj1.tires + " tires and is of " + carObj1.series +" series");
Car carObj2 = new Car(); // Object 2
carObj2.series = "X";
carObj2.tires = 3;
System.out.println(carObj2.brand + " has " + carObj2.tires + " tires and is of " + carObj2.series +" series");
}
}
构造函数：
非参数化构造函数：
no argument的构造函数被称为非参数构造函数（或no-argument构造函数）。
class Me{
Me(){
System.out.println("My name is Abhishek Pathak");
}
}
public class ClassObject {
public static void main(String[] args) {
Me me = new Me();
}
}
参数化构造函数
parameters的构造函数称为参数化构造函数。
class Car {
String brand = "Tesla";
int tires;
String series;
Car(int tires, String series) {
this.tires = tires;
this.series = series;
}
}
public class ClassObject {
public static void main(String[] args) {
Car carObj1 = new Car(1, "A"); // Object 1
System.out.println(carObj1.brand + " has " + carObj1.tires + " tires and is of " + carObj1.series +" series");
Car carObj2 = new Car(3, "X"); // Object 2
System.out.println(carObj2.brand + " has " + carObj2.tires + " tires and is of " + carObj2.series +" series");
}
}
这个关键字：Java中的此关键字是指类的当前实例。在OOPS中，它用来：
复制构造函数
class Car {
String brand = "Tesla";
int tires;
String series;
Car(CarObj obj1) {
this.tires = obj1.tires;
this.series = obj1.series;
}
}
多态性
1.编译时间多态性（静态）。
2.运行时多态性（动态）
让他们深入研究：
编译时间多态性
在编译时间（编译阶段）实现的多态性被称为编译时间多态性。示例：方法超载
方法超载
方法过载是一种允许您具有相同名称但功能不同的功能的技术。
此处考虑该函数的签名。
什么是功能签名？
在Java中，方法签名由名称以及其参数的数字，类型和顺序组成。返回类型和抛出异常不被视为方法签名的一部分，参数的名称也不是。编译器忽略了它们以检查方法的唯一性。
方法可以在以下基础上过载：
-
传递给函数的参数类型
-
传递给函数的参数数
代码：
class Student {
String name;
int roll;
public void display(String name) {
System.out.println("Name: " + name);
}
public void display(String name, int roll) {
System.out.println("Name: " + name + " roll: " + roll);
}
}
public class Polymorphism {
public static void main(String[] args) {
Student std = new Student();
std.display("Abhishek");
std.display("Abhishek", 20);
}
}
输出：
运行时多态性
运行时多态性也被称为动态多态性。
功能覆盖是运行时多态性的一个例子。
功能覆盖
简而言之，当我们从父类中覆盖函数时，功能覆盖了，这意味着子类具有与父类相同的函数，而子类也更改了某些字段。
这称为动态，因为在头部中创建了对象，这是动态的。当我们执行继承时，您将更多地了解。
代码：
将在Inheritance
现在，我们列表中的下一个是Great Inheritance
侵害
继承是一个对象获得其 parent> parent 对象的所有属性和行为的过程。
以这种方式，您可以重复使用，扩展或修改其他类中定义的属性和行为。
在Java中，继承另一类成员的类称为派生类，其成员继承的类称为 base类。 P>
派生类是基类的专业类。
我们有不同类型的继承：
-
单个继承
-
层次继承
-
多级继承
让我们一一深入研究：
1.单个继承
在Java中，我们使用
extends关键字实现继承。
当一个类继承另一个类时，它被称为单级继承。
class Brand {
int tires = 4;
public void name() {
System.out.println("This is class brand");
}
}
class Tesla extends Brand {
public void name(String name) {
System.out.println("The brand is: "+ name + " with " + this.tires +" tires");
}
}
public class Inheritance1 {
public static void main(String[] args) {
Tesla t = new Tesla();
t.name("Tesla");
}
}
在这里，我们可以观察到Tesla级扩展了品牌类别和Tesla类，使用可变轮胎。
。到目前为止，您可能已经观察到父母类中的两个函数名称，即 base类，name在子类中使用，即 derived clastive class 。这称为运行时多态性。
分层继承：
层次结构继承定义为从基类得出多个类的过程。
class Pencil {
int size = 2;
}
class Apsara extends Pencil{
Apsara(){
System.out.println("This is Apsara with pencil length" + this.size);
}
}
class Doms extends Pencil {
Doms(){
System.out.println("This is Doms with pencil length" + this.size);
}
}
多级继承：
多级继承是从另一个派生类派生类的过程。
class Brand {
int tires = 4;
}
class Manufacturer extends Brand{
String mname = "Tesla";
}
class Tesla extends Manufacturer {
public void name(String name) {
System.out.println("The brand is: "+ name + " with " + this.tires +" tires and manu by " + this.mname );
}
}
public class Inheritance1 {
public static void main(String[] args) {
Tesla t = new Tesla();
t.name("Tesla");
}
}
输出：
混合继承
混合继承是简单的，多重继承和层次继承的组合。
现在，我们将使用封装。
封装
封装是将数据和功能组合到一个称为类的单元中的过程。在封装中，数据无法直接访问；它可以通过类中的功能访问。
用更简单的词来保留班的属性私有和 public ; Getter 和 setter 提供了操纵这些属性的方法。
封装有助于我们实现数据隐藏。
数据隐藏：
数据隐藏是一种语言功能，可以限制对对象成员的访问，从而减少依赖关系的负面影响。例如，Java中的“受保护”和“私人”功能
在封装之前，我们需要了解访问修饰符的知识。
访问修饰符
访问修饰符是确定程序中类，方法，字段和构造函数的可见性或可访问性的关键字。
他们控制可以从不同类或软件包访问代码的哪些部分。
- 公共
- 受保护
- 默认
- 私人
让我们深入研究这些。
1.公共
公共访问修饰符允许从程序中的任何地方（即使从其他类和软件包）中的任何地方访问类，方法，字段或构造函数。
public class Car {
public String brand = "Tesla";
public void startEngine() {
System.out.println("Engine started.");
}
}
2.受保护：
受保护的访问修饰符允许在其自己的软件包以及其他软件包中的子类访问类，方法或字段中。
protected class Vehicle {
protected String type = "Automobile";
protected void honk() {
System.out.println("Honk honk!");
}
}
3.默认（无修饰符）
如果没有访问修改器，则被视为默认访问级别。只有在其自己的软件包中才能访问具有默认访问的类，方法或字段。
class Animal {
String name = "Unknown";
void makeSound() {
System.out.println("Some sound");
}
}
4.私人
私人访问修饰符将A 类成员的可见性限制在同一类中的 中。这是最严格的访问级别。
class BankAccount {
private double balance = 0.0;
private void deductFees() {
balance -= 10.0;
}
}
这足以容纳访问修饰符，我们将回到我们的封装。
。因此，封装利用访问修饰符来实现数据隐藏。
如上所述，封装利用getters和setters访问属性。
您将通过以下示例了解更多：
class Bank {
private double balance = 0.0;
public Bank(double initial) {
balance = initial;
}
public double getBalance() {
return balance;
}
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
System.out.println("Deposited: " + amount);
}
}
public void withdraw(double amount) {
balance -= amount;
System.out.println("Widrawl Done");
}
}
public class Encapsulation {
public static void main(String[] args) {
Bank bank = new Bank(10);
System.out.println("Initial Balance: " + bank.getBalance());
bank.deposit(30);
bank.withdraw(3);
System.out.println("Balance after widrawl: " + bank.getBalance());
}
}
此示例显示了完美的封装。属性balance是私人的，因此只有类方法才能使用和操纵。
尝试玩它。
现在，接下来我们有抽象
抽象
这次，我将使用一个简单的示例，确定
想象开车。
您不需要了解引擎如何工作的每个复杂细节；您只需要了解加速，制动和转向等基本功能即可。
抽象在软件开发中的工作方式相似。
它使您能够创建真实世界对象的简化模型，强调隐藏复杂性的重要性。
在这里，我们尝试实现抽象视图。
这不是一个简单的吗？
简单地说，它是隐藏不必要的细节，仅向用户显示基本零件和功能。
数据绑定
数据绑定是绑定应用程序UI和业务逻辑的过程。业务逻辑中的任何更改都将直接反映在应用程序UI上。
抽象以两种方式获得：
- 抽象类
- 接口（纯抽象）
让我们深入研究它们。
1.抽象类
在Java中，可以使用抽象类实现抽象。
以下是会有一些微妙的点：
- 必须用抽象关键字声明抽象类。
- 它可以具有抽象和非抽象方法。
- 无法实例化。
- 它也可以具有构造函数和静态方法。
- 它可以具有最终方法，该方法将迫使子类不改变该方法的主体。
abstract class Shape {
abstract void draw();
Shape(){
System.out.println("Creating new shape");
}
}
class Circle extends Shape {
void draw() {
System.out.println("I'm drawing Circle here");
}
}
class Square extends Shape {
void draw() {
System.out.println("I'm drawing Square here");
}
}
您可以看到，我们在派生的类中一次又一次使用draw方法。
2.接口（纯抽象）
这是获得抽象的另一种方法。
一些规格是：
-
默认情况下，接口中的所有字段都是公共，静态和最终的。
-
默认情况下所有方法都是公共的，默认是抽象的。
-
实现接口的类必须实现接口中声明的所有方法。
interface Shape {
double calculateArea();
double calculatePerimeter();
}
class Circle implements Shape {
double radius;
public Circle(double radius) {
this.radius = radius;
}
public double calculateArea() {
return Math.PI * radius * radius;
}
public double calculatePerimeter() {
return 2 * Math.PI * radius;
}
}
接口支持多个继承的功能
这足以按照基本要求，如果您想深入潜水，则必须使用Googulu（Google）
我将根据评论
来添加更多如果文章对您有所帮助，请留下类似，关注或任何ð。
您可以在LinkedIn，GitHub，Dev.to和hashnode上关注我。
bye