Java基础：如何理解面向对象?-每日运维

本篇开始会从基础开始把每一个知识点讲明白讲透彻，旨在让每个知识点都能在工作中和面试中用的上。如果有讲的不明白的地方欢迎公众号私信讨论，第一时间有问必答。

java的设计就是将java世界比作真实世界，一切事物都可以被某些类型定义，每一个具体的事物都是类型下面的实体对象，类型可以更抽象，比如“鸟类”，也可以更具体，比如“麻雀”，而一只活蹦乱跳的麻雀对象属于麻雀这个类型，也属于鸟类这个类型，而鸟类是麻雀类的抽象。

真实的世界中每种类型的特点以及类与类的关系是生来就有的，就像是我们看到天上飞的我们就知道它是鸟类，而java世界毕竟不是真实世界，他需要通过定义规则来约束这些关系。

面向对象中有四个特性，封装，继承，多肽，抽象，java利用这些特性来描述类和类与类的关系。

一、类

虽然java是模拟真实世界，但是java对类的定义是开放，程序员可以按照自己想象任意定义类，但是类的定义和现实世界又是一样的，我们在描述一个鸟类的时候，一般是说鸟有羽毛，五颜六色，会飞等等，但是归根结底是在阐述鸟的外观和技能，而在java中外观描述和技能对应的是类中的成员属性和成员方法。

二、对象

java中通过new关键字创建的就是一个具体的对象，它具备所属类的所有属性和方法，它可以在适当的地方被操作。

三、面向对象的特性

1.封装

封装也叫作信息隐藏或者数据访问保护，我们用一个非常通俗的现实例子来说明下:

public class bank {
    private String id;
    private long createTime;
    private BigDecimal balance;
    private long balanceLastModifiedTime;
}

这是一个银行存款的例子，在存款的时候有存款时间，存款后的余额，余额更改时间，如果这几个属性是public修饰，那么其他类都可以访问这几个属性，并且对其任意修改，这是不安全的，封装的目的把属性的修改权限私有化，比如时间只有内部可以改动，不需要对外开放，对于余额的改动银行依赖于存款人存多少钱，所以可以提供一个带入参的函数入口，类似于存款人把钱给到银行，由银行人员进行余额的变动，这是把权限最小化，尽可能增强安全性，通过有限的方法暴露必要的操作，我们代码中的get set方法就是封装的最简体现。

2.继承

继承是指子类继承父类，语法机制：extends

public class A extends D

一旦达成继承关系，子类就会拥有父类非private修饰的属性和方法。并且子类可以拥有自己独有的属性和方法，同时子类还可以用自己的方式实现父类的方法，即重写。

一个父类可以被多个子类继承，但是一个子类不能继承多个父类。

继承让代码可以复用，把子类共有的方法抽离到父类中实现，由子类来继承父类，从而达到代码精简。

关于继承还有两种特殊的继承：实现接口和继承抽象类。

我们先来了解下接口和抽象类。

(1) 抽象类

public abstract class A

一个普通的类如果被abstract修饰，就是一个抽象类，抽象类相对于普通类的特点如下：

可以存在abstract修饰的方法，即抽象方法，被abstract修饰的方法不能用private、static、synchronized、native等访问修饰符修饰，并且没有实现体。
不能实例化，只能被子类继承
如果子类继承了抽象类，并且实现了抽象类的所有抽象方法，那么子类是一个具体的类，如果没有全部实现其抽象方法，则子类也是一个抽象类
抽象类可以有构造方法，目的是让子类来调用构造方法初始化

(2) 接口

接口是一种特殊的抽象类，语法机制：interface

public interface B

接口其实就是一种特殊的抽象类，相对于抽象类不同的地方是：

只能被实现，其实现也是一种特殊的继承，却别是继承只能单继承，而实现可以多实现。
接口中默认所有的方法都是抽象方法。
接口中定义的成员变量默认是public static final，即只能够有静态的不能被修改的数据成员，而且必须赋初值。
一个类可以实现多个接口，一定程度上弥补了不能多继承的问题。
java中类可以继承类，也可以实现接口，接口也可以继承接口，而且接口继承接口可以多继承，即一个接口可以用关键字extends继承多个接口。

对于接口和抽象类的应用如何理解：

结合面向对象思想来理解，抽象类是类的溯源产物，比如：幼年猫-猫-猫科-动物，是一个类群里不断向上溯源就是抽象；而接口是对行为的分组，比如吃饭，睡觉，玩游戏。

那么在日常应用中，应该怎么应用呢？

从设计的角度讲，接口往往被用来定义一组行为，举个例子：

public class 鸟

cry();

public class 鸭 extends 鸟
cry(){
  嘎嘎嘎
}

public class 鸡 extends 鸟
cry(){
  吱吱吱
}

public class 乌鸦 extends 鸟
cry(){
  喳喳喳
}

如上代码，每种鸟都有自己独特的叫声，每种鸟都要重写cry方法，没有办法将叫这个行为抽象到父类中，也就无法利用父类实现代码复用，增加了代码的复杂性和开发工作量。

