Java学习总结——抽象类与接口

拾叁——抽象类与接口

一、抽象类

在 Java 中可以创建一种类专门用来做父类，这种类称为 “ 抽象类 ”。抽象类实际上也是一个类，只是与之前的普通类相比，内部新增了抽象方法。

1.抽象类的基本概念

抽象方法是只声明而未实现的方法，所有的抽象方法必须使用 abstract 关键字声明，包含抽象方法的类也必须使用 abstract class 声明。

抽象类定义规则如下：

（1）抽象类和抽象方法都必须用 abstract 关键字来修饰；

（2）抽象类不能直接实例化，也就是不能直接用 new 关键字去产生对象；

（3）抽象类定义时抽象方法只需声明，而不需实现；

（4）含有抽象方法的类必须被声明为抽象类，抽象类的子类必须实现所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。

抽象类定义格式如下：

        abstract class 类名称    //定义抽象类
        {
            声明数据成员；
            访问权限 返回值的数据类型 方法名称(参数……)
            {
                //定义一般方法
            }
            //定义抽象方法，在抽象方法里没有定义方法体
            abstract 返回值的数据类型 方法名称(参数……);    
        }

例如：

        abstract class Book    //定义一个抽象类
        {
            private String title = "Java";    //属性
            public void print()
            {
                //普通方法，有“{ }”表示有方法体
                System.out.println(title);
            }
            //没有定义方法体，是一个抽象方法
            public abstract void fun();    
        }

由此可知，抽象类的定义就是比普通类多了一些抽象方法的定义而已。虽然定义了抽象类，但是抽象类却不能直接使用。

        Book book = new Book();    //错误：Book是抽象的，无法实例化

如果一个类可以实例化对象，那么这个对象可以调用类中的属性或者是方法，但是抽象类中存在抽象方法，而抽象方法没有方法体，没有方法体的方法无法使用。

所以，对于抽象类的使用原则如下：

（1）抽象类必须有子类，子类使用 extends 继承抽象类，一个子类只能够继承一个抽象类；

（2）子类（ 如果不是抽象类 ）则必须实现抽象类之中的全部抽象方法；

（3）如果要想实例化抽象类的对象，则可以使用子类进行对象的向上转型来完成。

提示：在 Java 中，当子类继承父类时，子类可由此得到父类的方法。我们可在子类中，重新改写继承父类的同名方法，我们称这个过程为覆盖重写，简称覆写（ override ）。

从抽象类的设计理念可知，抽象类生来就是被继承的。在其内的抽象方法，通常是没有方法体的，抽象方法的本意就是期望子类重新定义这个方法，赋予新的内涵。因此，在其子类中的非抽象（ 具体 ）定义，我们用 “ 实现 ”，而非 “ 覆盖 ”，来描述这个过程。用 “ 实现 ”，相当于在子类中，将来自父类的抽象方法 “ 给予 ” 生命。

举例抽象类的用法：

//抽象类的用法
abstract class Person	//定义一个抽象类 Person
{
	String name;
	int age;
	String occupation;
	public abstract String talk();	//声明一个抽象方法talk()
}

class Student extends Person	//Student类继承自Person类
{
	public Student(String name,int age,String occupation)
	{
		this.name = name;
		this.age = age;
		this.occupation = occupation;
	}
	
	public String talk()	//实现抽象方法talk()
	{
		return "name:" + this.name + "age:" + this.age + "occupation" + this.occupation;
	}
}

class Worker extends Person	//Worker类继承自Person类
{
	public Worker(String name,int age,String occupation)
	{
		this.name = name;
		this.age = age;
		this.occupation = occupation;
	}
	
	public String talk()	//实现抽象方法talk()
	{
		return "name:" + this.name + "age:" + this.age + "occupation" + this.occupation;
	}
}

class AbstractClassDemo
{
	public static void main(String[] args)
	{
		Student s = new Student("张三",20,"学生");	//创建Student类对象s
		Worker w = new Worker("李四",25,"工人");	//创建Worker类对象w
		System.out.println(s.talk());	//调用被实现过的方法
		System.out.println(w.talk());
	}
}

举例抽象类中构造方法的定义使用：

//抽象类中构造方法的定义使用
abstract class Person	//定义一个抽象类 Person
{
	String name;
	int age;
	String occupation;

	public Person(String name,int age,String occupation)	//定义构造函数
	{
		this.name = name;
		this.age = age;
		this.occupation = occupation;
	}	
	public abstract String talk();	//声明一个抽象方法
}

class Worker extends Person	//声明抽象类的子类
{
	public Worker(String name,int age,String occupation)
	{
		//在这里必须明确调用抽象类中的构造方法
		super(name,age,occupation);
	}
	
	public String talk()	//实现抽象方法talk()
	{
		return "name:" + this.name + "age:" + this.age + "occupation" + this.occupation;
	}
}

class AbstractConstructor
{
	public static void main(String[] args)
	{
		Worker w = new Worker("李四",25,"工人");	//创建对象w
		System.out.println(w.talk());	//调用被实现过的方法
	}
}

举例验证 static 定义的内部抽象类：

//验证static定义的内部抽象类
abstract class Book
{
	public abstract void print();	//抽象方法
	static abstract class CD
	{
		//静态内部抽象类
		public abstract void get();	//抽象方法
	}
}

class JavaCD extends Book.CD //继承抽象类
{
	public void get()
	{
		System.out.println("java");
	}
}

public class StaticInnerAbstractClass
{
	public static void main(String[] args)
	{
		Book.CD cd = new JavaCD();	//实例化对象
		cd.get();
	}
}

抽象类的特征：

（1）抽象类中可以有构造方法

与一般类相同，抽象类也可以拥有构造方法，但是这些构造方法必须在子类中被调用，并且子类实例化对象的时候依然满足类继承的关系，先默认调用父类的构造方法，而后再调用子类的构造方法，毕竟抽象类之中还是存在属性的，但抽象类的构造方法无法被外部类实例化对象调用。

抽象类也可以像普通类一样，有构造方法、一般方法和属性，更重要的是还可以有一些抽象方法，需要子类去实现，而且在抽象类中声明构造方法后，在子类中必须明确调用。

（2）抽象类不能够使用 final 定义

因为使用 final 定义的类不能有子类，而抽象类使用的时候必须有子类，这是一个矛盾的问题，所以抽象类上不能出现 final 定义。

（3）Static 声明，抽象类内外不同

在外部抽象类上无法使用 static 声明，但是内部抽象类却可以使用 static 定义，使用 static 定义的内部抽象类就表示一个外部类。