目录
suibi

java面向对象三大特性(如何理解java的面向对象)


首先,Java中,除了8种基本数据类型。其他皆为对象。

Java的8种基本数据类型:byte short int long float double char boolean. 
基本数据类型的值,是直接存储在线程的方法栈中的
而对象的值存储在堆(Heap)中,在方法栈的栈帧里,只存了对象的地址引用
PS:详见JVM内存模型

面向对象主要有

三个基本特征:封装继承多态

五个基本原则: SOLID原则,即:

  • 单一职责原则(SRP)
  • 开放封闭原则(OCP)
  • 里氏替换原则(LSP)
  • 接口隔离原则(ISP)
  • 依赖倒置原则(DIP)

三个基本特征

如何快速理解java的面向对象及三个特性

基本特征的体现


封装

主要概念是指:隐藏对象的属性和实现细节,仅对外暴露公共的访问方式。封装是面向对象最基本的特征之一,是类和对象概念的主要特性。

良好的封装所具有的优点:

1,隐藏信息和细节,提高安全性

2,良好的封装可以减少耦合性,提高复用性

3,对类内部结构可以随意修改,只要保证公有接口始终返回正确的结果即可。

在Java中的体现:

public default protected private 等设置访问权限的关键字

例如,类的属性私有化 private修饰,提供公有的 setter getter 方法对值进行获取和修改。

同时,还可以在setter getter函数里进行数据校验和对返回值做限制。这就是提高安全性的体现。


继承

继承是一种联结类的层次模型,Java允许并且鼓励代码的重用,继承提供了一种明确表示共性的方法,来使代码可以进行复用。

继承的出现,让类与类之间产生了关联,提供了多态的前提条件

讲到继承,就要提到三个东西:构造器,protected关键字,向上转型:

1,构造器:我们已经知道,父类中private修饰的属性和方法子类是无法继承的,而还有一个无法继承的就是 构造器。构造器只能调用而不能被继承。

类在实例化的时候会调用自身构造器,而java编译器会默认在子类构造器的第一行用super()先调用父类的无参构造器。如果父类没有无参构造器,则子类在实例化的时候会报错。这个时候就需要显示的在子类构造器第一行(必须在第一行)指定构造器super(args)来指定调用父类哪个构造器。

2,protected关键字:proctected关键字修饰的属性和方法,可以隔绝外部其他类的访问,却可以让子类有权限访问。

但是最好还是把属性都以private修饰,父类中希望子类可以访问到,又不希望公有的方法,可以用protected修饰

3,向上转型:最典型的还是List list = new ArrayList() 将子类的实例声明为父类的类型,提高了通用性,也隐藏了子类的具体实现。因为这是一个由专用向通用的转换,所以总是安全的。唯一缺陷就是专有属性和方法的丢失。

但是继承同时又存在缺陷:

1),继承是一种强耦合关系,子类会由于父类的改变而改变

2),继承破坏了封装的特性,对于父类而言,它的实现和细节对于子类来说都是透明的

所以到底要不要继承:《Thinking in java》提供了一个解决方案:问一问自己是否需要从子类向父类进行向上转型。如果必须向上转型,则继承是必要的,但是如果不需要,则应当好好考虑自己是否需要继承

使用继承的时候,一定要注意,两个类之间是从属关系,父子关系 的。子类应该是基于父类原有的特性,派生出来,并在无需编父类代码的情况下,提供扩展的功能和方法。不要为了使用某个类的其中一个特性,而去继承该类。


多态

多态,指的就是:

程序中定义的引用变量所指向的具体类型,和通过该引用变量发出的方法调用,在编程期间并不确定,而是在程序运行期间才确定

如何理解多态

因为在程序运行时才确定到具体的类,所以不用修改源码,就能让引用变量绑定到不同的类型实现上,从而导致引用调用的方法发生改变,即不修改具体代码,就可以让程序在运行时改变绑定的具体代码,表现不同的运行状态。这就是多态性。

多态的好处

多态允许不同类对象,对同一个消息作出响应。即同一个消息可以根据发送对象的不同而采用不同的行为方式(发送消息就是函数调用)。

主要好处如下:

1)可替换性。多态对已存在的代码具有可替换性。

2)可扩充性。新增加的子类不影响已经存在的类结构。

3)接口性。多态是父类通过方法签名,向子类提供一个公共接口,由子类来完善或者重写它来实现的。

4)灵活性。

5)简化性。

Java中多态的体现

  • 重写(覆盖)
  • 动态链接(动态调用)
  • 重载

多态的三个必要条件

  • 继承
  • 重写
  • 向上转型。

多态的作用

