面向对象(OOP)-优快云博客

本文链接：https://blog.youkuaiyun.com/wzc3180043380/article/details/145738406

Java 面向对象编程：初学者指南

Java 面向对象编程：初学者指南

在 Java 编程的领域中，面向对象编程（Object-Oriented Programming，OOP）占据着核心地位，是一种极为重要的编程范式。对于刚踏入 Java 编程世界的初学者而言，透彻理解并熟练掌握面向对象编程的概念与技巧，是深入学习 Java、开启高效编程之旅的关键所在。接下来，就让我们逐步深入探索 Java 面向对象编程的基础概念，通过一系列简洁明了的代码示例，让这些抽象的知识变得具体可感。

归纳:

是软件开发中的一种编程风格,是一种程序设计思想

除了面向对象外,还有面向过程,指令式编程,函数式编程

现在主流的思想是面向过程和面向对象

早期编程比较简单,先有面向过程,后来程序越来越复杂,弊端比较多,所以有了面向对象

什么是面向对象编程

面向对象编程构建于 “对象” 这一核心概念之上。回顾我们的现实生活，周遭的诸多事物皆可被视作对象，像马路上飞驰的汽车、校园中穿梭的学生、城市里林立的房子等等。每一个对象都具备独特的属性（用以描述其状态）和行为（展现其动作）。在 Java 的编程语境里，面向对象编程借助类（Class）和对象（Object）来将这一概念具象化。

类（Class）

类可以形象地理解为对象的蓝图或者模板。它精准地定义了对象所拥有的属性以及能够执行的方法。举例来说，我们着手定义一个 “Person” 类，这个类中可能包含 “name”（对应人的姓名）和 “age”（对应人的年龄）等属性，同时还拥有 “speak”（实现说话功能）和 “walk”（实现走路功能）等方法。

以下为一个简单的 Java 类定义示例：

public class Person {

    // 属性

   String name;

   int age;

   // 方法

  public void speak() {

     System.out.println("My name is " + name + " and I am " + age + " years old.");

  }

}

在上述代码里，Person类拥有两个属性name和age，以及一个speak方法。speak方法的作用是在控制台打印出当前对象所代表人物的姓名和年龄信息。

一个类可以包含：字段，方法，构造方法

在person类中，分别有name,age,speak字段，他们也称为成员变量（在类的内部，但在方法的外部，方法内部叫做成员变量）

对象（Object）

对象是类的具体实例。一旦我们完成了类的定义，就能够依据这个类来创建对象，进而通过对象访问类中定义的属性和方法。

以下展示如何创建Person类的对象并调用其方法：

public class Main {

    public static void main(String[] args) {

      // 创建Person类的对象

      Person person1 = new Person();

             person1.name = "Alice";

             person1.age = 30;

      // 调用对象的方法

         person1.speak();

     }

}

在这段代码中，我们首先创建了一个Person类的对象person1。紧接着，为person1对象的name属性赋值为 “Alice”，age属性赋值为 30。最后，通过person1.speak()语句调用person1对象的speak方法，此时控制台便会输出 “Alice” 的相关信息。

      // 创建Person类的对象

      Person person1 = new Person();
创建JAVA对象时，需要用到new关键字。

这行代码就通过Person类创建了一个Person对象，所有对象在创建时都会在堆内存中分配空间。

创建对象的时候，需要一个main（）方法作为入口，main()方法可以在当前类中，也可以在另外一个类中。

在实际的开发中，我们通常不在当前类中直接创建对象并使用他，而是放在使用对象的类中，也可以放在另一个文件夹。

封装（Encapsulation）

封装是面向对象编程的一项关键特性。它将数据（即属性）和操作这些数据的方法紧密地封装在一起，巧妙地隐藏了对象内部的具体实现细节，仅对外提供公共的接口。通过运用封装特性，能够显著提升代码的安全性与可维护性。

在 Java 中，我们可借助访问修饰符（诸如private、public、protected）来实现封装。其中，private修饰符用于严格限制对类的属性和方法的访问，只有类内部的代码才有资格进行访问。

下面是一个运用private修饰符的示例：

public class BankAccount {

   // 私有属性

    private double balance;

   // 公共方法

   public void deposit(double amount) {

   if (amount > 0) {

   balance += amount;

   System.out.println("Deposited: " + amount + ". New balance: " + balance);

    } else {

        System.out.println("Invalid deposit amount.");

      }

}

    public void withdraw(double amount) {

       if (amount > 0 && amount <= balance) {

       balance -= amount;

       System.out.println("Withdrawn: " + amount + ". New balance: " + balance);

       } else {

          System.out.println("Insufficient funds or invalid withdrawal amount.");

         }

     }

}

在这个BankAccount类中，balance属性被声明为private，这就意味着外部代码无法直接对其进行访问或修改。只能通过类中提供的deposit和withdraw这两个公共方法来操作balance属性，如此一来，有效地保障了账户余额数据的安全性。

例如，在一个在线银行系统中，如果不使用封装，外部代码可能会随意修改账户余额，导致数据混乱和安全问题。而通过封装，只有经过授权的deposit和withdraw方法可以操作余额，确保了每一次余额变动都是符合业务逻辑且可追溯的。

