java中的抽象类和接口

java中的抽象类和接口

一、抽象类：

1、什么是抽象类？

Java中可以定义没有方法体的方法，方法的具体实现由子类完成，方法称为抽象方法，包含抽象方法的类就是抽象类。

2、抽象类和抽象方法分别是怎样定义的？

抽象类：访问修饰符abstractclass 类名{……}

抽象方法： 访问修饰符abstract返回类型 方法名(参数列表)

public abstract class Shape  
{  
    private String color;  
    
    //定义一个计算周长的抽象方法  
    public abstract double calPerimeter();  
    
    //定义一个返回形状的抽象方法  
    public abstract String getType();  
  
    //定义Shape的构造器，该构造器并不是用于创建Shape对象，而是用于被子类调用  
    public Shape(){}  
    public Shape(String color)  
    {  
        System.out.println("执行Shape的构造器...");  
        this.color = color;  
    }  
  
    public void setColor(String color)  
    {  
        this.color = color;  
    }  
    public String getColor()  
    {  
         return this.color;  
    }  
} 

3、抽象类和抽象方法的特点有哪些？

（1）抽象类和抽象方法都通过abstract关键字来修饰；

（2）抽象类不能实例化；抽象类可以没有、有一个或多个抽象方法，甚至全部方法都可以是抽象方法；

（3）抽象方法只有方法声明，没有方法实现；

（4）有抽象方法的类必须声明为抽象类；

（5）子类必须重写所有抽象方法才能实例化，否则子类还是一个抽象类。

/**
 *  抽象类Shape的继承类Triangle
 */
public class Triangle extends Shape  
{  
    //定义三角形的三边  
    private double a;  
    private double b;  
    private double c;  
  
    public Triangle(String color , double a , double b , double c)  
    {  
        super(color);  
        this.setSides(a , b , c);  
    }  
  
    public void setSides(double a , double b , double c)  
    {  
        if (a >= b + c || b >= a + c || c >= a + b)  
        {  
            System.out.println("三角形两边之和必须大于第三边");  
            return;  
        }  
        this.a = a;  
        this.b = b;  
        this.c = c;  
    }  
    
    //重写Shape类的的计算周长的抽象方法  
    public double calPerimeter()  
    {  
        return a + b + c;  
    }  
    
    //重写Shape类的的返回形状的抽象方法  
    public String getType()  
    {  
        return getColor() + "三角形";  
    }  
}  

4、抽象类和一般类的异同点有哪些？

相同点：抽象类和一般类都是用来描述事物的，都是内部定义了成员。

不同点：a、一般类有足够的信息描述事物；抽象类中描述的信息可能不足。  b、一般类不能定义抽象方法，只能定义非抽象方法；抽象类可以定义抽象方法，也可以定义非抽象方法。  c、一般类可以实例化；抽象类不可以实例化。

5、抽象的关键字不可以和哪些关键字共存？

• 
  
• final：被final修饰的类不能有子类。而abstract修饰的类一定是父类。
• 
  
• private：抽象类中的私有的抽象方法，不能被子类所知，也就无法复写，而抽象方法的出现就是要被复写。
• 
  
• static：如果static修饰抽象方法，那么对象都不用new了。直接类名.方法名调用就行了。

二、接口：

1、什么是接口？

接口是一种规范和标准，它们可以约束类的行为，是一些方法特征的集合，但是没有方法的实现。接口可以看作是一种特殊的“抽象类”，但是采用完全不同的语法来表示，两者的设计理念是不同的，抽象类利于代码复用，接口利于代码扩展和维护。

2、接口是如何定义的？

interface 接口名{}

/**
 *   java中的抽象类和接口————二、 2、接口是如何定义的？
 */
public interface Output  
{  
    //接口里只能定义常量  
    int MAX_CACHE_LINE = 50;  
    
    //接口里定义的只能是public的抽象实例方法，没有方法体  
    void out();  
    void getData(String msg);  
}  

3、类是如何实现接口的？

class 类名 implements 接口名{}

/**
 *  java中的抽象类和接口————二、 3、类是如何实现接口的？
 */
interface Product  
{  
    int getProduceTime();  
}  


//让Printer类实现Output和Product接口  
public class Printer implements Output , Product  
{  
    private String[] printData = new String[MAX_CACHE_LINE];  
    
    //当前需打印的作业数  
    private int dataNum = 0;  
    
    public void out()  thre
    {  
        //只要还有作业，继续打印  
        while(dataNum > 0)  
        {  
            System.out.println("打印机打印：" + printData[0]);  
            //把作业队列整体前移一位，并将剩下的作业数减1  
            System.arraycopy(printData , 1, printData, 0, --dataNum);  
        }  
    }  
    
    public void getData(String msg)  
    {  
        if (dataNum >= MAX_CACHE_LINE)  
        {  
            System.out.println("输出队列已满，添加失败");  
        }  
        else  
        {  
            //把打印数据添加到队列里，已保存数据的数量加1。  
            printData[dataNum++] = msg;  
        }  
    }  
    public int getProduceTime()  
    {  
        return 45;  
    }  
  
    public static void main(String[] args)  
    {  
        //创建一个Printer对象，当成Output使用  
        Output o = new Printer();  
        o.getData("xx5541336");
        o.getData("xx5541337");
        o.out();//这里利用了多态的特点  
        o.getData("xx5541338");  
        o.getData("xx5541339");  
        o.out();  
        //创建一个Printer对象，当成Product使用  
        Product p = new Printer();  
        System.out.println(p.getProduceTime());  
        //所有接口类型的引用变量都可直接赋给java.lang.Object类型的变量  
        Object obj = p;  
    }  
}  

4、接口的意义？

规范子类的行为，可以为定义标准提供编程支持，为代码的动态性提供更加灵活的类型匹配和识别标准，接口可以定义为引用，指向任何一个实现了该接口的类的实例对象；技术支持：动态绑定，抽象类型的引用，根据所指向的具体实现对象不同，而动态的改变。

三、抽象类和接口的区别：

抽象类是 含有abstract修饰符的class，abstract类不能创建实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体子类中实现，所以不能有抽象构造方法或抽象静态方法。如果子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

接口可以说成是抽象类的一种特例，接口中的所有方法必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。

语法区别：

（1）抽象类可以有构造方法，接口中不能有构造方法；

（2）抽象类中可以有普通成员变量，接口中没有普通成员变量；

（3）抽象类中可以包含非抽象的普通方法，接口中的所有方法都必须是抽象的，不能有非抽象的普通方法；

（4）抽象类中的抽象方法的访问类型可以是public、protected和默认作用域（不建议使用，因为默认作用域不能被其它包中的子类继承），接口中的方法只能是public类型的，并且默认即为public abstract类型；

（5）抽象类中可以包含静态方法，接口中不能包含静态方法；

（6）抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型；

（7）一个类可以实现多个接口，但只能继承一个抽象类。