本文详细介绍了Java中的抽象类和接口的概念，包括抽象方法、抽象类的特性，以及接口的定义、属性、实现和继承。通过抽象工厂模式的实例，展示了抽象类和接口在实际编程中的应用，强调了它们在多态性和类型安全性方面的作用。
1.概念
1.1抽象类的概念
1.1.1抽象方法
抽象方法是出现在基类中的一种方法，但要求在派生类中被重写。一个抽象方法只有方法头，没有方法主体。在Java中以关键字 abstract 修饰抽象方法。
public abstract void getArea();1.1.2抽象类
在面向对象的概念中，所有对象通过类来描述，但是反过来，并不是所有类都是用来描述对象的，如果一个类中没有包含足够的信息学来描述一个具体的对象，这个类就是抽象类。在Java中用关键字 abstract 修饰抽象类
public abstract class 类名
- 若类含有抽象方法，则类必须以abstract关键字声明为抽象类。
- 抽象类可以含零至多个普通方法，也可以含零至多个抽象方法
- 不论抽象类是否含有抽象方法，都不允许实例化，即不能创建抽象类的对象，因为其描述的是抽象概念。它只能作为其他类的基类。
- 若父类是抽象类，且子类不想成为抽象类，则子类必须将父类中的所有抽象方法重写为带方法体的普通方法否则子类仍必须是抽象类。
1.2接口的概念
1.2.1接口
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口定义的通用格式：
public inerface 接口名称
{
(方法头...)
}
- 接口中包含要实现的方法
- 接口不能被实例化，并且接口中所列的所有方法必须在别处被重写
- 接口的目的是为了给其他类提供行为说明
- 接口中的方法只有方法头加分号结尾，没有方法主体
1.2.2接口的属性
- 一个接口中可以有属性：接口中的所有属性都是public、final和static。
- 因为接口中的属性自动变为final，所以必须提供初始值。
public interface Doable
{
int FIELD1 = 1, FIELD2 = 2;
(Method headers...)
}
3.任何实现这个接口的类都可以访问这些变量
1.2.3接口的实现
- 一个接口可以被实现，一个实现类的接口，必须实现接口内的所有方法，否则就必须声明为抽象类。
- 如果一个类要实现接口，它需要在类头重使用implements关键字
public class RubberDuck extends Duck implements Quackable 3. Java允许一个类实现多个接口，当一个类实现多个接口时，它必须实现所有接口中的方法
4. 为了在类的定义中实现多个接口，需要写上关键字implements，并列出接口的名字，接口之间用逗号分隔。
public class MyClass implements Interface1,
Interface2,
Interface3
1.2.4接口的继承
- 与类的继承类似，接口之间也可以继承，
- 接口只能继承接口而不能继承类，
- 接口可以继承多个父接口，彼此以逗号隔开（父接口顺序可任意），表达的逻辑时子接口既是一种父接口1，也是一种父接口2，…
1.2.5多态性和接口
- Java允许创建接口类型的引用变量，接口引用变量可以存放任何实现该接口的对象的地址，不管类的类型，这是多态的另一个实例
- 不可创建接口的实例
- 当接口变量指向一个对象时，接口中声明的方法必须是有效的，当你想访问被接口引用变量所指向的对象的其他方法时，必须进行强制类型转换
2.抽象类与接口的比较
2.1关键字
抽象类关键字：abstract class
接口关键字：interface
2.2字段变量和方法
抽象类：变量无限制，方法既可以含普通方法，也可以含抽象方法
接口：所有的变量必须是public、static、final，可以包含public的抽象实例方法、public的默认方法以及public的静态方法，接口所有方法都是抽象方法并且是public的
2.3继承/实现
抽象类：只能被类或者抽象类继承，不支持多重继承
接口：既可以被接口继承也能被类或者抽象类继承，可以继承多个接口
3.实例（抽象工厂模式）
步骤1：
为形状创建一个接口
public interface Shap {
void draw();
}步骤2：
创建实现Shap接口的实体类
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
} public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}步骤3：
为颜色创建一个接口
public interface Color {
void fill();
} 步骤4：
创建实现接口的实体类
public class Red implements Color {
@Override
public void fill() {
System.out.println("Inside Red::fill() method.");
}
}
public class Green implements Color {
@Override
public void fill() {
System.out.println("Inside Green::fill() method.");
}
}public class Blue implements Color {
@Override
public void fill() {
System.out.println("Inside Blue::fill() method.");
}
}步骤5：
为Color和Shap对象创建抽象类来获取工厂
public abstract class AbstractFactory {
public abstract Color getColor(String color);
public abstract Shape getShape(String shape);
}
步骤6：
创建扩展了AbstractFactory的工厂类，基于给定的信息生成实体类的对象
public class ShapeFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType) {
if(shapeType == null)
return null;
if(shapeType.equalsIgnoreCase("CIRCLE"))
return new Circle();
else if (shapeType.equalsIgnoreCase("RECTANGLE"))
return new Rectangle();
else if(shapeType.equalsIgnoreCase("SQUARE"))
return new Square();
return null;
}
@Override
public Color getColor(String color) {
return null;
}
}
public class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType) {
return null;
}
@Override
public Color getColor(String color) {
if(color == null)
return null;
if(color.equalsIgnoreCase("RED"))
return new Red();
else if(color.equalsIgnoreCase("GREEN"))
return new Green();
else if(color.equalsIgnoreCase("BLUE"))
return new Blue();
return null;
}
}
步骤7：
创建一个工厂生成器，通过传递形状或者颜色信息来获取工厂
public class FactoryProducer {
public static AbstractFactory getFactory(String choice) {
if(choice.equalsIgnoreCase("SHAPE"))
return new ShapeFactory();
else if(choice.equalsIgnoreCase("COLOR"))
return new ColorFactory();
return null;
}
}
public class AbstractFactortPatterbDemo {
public static void main(String[] args) {
// 获取形状工厂
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
// 通过FactoryProducer类生成了一个ShapeFactory类的对象并赋值给抽象类AbstractFactory的引用变量shapFactory
// 获取形状为 Cirle 的对象
Shape shape1 = shapeFactory.getShape("CIRCLE");
// 通过ShapeFactory类创建了一个Circle类对象，赋值给Shape接口的引用变量shape1
// 调用 Circle 的 draw方法
shape1.draw();
// 输出 Inside Circle::draw() method.
//获取形状为 Rectangle 的对象
Shape shape2 = shapeFactory.getShape("RECTANGLE");
// 通过ShapeFactory类创建了一个Rectangle类对象，赋值给Shape接口的应用变量shape2
//调用 Rectangle 的 draw 方法
shape2.draw();
// 输出 Inside Rectangle::draw() method.
//获取形状为 Square 的对象
Shape shape3 = shapeFactory.getShape("SQUARE");
// 通过ShapeFactory类创建了一个Square类对象，赋值给了Shape接口的应用变量shape3
//调用 Square 的 draw 方法
shape3.draw();
// 输出 Inside Square::draw() method.
//获取颜色工厂
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
// 通过FactoryProducer类生成了一个ColorFactory类的对象并赋值给抽象类AbstractFactory的引用变量shapFactory
//获取颜色为 Red 的对象
Color color1 = colorFactory.getColor("RED");
// 通过ColorFactory类创建了一个Red类对象，赋值给Color接口的引用变color1
//调用 Red 的 fill 方法
color1.fill();
// 输出Inside Red::fill() method.
//获取颜色为 Green 的对象
Color color2 = colorFactory.getColor("GREEN");
// 通过ColorFactory类创建了一个Green类对象，赋值给Color接口的引用变color2
//调用 Green 的 fill 方法
color2.fill();
// 输出 Inside Green::fill() method.
//获取颜色为 Blue 的对象
Color color3 = colorFactory.getColor("BLUE");
// 通过ColorFactory类创建了一个Blue类对象，赋值给Color接口的引用变color3
//调用 Blue 的 fill 方法
color3.fill();
// 输出 Inside Blue::fill() method.
}
}步骤9：
输出
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method. 
扫一扫
260
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
