该系列博文会告诉你如何从入门到进阶,一步步地学习Java基础知识,并上手进行实战,接着了解每个Java知识点背后的实现原理,更完整地了解整个Java技术体系,形成自己的知识框架。
当编写一个类时,常常会为该类定义一些方法,这些方法用以描述该类的行为方式,那么这些方法都有具体的方法体。但在某些情况下,某个父类只是知道其子类应该包含怎样的方法,但无法准确地知道这些子类如何实现这些方法。例如定义了一个Shape类,这个类应该提供一个计算周长的方法calPerimeter(),但不同Shape子类对周长的计算方法是不一样的,即Shape类无法准确地知道其子类计算周长的方法。
可能有读者会提出,既然Shape类不知道如何实现calPerimeter()方法,那就干脆不要管它了!这不是一个好思路:假设有一个Shape引用变量,该变量实际上引用到Shape子类的实例,那么这个Shape变量就无法调用calPerimeter()方法,必须将其强制类型转换为其子类类型,才可调用calPerimeter0方法,这就降低了程序的灵活性。
如何既能让Shape类里包含calPerimeter()方法,又无须提供其方法实现呢?使用抽象方法即可满足该要求:抽象方法是只有方法签名,没有方法实现的方法。
抽象方法和抽象类必须使用abstract修饰符来定义,有抽象方法的类只能被定义成抽象类,抽象类里面可以没有抽象方法。
抽象方法和抽象类的规则如下:
说了一大堆概念,听得有点糊涂了,下面我们来看一段代码:
下面定义一个Shape抽象类:
public abstract class Shape {
{
System.out.println("执行Shape的初始化块");
}
private String color;
//定义一个计算周长的抽象方法
public abstract double calPerimeter();
//定义一个返回形状的抽象方法
public abstract String getType();
//定义Shape的构造器,该构造器并不是用于创建对象,而是被子类调用
public Shape() {}
public Shape(String color) {
System.out.println("执行Shape的构造器");
this.color=color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
上面的Shape类里包含了两个抽象方法:calPerimeter()和 getType(),所以这个Shape类只能被定义成抽象类。Shape类里既包含了初始化块,也包含了构造器,这些都不是在创建 Shape对象时被调用的,而是在创建其子类的实例时被调用。
抽象类不能用作创建实例,只能当做父类被其他子类继承。
下面定义一个三角形类,三角形类被定义成普通类,继承Shape抽象类,因此必须实现Shape类中的抽象方法
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);
setSize(a, b, c);
}
public void setSize(double a,double b,double c) {
if(a+b<=c||a+c<=b||b+c<=a) {
System.out.println("三角形两边之和必须大于第三边");
return;
}
this.a=a;
this.b=b;
this.c=c;
}
//重写Shape类计算周长的方法
@Override
public double calPerimeter() {
return a+b+c;
}
//重写Shape类返回形状的方法
@Override
public String getType() {
// TODO Auto-generated method stub
return "三角形";
}
}
上面的Triangle类继承了Shape抽象类,并实现了Shape类中两个抽象方法,是一个普通类,因此可以创建 Triangle类的实例,可以让一个Shape类型的引用变量指向Triangle对象。
下面编写测试代码:
public class TestShape {
public static void main(String[] args) {
Shape s1=new Triangle("黑色", 3, 4, 5);
System.out.println(s1.getColor());
System.out.println(s1.getType());
}
}
输出结果:
执行Shape的初始化块
执行Shape的构造器
黑色
三角形
利用抽象类和抽象方法的优势,可以更好的发挥多态的优势,使得程序更加灵活。
使用抽象类有以下几点需要注意:
1、当使用abstract修饰类时,表明这个类时抽象类,不能实例化,只能被继承;当使用abstract修饰方法时,表明这个方法必须由子类去实现。
2、final修饰的类不能被继承,final修饰的方法不能被重写,因此final和abstract不能同时出现。
3、abstract不能用于修饰成员变量,不能用于修饰局部变量,即没有抽象变量、没有抽象成员变量等说法;abstract也不能用于修饰构造器,没有抽象构造器,抽象类里定义的构造器只能是普通构造器。
4、当使用static修饰一个方法时,表明这个方法属于该类本身,即通过类就可调用该方法,但如果该方法被定义成抽象方法,则将导致通过该类来调用该方法时出现错误(调用了一个没有方法体的方法肯定会引起错误)。因此static和abstract不能同时修饰某个方法,即没有所谓的类抽象方法。
5、abstract修饰的方法没有方法体,必须被之类重写才有意义,所以抽象方法不能用private修饰,也就是private和abstract不能同时使用。
抽象类是从多个类中抽象出来的模板,如果将这种抽象进行得更彻底,则可以提炼出一种更加特殊的“抽象类”——接口(interface)。Java9对接口进行了改进,允许在接口中定义默认方法和类方法,默认方法和类方法都可以提供方法实现,Java9为接口增加了一种私有方法,私有方法也可提供方法实
和类定义的不同,定义接口不再使用class关键字,而是使用interface关键字。接口的基本语法如下:
[修饰符] interface 接口名称 extends 父接口1 父接口2 ....
{
零到多个常量定义...
零到多个抽象方法定义...
零到多个内部类,接口,枚举定义...
零到多个私有方法,默认方法或者类方法定义...
}
下面来看一个具体的接口:
public interface Output {
//接口中定义的成员变量只能是常量
int MAX_CACHE_LINE=50;
//接口中定义的普通方法只能是public abstract抽象方法
void out();
//在接口中定义默认方法,需要用default修饰
default void print(String...msg) {
for (String str : msg) {
System.out.println(str);
}
}
//在接口中定义类方法,需要使用static修饰
static String staticTest() {
return "接口中的类方法";
}
//定义私有方法
private void foo() {
System.out.println("接口中的私有方法");
}
//定义私有静态方法
private static void bar() {
System.out.println("bar私有静态方法");
}
}
接口的继承和类继承不一样,接口完全支持多继承,即一个接口可以有多个直接父接口。和类继承相似,子接口扩展某个父接口,将会获得父接口里定义的所有抽象方法、常量。
一个接口继承多个父接口时,多个父接口排在extends关键字之后,多个父接口之间以英文逗号(,)隔开。下面程序定义了三个接口,第三个接口继承了前面两个接口。
interface InterfaceA{
int PROP_A=5;
void testA();
}
interface InterfaceB{
int PROP_B=6;
void testB();
}
interface InterfaceC extends InterfaceA,InterfaceB{
int PROP_C=7;
void testC();
}
public class InterfaceExtendsTest {
public static void main(String[] args) {
System.out.println(InterfaceC.PROP_A);
System.out.println(InterfaceC.PROP_B);
System.out.println(InterfaceC.PROP_C);
}
}
接口不能用于创建实例,但接口可以用于声明引用类型变量。当使用接口来声明引用类型变量时,这个引用类型变量必须引用到其实现类的对象。除此之外,接口的主要用途就是被实现类实现。归纳起来,接口主要有如下用途。
一个类可是实现多个接口,用关键字implements实现,类实现接口的语法格式如下:
[修饰符] class 类名 extends 父类 implements 接口1,接口2...{
类体部分
}
注意:类实现接口时必须要实现接口中所有的抽象方法
interface interfaceA{
void printA();
}
interface interfaceB{
void printB();
}
public class ImplmentsTest implements interfaceA,interfaceB {
@Override
public void printB() {
System.out.println("printB");
}
@Override
public void printA() {
System.out.println("printA");
}
}
上述代码的ImplmentsTest实现了两个接口,并重写了其中的抽象方法
相同点:
不同点: