Abstract是Java中的一个重要关键字，可以用来修饰一个类或者一个方法。修饰一个方法时，表示该方法只有特征签名（signature），没有具体实现，而是把具体实现留给继承该类的子类。一个类中只要有一个abstract方法，那么这个类就要被声明为abstract，但是其中可以有非 abstract方法。
   abstract类可以使得类的设计者能够创建方法的原型，而真正的实现留给使用这个类的人。
   继承一个abstract类的子类，要么实现父类的所有abstract方法，要么也声明为abstract类，这时仍然可以保留一些abstract方法，把具体实现留给下一级的子类。
    abstract类和接口一样,不能创建它们的实例.一个抽象类即使有公共的构造函数,也无法通过new直接创建实例.因为既然它是抽象类,就至少有一个抽象方法,因此必须创建该抽象类的一个子类(通常为内部匿名类)实现其中的抽象方法 。




范例1:

abstract class shape
{
 String color;
 public void setcolor(String scolor)
 {
   color=scolor;
 }
 abstract void show();
}
class rectangle extends shape
{
 int w,h;
 public rectangle(int w1,int h1)
 {
  w=w1;
  h=h1;
  
 }
 public void show()
 {
  System.out.println("color="+color);
  System.out.println("area="+w*h);
  
 }
}
public class abstractc
{
 public static void main(String args[])
 {
  rectangle myrectangle=new rectangle(5,10);
  myrectangle.setcolor("red");
  myrectangle.show();
    }
}

范例2:

abstract class shape
{
 String color;
 public void setcolor(String scolor)
 {
   color=scolor;
 }
 abstract void show();
}
class rectangle extends shape
{
 int w,h;
 public rectangle(int w1,int h1)
 {
  w=w1;
  h=h1;
  
 }
 public void show()
 {
  System.out.println("color="+color);
  System.out.println("area="+w*h);
  
 }
}
public class abstractc
{
 public static void main(String args[])
 {
  shape shape1=new rectangle(5,10);
  shape1.setcolor("red");
  shape1.show();
    }
}

范例3:

abstract class shape
{
 String color;
 public void setcolor(String scolor)
 {
   color=scolor;
 }
 abstract void show();
}
class rectangle extends shape
{
 int w,h;
 public rectangle(int w1,int h1)
 {
  w=w1;
  h=h1;
  
 }
 public void show()
 {
  System.out.println("color="+color);
  System.out.println("area="+w*h);
  
 }
}
public class abstractc
{
 public static void main(String args[])
 {
  shape myshape[];
  myshape=new shape[2];
  myshape[0]=new rectangle(5,10);
  myshape[0].setcolor("red");
  myshape[0].show();
  myshape[1]=new rectangle(5,10);
  myshape[1].setcolor("white");
  myshape[1].show();
  
    }
}

 

 



java中abstract的用法


abstract（抽象）修饰符，可以修饰类和方法

1，abstract修饰类，会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类就像当于一类的半成品，需要子类继承并覆盖其中的抽象方法。

2，abstract修饰方法，会使这个方法变成抽象方法，也就是只有声明（定义）而没有实现，实现部分以"；"代替。需要子类继承实现（覆盖）。

注意：有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。

abstract修饰符在修饰类时必须放在类名前。

abstract修饰方法就是要求其子类覆盖（实现）这个方法。调用时可以以多态方式调用子类覆盖（实现）后的方法，也就是说抽象方法必须在其子类中实现，除非子类本身也是抽象类。

注意：父类是抽象类，其中有抽象方法，那么子类继承父类，并把父类中的所有抽象方法都实现（覆盖）了，子类才有创建对象的实例的能力，否则子类也必须是抽象类。抽象类中可以有构造方法，是子类在构造子类对象时需要调用的父类（抽象类）的构造方法。
举个简单的例子下面有一个抽象类

abstract class E{
public abstract void show();//public abstract 可以省略
}
然后其它类如果继承它通常为了实现它里面的方法
class F extends E{
     void show(){
    //写具体实现的代码 
}
}


最后再主方法里面定义一个父类引用指向子类对象,就会发生多态现象,比如 

E e=new F();
e.show();


实际调用了子类里面的show()方法