我们知道,封装可以隐藏细节,使得代码模块化,继承可以扩展已存在的模块化代码(父类),实现代码的复用。

而多态,则是实现了接口的复用,多态的作用,就是在类的实现和派生的时候,保证使用基类下面,任意一个子类实例的属性和方法,都可以正确调用。

虚拟机如何实现多态

在JVM中,是使用了动态绑定技术(dynamic binding),执行期间判断所引用对象的实际类型,根据实际类型调用对应的方法.

重载严格意义上并不属于多态,重载的具体实现是:编译器根据不同的参数表,对同名函数的名称做修饰,然后这些同名函数就变成了不同的函数。对重载函数的调用,在编译期间就已经确定了,是静态的(注意!是静态的),因此,重载和多态无关。真正和多态相关的是重写,当子类重写了父类中的函数后,父类的 指针,根据赋值给它不同的子类对象指针,动态的调用属于子类的该函数,这样在编译期间是无法确定的,只有在运行期间,才会把动态链接转变为直接引用(称为动态链接,详见JVM内存模型-栈帧)


五个基本原则

  • 单一职责原则(Single-Resposibility Principle SRP)
  • 对一个而言,应该仅有一个引起它变化的原因

本原则是我们非常熟悉的"高内聚原则"的引申。同时,本原则还揭示了内聚性和耦合性:如果一个类承担的职责过多,那么这些职责就会相互依赖,一个职责的变化可能会影响另一个职责的履行。其实OOP的实质,就是合理进行类的职责分配

  • 开—闭原则(Open-Closed principle OCP)
  • 软件应该是可以扩展的,但是不可以修改

也就是对扩展开放,对修改封闭。当变化来临时,不需要(或者不允许)修改原来的代码,只需要在原有的基础上扩展(同时原有的代码也要求支持扩展),那么这个软件设计就是满足开闭原则的。

此原则在Java中最典型的体现就是:抽象类 抽象基类 和 接口。通过抽象类,把一些不可变的操作封装起来,而提供抽象接口供子类实现,来实现各自变化的需求。

这个原则应用在类的设计中,要满足该原则就要充分的考虑到接口封装,抽象机制和多态。

  • 里氏替换原则(Liskov-Substituion Principle LSP)
  • 子类型必须能够替换掉它们的基类型

本原则和开闭原则关系密切,正是基于子类的可替换性,才使得基类可以无需修改,只要子类继承就可以实现扩展特性。这是保证继承复用的基础

在Java中的典型体现就是 基于接口的框架设计,例如JDBC集合类

JDBC只提供了基本的接口,返回的对象类型也是接口,这样就在选择返回对象的时候,有了更大的灵活性:只要是继承了返回接口类型的子类实例,都可以作为结果返回。而服务提供者无需暴露子类的实现,调用者也无需关心子类的实现。而提供者在对实现进行优化升级时,对调用者也是不可见,同时也没有影响的。

集合类提供了一些基本集合的接口,例如 List Map Set。我们可以在声明时用这些接口类型作为声明对象,无需关心具体的实现类型是如何操作的,集合框架可以很好的把实现类型和代码隐藏起来,对调用者透明。例如List可以用来接收ArrayList,也可以用来接收LinkedList。可以用来接收任何实现了List接口的类的实例。

以上两点,充分的利用了里氏替换原则的特性,实现了封装的基本特征。

  • 接口隔离原则(Interface-Segregation Principle ISP)
  • 多个专用接口优于一个单一的通用接口

本原则是单一职责原则用于接口设计的自然结果。基本思想就是,不要让客户端依赖他们不需要的接口。

一个接口应该保证,实现该接口的实例对象可以只呈现一个单一的角色。这样当接口发生改变时,对其他客户端造成的影响会更小。

把多个不同职责的功能分到不同的接口中去,提高代码的灵活性和稳定性,降低耦合性。

  • 依赖倒置原则(Dependecy-Inversion Principle DIP)
  • 抽象不应该依赖于细节,细节应该依赖于抽象

具体来说就是,软件设计中,高层不依赖于低层,两者都依赖于抽象。抽象应该依赖于抽象,而不依赖于具体实现细节。即:对接口编程

在Java中的体现还是,接口 和 抽象类

拿最简单的Spring IOC来说,当我们注入的时候,接收参数类型应该是接口,而注入的对象,可以是实现了接口的各种子类,当我们想改变接口表现的特性的时候,无需修改代码,只要修改注入的实现类对象就可以。

RPC框架(例如Dubbo)开放的接口也同样基于这个原则。

上面说的JDBC,集合类框架 都基于这个原则来提供实现。提供接口对象,而把实现类隐藏在内部。


写笔记

咨询

您的电子邮箱地址不会被公开。