Java 面向对象编程 II
原文：http://zetcode.com/lang/java/oop2/
在 Java 教程的这一章中，我们将继续对 Java OOP 的描述。 我们提到了抽象类和方法，接口，多态以及各种嵌套类。
Java 抽象类和方法
在设计应用时，我们经常发现我们的类具有很多通用功能。 这些共同点可以被提取并放入父类中。 这样，我们可以减少代码的大小，并使我们的应用更紧凑。 我们可能会发现父类是无形的，虚幻的实体-一个想法。 在桌子上，我们有一支笔，一本书，一支铅笔或一杯茶。 一个项目可能被视为所有这些事情的父类。 该类将包含这些项目的一些常见特质。 例如 id，权重或颜色。 我们可以实现getId()方法，但是不能在此类中实现getWeight()或getColor()方法。 物品没有重量或颜色。 这些方法只能在Item类的子类中实现。 对于这些情况，我们有抽象的方法和类。 Item类是抽象类的候选人-抽象类不能创建，并且其某些或所有方法不能实现。
使用abstract关键字创建抽象类或方法。 抽象类不能被实例化，但是可以被子类化。 如果一个类至少包含一个抽象方法，则也必须将其声明为抽象方法。 抽象方法无法实现； 他们只是声明方法的签名。 当我们从抽象类继承时，所有抽象方法都必须由派生类实现，或者该类本身必须是抽象的。
单个抽象类由相似类的子类继承，这些相似类具有很多共同点（抽象类的实现部分），但也有一些区别（抽象方法）。
抽象类可能具有完全实现的方法，也可能具有定义的成员字段。 因此，抽象类可以提供部分实现。 程序员经常将一些通用功能放入抽象类中。 这些抽象类随后会被子类化以提供更具体的实现。 通用功能在抽象类中实现，不同之处由抽象方法提示。 例如，Qt 图形库具有QAbstractButton，它是按钮小部件的抽象基类，提供按钮所共有的功能。 按钮Q3Button，QCheckBox，QPushButton，QRadioButton和QToolButton从此基本抽象类继承并提供其特定功能。
static，private和final方法不能是抽象的，因为这些类型的方法不能被子类覆盖。 同样，final类不能具有任何抽象方法。
正式地说，抽象类用于强制执行协议。 协议是所有实现对象都必须支持的一组操作。
AbstractClass.java
package com.zetcode;
abstract class Drawing {
protected int x = 0;
protected int y = 0;
public abstract double area();
public String getCoordinates() {
return String.format("x: %d, y: %d", this.x, this.y);
}
}
class Circle extends Drawing {
private int r;
public Circle(int x, int y, int r) {
this.x = x;
this.y = y;
this.r = r;
}
@Override
public double area() {
return this.r * this.r * Math.PI;
}
@Override
public String toString() {
return String.format("Circle at x: %d, y: %d, radius: %d",
this.x, this.y, this.r);
}
}
public class AbstractClass {
public static void main(String[] args) {
Circle c = new Circle(12, 45, 22);
System.out.println(c);
System.out.format("Area of circle: %f%n", c.area());
System.out.println(c.getCoordinates());
}
}
我们有一个抽象基类Drawing。 该类定义两个成员字段，定义一个方法并声明一个方法。 一种方法是抽象的，另一种是完全实现的。 Drawing类是抽象的，因为我们无法绘制它。 我们可以画一个圆，一个点或一个正方形，但是我们不能画一个Drawing。 Drawing类对我们可以绘制的对象具有一些通用功能。
abstract class Drawing {
我们使用abstract关键字定义一个抽象类。
public abstract double area();
抽象方法之前还带有abstract关键字。 Drawing类是一个想法。 这是不真实的，我们无法为其实现area()方法。 在这种情况下，我们使用抽象方法。 该方法将在更具体的实体（例如圆圈）中实现。
class Circle extends Drawing {
Circle是Drawing类的子类。 因此，它必须实现抽象的area()方法。
@Override
public double area() {
return this.r * this.r * Math.PI;
}
在这里，我们正在实现area()方法。
$ java com.zetcode.AbstractClass
Circle at x: 12, y: 45, radius: 22
Area of circle: 1520.530844
x: 12, y: 45
我们创建一个Circle对象并打印其面积和坐标。
Java 接口
遥控器是观众和电视之间的接口。 它是此电子设备的接口。 外交礼仪指导外交领域的所有活动。 道路规则是驾车者，骑自行车的人和行人必须遵守的规则。 编程中的接口类似于前面的示例。
接口是：
- API
- 合约
对象通过其公开的方法与外界交互。 实际的实现对程序员而言并不重要，或者也可能是秘密的。 公司可能会出售图书馆，但它不想透露实际的实现情况。 程序员可能会在 GUI 工具箱的窗口上调用maximize()方法，但对如何实现此方法一无所知。 从这个角度来看，接口是对象与外界交互的方式，而又不会过多地暴露其内部功能。
从第二个角度来看，接口就是契约。 如果达成协议，则必须遵循。 它们用于设计应用的架构。 他们帮助组织代码。
接口是完全抽象的类型。 它们使用interface关键字声明。 在 Java 中，接口是引用类型，类似于只能包含常量，方法签名和嵌套类型的类。 没有方法主体。 接口无法实例化-它们只能由类实现或由其他接口扩展。 所有接口成员都隐式具有公共访问权限。 接口不能具有完全实现的方法。 Java 类可以实现任何数量的接口。 接口扫描还可以扩展任何数量的接口。 实现接口的类必须实现接口的所有方法签名。
接口用于模拟多重继承。 Java 类只能从一个类继承，但可以实现多个接口。 具有接口的多重继承与继承方法和变量无关，而与继承接口所描述的思想或契约有关。
接口的主体包含抽象方法，但是根据定义，由于接口中的所有方法都是抽象的，因此不需要abstract关键字。 由于接口指定了一组公开的行为，因此所有方法都是隐式公共的。 接口除了方法声明外，还可以包含常量成员声明。 接口中定义的所有常数值都是public，static和final隐式。 这些修饰符可以省略。
接口和抽象类之间有一个重要的区别。 抽象类为继承层次结构中相关的类提供部分实现。 另一方面，可以通过彼此不相关的类来实现接口。 例如，我们有两个按钮。 经典按钮和圆形按钮。 两者都继承自抽象按钮类，该类为所有按钮提供了一些通用功能。 实现类是相关的，因为它们都是按钮。 而类别Database和SignIn彼此不相关。 我们可以应用ILoggable接口，该接口将迫使他们创建执行日志记录的方法。
SimpleInterface.java
package com.zetcode;
interface IInfo {
void doInform();
}
class Some implements IInfo {
@Override
public void doInform() {
System.out.println("This is Some Class");
}
}
public class SimpleInterface {
public static void main(String[] args) {
Some sm = new Some();
sm.doInform();
}
}
这是一个演示接口的简单 Java 程序。
interface IInfo {
void doInform();
}
这是接口IInfo。 它具有doInform()方法签名。
class Some implements IInfo {
我们实现了IInfo接口。 要实现特定的接口，我们使用implements关键字。
@Override
public void doInform() {
System.out.println("This is Some Class");
}
该类提供了doInform()方法的实现。 @Override注解告诉编译器我们正在重写方法。
Java 不允许直接从多个类中继承。 它允许实现多个接口。 下一个示例显示了一个类如何实现多个接口。
MultipleInterfaces.java
package com.zetcode;
interface Device {
void switchOn();
void switchOff();
}
interface Volume {
void volumeUp();
void volumeDown();
}
interface Pluggable {
void plugIn();
void plugOff();
}
class CellPhone implements Device, Volume, Pluggable {
@Override
public void switchOn() {
System.out.println("Switching on");
}
@Override
public void switchOff() {
System.out.println("Switching on");
}
@Override
public void volumeUp() {
System.out.println("Volume up");
}
@Override
public void volumeDown() {
System.out.println("Volume down");
}
@Override
public void plugIn() {
System.out.println("Plugging in");
}
@Override
public void plugOff() {
System.out.println("Plugging off");
}
}
public class MultipleInterfaces {
public static void main(String[] args) {
CellPhone cp = new CellPhone();
cp.switchOn();
cp.volumeUp();
cp.plugIn();
}
}
我们有一个CellPhone类，它从三个接口继承。
class CellPhone implements Device, Volume, Pluggable {
该类实现所有三个用逗号分隔的接口。 CellPhone类必须实现来自所有三个接口的所有方法签名。
$ java com.zetcode.MultipleInterfaces
Switching on
Volume up
Plugging in
运行程序，我们得到此输出。
下一个示例显示接口如何形成层次结构。 接口可以使用extends关键字从其他接口继承。
InterfaceHierarchy.java
package com.zetcode;
interface IInfo {
void doInform();
}
interface IVersion {
void getVersion();
}
interface ILog extends IInfo, IVersion {
void doLog();
}
class DBConnect implements ILog {
@Override
public void doInform() {
System.out.println("This is DBConnect class");
}
@Override
public void getVersion() {
System.out.println("Version 1.02");
}
@Override
public void doLog() {
System.out.println("Logging");
}
public void connect() {
System.out.println("Connecting to the database");
}
}
public class InterfaceHierarchy {
public static void main(String[] args) {
DBConnect db = new DBConnect();
db.doInform();
db.getVersion();
db.doLog();
db.connect();
}
}
我们定义了三个接口。 接口按层次结构组织。
interface ILog extends IInfo, IVersion {
ILog接口从两个接口继承。
class DBConnect implements ILog {
DBConnect类实现ILog接口。 因此，它必须实现所有三个接口的方法。
@Override
public void doInform() {
System.out.println("This is DBConnect class");
}
DBConnect类实现doInform()方法。 该方法由该类实现的ILog接口继承。
$ java com.zetcode.InterfaceHierarchy
This is DBConnect class
Version 1.02
Logging
Connecting to the database
这是示例输出。
Java 多态
多态是对不同的数据输入以不同方式使用运算符或函数的过程。 实际上，多态意味着如果类 B 从类 A 继承，则不必继承关于类 A 的所有内容； 它可以完成 A 类所做的某些事情。
通常，多态是以不同形式出现的能力。 从技术上讲，它是重新定义派生类的方法的能力。 多态与将特定实现应用于接口或更通用的基类有关。
简而言之，多态是重新定义派生类的方法的能力。
Polymorphism.java
package com.zetcode;
abstract class Shape {
protected int x;
protected int y;
public abstract int area();
}
class Rectangle extends Shape {
public Rectangle(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public int area() {
return this.x * this.y;
}
}
class Square extends Shape {
public Square(int x) {
this.x = x;
}
@Override
public int area() {
return this.x * this.x;
}
}
public class Polymorphism {
public static void main(String[] args) {
Shape[] shapes = { new Square(5),
new Rectangle(9, 4), new Square(12) };
for (Shape shape : shapes) {
System.out.println(shape.area());
}
}
}
在上面的程序中，我们有一个抽象的Shape类。 此类演变为两个后代类别：Rectangle和Square。 两者都提供了自己的area()方法实现。 多态为 OOP 系统带来了灵活性和可伸缩性。
@Override
public int area() {
return this.x * this.y;
}
...
@Override
public int area() {
return this.x * this.x;
}
Rectangle和Square类具有area()方法的自己的实现。
Shape[] shapes = { new Square(5),
new Rectangle(9, 4), new Square(12) };
我们创建三个形状的数组。
for (Shape shape : shapes) {
System.out.println(shape.area());
}
我们遍历每个形状，并在其上调用area()方法。 编译器为每种形状调用正确的方法。 这就是多态的本质。
Java 嵌套类
可以在另一个类中定义一个类。 这种类在 Java 术语中称为嵌套类。 非嵌套类的类称为顶级类。
Java 有四种类型的嵌套类：
- 静态嵌套类
- 内部类
- 本地类
- 匿名类
使用嵌套类可以提高代码的可读性并改善代码的组织。 内部类通常在 GUI 中用作回调。 例如在 Java Swing 工具箱中。
Java 静态嵌套类
静态嵌套类是可以在没有封闭类实例的情况下创建的嵌套类。 它可以访问封闭类的静态变量和方法。
SNCTest.java
package com.zetcode;
public class SNCTest {
private static int x = 5;
static class Nested {
@Override
public String toString() {
return "This is a static nested class; x:" + x;
}
}
public static void main(String[] args) {
SNCTest.Nested sn = new SNCTest.Nested();
System.out.println(sn);
}
}
该示例展示了一个静态的嵌套类。
private static int x = 5;
这是SNCTest类的私有静态变量。 可以通过静态嵌套类访问它。
static class Nested {
@Override
public String toString() {
return "This is a static nested class; x:" + x;
}
}
定义了一个静态的嵌套类。 它具有一种打印消息并引用静态x变量的方法。
SNCTest.Nested sn = new SNCTest.Nested();
点运算符用于引用嵌套类。
$ java com.zetcode.SNCTest
This is a static nested class; x:5
这是com.zetcode.SNCTest程序的输出。
Java 内部类
普通或顶级类的实例可以单独存在。 相比之下，内部类的实例必须绑定到顶级类才能实例化。 内部类也称为成员类。 它们属于封闭类的实例。 内部类可以访问封闭类的成员。
InnerClassTest.java
package com.zetcode;
public class InnerClassTest {
private int x = 5;
class Inner {
@Override
public String toString() {
return "This is Inner class; x:" + x;
}
}
public static void main(String[] args) {
InnerClassTest nc = new InnerClassTest();
InnerClassTest.Inner inner = nc.new Inner();
System.out.println(inner);
}
}
在InnerClassTest类中定义了一个嵌套类。 它可以访问成员x变量。
class Inner {
@Override
public String toString() {
return "This is Inner class; x:" + x;
}
}
InnerClassTest类的主体中定义了Inner类。
InnerClassTest nc = new InnerClassTest();
首先，我们需要创建顶级类的实例。 没有封闭类的实例，内部类将不存在。
InnerClassTest.Inner inner = nc.new Inner();
一旦实例化了顶级类，就可以创建内部类的实例。
$ java com.zetcode.InnerClassTest
This is Inner class; x:5
这是com.zetcode.InnerClassTest程序的输出。
Java 变量隐藏
如果内部作用域中的变量与外部作用域中的变量具有相同的名称，则将其隐藏。 仍然可以在外部范围中引用该变量。
Shadowing.java
package com.zetcode;
public class Shadowing {
private int x = 0;
class Inner {
private int x = 5;
void method1(int x) {
System.out.println(x);
System.out.println(this.x);
System.out.println(Shadowing.this.x);
}
}
public static void main(String[] args) {
Shadowing sh = new Shadowing();
Shadowing.Inner si = sh.new Inner();
si.method1(10);
}
}
我们在顶级类，内部类和方法内部定义一个x变量。
System.out.println(x);
该行引用在方法的本地范围内定义的x变量。
System.out.println(this.x);
使用this关键字，我们引用Inner类中定义的x变量。
System.out.println(Shadowing.this.x);
在这里，我们指的是Shadowing顶级类的x变量。
$ java com.zetcode.Shadowing
10
5
0
这是示例输出。
Java 本地类
本地类是内部类的特例。 本地类是在块中定义的类。 （块是括号之间的零个或多个语句的组。）本地类可以访问其封闭类的成员。 此外，如果声明了final，则本地类可以访问本地变量。 原因是技术上的。 本地类实例的生存期可能比定义该类的方法的执行时间更长。 为了解决这个问题，将局部变量复制到局部类中。 为了确保以后不会更改它们，必须将它们声明为final。
本地类别不能为public，private，protected或static。 不允许将它们用于局部变量声明或局部类声明。 除了声明为static和final的常量外，局部类不能包含静态字段，方法或类。
LocalClassTest.java
package com.zetcode;
public class LocalClassTest {
public static void main(String[] args) {
final int x = 5;
class Local {
@Override
public String toString() {
return "This is Local class; x:" + x;
}
}
Local loc = new Local();
System.out.println(loc);
}
}
本地类在main()方法的主体中定义。
@Override
public String toString() {
return "This is Local class; x:" + x;
}
如果局部类声明为final，则可以访问它们。
Java 匿名类
匿名类是没有名称的本地类。 它们使我们能够同时声明和实例化一个类。 如果我们只想使用匿名类，则可以使用匿名类。 匿名类在单个表达式中定义和实例化。 当事件处理代码仅由一个组件使用，因此不需要命名引用时，也可以使用匿名内部类。
匿名类必须实现接口或从类继承。 但是不使用implements和extends关键字。 如果new关键字后面的名称是类的名称，则匿名类是命名类的子类。 如果在new之后的名称指定了接口，则匿名类将实现该接口并扩展Object。
由于匿名类没有名称，因此无法为匿名类定义构造器。 在匿名类的主体内部，我们无法定义任何语句； 仅方法或成员。
AnonymousClass.java
package com.zetcode;
public class AnonymousClass {
interface Message {
public void send();
}
public void createMessage() {
Message msg = new Message() {
@Override
public void send() {
System.out.println("This is a message");
}
};
msg.send();
}
public static void main(String[] args) {
AnonymousClass ac = new AnonymousClass();
ac.createMessage();
}
}
在此代码示例中，我们创建一个匿名类。
interface Message {
public void send();
}
匿名类必须是子类或必须实现接口。 我们的匿名类将实现Message接口。 否则，编译器将无法识别类型。
public void createMessage() {
Message msg = new Message() {
@Override
public void send() {
System.out.println("This is a message");
}
};
msg.send();
}
匿名类是本地类，因此它是在方法主体中定义的。 表达式中定义了一个匿名类。 因此，右括号后面是一个分号。
在 Java 教程的这一部分中，我们继续介绍 Java 中的面向对象编程。
