来源：The Geek Asian 让我们看一下面向对象编程的四个基本原理，并尝试了解它们是如何工作的。面向对象编程（OOP）是主要的编程范式之一。它可以很简单，也可以相反，非常复杂。这完全取决于您决定如何开发应用程序。 ![喝咖啡休息#90。 面向对象编程的 4 个支柱 - 1]()
OOP 有 4 个支柱：
![Java-университет]()
在此代码中，我们限制了对balance变量的访问，并添加了一个setBalance()方法，允许用户设置Account的余额值。setter 在将提供的值分配给变量之前检查它。如果该值小于零，则会引发异常。这确保了数据的完整性不会受到损害。在解释了上面的例子之后，我希望封装作为 OOP 四大支柱之一的价值是显而易见的。
OOP 有 4 个支柱：
- 封装。
- 遗产。
- 抽象。
- 多态性。
1. 封装
我们都研究过封装，即隐藏数据元素并允许用户使用公共方法访问数据。我们称这些为 getter 和 setter。现在让我们忘记这一点并找到一个更简单的定义。封装是一种限制用户直接更改数据成员或类变量以维护数据完整性的方法。我们如何做到这一点？我们通过将访问修饰符切换为私有并公开可用于访问数据的公共方法来限制对变量的访问。下面我们看一下具体的例子。这将帮助我们理解如何使用封装来维护数据完整性。不带封装：/**
* @author thegeekyasian.com
*/
public class Account {
public double balance;
public static void main(String[] args) {
Account theGeekyAsianAccount = new Account();
theGeekyAsianAccount.balance = -54;
}
}/**
* @author thegeekyasian.com
*/
public class Account {
private double balance;
public void setBalance(double balance) {
if(balance >= 0) { // Validating input data in order to maintain data integrity
this.balance = balance;
}
throw new IllegalArgumentException("Balance cannot be less than zero (0)");
}
public static void main(String[] args) {
Account theGeekyAsianAccount = new Account();
theGeekyAsianAccount.setBalance(1); // Valid input - Allowed
theGeekyAsianAccount.setBalance(-55); // Stops user and throws exception
}
}
2. 继承
继承是一种获取具有共同特征的另一个类的属性的方法。这使我们能够提高可重用性并减少代码重复。当子元素继承其父元素的属性时，该方法还具有子父交互的原理。让我们深入研究两个简单的示例，看看继承如何使代码更简单、更可重用。没有继承：/**
* @author thegeekyasian
*/
public class Rectangle {
private int width;
private int height;
public Rectangle(int width, int height) {
this.width = width;
this.height = height;
}
public int getArea() {
return width * height;
}
}
public class Square {
private int width; // Duplicate property, also used in class Rectangle
public Square(int width) {
this.width = width;
}
public int getArea() { // Duplicate method, similar to the class Rectangle
return this.width * this.width;
}
}/**
* @author thegeekyasian
*/
public class Rectangle {
private int width;
private int height;
public Rectangle(int width, int height) {
this.width = width;
this.height = height;
}
public int getArea() {
return width * height;
}
}
public class Square extends Rectangle {
public Square(int width) {
super(width, width); // A rectangle with the same height as width is a square
}
}3. 抽象
抽象是一种通过隐藏对象不必要或不相关的细节来仅向用户呈现基本细节的技术。它有助于降低用户侧的操作复杂性。抽象允许我们向用户提供一个简单的界面，而不需要复杂的细节来执行操作。简而言之，它使用户能够驾驶汽车，而无需他们确切了解发动机的工作原理。让我们先看一个例子，然后讨论抽象如何帮助我们。/**
* @author thegeekyasian.com
*/
public class Car {
public void lock() {}
public void unlock() {}
public void startCar() {
checkFuel();
checkBattery();
whatHappensWhenTheCarStarts();
}
private void checkFuel() {
// Check fuel level
}
private void checkBattery() {
// Check car battery
}
private void whatHappensWhenTheCarStarts() {
// Magic happens here
}
}4、多态性
OOP 四大支柱中的最后一个也是最重要的是多态性。多态性意味着“多种形式”。顾名思义，它是一个允许您以多种或不同方式执行操作的函数。当我们谈论多态性时，除非我们谈论它的类型，否则没有太多可讨论的。多态性有两种类型：- 方法重载——静态多态（Static Binding）。
- 方法重写——动态多态（动态绑定）。
方法重载-静态多态：
方法重载或静态多态性，也称为静态绑定或编译时绑定，是一种在编译时确定方法调用的类型。方法重载允许我们拥有多个具有相同名称、不同参数数据类型或不同数量参数或两者兼而有之的方法。但问题是，为什么方法重载（或静态多态性）有用？让我们看一下下面的示例，以更好地理解方法重载。没有方法重载：/**
* @author thegeekyasian.com
*/
public class Number {
public void sumInt(int a, int b) {
System.out.println("Sum: " + (a + b));
}
public void sumDouble(double a, double b) {
System.out.println("Sum: " + (a + b));
}
public static void main(String[] args) {
Number number = new Number();
number.sumInt(1, 2);
number.sumDouble(1.8, 2.5);
}
}/**
* @author thegeekyasian.com
*/
public class Number {
public void sum(int a, int b) {
System.out.println("Sum: " + (a + b));
}
public void sum(double a, double b) {
System.out.println("Sum: " + (a + b));
}
public static void main(String[] args) {
Number number = new Number();
number.sum(1, 2);
number.sum(1.8, 2.5);
}
}方法重写 - 动态多态性：
与方法重载不同，方法重写允许您具有与多个方法完全相同的签名，但它们必须位于多个不同的类中。问题是，它有什么特别之处？这些类具有 IS-A 关系，即它们必须相互继承。换句话说，在方法重写或动态多态中，方法在运行时被调用时动态处理。这是基于对其初始化的对象的引用来完成的。这是方法重写的一个小例子：/**
* @author thegeekyasian.com
*/
public class Animal {
public void walk() {
System.out.println("Animal walks");
}
}
public class Cat extends Animal {
@Override
public void walk() {
System.out.println("Cat walks");
}
}
public class Dog extends Animal {
@Override
public void walk() {
System.out.println("Dog walks");
}
}
public class Main {
public static void main(String[] args) {
Animal animal = new Animal();
animal.walk(); // Animal walks
Cat cat = new Cat();
cat.walk(); // Cat walks
Dog dog = new Dog();
dog.walk(); // Dog walks
Animal animalCat = new Cat(); // Dynamic Polymorphism
animalCat.walk(); // Cat walks
Animal animalDog = new Dog(); // Dynamic Polymorphism
animalDog.walk(); //Dog walks
}
}
GO TO FULL VERSION