面向对象思想1【笔记】

面向对象思想概述

类与对象

类中的成员变量对应着对象的状态

类中的成员函数对应着对象的行为

在只属于类的一部分中有类的静态变量和类的静态函数

逻辑上存在

物理上

在其中的employee类代码中，只有一个getpaid函数，那么怎么给这两个用呢，这就有了this.

类的静态变量和静态函数

没有this引用，静态变量全局独一份

普通的函数引用静态函数或者静态变量是可以的

对象上引用静态变量和静态函数会产生编译器警告

在静态函数上引用普通成员变量或者函数是不行的，会产生编译错误

类的特殊函数

构造函数，没有返回值，在类函数下的同名函数是构造函数，构造函数还可以进行重载

Equals

Hashcode

Tostring

接口

接口和类是很像的

为什么要有接口的概念

从用户（使用实现的代码）角度看问题

协作

接口与类相比

由编译器强制的一个模块间协作的合约（contract）

无成员变量

接口的申明

接口和抽象类的不同

在c++中，接口和抽象类是没有什么不同的

在java中，就有一些区别

从实现角度看，接口与抽象类有一些不同

抽象类可以有成员变量

抽象类可以有部分实现

抽象类不可以多重继承，只能继承一个

为什么设计成这样？

从用户角度来考虑问题

强调合约

强制协作双方无法犯错

接口的多重实现？

例题：包装链表类，实现iterable接口

具体代码如下：

package interview.oop.linkedlist;

import java.util.Iterator;
import java.util.NoSuchElementException;

import interview.common.Node;

public class LinkedList<T> implements Iterable<T> {

  private Node<T> head;
  private Node<T> tail;

  public static <T> LinkedList<T> newEmptyList() {
    return new LinkedList<T>();
  }

  private LinkedList() {
    head = null;
    tail = null;
  }

  public void add(T value) {
    Node<T> node = new Node<>(value);
    if (tail == null) {
      head = node;
    } else {
      tail.setNext(node);
    }
    tail = node;
  }

  private class ListIterator implements Iterator<T> {
    private Node<T> currentNode;

    public ListIterator(Node<T> head) {
      currentNode = head;
    }

    @Override
    public boolean hasNext() {
      return currentNode != null;
    }

    @Override
    public T next() {
      if (currentNode == null) {
        throw new NoSuchElementException();
      }
      T value = currentNode.getValue();
      currentNode = currentNode.getNext();
      return value;
    }
  }

  @Override
  public Iterator<T> iterator() {
    return new ListIterator(head);
  }
}

Tester.java

package interview.oop.linkedlist;

public class Tester {

  public static void main(String[] args) {
    LinkedList<Integer> list = LinkedList.newEmptyList();
    for (int i = 0; i < 100; i++) {
      list.add(i);
    }

    for (Integer value : list) {
      System.out.println(value);
    }

    LinkedList<String> stringList = LinkedList.newEmptyList();
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 100; i++) {
      sb.append("a");
      stringList.add(sb.toString());
    }

    for (String value : stringList) {
      System.out.println(value);
    }
  }
}

总结:

阅读接口注释，严格按照合约来实现

循环不变式用于假想的循环中