文章末尾，有借鉴学习的说明，请仔细阅读，细化知识。
接口Interface：
package com.wangku.classx;
public interface InterfaceWK {
/**
* minus减法
* */
public abstract int xminus(int x,int y);
}
抽象类Abstract Class：
package com.wangku.classx;
public abstract class AbstractWK {
/**
* add加法
* */
public int xadd(int x,int y){
return x + y;
}
/**
* multiply乘法
* */
public abstract int xmultiply(int x,int y);
}
类Class：
package com.wangku.classx;
public class ClassWK extends AbstractWK implements InterfaceWK {
@Override
public int xminus(int x, int y) {
return x - y;
}
@Override
public int xmultiply(int x, int y) {
return x * y;
}
/**
* 除法
* */
public int xdivide(int x,int y){
return x / y;
}
}
测试类：
package com.wangku.classx;
public class ClassxTest {
public static void main(String[] args) {
//AbstractWK methods: xadd, xmultiply
//InterfaceWK methods: xminus
//ClassWK methods: xdivide ;extends AbstractWK and implements InterfaceWK
AbstractWK awk = new ClassWK();
InterfaceWK iwk = new ClassWK();
ClassWK cwk = new ClassWK();
//call methods
System.out.println("awk hascode:"+awk.hashCode());
System.out.println("iwk hascode:"+iwk.hashCode());
System.out.println("cwk hascode:"+cwk.hashCode());
if(awk.equals(iwk)){
System.out.println("awk and iwk is equals object");
}else{
System.out.println("awk and iwk is not equals object");
}
if(awk.equals(cwk)){
System.out.println("awk and cwk is equals object");
}else{
System.out.println("awk and cwk is not equals object");
}
if(iwk.equals(cwk)){
System.out.println("iwk and cwk is equals object");
}else{
System.out.println("iwk and cwk is not equals object");
}
}
}
用各对象调用方法：
//Abstract Class~ object call methods
//Interface ~ object call methods
//Class~ object call methods
上测试类ClassxTest的输出结果：
awk hascode:1414159026
iwk hascode:1569228633
cwk hascode:778966024
awk and iwk is not equals object
awk and cwk is not equals object
iwk and cwk is not equals object
借鉴自：Java学习笔记(必看).doc，O(∩_∩)O谢谢！
面向对象和面向过程两思想的区别：
a：面向对象主要针对面向过程，而面向过程的基本单元是函数。
b：面向过程的思想：由过程、步骤、函数组成，以过程为核心；面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。
c：面向过程是先有算法，后有数据结构。面向对象是先有数据结构，然后再有算法。
面向对象思想：
1：分类是人们认识世界的一个很自然的过程，在日常生活中会不自觉地进行分类，面向对象符合人们看待事物的一般规律。
对象两点特征：
*.属性：用来描述对象的特征。比如，车：品牌，颜色，价格等
*.方法：告诉外界对象的功能(行为)。比如，车：发动，停止，加速等
注：每个对象的每个属性都拥有特定值(不同的汽车)
属性为方法的基础,大的对象的属性可以是一个对象
对象是用来描述客观事物的一个实体,由一组属性和方法构成。对象的属性和方法通常被封装在一起,共同体现事物的特征，二者依赖
2：类是具有相同属性和方法的一组对象的集合
类是对象(客观事物)的模板(抽象)，通过类来看待对象。确定生成的对象会拥有什么样的属性和方法
区分：对象(本身)、对象的实现者、对象的调用者。
3：使用对象一般从调用它的方法，对象方法对于其他对象来说，方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。
4:在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。
开发过程是用多个简单的对象的多个简单的方法，来实现复杂的功能 。
从语法上来看，一个类是一个新的数据类型。
在面向对象编程中，除了简单数据类型，剩下就是对象类型。
5:对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）,这样才能使每个对象本身做成最好的。
对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。
实现高内聚就是要最大限度的提高复用性（复用性好是因为高内聚）。可复用性是OOP的基础。
例如：一个项目组，有需求组，设计组，开发组，测试组，客户组。我们作为项目组不同组的成员，就具有在自己组的特性是我们强项，比如开发组的组员就很擅长开发，解决开发问题。这样我们作为项目组(系统)的不同成员(各部分)，各司其职、各尽所能。
用类来生成对象的语句：
Student s=new Student()。
第一个Student表示这是用Student类进行定义。
"Student()"表示调用一个无参数的构造方法。如果()中有参数，则系统构造对象的过程中调用有参的方法。
此时S称为一个对象变量。
Student s的存储区域存放的是地址：一个对象在内存上占有一个连续地址，首地址赋予s空间。
S称为对象Student的引用。
注意：在对象变量中存放的是引用(地址)；在简单变量中存放的是数值。
多态：多态指的是编译时类型变化，而运行时类型不变。
多态分两种：
① 编译时多态：编译时动态重载；
② 运行时多态：指一个对象可以具有多个类型。
对象是客观的，人对对象的认识是主观的。
例：
Animal a=new Dog()；查看格式名称；
Dog d=(Dog)a。声明父类来引用子类。(？？？)
运行时多态的三原则：（应用时为覆盖）
1、对象不变；（改变的是主观认识）
2、对于对象的调用只能限于编译时类型的方法，如调用运行时类型方法报错。
在上面的例子中：
Animal a=new Dog()；
对象a的编译时类型为Animal，运行时类型为dog。
注意：编译时类型一定要为运行时类型的父类（或者同类型）。运行时的变量仍然为编译时类型变量，不会覆盖。
对于语句：
Dog d=(Dog)a。将d强制声明为a类型，此时d为Dog()，此时d就可以调用运行时类型。注意：a和d指向同一对象。
3、在程序的运行时，动态类型判定。运行时调用运行时类型，即它调用覆盖后的方法。
关系运算符：instanceof
a instanceof Animal;(这个式子的结果是一个布尔表达式)
a为对象变量，Animal是类名。
上面语句是判定a是否可以贴Animal标签。如果可以贴则返回true，否则返回false。
在上面的题目中： a instanceof Animal返回 True， a instanceof Dog也返回 True，
instanceof用于判定是否将前面的对象变量赋值后边的类名。
Instanceof一般用于在强制类型转换之前判定变量是否可以强制转换。
如果Animal a=new Animal()；
Dog d=Dog()a;
此时编译无误，但运行则会报错。
Animal a=new Dog()相当于下面语句的功能：
Animal a=getAnimal()；
Public static Animal.getAnimal;
Return new Dog()；
JAVA的核心概念：接口（interface）
接口与类属于同一层次，实际上，接口是一种特殊的抽象类。
与类相似，一个文件只能有一个public接口，且与文件名相同。
在一个文件中不可同时定义一个public接口和一个public类。
一个接口中，所有方法为公开、抽象方法；所有的属性都是公开、静态、常量。
一个类实现一个接口的格式：
class IAImple implements IA{
};
一个类实现接口，相当于它继承一个抽象类。
类必须实现接口中的方法，否则其为一抽象类。
实现中接口和类相同。
接口中可不写public，但在子类中实现接口的过程中public不可省。
（如果剩去public则在编译的时候提示出错：对象无法从接口中实现方法。）
注：
① 一个类除继承另外一个类，还可以实现接口；
class IAImpl extends java.util.Arrylist implement IA{}
继承类 实现接口
这样可以实现变相的多继承。
② 一个类只能继承另外一个类，但是它可以继承多个接口，中间用“，”隔开。
Implements IA,IB
所谓实现一个接口，就是指实现接口中的方法。
③ 接口和接口之间可以定义继承关系，并且接口之间允许实现多继承。
例：interface IC extends IA,IB{};
接口也可以用于定义对象
IA I=new IAImpl();
实现的类从父类和接口继承的都可做运行时类型。
IAImple extends A implement IA,IB
IB I=new IAImple();
I instance of IAImple;
I instance of A;
I instance of IA;
I instance of IB;
返回的结果均为true.
接口和多态都为JAVA技术的核心。
接口往往被我们定义成一类XX的东西。
接口实际上是定义一个规范、标准。
① 通过接口可以实现不同层次、不同体系对象的共同属性；
通过接口实现write once as anywhere.
以JAVA数据库连接为例子：JDBC制定标准；数据厂商实现标准；用户使用标准。
接口通常用来屏蔽底层的差异。
②接口也因为上述原因被用来保持架构的稳定性。