Java 中的面向对象

Java 中的类

Java 中的类有四种(为避免混淆,后文称为“广义类”):

  • 接口 interface – interface
  • 抽象类 abstract class – abstract class
    且必须包含抽象方法 abstract method
  • 具体类 concrete class – class

    • 枚举 enumeration – enum

它们可以放置在:

  • 外部 outer:java 源文件的最外层
  • 内部 inner:另一个类的的内部

枚举 enumeration

枚举 enum
本质是一个继承自 java.lang.Enum
的具体类(语法糖 grammar sugar)。

  • 枚举可以实现接口,但是不能继承其他类。
  • 枚举的 constructor 必须为 private。

示例如下:

enum Classification {
  CONVEX_QUADRILATERAL,
  PARALLELOGRAM,
  RHOMBUS,
  RECTANGLE,
  SQUARE
}

Classification c = Classification.RECTANGLE;
c.name(); // "RECTANGLE"
c == Classification.RHOMBUS; // false
enum Classification {
  CONVEX_QUADRILATERAL("Convex Quadrilateral"),
  PARALLELOGRAM("Parallelogram"),
  RHOMBUS("Rhombus"),
  RECTANGLE("Rhombus"),
  SQUARE("Square");

  private String information;

  private Classification(String information) {
      this.information = information;
  }

  /**
   * @return the information
   */
  public String getInformation() {
      return information;
  }

  /**
   * @param information the information to set
   */
  public void setInformation(String information) {
      this.information = information;
  }
}

Classification c = Classification.RECTANGLE;
c.name(); // "RECTANGLE"
c == Classification.RHOMBUS; // false
c.getInformation(); // "Rectangle"

访问控制符 access modifier

分类

访问控制符包括:

private
protected
public

字段 field / 方法 method / 广义内部类 inner class

访问控制符 可访问性
private 同类内部可见 with in the same class
(default) 同包内部可见 with in the same package
protected default + 非同包子类内部可见 default + sub classes in different package
public 不限制 everywhere

PS: 用 private 限制构造器 constructor 后,其他类中将不能够通过 new 的方式来获取这个类的对象,这能有效控制对象的创建行为。这在某些设计模式中是必要的。

广义外部类 outer class

访问控制符 可访问性
(default) 同包内部可见 with in the same package
public 不限制 everywhere

static 和 final

static

关键字 static
有这些含义:

  • 在内存中只有一份 copy 。 | There is only one copy in memory.
  • 能通过 object 访问,也能通过 class 访问。不需要创建 object 就可以访问。属于 class 不属于 object。 | It could be called without instance.
用于 含义
字段 field 在内存中只有一份 copy 。能通过 object 访问,也能通过 class 访问。
方法 method 在内存中只有一份 copy 。能通过 object 访问,也能通过 class 访问。 根据操作系统的基本原理,即使 method 不使用 static 修饰,在内存中也只有一份 copy 。
static 和 default method 的区别在于—— static method 只能访问有 static field;
default method 能够访问所有的 Field。
广义内部类 inner class 能通过 object 访问,也能通过 class 访问。

final

关键字 final
的含义是:一旦赋值,不可改变。

用于 含义
变量 variable 常量,禁止修改 constant, cannot be modified
字段 field 常量或运行时常量,禁止修改 constant or runtime constant, cannot be modified
具体方法 concrete method 禁止重写 prevent method overriding
具体类 concrete class 禁止继承 prevent inheritance

广义常量

常量 constant 指的是在编译时 compile time 就确定下来保持不变的量,属于静态绑定 static binding。

运行时常量 runtime constant 指的是在运行时 runtime 才能确定的量,一旦确定则保持不变,属于动态绑定 dynamic binding。

public class Playground {
  public static final String SLOGAN_0 = "constant"; // constant
  public final String slogan1 = "dynamic constant"; // runtime constant

  public static void main(String[] args) {
    final String SLOGAN_2 = "constant"; // constant
    Playground playground = new Playground();
    System.out.println(SLOGAN_0);
    System.out.println(playground.slogan1);
    System.out.println(SLOGAN_2);
  }

  public Playground() {
    // constructor
  }

  public void finalize() {
    // destructor - execute before garbage collection
  }
}

命名方式:

  • https://google.github.io/styl…

  • https://www.cnblogs.com/lanxu…

    – 5.2.4

重写 overriding

