Java 面向对象的编程

面向对象编程
Java 对象
Java 对象属性
Java 方法
Java 访问修饰符
Java 构造器
Java super关键字
Java 构造器链接
Java 类常量
Java toString方法
Java 中的继承
final类，private构造器

原文：http://zetcode.com/lang/java/oop/

Java 教程的这一部分是 Java 面向对象编程的简介。我们提到了 Java 对象，对象属性和方法，对象构造器以及访问修饰符。此外，我们讨论了super关键字，构造器链接，类常量，继承，最终类和私有构造器。

共有三种广泛使用的编程示例：过程编程，函数编程和面向对象的编程。 Java 原则上是一种面向对象的编程语言。从 Java8 开始，它对函数式编程提供了一些支持。

面向对象编程

面向对象编程（OOP）是一种使用对象及其相互作用设计应用和计算机程序的编程示例。

以下是 OOP 中的基本编程概念：

抽象
多态
封装
继承

抽象通过建模适合该问题的类来简化复杂的现实。多态是将运算符或函数以不同方式用于不同数据输入的过程。封装对其他对象隐藏了类的实现细节。继承是一种使用已经定义的类形成新类的方法。

Java 对象

对象是 Java OOP 程序的基本构建块。对象是数据和方法的组合。在 OOP 程序中，我们创建对象。这些对象通过方法进行通信。每个对象都可以接收消息，发送消息和处理数据。

创建对象有两个步骤。首先，我们定义一个类。类是对象的模板。它是一个蓝图，描述了类对象共享的状态和行为。一个类可以用来创建许多对象。在运行时从类创建的对象称为该特定类的实例。

SimpleObject.java

package com.zetcode;
class Being {}
public class SimpleObject {
    public static void main(String[] args) {
        Being b = new Being();
        System.out.println(b);
    }
}

在第一个示例中，我们创建一个简单的对象。

class Being {}

这是一个简单的类定义。模板的主体为空。它没有任何数据或方法。

Being b = new Being();

我们创建Being类的新实例。为此，我们使用了new关键字。 b变量是创建对象的句柄。

System.out.println(b);

我们将对象打印到控制台以获取该对象的一些基本描述。打印对象是什么意思？实际上，当我们打印对象时，我们将其称为toString()方法。但是我们还没有定义任何方法。这是因为创建的每个对象都继承自基本Object。它具有一些基本功能，可以在所有创建的对象之间共享。其中之一是toString()方法。

$ javac com/zetcode/SimpleObject.java
$ ls com/zetcode/
Being.class  SimpleObject.class  SimpleObject.java

编译器创建两个类文件。 SimpleObject.class是应用类，Being.class是我们在应用中使用的自定义类。

$ java com.zetcode.SimpleObject 
com.zetcode.Being@125ee71

我们获得对象是实例的类的名称，@字符以及对象的哈希码的无符号十六进制表示形式。

Java 对象属性

对象属性是捆绑在类实例中的数据。对象属性称为实例变量或成员字段。实例变量是在类中定义的变量，该类中的每个对象都有一个单独的副本。

ObjectAttributes.java

package com.zetcode;
class Person {
    public String name;
}
public class ObjectAttributes {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "Jane";
        Person p2 = new Person();
        p2.name = "Beky";
        System.out.println(p1.name);
        System.out.println(p2.name);
    }
}

在上面的 Java 代码中，我们有一个带有一个成员字段的Person类。

class Person {
    public String name;
}

我们声明一个名称成员字段。 public关键字指定可以在类块之外访问成员字段。

Person p1 = new Person();
p1.name = "Jane";

我们创建Person类的实例，并将名称变量设置为"Jane"。我们使用点运算符来访问对象的属性。

Person p2 = new Person();
p2.name = "Beky";

我们创建Person类的另一个实例。在这里，我们将变量设置为"Beky"。

System.out.println(p1.name);
System.out.println(p2.name);

我们将变量的内容打印到控制台。

$ java com.zetcode.ObjectAttributes 
Jane
Beky