继承（Inheritance）

继承是面向对象编程的又一重要特性。它允许一个类（即子类）继承另一个类（即父类）的属性和方法。借助继承机制，能够实现代码的高度复用，极大地提升编程效率。

在 Java 中，使用extends关键字来达成继承关系的建立。例如，我们可以定义一个Student类，使其继承自Person类：

public class Student extends Person {

   int studentId;
 
  public void study() {

     System.out.println(name + " is studying.");

   }

}

在这个例子里，Student类继承了Person类的name和age属性以及speak方法。与此同时，Student类还新增了自身特有的属性studentId和方法study。

以下展示如何使用Student类：

public class Main {

   public static void main(String[] args) {

      Student student1 = new Student();

              student1.name = "Bob";

              student1.age = 20;

              student1.studentId = 12345;

              student1.speak();

              student1.study();

   }

}

在上述代码中，我们创建了一个Student类的对象student1。由于Student类继承自Person类，所以student1对象既可以调用Person类的speak方法，也能够调用Student类自身定义的study方法。

以一个学校管理系统为例，系统中需要处理学生、教师等不同角色的信息。如果分别为学生和教师编写独立的类，会存在大量重复代码，比如姓名、年龄等基本信息的处理。通过继承，将公共部分放在父类Person中，学生类和教师类只需继承Person类并添加各自特有的属性和方法，就能大大减少代码量，提高开发效率。

如果子类只是重写了父类的方法，那么他们之间的关系就是is-a的关系，但如果子类增加了新的方法，那么他们之间的关系就变成了is-like-a的关系

多态（Polymorphism）

多态指的是同一个方法在不同的对象上能够展现出不同的行为。多态性赋予了我们使用统一接口来处理不同类型对象的能力，极大地增强了代码的灵活性和扩展性。

在 Java 中，多态主要通过方法重写（Override）和接口实现这两种方式来达成。

方法重写（Override）

方法重写是指子类重新定义父类中已有的方法。当子类对象调用重写后的方法时，实际执行的是子类中定义的方法逻辑。

以下为一个方法重写的示例：

public class Animal {

      public void makeSound() {

          System.out.println("The animal makes a sound.");

      }

}


public class Dog extends Animal {

   @Override

   public void makeSound() {

      System.out.println("The dog barks.");

   }

}



public class Cat extends Animal {

   @Override
   
   public void makeSound() {

      System.out.println("The cat meows.");

   }

}

在这个例子中，Dog类和Cat类都继承自Animal类，并且分别对makeSound方法进行了重写。

以下展示如何运用多态特性：

public class Main {

    public static void main(String[] args) {

       Animal animal1 = new Dog();

       Animal animal2 = new Cat();

              animal1.makeSound();

              animal2.makeSound();

     }

}

在上述代码中，我们创建了Dog类和Cat类的对象，并将它们分别赋值给Animal类型的变量animal1和animal2。当调用makeSound方法时，程序会依据对象的实际类型（Dog或Cat）来执行相应的方法逻辑，从而成功实现了多态性。

在一个简单的游戏开发场景中，游戏中有多种角色，如战士、法师、刺客等，每个角色都有攻击行为，但攻击方式不同。通过多态，我们可以定义一个统一的attack方法，每个角色类继承并根据自身特点重写该方法。这样在游戏逻辑中，我们可以通过统一的接口调用不同角色的攻击方法，而无需为每个角色单独编写复杂的调用逻辑，使代码更加简洁和易于维护。

总结

通过本文的学习，我们全面且深入地了解了 Java 面向对象编程的基础概念，涵盖了类、对象、封装、继承和多态。这些概念构成了 Java 编程大厦的基石，对它们的深刻理解与熟练掌握，对于我们进一步深入学习 Java 编程、开发出高质量的程序而言，具有至关重要的意义。希望本文所提供的简单且直观的示例，能够切实帮助初学者更好地理解和应用这些概念，为后续的 Java 学习之路筑牢根基，让大家在 Java 编程的广阔天地中能够顺利启航，不断探索和创造出更多优秀的程序作品。

在后续的学习过程中，建议大家多做练习，尝试将这些概念运用到实际项目中，通过不断实践来加深理解。例如，可以尝试开发一个简单的学生管理系统，运用类来描述学生、教师等对象，利用封装保护数据安全，通过继承实现代码复用，借助多态实现不同对象的统一操作。相信通过这样的实践，你会对 Java 面向对象编程有更深刻的认识和掌握。

同时，要注意在实际编程中，合理运用这些概念。比如在封装时，要谨慎设计公共接口，确保接口的易用性和安全性；在继承时，要注意父类和子类之间的关系合理性，避免过度继承导致代码混乱；在多态应用中，要清晰定义不同对象的行为，确保程序逻辑的正确性。

总之，Java 面向对象编程是一个强大而有趣的领域，随着学习的深入，你会发现它蕴含着无尽的可能，能够帮助你解决各种复杂的编程问题。希望大家在学习过程中保持热情，不断探索，逐步成为 Java 编程的高手。