如果每种鸟都有自己独特的叫声，那每个鸟类都要重写cry方法也是没有办法但是必须这么做的事情。但事实上，鸟类的数量远远大于叫的方式的数量，也就是说，可能一百种鸟的叫声都是吱吱吱，一百种鸟的叫声都是咕咕咕，这种情况下，就可以通过接口来设计了。

就是用接口定义行为，由具体的行为类实现接口，每个鸟类再将叫的行为委托给行为类实现。

public interface cry

public class Zhizhizhi implements cry
cry(){
吱吱吱
}

public class Gagaga implements cry
cry(){
嘎嘎嘎
}

public class 鸭 extends 鸟
Gagaga gagaga;
cry(){
  gagaga.cry();
}

public class 鸡 extends 鸟
Zhizhizhi zhizhizhi;
cry(){
  zhizhizhi.cry();
}

如上代码，将行为从具体的类中分离出来单独定义为行为类，具体类和行为类以组合在一起，这样就可以复用代码。

所有的行为都需要这样设计吗？并不是，只有当前类独有的行为可以在当前类中单独实现。而那些变化多端的行为就要以这样方式设计。

从开发的角度讲，接口往往用于隔离接口和实现达到解耦的效果

日常开发中我们设计一个功能，往往是以接口的形式对外暴露，不暴露实现，这样的设计为了隔离接口和具体的实现，提高代码的扩展性。

3.多态

多态是指子类可以替换父类，父类的引用可以指向子类，我们直接用代码来说明：

public class DynamicArray {
  
  private static final int DEFAULT_CAPACITY = 10;
  protected int size = 0;
  protected Integer[] elements = new Integer[DEFAULT_CAPACITY];

  public int size() {
   return this.size;
  }

  public Integer get(int index) {
   return elements[index];
  }

  public void add(Integer e) {
   elements[size++] = e;
  }

 }

 public class SortedDynamicArray extends DynamicArray {
  @Override
  public void add (Integer e) {
   int i;
   for (i = size - 1; i >= 0; --i) {
    if (elements[i] > e) {
     elements[i + 1] = elements[i];
    } else {
     break;
    }
   }
   elements[i + 1] = e;
   ++size;
  }
 }

 public class Example {
  public static void test(DynamicArray dynamicArray) {
   dynamicArray.add(5);
   dynamicArray.add(1);
   dynamicArray.add(3);
   for (int i = 0; i < dynamicArray.size(); ++i) {
    System.out.println(dynamicArray.get(i));
   }
  }

  public static void main(String args[]) {
   DynamicArray dynamicArray = new SortedDynamicArray();
   test(dynamicArray);
  }
 }

public interface Iterator {

  String hasNext();

  String next();

  String remove();

 }

 public class Array implements Iterator {
  
  private String[] data;

  public String hasNext() { ...}

  public String next() { ...}

  public String remove() { ...}

 }

 public class LinkedList implements Iterator {

  private LinkedListNode head;

  public String hasNext() { ...}

  public String next() { ...}

  public String remove() { ...}

 }

 public class Demo {
  private static void print(Iterator iterator) {
   while (iterator.hasNext()) {
    System.out.println(iterator.next());
   }
  }

  public static void main(String[] args) {
   Iterator arrayIterator = new Array();
   print(arrayIterator);
   Iterator linkedListIterator = new LinkedList();
   print(linkedListIterator);
  }
 }

上面两个案例中最关键的代码：

DynamicArray dynamicArray = new SortedDynamicArray();

Iterator arrayIterator = new Array();

这两行代码都是用父类来接收子类，其实这就是多肽，但是要达到这样的目的是要依赖于“继承”或者“实现”，正如上面的代码一样。

多态特性能提高代码的可扩展性和复用性。

在那个例子中，我们利用多态的特性，仅用一个print()函数就可以实现遍历打印不同类型（Array、LinkedList）集合的数据。当再增加一种要遍历打印的类型的时候，比如HashMap，我们只需让HashMap实现Iterator接口，重新实现自己的hasNext()、next()等方法就可以了，完全不需要改动print()函数的代码。所以说，多态提高了代码的可扩展性。

总结

Java的基础就是面向对象思想，支撑面向对象思想是：封装，继承，多肽，抽象，接口，后续的设计模式都是建立在这些基础特性上面，要想开发出高质量代码必须先掌握基础。

Java基础：如何理解面向对象?

一、类

二、对象

三、面向对象的特性

1.封装

2.继承

3.多态

总结

相关文章

发布评论取消回复

大猫

开启3389端口命令，要怎么开启3389端口命令

win10优化驱动器怎么启动

MySQL DNS查找和主机缓存解读

Java基础：如何理解面向对象?

一、类

二、对象

三、面向对象的特性

1.封装

2.继承

3.多态

总结

相关文章

发布评论 取消回复

大猫

开启3389端口命令，要怎么开启3389端口命令

win10优化驱动器怎么启动

MySQL DNS查找和主机缓存解读

发布评论取消回复