前言

提前声明，本篇文章包含一些基础篮球知识，如果你是篮球小白，我建议先去关注下NBA官方抖音号，了解下NBA，再来阅读本文章啊bro！

一、面向过程 VS 面向对象

面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特 性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护

缺点：性能比面向过程低

比如我给詹姆斯赋予了一个扣篮的功能，它通过调用就可以在比赛中实现扣篮。 面向对象呢就是把现实问题抽象为对象，通过调用每个对象的属性或功能去解决问题。 如果我要修改我的需求，把詹姆斯换成库里，我用面向过程是不是得把每个步骤中的詹姆斯改为库里。而用面向对象解决，我甚至可以重新创一个对象比如库里，仅仅在调用的时候选择库里就行了

面向过程

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消 耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能 是最重要的因素。

缺点：没有面向对象易维护、易复用、易扩展

二、面向对象关键概念

现在让我们一不一样的视角来了解下面向对象（OOP）。

从上图我们可以看到面向对象主要包括六大部分——类、对象、继承、封装、多态、抽象。面向对象呢就像是一支NBA球队，而这些类呢就是球队里的不同位置（中锋、前锋、后卫等等），每个类里都有对应的球员，也就是对象，有的位置呢它有别的位置的一些球员和他们的篮球技能，如果一个后卫（我们这里以库里为例)在换成小个子阵容后，他成了篮下能力最强的人，那么这时库里就会做出一些中锋该做的事，抢篮板、挡拆等等，这就是继承与多态，不过有些球员呢，我们不需要他做别的事，只需要他在原来的位置上做好自己该做的事，这也就是封装，至于抽象这个概念呢，我想就用伦纳德本人举例，他拥有极强的篮球得分和防守能力，但是目前这也仅仅是声明，应为他压根儿不打球，也就是说这是一个没有实现的声明，但是它可交给他的队友这些技能，让她们在赛场上实现，大概这就是抽象吧。

相信你在看完这段文字后再来了解面向对象会比较容易理解些

三、类与对象

类（Class）：类是对现实世界中事物的抽象，是对象的蓝图。它定义了对象的属性（字段）和行为（方法）。

对象（Object）：对象是类的实例，具有类所定义的属性和方法。每个对象都有独立的状态和行为。

示例代码：

class Animal {

String name;

// Constructor

public Animal(String name) {

this.name = name;

}

// Method

public void speak() {

System.out.println(name + " makes a noise.");

}

}

public class Main {

public static void main(String[] args) {

// 创建对象

Animal dog = new Animal("Dog");

dog.speak(); // 输出: Dog makes a noise.

Animal cat = new Animal("Cat");

cat.speak(); // 输出: Cat makes a noise.

}

}

在这段代码中Animal 类定义了一个属性 name，用于存储动物的名字。构造方法用于初始化这个属性。speak 方法打印出动物的叫声。在主类中，main 方法创建了 Animal 类型的对象 dog 和 cat，并调用 speak 方法输出它们的叫声。

（NBA版）Animal类就相当于后卫这个位置，在这个位置里定义了一个投篮属性name，用于储存球员的名字，speak方法打印出球员的投篮姿势。在主类中（可以理解为教练上的阵容)，创建了后卫哈登和库里，哈登左手投篮，库里右手投篮。

四、封装

封装（Encapsulation）：封装是将对象的状态（属性）和行为（方法）捆绑在一起，并通过访问修饰符控制对这些属性和方法的访问，保护对象的内部状态不被外部随意修改。使用 getter 和 setter 方法来安全地访问信息。

示例代码：

class Person {

private String name; // 私有属性

// Constructor

public Person(String name) {

this.name = name;

}

// Getter

public String getName() {

return name;

}

// Setter

public void setName(String name) {

this.name = name;

}

}

public class Main {

public static void main(String[] args) {

Person person = new Person("Alice");

System.out.println(person.getName()); // 输出: Alice

person.setName("Bob");

System.out.println(person.getName()); // 输出: Bob

}

}

Person 类有一个私有属性 name，外部无法直接访问该属性。提供了 getName 和 setName 方法用于获取和设置该属性的值。这样可以控制外部对 name 属性的访问。在 Main 类的 main 方法中，通过创建 Person 对象并利用 getter 和 setter 方法演示了封装的特性。

(NBA版)Person类相当于中锋这个位置，这个位置上有个球员叫做奥尼尔（name),他只能打中锋，不能打其他位置。

五、继承

继承（Inheritance）：继承允许一个类（子类）从另一个类（父类）派生，子类可以继承父类的属性和方法，同时也可以增加新的特性或重写父类的方法。这样可以实现代码的重用。

示例代码：

class Animal {

public void sound() {

System.out.println("Animal makes a sound");

}

}

class Dog extends Animal {

@Override

public void sound() { // 方法重写

System.out.println("Dog barks");

}

}

public class Main {

public static void main(String[] args) {

Animal myDog = new Dog();

myDog.sound(); // 输出: Dog barks

}

}

Animal 类定义了一个 sound 方法，提供了动物叫声的默认实现。Dog 类继承自 Animal 类，并重写了 sound 方法提供了具体的实现。在 Main 类的 main 方法中，使用多态性，将 Dog 对象赋值给 Animal 类型的引用，并调用 sound 方法，实际调用的是 Dog 类中的实现。