我们看到了程序的输出。 Person类的每个实例都有一个单独的名称成员字段副本。

Java 方法

方法是在类主体内定义的函数。它们用于通过对象的属性执行操作。方法将模块化带入我们的程序。

在 OOP 范式的封装概念中，方法至关重要。例如，我们的AccessDatabase类中可能有一个connect()方法。我们无需知道方法connect()如何精确地连接到数据库。我们只需要知道它用于连接数据库。这对于划分编程中的职责至关重要，尤其是在大型应用中。

对象组的状态和行为。方法代表对象的行为部分。

Methods.java

package com.zetcode;
class Circle {
    private int radius;
    public void setRadius(int radius) {
        this.radius = radius;
    }
    public double area() {
        return this.radius * this.radius * Math.PI;
    }
}
public class Methods {
    public static void main(String[] args) {
        Circle c = new Circle();
        c.setRadius(5);
        System.out.println(c.area());
    }
}

在代码示例中，我们有一个Circle类。在该类中，我们定义了两个方法。 setRadius()方法为radius成员分配一个值，area()方法根据类成员和常数计算圆的面积。

private int radius;

我们的类只有一个成员字段。它是圆的半径。 private关键字是访问说明符。它表明变量仅限于外部世界。如果要从外部修改此变量，则必须使用公共可用的setRadius()方法。这样我们可以保护我们的数据。

public void setRadius(int radius) {
    this.radius = radius;
}

这是setRadius()方法。 this变量是一个特殊变量，我们用它来访问方法中的成员字段。 this.radius是实例变量，而radius是局部变量，仅在setRadius()方法内部有效。

Circle c = new Circle();
c.setRadius(5);

我们创建Circle类的实例，并通过在圆对象上调用setRadius()方法来设置其半径。点运算符用于调用该方法。

public double area() {
    return this.radius * this.radius * Math.PI;
}

area()方法返回圆的面积。 Math.PI是内置常数。

$ java com.zetcode.Methods 
78.53981633974483

运行示例，我们得到上面的输出。

Java 访问修饰符

访问修饰符设置方法和成员字段的可见性。 Java 具有三个访问修饰符：public，protected和private。可以从任何地方访问public成员。 protected成员只能在类本身内，被继承的类以及同一包中的其他类访问。最后，private成员仅限于包含类型，例如仅在其类或接口内。如果不指定访问修饰符，则将具有包专用的可见性。在这种情况下，成员和方法可在同一包中访问。

访问修饰符可防止意外修改数据。它们使程序更强大。

	类	包	子类（相同的包）	子类（其他包）	全局
`public`	`+`	`+`	`+`	`+`	`+`
`protected`	`+`	`+`	`+`	`+`	`o`
没有修饰符	`+`	`+`	`+`	`o`	`o`
`private`	`+`	`o`	`o`	`o`	`o`

上表总结了 Java 访问修饰符（+是可访问的，o是不可访问的）。

AccessModifiers.java

