抽象，接口和Object类

　　　在面向对象的概念中，所有的对象都是通过类来表述的，但并不是所有的类都是用来描绘对象的，如果一个类中么有包含足够的信息来描绘一类具体的对象，这样的类就是抽象类。抽象类往往用来表征对问题领域进行分析、设计中得出抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。抽象类对其共通行为提供规范，但并不实现，而将其具体实现放到子类中完成，通过“abstract”关键字描述。

举个栗子：

定义一个平面图形类Shape，任何平面图形都有周长和面积。

public abstract class Shape {
double dim;
public Shape(double dim){
this.dim = dim;
} 
//抽象方法， 获得面积
public abstract void callArea();
//抽象方法， 获得周长
public abstract void callPerimeter();
}

抽象方法：

从语法层面上看，在java中凡是用到abstract修饰的类都是抽象类。在java中，如果某个方法没有提供方法体实现，这种方法称为抽象方法。包含一个或者多个抽象方法的类叫做抽象类。
抽象类还可以包含具体数据和具体的方法，也可以包括构造方法。定义抽象类的目的是提供可由其子类共享的一般形式，子类可以根据自身需要扩展抽象类。

举个栗子：

定义Shape的一个子类Circle来演示抽象类的使用

 1 public class Circle extends Shape{
 2 public Circle(double dim) {
 3 super(dim);
 4 }
 5 //实现父类的抽象方法
 6 @Override
 7 public void callArea() {
 8 System.out.println("圆的面积="+3.14*dim*dim);
 9 }
10 //实现父类的抽象方法
11 @Override
12 public void callPerimeter() {
13 System.out.println("圆的周长="+2*3.14*dim);
14 }
15 }

抽象类除了使用abstract关键字定义实现，还可以通过继承实现，即该类在继承一个抽象类或者接口的时候，没有为所有抽象方法提供实现细节或方法主体时，当前类也是抽象类。

 1 public abstract class Circle extends Shape{
 2 public Circle(double dim) {
 3 super(dim);
 4 }
 5 //实现父类的抽象方法
 6 @Override
 7 public void callPerimeter() {
 8 System.out.println("圆的周长="+2*3.14*dim);
 9 }
10 }

接口：

抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更彻底，则可以抽象出一种更特殊的“抽象类”----接口(interface)，接口里不能含有普通的方法，接口里的方法必须是抽象方法。

和类定义不同，定义接口不能用class关键字，而是使用interface关键字，其语法为：

1 [访问修饰符] interface 接口名称[extends 父类接口名表]{
2 [访问修饰符] final 数据类型 常量名 = 值； //常量声明
3 [访问修饰符] 返回值类型 方法名(参数列表)； //抽象方法
4 }

举个栗子：

1 public interface Shape {
2 //面积
3 double area = 100.0;
4 //画出自己
5 void draw();
6 //得到面积
7 double getArea();
8 }
因为所有定义在接口中的常量都默认为public static final ， 所有定义在接口中的方法默认为public abstract。 所以可以不用修饰符限定它们。

接口的实现：

多个无关的类可以实现同一个接口；
一个类可实现多个无关的接口；

<modifier> class <name> [extends <superclass>]
[implements<interface>[,<interface>]*]
{
<declarations>*
}

因为Java 是基于单根继承的，即Java 继承中，只能继承一个类，在Java中，可以通过接口来模拟多继承；
自定义Circle类，实现Shape接口：

public class Circle implements Shape{
@Override
public void draw() {
System.out.println("draw a circle...");
}
@Override
public double getArea() {
//area = 200.0;//error 常量的值不可被改变
return area;
}
 public static void main(String[] args) {
Shape shape = new Circle();
shape.draw();
System.out.println(shape.getArea());
}
}

接口实现的一些注意事项：
在类的声明部分，用implements关键字声明将要实现那些接口；

