面向对象思想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 implements Iterable {

private Node head;
private Node tail;

public static LinkedList newEmptyList() {
return new LinkedList();
}

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

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

private class ListIterator implements Iterator {
private Node currentNode;

public ListIterator(Node 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 iterator() {
return new ListIterator(head);
}
}

Tester.java

package interview.oop.linkedlist;

public class Tester {

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

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

LinkedList 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);
}
}
}

总结:

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

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