（NBA版)后卫这个位置有一个投篮的技能，中锋呢在训练中继承了这个技能，他也能投篮，并且还改进了下，自抛自扣——假装投篮，将球投到篮板待球弹回再扣篮。而在实际比赛中一个后卫名叫威斯布鲁克用出了这招。

六、多态

多态（Polymorphism）：多态允许同一方法在不同的对象上表现出不同的行为。实现多态的方式包括方法重载（在同一类中定义同名但参数不同的方法）和方法重写（在子类中重写父类的方法）。

示例代码：

class Animal {

public void sound() {

System.out.println("Animal makes a sound"); // 默认动物叫声

}

}

class Cat extends Animal {

@Override

public void sound() {

System.out.println("Cat meows"); // 猫的叫声

}

}

class Dog extends Animal {

@Override

public void sound() {

System.out.println("Dog barks"); // 狗的叫声

}

}

public class Main {

public static void main(String[] args) {

Animal myAnimal1 = new Cat(); // myAnimal1 是 Cat 类型的对象

Animal myAnimal2 = new Dog(); // myAnimal2 是 Dog 类型的对象

makeSound(myAnimal1); // 输出: Cat meows

makeSound(myAnimal2); // 输出: Dog barks

}

// 接受Animal类型的参数

public static void makeSound(Animal animal) {

animal.sound(); // 动态绑定，运行时决定调用哪个方法

}

}

Animal 类和它的子类 Cat 和 Dog 都定义了 sound 方法。子类重写了该方法以提供特定的叫声。Main 类的 main 方法中，分别创建 Cat 和 Dog 的对象，使用相同的 Animal 类型引用。通过调用 makeSound 方法，实现多态：Animal 类型的引用根据实际对象类型来决定实际调用的方法，体现了动态绑定。

（NBA版)后卫这个位置呢有得分后卫和控球后卫，他们有不同的得分方式，比赛时，上这两种后卫，分别得分，得分后卫直接选择干拔得分，控球后卫选择助攻队友扣篮得分。

七、抽象

抽象的概念

1.定义：

抽象是从一组对象中提取出共同的特征和行为，而不考虑其具体的实现细节。它使得开发者可以处理对象的概念，而不必关注其具体实现。

2.抽象类（Abstract Class）：

抽象类是一个不能被实例化的类，它只能被其他类继承。抽象类可以包含抽象方法（没有实现的方法）和具体方法（有实现的方法）。一般用于提供一个基础，然后其他子类可以基于这个基础进行具体实现。

3.接口（Interface）：

接口是一种特殊的抽象类，它只包含方法的声明而不包含方法的实现。一个类可以实现多个接口，从而能够拥有多种行为。在Java中，接口为实现类提供了一种实现多态的方式

抽象类：

interface Vehicle {

void start(); // 抽象方法

void stop(); // 抽象方法

}

class Car implements Vehicle {

public void start() {

System.out.println("Car is starting.");

}

public void stop() {

System.out.println("Car is stopping.");

}

}

class Bicycle implements Vehicle {

public void start() {

System.out.println("Bicycle is starting.");

}

public void stop() {

System.out.println("Bicycle is stopping.");

}

}

public class Main {

public static void main(String[] args) {

Vehicle myCar = new Car();

myCar.start(); // 输出: Car is starting.

myCar.stop(); // 输出: Car is stopping.

Vehicle myBicycle = new Bicycle();

myBicycle.start(); // 输出: Bicycle is starting.

myBicycle.stop(); // 输出: Bicycle is stopping.

}

}

Animal 是一个抽象类，包含一个抽象方法 makeSound()，以及一个具体的方法 eat()。Dog 类继承了 Animal 并实现了 makeSound() 方法。

（NBA版)伦纳德有优秀的低位单打技术，但他不打球，于是他把这招交给了祖巴茨，祖巴茨在比赛中实现了这个技术。

接口：

interface Vehicle {

void start(); // 抽象方法

void stop(); // 抽象方法

}

class Car implements Vehicle {

public void start() {

System.out.println("Car is starting.");

}

public void stop() {

System.out.println("Car is stopping.");

}

}

class Bicycle implements Vehicle {

public void start() {

System.out.println("Bicycle is starting.");

}

public void stop() {

System.out.println("Bicycle is stopping.");

}

}

public class Main {

public static void main(String[] args) {

Vehicle myCar = new Car();

myCar.start(); // 输出: Car is starting.

myCar.stop(); // 输出: Car is stopping.

Vehicle myBicycle = new Bicycle();

myBicycle.start(); // 输出: Bicycle is starting.

myBicycle.stop(); // 输出: Bicycle is stopping.

}

}

Vehicle 是一个接口，定义了两个方法 start() 和 stop()。Car 和 Bicycle 类实现了这个接口，并提供了具体的实现。通过这种方式，您可以使用相同的接口与不同的实现进行交互。

(NBA版) 全明星赛（指Vehicle）是一个接口，这场比赛定义了两种得分方式扣篮和三分。首发（Car）和替补（Bicycle）都上场了，并用这两种方式得分了。

八、总结

面向对象这一部分在Java中就是手机里的苹果，篮球里的乔丹，希望这篇文章能帮助你更好地理解这一编程重点。