Java 面向对象的编程

原文：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 描述的第一部分。

---

我们一直在努力

apachecn/AiLearning

---