Java学习日记之类和对象还要掌握：抽象类和接口

Java中，有一种类天生只能作为父类出现。
这种类就是抽象类。
抽象类是一种特殊的类，他不能生成对象，只能作为父类而存在，抽象类具有高度抽象的特征，为所有的子类提供统一的抽象方法，在子类中抽象类可以一不同的形式实现，而信息传递的接口保持一致。
**创建抽象类**
关键字abstract修饰的类为抽象类，抽象类是只有定义而无法实现对戏那个的类，抽象类只关心所应实现的功能，而不对功能细节做考虑。
语法如下：

abstract class animal
{
//抽象类类体
}

abstract所修饰的方法为抽象方法，抽象方法在形式上仅有方法的方法头部，而没有方法体。
如：

abstract void show();

抽象方法只是定义功能而不实现，这就决定了抽象方法只能在父类派生子类的时候才能通过覆盖实现。抽象类中可以没有抽象方法，但是抽象方法只能在抽象类中。如果抽象类派生出一个非抽象的子类，因为非抽象子类可以创建对象，所以在子类中必须覆盖掉父类中的所有抽象方法，否则只能将子类定义为抽象类。
示例1：

public static void main(String[] args) {
// TODO Auto-generated method stub
dog myDog = new dog();
myDog.show();
}

}
abstract class animal
{
//抽象类类体
abstract void show();
}
class dog extends animal
{
public void show()
{
System.out.println("wangwang!");
}
}

dog类继承于animal类，animal类中有抽象方法show(),子类中必须实现，所以子类必须覆盖该父类中的show类，否则就只能将dog类改为抽象类，但是抽象类无法生成对象，是无法实现show()方法的。
我们在写大程序的时候，一般是先设计最顶层、最抽象的类和方法，然后逐步实现细节化的类和方法。这种设计方法由粗到细，容易理解和分析。
**接口**
在实际的程序设计中，我们往往会遇到这样的情况：有的了既需要继承子一个父类，有需要继承另一个父类，而Java中不允许多继承，这就导致了设计的麻烦。
为此，Java中定义了一种特殊的类，称之为接口，用来实现多继承。有了接口，子类就可以继承自多个接口而实现多重继承了。
接口实际上就是一种特殊的抽象类，定义特殊，其内部只能包含静态常量和抽象方法。接口的定义和使用与常规的类有所不同。
接口的声明：

interface inte
{
//类体，只能由静态常量和抽象方法组成。
}

接口中的常量默认为public static final 类型，如果接口中定义：
double PI = 3.14；
则实际上为：
public static final double PI = 3.14；
我们声明一个示例接口如下：

interface inte
{
double PI = 3.14;
abstract void out();
}

如同其他类，接口可以继承父类接口的成员变量和方法。因为接口支持多重继承，所以接口之间可以有多个父类。通过继承，一个接口可以继承父接口中的所有成员变量和方法。
接口的多重继承：

interface 接口名 extends 父接口1，父接口2，父接口3······
{
//
}

我们定义接口就是为了实现它的多重继承。要使抽象类发挥功能，必须通过非抽象子类覆盖父类中的所有抽象方法来生成对象。在Java中，要让接口发挥其功能，需要定义一个子类，实现并覆盖掉接口中的所有抽象方法，这就是接口的实现。实现接口就是通过关键字implements来声明的：

class 类名 implements 接口名
{
//接口的实现方法。
}

示例2：

public class InterfaceExample {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
sonClass myClass = new sonClass();
myClass.out();
}
}
interface inte
{
double PI = 3.14;
abstract void out();
}
class sonClass implements inte
{
public void out()
{
System.out.println(PI);
}
}

**对象的复制**
对象之间可以复制，如同变量的复制形。同一个类的不同对象引用之间可以任意相互赋值。
对象的赋值一般有两种形式：第一种就是已经生成了对象直接赋值，例如：
mycalss m1,m2;
m1 = new mycalss();
m2 = m1;
第二种就是采取集成接口Cloneable,并覆盖clone()方式，实现复制。
示例3：

public class InterfaceExample {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
CloneClass cc1,cc2,cc3;
cc1 = new CloneClass();
cc2 = cc1;
cc2.i =2;
System.out.println(cc1.i+"----------"+cc2.i);
cc3 = (CloneClass)cc1.clone();
cc3.i=3;
System.out.println(cc1.i+"----------"+cc2.i+"----------"+cc3.i);
}

}
class CloneClass implements Cloneable
{
public int i;
public Object clone()
{
CloneClass c = null;
try{
c=(CloneClass)super.clone();
}catch(CloneNotSupportedException e){}
return c;
}
}

**对象的上转型**
Java中，对象的转型就是之具有继承关系的类之间可是出现对象转型。也就说父类型和子类型之间可以复制。
·子类的对象可以直接复制给父类的对象，这称之为上转型对象
·通过强制类型转换，也能讲父类对象赋值给子类对象。
示例4：

public class InterfaceExample {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
fatherClass fat;
sonClass son = new sonClass();
fat = son;                 //对象的上转型
fat.show();
son.show(3);
fatherClass fat2 = new fatherClass();
sonClass son2;
son2 = (sonClass)fat2;     //父类对象给子类对象赋值需要强制类型转换,而且需要抛出异常
son2.show(4);
fat2.show();
}
}
class fatherClass
{
void show()
{
System.out.println("father");
}
}
class sonClass extends fatherClass
{
void show(int i)
{
System.out.println("son");
}
}