抽象类

抽像类的概念：包含一个抽象方法的类就称为抽像类·

抽象方法：只声明而未实现的方法称为抽像方法，抽象方法必须使用abstract关键字声明。

抽象类的定义及使用规则

• 包含一个抽象方法的类必须是抽象类：
• 抽象类和抽象方法都要使用abstract关键字声明：
• 抽象方法只需声明而不需要实现：
• 抽象类必须被了继承，了类（如果不是抽象类）必须覆写抽象类中的全部抽象方法。

抽象类的定义格式

abstract class A{	// 是定义了一个抽象类
	public static final String FLAG = "CHINA" ;	// 全局常量
	private String name = "高琦淞" ;	// 定义一个普通的属性
	public void setName(String name){
		this.name = name ;
	}
	public String getName(){
		return this.name ;
	}
	public abstract void print() ;		// 定义抽象方法
}

抽类的定义虽然跟普通类非常相似，但是却不能直实例化

抽能类必须有子类，子类必须覆写抽能类中的全部抽方法．

abstract class A{	// 是定义了一个抽象类
	public static final String FLAG = "CHINA" ;	// 全局常量
	private String name = "高琦淞" ;	// 定义一个普通的属性
	public void setName(String name){
		this.name = name ;
	}
	public String getName(){
		return this.name ;
	}
	public abstract void print() ;		// 定义抽象方法
};
class B extends A{	// 继承抽象类，因为B是普通类，所以必须覆写全部抽象方法
	public void print(){
		System.out.println("FLAG = " + FLAG) ;
		System.out.println("姓名 = " + super.getName()) ;
	}
};
public class AbstractDemo02{
	public static void main(String args[]){
		B b = new B() ;
		b.print() ;
	}
};

思考

1.一个抽象类可以使用final关键字声明吗？

2.一·个抽象类可以定义构造方法吗？

abstract class A{	// 是定义了一个抽象类
	public A(){
		System.out.println("A、抽象类中的构造方法。") ;
	}
};
class B extends A{	// 继承抽象类，因为B是普通类，所以必须覆写全部抽象方法
	public B(){
		super() ;
		System.out.println("B、子类中的构造方法。") ;
	}
};
public class AbstractDemo03{
	public static void main(String args[]){
		B b = new B() ;
	}
};

结果：

package Jichu;

abstract class Persons{
	private String name ;		// 定义name属性
	private int age ;			// 定义age属性
	public Persons(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return this.name ;
	}
	public int getAge(){
		return this.age ;
	}
	public abstract String getInfo() ;	// 抽象方法
};
class Students extends Persons{
	private String school ;
	public Students(String name,int age,String school){
		super(name,age) ;	// 指定要调用抽象类中有两个参数的构造方法
		this.school = school ;
	}
	public void setSchool(String school){
		this.school = school ;
	}
	public String getSchool(){
		return this.school ;
	}
	public String getInfo(){
		return	"姓名：" + super.getName()  + 
				"；年龄：" + super.getAge() + 
				"；学校：" + this.getSchool() ;
	}
};
public class AbstractDemo03{
	public static void main(String args[]){
		Student stu = new Student("张三",30,"清华大学") ;
		System.out.println(stu.getInfo()) ;
	}
};

总结：

1、抽像类使用的时候一定要有子类，子类仍然使用extends关键字继一个抽类，同样

会存在单继承的关系,一个子类不能同时继多个抽能类。

2、抽象类类中絶对不能使用final关键字声明

3、抽象类中允许有构造方法，而且完全符合子类对的实例化过程。