抽象类和接口

                                                抽象类和接口

一：抽象类

指在类中定义方法，但是在类中不去实现它，而在它的子类中去具体实现，继承抽象类的子类必须实现父类的抽象方法，除非子类是一个被定义的抽象类。

在定义抽象类是要注意，包含抽象方法的类必须为声明为抽象类，但抽象类可以不包含任何抽象方法，只需使用abstract修饰即可。另为抽象类是不可以别实例化的，因为抽象类中有可能包含抽象方法，抽象方法是没有方法体的，不可以被调用，如果要想定义抽象类中定义的方法，则需要创建一个子类，崽子类中将抽象类中的抽象方法实现。

//定义一个抽象类
abstract class Animal{ 
//定义抽象方法shout() 
abstract void shout(){ 

    } 
} 
//定义Dog类继承抽象类
Animal class Dog extends Animal{
//实现抽象方法 
    void shout（）{ 
        System.out.println("狗叫声……旺旺");
     } 
} 
//定义测试类
public class Excemple{ public static void main(String []args){ 
    Animal A=new Animal(); //创建实例化对象 
    A.shout(); //调用Animal的shout方法
     }
 }

子类实现了父类的抽象方法后，可以正常进行实例化。

二：接口

接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。如果实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情。

如果一个类中所有的方法都是抽象的，则可以将这个类用另外一种方式来定义，即接口，在定义接口时，需要使用interface关键字来声明。

//定义接口 
interface Animal{
    int age=5; //定义局部变量 
    void reading(); //定义抽象方法 
    void run();
}

从上面的这个例子可以看出，抽象方法reading()并没有使用abstract关键字修饰，这是因为接口中定义的变量和方法都包含一些默认的修饰符，接口中定义的方法默认使用“public abstract”来修饰，即抽象方法接口中的变量默认使用“public static final”来修饰，即全局变量。

由于接口中方法都是抽象方法，因此不能使用实例化对象的方式来调用接口中的方法，此时需要定义一个类，并使用implement关键字来实现接口中的所有方法。

//定义接口 
interface Test{ 
    int age=5; //定义局部变量 
    void reading(); //定义抽象方法 
    void run(); } 
//Demo类实现Test接口 
class Demo implement Test{ 
    //实现reading方法 
    public void reading(){ 
        System.out.println("reading方法"); 
    } 
//实现run方法 
public void run(){
     System.out.println("run方法"); 
    } 
} 
//定义测试类 
public class Example{ 
    public static void main(String []args){ 
        Demo d=new Demo(); 
        d.reading(); //调用Demo类的reading方法 
        d.run(); 
    } 
}

可以看出Demo在实现了Test接口后是可以被实例化的。

1.抽象类和接口的区别

参数	抽象类	接口
默认方法的实现	它可以有默认的方法实现	接口完全是抽象的。它根本不存在方法的实现
实现	子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。	子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
构造器	抽象类可以有构造器	接口不能有构造器
与正常Java类的区别	除了你不能实例化抽象类之外，它和普通Java类没有任何区别	接口是完全不同的类型
访问修饰符	抽象方法可以用public、protected、default这些修饰符修饰	接口方法默认修饰符是public。不可以使用其它修饰符来修饰。
main方法	抽象方法可以有main方法	接口没有main方法，因此我们不能运行它。
多继承	抽象方法可以继承一个类和实现多个接口	接口可以继承一个或多个接口
添加新方法	如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。	如果你往接口中添加方法，那么你必须改变实现该接口的类。

2.抽象类和接口的使用

1.当想拥有一些方法并且想让它们中的一些有默认实现，那么这时候就可以使用抽象类。

2.如果像实现多重继承，则必须使用接口。由于Java中不支持多继承，所以子类不能够继承多个类，但是可以实现多个接口。因此可以使用接口来解决。

3.如果设计的功能或者行为需要不断地变化，那么就需要使用抽象类。如果不断改变功能或者行为并且使用接口，那么就需要改变所有实现了该接口的类。

3.接口多继承实例

//定义接口 
interface Test{ 
    int age=5; //定义局部变量 
    void reading(); //定义抽象方法 
    void run(); 
} 
//定义LandTest接口，继承自Test 
interface LandTest extends Test{ 
    void livestream(); 
} 
//Demo类实现Test接口 
class Demo implement LandTest { 
    //实现reading方法 
    public void reading(){ 
        System.out.println("reading方法"); 
} 
//实现run方法 
public void run(){ 
    System.out.println("run方法"); 
} 
//实现livestream方法 
public void livestream(){ 
    System.out.println("livestream方法");
     } 
} 
//定义测试类 
public class Example{ 
    public static void main(String []args){ 
        Demo d=new Demo(); 
        d.reading(); //调用Demo类的reading方法 
        d.run(); 
        d.livestream(); 
    } 
}

LandTest 接口继承了Test接口，因此LandTest 继承了三个接口方法，当Demo 类实现LandTest接口中的方法时，需要实现两个接口中的三个方法。

接口特点：

     1.接口中的方法都是抽象，不能实例化。

     2.当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法。

     3.一个类implement关键字实现接口时，可以实现多个接口，被实现的多个接口之间需要使用逗号隔开。

举例：

interface Run{ 
    程序代码…… 
} 
interface FLy{ 
    程序代码…… 
} 
class Bird implements Run,Fly{ 
    程序代码…… 
}

一个接口可以通过extends关键字继承多个接口，接口之间通逗号隔开，如下：

interface Runing{ 
    程序代码…… 
} 
interface Flying{ 
    程序代码…… 
} 
interface Eating extends Rubing,Flying{ 
    程序代码 
}

一个类在继承另一个类的同时换可以实现接口，此时，extends关键字必须位于implement关键字之前，如下

class Demo extends Caniade implement Test{       //先继承，在实现 
    程序代码…… 
}