标签：
在类前面使用 abstract 修饰的类就是抽象类
（1）在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
（2）从多个具有相同特征的子类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。
限制规定子类必须实现的某些方法，但不关注实现细节。
（1）使用abstract定义抽象类
（2）abstract定义抽象方法，只有声明，不需要实现
（3）抽象类中可包含一般方法，不一定包含抽象方法，但包含抽象方法的类一定要声明为抽象类
（4）抽象类中定义构造方法是多余的
（5）抽象类不能直接创建，可以定义引用变量
（6）abstract 不能与private、static、final、或native并列修饰同一方法
（7）若一个类被定义为抽象类，则该类就不能用new运算符创建具体实例对象，而必须用覆盖的方式来实现抽象类中的方法
如对于几何形状，是一个抽象的概念，由此可派生出"长方形"、“圆形”等具体的几何形状，所以把形状（Shape）定义为抽象的父类。此外，如果要规定每个形状类都编写计算其面积和长度的方法。由于每个具体的几何形状的面积和周长计算方法不同，所以放在父类不恰当。可以将其定义为抽象方法，具体处理方式放在子类中定义
public class demo1 {
/**
* @param args
*/
public static void main(String[] args) {
Shape rec = new Rectangle("长方形", 3.5, 5); //声明父类对象，指向子类对象
System.out.print("面积="+rec.getArea());
System.out.println("周长="+rec.getLength());
Circle cir = new Circle("圆", 3.5);
System.out.print("面积="+cir.getArea());
System.out.print("周长="+cir.getLength());
}
}
abstract class Shape{ //定义抽象类Shape
protected String name;
public Shape(String xm)
{
name = xm;
System.out.println("名称："+name);
}
abstract public double getArea(); //声明抽象方法
abstract public double getLength();
}
class Circle extends Shape //定义继承来自Shape的子类Circle
{
private final double PI = 3.14;
private double radius;
public Circle(String shapeName,double r) //构造方法
{
super(shapeName);
radius=r;
}
public double getArea() {
return PI*radius*radius;
}
public double getLength() {
return 2*PI*radius;
}
}
class Rectangle extends Shape //定义继承来自Shape的子类Rectangle
{
private double width;
private double height;
public Rectangle(String shapeName,double width,double height)
{
super(shapeName);
this.width = width;
this.height = height;
}
public double getArea() {
return width*height;
}
public double getLength() {
return 2*(width+height);
}
}
接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类方法的具体实现，它只规定这些类里必须提供的某些方法。
接口实际上就是一种特殊的抽象类。
使用 interface 关键字：
[修饰符] interface 接口名[extends 父接口1，父接口2……]
{
0个~多个常量定义
0个~多个抽象方法定义
}
接口中的方法只能是抽象方法，总是使用，即使定义时不添加public abstract修饰符，系统也是默认加上的。
（1）接口的数据成员必须初始化
（2）接口中的方法必须全部声明为 abstract ，接口的方法必须全部是抽象方法
格式固定，不能改变extends和Implements顺序的调换。
生成接口:
也可以自己写
1 public class demo1 { 2 /** 3 * @param args 4 */ 5 public static void main(String[] args) { 6 IShape cir = new Circle(3.5); 7 System.out.print("面积="+cir.getArea()); 8 System.out.println("周长="+cir.getLength()); 9 Rectangle rec = new Rectangle(3.5, 5); //声明父类对象，指向子类对象 10 System.out.print("面积="+rec.getArea()); 11 System.out.println("周长="+rec.getLength()); 12 13 } 14 } 15 16 interface IShape { 17 final double PI = 3.14; 18 abstract double getArea(); //声明抽象方法 19 abstract double getLength(); 20 21 } 22 23 24 25 class Circle implements IShape //以IShape接口来实现Circle类 26 { 27 private double radius; 28 public Circle(double r) //构造方法 29 { 30 this.radius=r; 31 } 32 public double getArea() { 33 return PI*radius*radius; 34 } 35 public double getLength() { 36 return 2*PI*radius; 37 } 38 39 } 40 41 class Rectangle implements IShape //以IShape接口来实现Circle类 42 { 43 private double width; 44 private double height; 45 public Rectangle(double width,double height) 46 { 47 this.width = width; 48 this.height = height; 49 } 50 public double getArea() { 51 52 return width*height; 53 } 54 public double getLength() { 55 56 return 2*(width+height); 57 } 58 }
与类相似，接口也有继承性，定义接口时可通过extend关键字声明该新接口是某个已存在父接口的子接口，将继承父接口的所有变量和方法。
与类的继承不同的地方是，一个接口可以有一个以上的父接口，之间用“，”隔开。若子接口中定义了与父接口同名的常量或者相同方法，将覆盖。
内部类是定义在类中的类，主要作用是将逻辑上相关的类放在一起；而匿名类是一种特殊的内部类，没有类名，在定义类的同时，就生成该类的实例，由于不会再其他地方用到该类，所以不用取名字。
标签：
原文地址：http://www.cnblogs.com/Kevin127/p/4984539.html