接口里的抽象方法访问修饰符都已指定为public，因此，类在实现方法时，必须显示地使用public修饰符，否则，将缩小接口定义方法的访问控制范围。
如果实现某接口的类不是abstract类，则在类的定义部分里必须全部实现指定接口的所有抽象方法，而且方法头部分应该与接口中的定义完全一直；
如果实现某接口的类是abstract类，则它可以不实现该接口所有的方法，但其非abstract的子类必须有所有抽象方法的实现的方法体；

Object类

Object类是所有Java类的基类或根类，所有类的对象(包括数组对象)都继承了Object的方法。

如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类。

1 public class Animal{
2 .........
3 } 
4 等价于：
5 public class Animal extends Object{
6 .........
7 }

Object类常用方法：

方法	含义
boolean equals(Object obj)	指示某个其他对象是否与此对象“相等”；
String toString()	返回该对象的字符串表示；
int hashCode()	返回该对象的哈希码值；
Object clone()	创建并返回此对象的一个副本；
void finalize()	当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法；

toString 方法：

Object类中定义有public String toString()方法，其返回值是String类型，描述当前对象有关的信息；
在进行String与其他类型数据的连接操作时(如：System.out.println(“info”+person))，将自动调用该对象类的toString(()方法；
可以根据需要在用户自定义类型中重写toString()方法；
一个字符串和另外一种类型连接的时候，另外一种类型会自动转换成String类型，然后再和字符串连接；

举个栗子：

1 public class TestToString {
2 public static void main(String[] args) {
3 Duck d = new Duck();
4 
5 // 输出的结果：
6  Duck@e0a386
7 System.out.println(d);
8 }
9 }
如果没有重写toString方法， 那么输出来的默认的字符串内容是”类名+哈希编码”；

重写toString方法例子：
为了使打印出来的信息能看懂，那么在Duck类里面把继承下来的toString()方法进行重写：

public class Duck {
//重写object类的toString()方法
@Override
public String toString() {
return "I'm a cool Duck";
} 
public static void main(String[] args) {
Duck d = new Duck();
System.out.println(d);
// 输出的结果： I'm a cool Duck
}
}

equals 方法：

判断两个对象是否相等，是要看两个对象引用是否指向同一个对象，“是”则返回true,“否”则返回false。

Java语言规范要求equals方法具有以下特点：

自反性对于任何非空引用值，x.equals(x)都应返回true；
对称性对于任何非空引用值x和y，当且仅当y.equals(x)返回true时，x.equals(y)才应返回true；
传递性对于任何非空引用值x、y和z，如果x.equals(y)返回true，并且y.equals(z)返回true，那么x.equal(z)应返回true；
一致性对于任何非空引用值x和y，多次调用x.equals(y)始终返回true或始终返回false，前提是对象上equals比较中所用的信息没有被修改；
对于任何非空引用值，x，x.equals(null)都应返回false；

Object下的equals方法源码：

1 public boolean equals(Object obj) {
2       return (this == obj);
3 }
通常自定义的对象， 需要重写equals方法， 比较的结果才会为真。

举个栗子 equals ：

1 public class TestEquals{
2 public static void main(String args[]){
3 String s1=new S ring("hello");
4 String s2=new String("hello");
5 System.out.println(" 1==c2: "+(s1==s2));//false
6 System.out.println("s1.equals(s2): "+s1.equals(s2));//true
7 }
8 }

equals与“==” ：

“==”操作符的作用：
1）用于基本数据类型的比较；
2）判断引用是否指向堆内存的同一块地址；
equals的作用：
用于判断两个变量是否是对同一个对象的引用，即堆中的内容是否相同，返回值为布尔类型；

举个栗子：

1      String s1 = new String("java);
2      String s2 = new String("java");
3     System.out.println(s1==s2); //false
4     System.out.println(s1.equals(s2)); //true

同一个对象， “==”和equasl结果相同：

1     String s1 = new String("java");
2     String s2 = s1;
3     System.out.println(s1==s2); //true
4     System.out.println(s1.equals(s2)); //true

如果值相同，对象就相同，所以“==”和equals结果一样 :

1     String s1 = "java";
2     String s2 = "java";
3     System.out.println(s1==s2); //true
4     System.out.println(s1.equals(s2)); //true