JAVA类

OOP

什么是面向对象的编程

OOP表示面向对象的编程

过程编程是关于编写对数据执行操作的过程或方法，而面向对象编程是关于创建包含数据和方法的对象。

面向对象编程与过程编程相比有几个优点：

• OOP 更快更容易执行
• OOP 为程序提供了清晰的结构
• OOP 有助于保持 Java 代码干燥（ DRY，”Don’t Repeat Yourself”），并使代码更易于维护、修改和调试
• OOP 使得用更少的代码和更短的开发时间创建完全可重用的应用程序成为可能

**提示：**DRY 原则旨在减少代码的重复。您应该提取应用程序中通用的代码，然后将它们放在某处并重复使用它们。

类和对象

类 水果	对象 苹果
类 汽车	对象 奥迪

类/对象

创建类

使用关键字class

使用变量 x 创建名为 "Main" 的类：

public class Main {
  int x = 5;
}

创建对象

在 Java 中，对象是从类创建的。我们已经创建了名为 Main 的类，所以现在我们可以使用它来创建对象。

如需创建 Main 对象，请指定类名，后跟对象名，并使用关键字 new：

创建名为 “myObj“ 的对象并打印 x 的值：

public class Main {
  int x = 5;

  public static void main(String[] args) {
    Main myObj = new Main();
    System.out.println(myObj.x);
  }
}

多个对象

创建两个 Main 对象：

public class Main {
  int x = 5;

  public static void main(String[] args) {
    Main myObj1 = new Main();  // 对象 1
    Main myObj2 = new Main();  // 对象 2
    System.out.println(myObj1.x);
    System.out.println(myObj2.x);
  }
}

使用多个类

可以创建一个类的对象并在另一个类中访问它。这通常用于更好地组织类（一个类拥有所有属性和方法，而另一个类拥有 main() 方法（要执行的代码））。

请记住，java 的文件名应与类名相匹配。在这个例子中，我们在同一个目录/文件夹中创建了两个文件：

• Main.java
• Second.java

Main.Java：

public class Main {
  int x = 5;
}

Second.Java

class Second {
  public static void main(String[] args) {
    Main myObj = new Main();
    System.out.println(myObj.x);
  }
}

运行 Second.java 文件：输出的将是5

Java类属性

Java类属性

我们在例子中为 x 使用了术语“变量”（如下所示）。它实际上是类的属性。或者你可以说类属性是类中的变量：

创建一个名为 “Main“ 的类，有两个属性：x 和 y：

public class Main {
  int x = 5;
  int y = 3;
}

类属性的另一个术语是字段（field）。

访问属性

可以通过创建类的对象并使用点语法 (.) 来访问属性：

下例将创建 Main 类的一个对象，名称为 myObj。我们使用对象上的 x 属性来打印其值：

创建一个名为 “myObj“ 的对象并打印 x 的值：

public class Main {
  int x = 5;

  public static void main(String[] args) {
    Main myObj = new Main();
    System.out.println(myObj.x);
  }
}

还可以修改属性的值

public class Main {
  int x;

  public static void main(String[] args) {
    Main myObj = new Main();
    myObj.x = 40;
    System.out.println(myObj.x);
  }
}//将x的值改为40

覆盖现有的值

public class Main {
  int x = 10;

  public static void main(String[] args) {
    Main myObj = new Main();
    myObj.x = 25; // x 目前是 25
    System.out.println(myObj.x);
  }
}//将x的值覆盖为25

如果不想覆盖现有值，请将属性声明为 final：

public class Main {
  final int x = 10;

  public static void main(String[] args) {
    Main myObj = new Main();
    myObj.x = 25; // 将产生错误：无法为 final 变量赋值
    System.out.println(myObj.x);
  }
}

final 关键字被称为“修饰符”

多个对象

如果创建一个类的多个对象，则可以更改对象中的属性值，同时不会影响另一个对象中的属性值：

将 myObj2 中 x 的值更改为 25，并保持 myObj1 中的 x 不变：

public class Main {
  int x = 5;

  public static void main(String[] args) {
    Main myObj1 = new Main();  // 对象 1
    Main myObj2 = new Main();  // 对象 2
    myObj2.x = 25;
    System.out.println(myObj1.x);  // 输出 5
    System.out.println(myObj2.x);  // 输出 25
  }
}

多重属性

可以根据需要指定任意数量的属性：

public class Main {
  String fname = "Bill";
  String lname = "Gates";
  int age = 24;