重写 overriding指的是,当子类继承父类时,若子类和父类存在同名同参数方法,父类方法将不可见(另一种说法是“覆盖”)。重写发生在运行时 runtime。

有个容易混淆的概念叫做 重载 overloading
。重载指的是,允许多个方法采用相同的名称,只要输入参数不一致即可。函数的调用是由编译器确定的,也就是说,重载发生在编译时 compile time。

abstract

修饰方法

public abstract void exampleMethood();

上述代码声明一个抽象方法 abstract method。
抽象方法声明以 ;
结尾,不能定义具体实现。

由于抽象方法最终要被实现 implement,因此
通常使用 public
修饰

(有封装 encapsulation 需求的除外,下同),
禁止使用 final
修饰。

修饰类

下列代码定义一个 “被标记为 abstract 的类“ class tagged by abstract。

public abstract class ExampleClass {
  // ...
}

如果该类包含抽象方法,那么称为抽象类 abstract class。下列代码定义了一个【突四边形】抽象类。

package geometry;

public abstract class ConvexQuadrilateralAbstract implements TwoDimensionalGeometry {
  public abstract String classify();

  private static final int EDGE_NUMBER = 4;
  private final int vertexNumber = 4;

  @Override
  public int edgeNumber() {
    return EDGE_NUMBER;
  }

  public ConvexQuadrilateralAbstract() {
    System.out.println("[constructor] ConvexQuadrilateralAbstract");
  }

  /**
   * @return the vertexNumber
   */
  public int getVertexNumber() {
    return vertexNumber;
  }
}

注意:

  • 如果一个”被标记为 abstract 的类“中不含括抽象方法,那么 Java 会将其理解为具体类 concrete class,具体表现为可以正常实例化 instantiate。 抽象类必须包含1+个抽象方法。
  • 如果一个类包含抽象方法,那么必须将其标记为 abstract
    ,否则编译报错。
  • 抽象类无法进行实例化 instantiate。
  • 由于抽象类最终要被其他类继承 inherit,
    因此通常使用 public
    修饰,禁止使用 final
    修饰。

接口 interface

下列代码定义了一个【二维几何】接口。

package geometry;

public interface TwoDimensionalGeometry {
  public abstract int edgeNumber();

  public abstract double calculatePerimeter();

  public abstract double calculateArea();
}

注意:

  • 接口 interface 只能包含抽象方法 abstract method。
  • 由于接口最终要被其他类实现 implement,
    因此通常使用 public
    修饰,禁止使用 final
    修饰。

比较

类型 抽象方法 实例化
具体类 concrete class 禁止包含抽象方法 no abstract method 允许 can instantiate
抽象类 abstract class 至少包含一个方法 at least one abstract method 禁止 cannot instantiate
接口 interface 所有方法必须为抽象方法 all methods must be abstract 禁止 cannot instantiate

继承 inherit

通过关键字 extends
进行继承,示例如下:

public class Rectangle extends Parallelogram {
  // ...
}

具体类/抽象类 只能继承一个
具体类/抽象类。

抽象类可以继承具体类。

实现 implement

通过关键字 implements
进行实现,示例如下:

public abstract class ConvexQuadrilateralAbstract implements TwoDimensionalGeometry {
  // ...
}
public final class Triangle implements TwoDimensionalGeometry, java.io.Serializable {
  // ...
}

具体类/抽象类可以实现多个 接口

面向对象 object-oriented

Java 包含面向对象 object-oriented 的四个特性:

  • 封装 encapsulation

    • 访问控制符 | access modifier
  • 继承 inheritance

    • 继承一个类(单继承) | inherit a class (single inheritance)
    • 实现多个接口(多实现) | implement some interface (multiple implementation)
    • 在某种程度上,多实现提供了一种间接的多继承的方法。 | To some extent, multiple implementation provides an indirect method of multiple inheritance.
  • 多态 polymorphism

    • 重写 | overriding
  • 抽象 abstraction

    • 对象 => 具体类 => 抽象类 => 接口 | object => concrete class => abstract class => interface

参考资料

  • https://blog.csdn.net/qiumeng…

  • https://www.cnblogs.com/swift…

  • https://www.cnblogs.com/swift…

  • https://blog.csdn.net/qq_2709…

原文 

https://segmentfault.com/a/1190000022209612

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » Java 中的面向对象

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址