java--抽象类

一、概念

抽象方法：被abstract修饰的方法；

抽象类：被abstract修饰的类，抽象类就是模糊的，看不清的，该类中所有的方法不足以描述一个具体的事物，并且所有继承于该类的子类都必须有继承的抽象类中的抽象方法。继承抽象类的子类，必须完成父类中的去全部抽象方法，该抽象方法没有确定的功能，在子类中完成具体的功能。比如我们定义一个抽象类--学生，要求学生必须学习，那么就相当于我们在学生这个抽象类中有一个抽象方法--学习，所有继承于学生的类都必须有学习的这个方法，至于具体不同的学生学习的内容，这个就是不确定的，在继承学生类的子类中，就可以对学习方法做具体的说明。

二、注意点

抽象类的使用注意点如下：

1.  抽象方法一定在抽象类中；

2.  抽象方法和抽象类都必须用 abstract关键字修饰；

3.  抽象类不可以用new创建对象 抽象类无法实例化；

4.  抽象类中的方法想要被使用 ，必须由子类重写其所有抽象方法；

5.  一个抽象类中可以包含抽象方法和非抽象方法 ，但如果一个方法被抽象修饰,它所在的类必须是抽象的，抽象类可以不定义抽象方法；

6.  抽象类中有构造函数，但是由于“抽象”对类的限定，使得这个抽象修饰的类无法创建对象；

7.  abstract只是一个修饰符，在定义的抽象类中如果没有抽象方法，那么，这样定义只是为了不让该类实例化。

8.  如果一个普通子类继承了一个抽象子类，该抽象子类又继承一个抽象的父类，那么该普通子类必须得重写抽象父类中所有的抽象方法，如果在抽象子类已重写过的抽象方法 ，普通子类就不需要重写了；

三、实例测试

1.定义一个抽象类

//定义一个学生类(抽象)
abstract class Student
{
	abstract void study();//定义一个抽象方法
	void eat(){//定义一个普通方法
		System.out.println("eat");
	}
}   

如果此时直接实例化该类如下：

class Demo_1 
{
	public static void main(String[] args) 
	{
		Student s = new Student();//实例化
	}
}

此时的运行结果如下：

由此验证注意点3，因为Student为抽象类，所以无法对其进行实例化。

2. 子类对于抽象类中方法的重写

在学生类中创建两个抽象类方法，对于重新创建一个类继承于学生类，如下代码：

//定义一个学生类(抽象)
abstract class Student
{
	abstract void study();//定义一个抽象方法
	abstract void mathod();
	void eat(){//定义一个普通方法
		System.out.println("eat");
	}
}
class VRStudent extends Student//定义一个类继承于学生
{
	//重写抽象方法study();
	void study(){
		System.out.println("VR");
	}
	//重写抽象方法mathod();
	void mathod(){
		System.out.println("VRStudent_mathod");
	}
} 
class Demo_1 
{
	public static void main(String[] args) 
	{
		VRStudent v = new VRStudent();//实例化类
		v.study();//调用对象方法
		v.mathod();
		v.eat();
	}
}

运行结果如下：

在Student类中，有普通方法和抽象方法，VRStudent继承于Student类，并在该类中重写了学生类中的所有抽象方法，实例化该类之后，调用输出不会报错，从结果中也能

看出，在抽象类中非抽象的成员可以不用在子类中重写，可以直接使用。

那么如果没有将抽象类全部重写，如下：

//定义一个学生类(抽象)
abstract class Student
{
	abstract void study();//定义一个抽象方法
	abstract void mathod();
	void eat(){//定义一个普通方法
		System.out.println("eat");
	}
}
class JavaStudent extends Student
{
	void study(){
		System.out.println("java");
	}
}
class Demo_1 
{
	public static void main(String[] args) 
	{
		JavaStudent J = new JavaStudent();
		J.study();
	}
}

运行结果如下：

 建立子类对象调用，如果只重写其中一部分方法，子类就会继承父类的抽象方法， 那么子类也是个抽象类，就必须对子类也添加abstract修饰符。

3. 关于多层继承

abstract class Student
{
	private String name;
	public Student(){
		super();
	}
	public Student(String name){
		super();
		this.name = name;
	}
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public abstract void study();
	public abstract void method();
}
//继承于学生类 重写所有抽象方法
class MiddleStudent extends Student
{
	public void study(){
	
	}
	public void method(){
	
	}
}
//继承学生类 重写其中一个方法，相当于本类也是抽象类，要添加abstract修饰符
abstract class ColleageStudent extends Student
{
	public void method(){
	
	}//重写一个方法
}
//继承于ColleageStudent类
class LittleStudent extends ColleageStudent
{
	//重写另一个方法，在ColleageStudent中重写了一个抽象方法，在本类中就只用重写一个了
	public void study(){
	
	}
}
class Demo_1 
{
	public static void main(String[] args) 
	{
		LittleStudent J = new LittleStudent();
	}
}