package com.zetcode;
class Person {
    public String name;
    private int age;
    public int getAge() {
        return this.age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
public class AccessModifiers {
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "Jane";
        p.setAge(17);
        System.out.println(String.format("%s is %d years old",
                p.name, p.getAge()));
    }
}

在上面的程序中，我们有两个成员字段：public和private。

public int getAge() {
    return this.age;
}

如果成员字段是私有的，则访问它的唯一方法是通过方法。如果要在类外部修改属性，则必须将方法声明为public。这是数据保护的重要方面。

public void setAge(int age) {
    this.age = age;
}

setAge()方法使我们能够从类定义之外更改私有age变量。

Person p = new Person();
p.name = "Jane";

我们创建Person类的新实例。因为name属性是public，所以我们可以直接访问它。但是，不建议这样做。

p.setAge(17);

setAge()方法修改age成员字段。由于已声明private，因此无法直接访问或修改。

System.out.println(String.format("%s is %d years old",
        p.name, p.getAge()));

最后，我们访问两个成员以构建一个字符串，该字符串将打印到控制台。

$ java com.zetcode.AccessModifiers 
Jane is 17 years old

运行示例，我们将获得以下输出。

以下程序显示访问修饰符如何影响子类继承成员的方式。

ProtectedMember.java

package com.zetcode;
class Base {
    public String name = "Base";
    protected int id = 5323;
    private boolean isDefined = true;
}
class Derived extends Base {
    public void info() {
        System.out.println("This is Derived class");
        System.out.println("Members inherited:");
        System.out.println(this.name);
        System.out.println(this.id);
        // System.out.println(this.isDefined);
    }
}
public class ProtectedMember {
    public static void main(String[] args) {
        Derived drv = new Derived();
        drv.info();
    }
}

在此程序中，我们有一个Derived类，该类继承自Base类。 Base类具有三个成员字段，所有成员字段均具有不同的访问修饰符。 isDefined成员未继承。 private修饰符可以防止这种情况。

class Derived extends Base {

Derived类继承自Base类。要从另一个类继承，我们使用extends关键字。

System.out.println(this.name);
System.out.println(this.id);
// System.out.println(this.isDefined);

public和protected成员由Derived类继承。可以访问它们。 private成员未继承。访问成员字段的行被注释。如果我们取消注释该行，则代码将无法编译。

$ java com.zetcode.ProtectedMember 
This is Derived class
Members inherited:
Base
5323

运行程序，我们收到此输出。

Java 构造器

构造器是一种特殊的方法。创建对象时会自动调用它。构造器不返回值，也不使用void关键字。构造器的目的是初始化对象的状态。构造器与类具有相同的名称。构造器是方法，因此它们也可以重载。构造器不能直接调用。 new关键字调用它们。构造器不能声明为同步，最终，抽象，本地或静态。

构造器不能被继承。它们按继承顺序被调用。如果我们不为类编写任何构造器，则 Java 提供隐式默认构造器。如果提供任何类型的构造器，则不提供默认值。

Constructor.java

package com.zetcode;
class Being {
    public Being() {
        System.out.println("Being is created");
    }
    public Being(String being) {
        System.out.println(String.format("Being %s is created", being));
    }
}
public class Constructor {
    @SuppressWarnings("ResultOfObjectAllocationIgnored")
    public static void main(String[] args) {
        new Being();
        new Being("Tom");
    }
}

我们有一个存在类。此类具有两个构造器。第一个不带参数，第二个不带参数。

public Being() {
    System.out.println("Being is created");
}

该构造器不接受任何参数。

public Being(String being) {
    System.out.println(String.format("Being %s is created", being));
}

此构造器采用一个字符串参数。

@SuppressWarnings("ResultOfObjectAllocationIgnored")

此注释将禁止警告我们不要将创建的对象分配给任何变量。通常，这将是可疑的活动。

new Being();

创建Being类的实例。创建对象时将调用无参数构造器。

new Being("Tom");

创建Being类的另一个实例。这次，在创建对象时调用带有参数的构造器。

$ java com.zetcode.Constructor 
Being is created
Being Tom is created

这是程序的输出。

在下一个示例中，我们初始化类的数据成员。变量的初始化是构造器的典型工作。

MemberInit.java

package com.zetcode;
import java.util.Calendar;
import java.util.GregorianCalendar;
class MyFriend {
    private GregorianCalendar born;
    private String name;
    public MyFriend(String name, GregorianCalendar born) {
        this.name = name;
        this.born = born;
    }
    public void info() {
        System.out.format("%s was born on %s/%s/%s\n",
                this.name, this.born.get(Calendar.DATE),
                this.born.get(Calendar.MONTH),
                this.born.get(Calendar.YEAR));
    }
}
public class MemberInit {
    public static void main(String[] args) {
        String name = "Lenka";
        GregorianCalendar born = new GregorianCalendar(1990, 3, 5);
        MyFriend fr = new MyFriend(name, born);
        fr.info();
    }
}

我们有一个带有数据成员和方法的MyFriend类。

private GregorianCalendar born;
private String name;

类定义中有两个私有变量。

public MyFriend(String name, GregorianCalendar born) {
    this.name = name;
    this.born = born;
}

在构造器中，我们启动两个数据成员。 this变量是一个处理器，用于从方法中引用对象变量。如果构造器参数的名称与成员的名称相等，则需要使用this关键字。否则，用法是可选的。

MyFriend fr = new MyFriend(name, born);
fr.info();

我们创建带有两个参数的MyFriend对象。然后我们调用对象的info()方法。

$ java com.zetcode.MemberInit 
Lenka was born on 5/3/1990

这是com.zetcode.MemberInit程序的输出。

Java `super`关键字

super关键字是在子类中用于引用直接父类对象的引用变量。它可以用来引用父对象的 a）实例变量，b）构造器，c）方法。

SuperVariable.java

package com.zetcode;
class Shape {
    int x = 50;
    int y = 50;
}
class Rectangle extends Shape {
    int x = 100;
    int y = 100;
    public void info() {
        System.out.println(x);
        System.out.println(super.x);
    }
}
public class SuperVariable {
    public static void main(String[] args) {
        Rectangle r = new Rectangle();
        r.info();
    }
}

在示例中，我们使用super关键字引用了父变量。

public void info() {
    System.out.println(x);
    System.out.println(super.x);
}

在info()方法内部，我们使用super.x语法引用父级的实例变量。

如果构造器未显式调用超类构造器，则 Java 将自动插入对超类的无参数构造器的调用。如果超类没有无参数构造器，则会得到编译时错误。

ImplicitSuper.java

package com.zetcode;
class Vehicle {
    public Vehicle() {
        System.out.println("Vehicle created");
    }
}
class Bike extends Vehicle {
    public Bike() {
        // super();
        System.out.println("Bike created");
    }
 }
public class ImplicitSuper {
    public static void main(String[] args) {
        Bike bike = new Bike();
        System.out.println(bike);
    }
}

该示例演示了对父级构造器的隐式调用。

public Bike() {
    // super();
    System.out.println("Bike created");
}

如果我们取消注释该行，则会得到相同的结果。

$ java com.zetcode.ImplicitSuper
Vehicle created
Bike created
com.zetcode.Bike@15db9742

创建Bike对象时，将调用两个构造器。

一个类中可以有多个构造器。

SuperCalls.java

package com.zetcode;
class Vehicle {
    protected double price;
    public Vehicle() {
        System.out.println("Vehicle created");
    }
    public Vehicle(double price) {
        this.price = price;
        System.out.printf("Vehicle created, price %.2f set%n", price);
    }    
}
class Bike extends Vehicle {
    public Bike() {
        super();
        System.out.println("Bike created");
    }
    public Bike(double price) {
        super(price);
        System.out.printf("Bike created, its price is: %.2f %n", price);
    }    
 }
public class SuperCalls {
    public static void main(String[] args) {
        Bike bike1 = new Bike();
        Bike bike2 = new Bike(45.90);
    }
}

该示例使用super的不同语法来调用不同的父构造器。

super();

在这里，我们称为父级的无参数构造器。

super(price);

此语法调用具有一个参数的父级构造器：自行车的价格。

$ java com.zetcode.SuperCalls
Vehicle created
Bike created
Vehicle created, price 45.90 set
Bike created, its price is: 45.90

这是示例输出。

Java 构造器链接

构造器链接是从构造器调用另一个构造器的能力。要从同一类调用另一个构造器，我们使用this关键字。要从父类中调用另一个构造器，我们使用super关键字。

ConstructorChaining.java

package com.zetcode;
class Shape {
    private int x;
    private int y;   
    public Shape(int x, int y) {
        this.x = x;
        this.y = y;
    }
    protected int getX() {
        return this.x;
    }
    protected int getY() {
        return this.y;
    }            
}
class Circle extends Shape {
    private int r;
    public Circle(int r, int x, int y) {
        super(x, y);        
        this.r = r;
    }
    public Circle() {
        this(1, 1, 1);
    }
    @Override
    public String toString() {
        return String.format("Circle: r:%d, x:%d, y:%d", r, getX(), getY());
    }
}
public class ConstructorChaining {
    public static void main(String[] args) {
        Circle c1 = new Circle(5, 10, 10);
        Circle c2 = new Circle();
        System.out.println(c1);
        System.out.println(c2);
    }
}

我们有一个Circle类。该类具有两个构造器。一种采用一个参数，一种不采用任何参数。

class Shape {
    private int x;
    private int y;
...
}

Shape类负责处理各种形状的x和y坐标。

public Shape(int x, int y) {
    this.x = x;
    this.y = y;
}

Shape类的构造器使用给定的参数启动x和y坐标。

protected int getX() {
    return this.x;
}
protected int getY() {
    return this.y;
}

我们定义了两种方法来检索坐标值。成员是私有的，因此唯一可能的访问是通过方法。

class Circle extends Shape {
    private int r;
...
}

Circle类继承自Shape类。它定义了特定于此形状的radius成员。

public Circle(int r, int x, int y) {
    super(x, y);        
    this.r = r;
}

Circle类的第一个构造器采用三个参数：radius以及x和y坐标。使用super关键字，我们调用传递坐标的父级构造器。请注意，super关键字必须是构造器中的第一条语句。第二条语句启动Circle类的radius成员。

public Circle() {
    this(1, 1, 1);
}

第二个构造器不带参数。在这种情况下，我们提供一些默认值。 this关键字用于调用同一类的三参数构造器，并传递三个默认值。

@Override
public String toString() {
    return String.format("Circle: r:%d, x:%d, y:%d", r, getX(), getY());
}

在toString()方法内部，我们提供Circle类的字符串表示形式。要确定x和y坐标，我们使用继承的getX()和getY()方法。

$ java com.zetcode.ConstructorChaining 
Circle: r:5, x:10, y:10
Circle: r:1, x:1, y:1

这是示例的输出。

Java 类常量

可以创建类常量。这些常量不属于具体对象。他们属于类。按照约定，常量用大写字母表示。

ClassConstant.java

package com.zetcode;
class Math {
    public static final double PI = 3.14159265359;
}
public class ClassConstant {
    public static void main(String[] args) {
        System.out.println(Math.PI);
    }
}

我们有一个带有PI常量的Math类。

public static final double PI = 3.14159265359;

final关键字用于定义常数。使用static关键字可以引用成员而无需创建类的实例。 public关键字使它可以在类的主体之外访问。

$ java com.zetcode.ClassConstant 
3.14159265359

Running the example we get the above output.

Java `toString`方法

每个对象都有toString()方法。它返回人类可读的对象表示形式。默认实现返回Object类型的标准名称。当我们以对象作为参数调用System.out.println()方法时，将调用toString()。

ThetoStringMethod.java

package com.zetcode;
class Being {
    @Override
    public String toString() {
        return "This is Being class";
    }
}
public class ThetoStringMethod {
    public static void main(String[] args) {
        Being b = new Being();
        Object o = new Object();
        System.out.println(o.toString());
        System.out.println(b.toString());
        System.out.println(b);
    }
}

我们有一个Being类，其中我们重写了toString()方法的默认实现。

@Override
public String toString() {
    return "This is Being class";
}

创建的每个类都从基Object继承。 toString()方法属于此对象类。 @Override注解通知编译器该元素旨在替代超类中声明的元素。然后，编译器将检查我们是否未创建任何错误。

Being b = new Being();
Object o = new Object();

我们创建两个对象：一个自定义对象和一个内置对象。

System.out.println(o.toString());
System.out.println(b.toString());

我们在这两个对象上显式调用toString()方法。

System.out.println(b);

正如我们之前指定的，将对象作为System.out.println()的参数将调用其toString()方法。这次，我们隐式调用了该方法。

$ java com.zetcode.ThetoStringMethod 
java.lang.Object@125ee71
This is Being class
This is Being class

这是我们运行示例时得到的。

Java 中的继承

继承是一种使用已经定义的类形成新类的方法。新形成的类称为派生的类，我们从中衍生的类称为基类。继承的重要好处是代码重用和降低程序的复杂性。派生类（后代）将覆盖或扩展基类（祖先）的功能。

Inheritance.java

package com.zetcode;
class Being {
    public Being() {
        System.out.println("Being is created");
    }
}
class Human extends Being {
    public Human() {
        System.out.println("Human is created");
    }
}
public class Inheritance {
    @SuppressWarnings("ResultOfObjectAllocationIgnored")
    public static void main(String[] args) {
        new Human();
    }
}

在此程序中，我们有两个类：基础Being类和派生的Human类。派生类继承自基类。

class Human extends Being {

在 Java 中，我们使用extends关键字创建继承关系。

new Human();

我们实例化派生的Human类。

$ java com.zetcode.Inheritance
Being is created
Human is created

我们可以看到两个构造器都被调用了。首先，调用基类的构造器，然后调用派生类的构造器。

接下来是一个更复杂的示例。

Inheritance2.java

package com.zetcode;
class Being {
    static int count = 0;
    public Being() {
        count++;
        System.out.println("Being is created");
    }
    public void getCount() {
        System.out.format("There are %d Beings%n", count);
    }
}
class Human extends Being {
    public Human() {
        System.out.println("Human is created");
    }
}
class Animal extends Being {
    public Animal() {
        System.out.println("Animal is created");
    }
}
class Dog extends Animal {
    public Dog() {
        System.out.println("Dog is created");
    }
}
public class Inheritance2 {
    @SuppressWarnings("ResultOfObjectAllocationIgnored")
    public static void main(String[] args) {
        new Human();
        Dog dog = new Dog();
        dog.getCount();
    }
}

对于四个类，继承层次结构更加复杂。 Human和Animal类继承自Being类，Dog类直接继承自Animal类，间接继承自Being类。

static int count = 0;

我们定义一个static变量。静态成员由类的所有实例共享。

public Being() {
    count++;
    System.out.println("Being is created");
}

每次实例化Being类时，我们将count变量增加一。这样，我们就可以跟踪创建的实例数。

class Animal extends Being {
...
class Dog extends Animal {
...

Animal继承自Being，Dog继承自Animal。 Dog也间接继承自Being。

new Human();
Dog dog = new Dog();
dog.getCount();

我们从Human和Dog类创建实例。我们称为Dog对象的getCount()方法。

$ java com.zetcode.Inheritance2 
Being is created
Human is created
Being is created
Animal is created
Dog is created
There are 2 Beings

Human对象调用两个构造器。 Dog对象调用三个构造器。有两个实例化的Beings。

`final`类，`private`构造器

带有final修饰符的类不能被子类化。带有带有private修饰符的构造器的类无法实例化。

FinalClass.java

package com.zetcode;
final class MyMath {
    public static final double PI = 3.14159265358979323846;
    // other static members and methods
}
public class FinalClass {
    public static void main(String[] args) {
        System.out.println(MyMath.PI);
    }
}

我们有一个MyMath类。此类具有一些静态成员和方法。我们不希望任何人从我们的类继承；因此，我们将其声明为final。

此外，我们也不想允许从我们的类中创建实例。我们决定仅在静态上下文中使用它。声明一个私有构造器，该类无法实例化。

MyMath.java

package com.zetcode;
final class MyMath {
    private MyMath() {}
    public static final double PI = 3.14159265358979323846;
    // other static members and methods
}
public class PrivateConstructor {
    public static void main(String[] args) {
        System.out.println(MyMath.PI);
    }
}

我们的MyMath类无法实例化，也不能被子类化。这就是java.lang.Math用 Java 语言设计的方式。

这是 Java 中 OOP 描述的第一部分。