  public static void main(String[] args) {
    Main myObj = new Main();
    System.out.println("Name: " + myObj.fname + " " + myObj.lname);
    System.out.println("Age: " + myObj.age);
  }
}

类方法

Java类方法

方法是在类中声明的，并且它们用于执行某些操作：

在 Main 中创建名为 myMethod() 的方法：

public class Main {
  static void myMethod() {
    System.out.println("Hello World!");
  }
}

myMethod() 在被调用时打印文本（操作）。如需调用方法，请写方法名称，后跟两个括号 () 和一个分号；

在 main 中，调用 myMethod()：

public class Main {
  static void myMethod() {
    System.out.println("Hello World!");
  }

  public static void main(String[] args) {
    myMethod();
  }
}

// 输出 "Hello World!"

静态与非静态

您经常会看到具有 static 或 public 属性和方法的 Java 程序。

在上面的例子中，我们创建了一个 static 方法，这意味着它可以在不创建类的对象的情况下访问，而 public 不同，它只能被对象访问：

演示 static 方法和 public 方法之间差异的例子：

public class Main {
  // 静态方法：
  static void myStaticMethod() {
    System.out.println("无需创建对象即可调用静态方法");
  }

  // 公共方法：
  public void myPublicMethod() {
    System.out.println("公共方法必须通过创建对象来调用");
  }

  // 主方法：
  public static void main(String[] args) {
    myStaticMethod(); // 调用静态方法
    // myPublicMethod(); 这会编译错误

    Main myObj = new Main(); // 创建 Main 的对象
    myObj.myPublicMethod(); // 调用对象的公共方法
  }
}

使用对象访问方法

创建名为 myCar 的 Car 对象。调用 myCar 对象上的 fullThrottle() 和 speed() 方法，并运行程序：

// 创建 Main 类
public class Main {
 
  // 创建 fullThrottle() 方法
  public void fullThrottle() {
    System.out.println("这辆车正以最快的速度行驶！");
  }

  // 创建 speed() 方法并添加参数
  public void speed(int maxSpeed) {
    System.out.println("最高速是：" + maxSpeed);
  }

  // 在 main 中，调用 myCar 对象上的方法
  public static void main(String[] args) {
    Main myCar = new Main();   // 创建 myCar 对象
    myCar.fullThrottle();      // 调用 fullThrottle() 方法
    myCar.speed(200);          // 调用 speed() 方法
  }
}

// 这辆车正以最快的速度行驶！
// 最高速是：200

例子解释

1. 我们使用 class 关键字创建了一个自定义的 Main 类。
2. 我们在 Main 类中创建了 fullThrottle() 和 speed() 方法。
3. fullThrottle() 方法和 speed() 方法在调用时会打印出一些文本。
4. speed() 方法接受一个名为 maxSpeed 的 int 参数 - 我们将在 8. 中使用它。
5. 为了使用 Main 类及其方法，我们需要创建 Main 类的对象。
6. 然后，转到 main() 方法，您现在知道它是运行程序的内置 Java 方法（执行 main 中的任何代码）。
7. 通过使用 new 关键字，我们创建了名为 myCar 的对象。
8. 然后，我们在 myCar 对象上调用 fullThrottle() 和 speed() 方法：使用对象的名称（myCar），后跟一个点（.），后跟方法的名称（fullThrottle(); 和 speed(200);)。请注意，我们在 speed() 方法中添加了一个 int 参数 200。

请记住

点 (.) 用于访问对象的属性和方法。

如需在 Java 中调用方法，请写：方法名称，后跟一组括号 ()，后跟分号 (;)。

类必须具有匹配的文件名（Main 和 Main.java）。

使用多个类

就像我们在 类和对象 一章中讲到的那样，创建一个类的对象并在另一个类中访问它是一个很好的做法。

请记住，java 文件的名称应与类名称匹配。在本例中，我们在同一目录中创建了两个文件：

• Main.java
• Second.java

Main.java

public class Main {
  public void fullThrottle() {
    System.out.println("这辆车正以最快的速度行驶！");
  }

  public void speed(int maxSpeed) {
    System.out.println("最高速是：" + maxSpeed);
  }
}

Second.java

class Second {
  public static void main(String[] args) {
    Main myCar = new Main();     // 创建 myCar 对象
    myCar.fullThrottle();      // 调用 fullThrottle() 方法
    myCar.speed(200);          // 调用 speed() 方法
  }
}

运行 Second.java 文件：

C:\Users\Your Name>java Second

输出将是：

这辆车正以最快的速度行驶！
最高速是：200

Java构造函数