抽象类相关的规定

1.抽象类只是比普通类多了一些抽象方法的定义而已，所以在抽象类之中依然允许提供有构造方法，并且子类也会遵守子类对象的实例化流程。实例化子类对象钱一定要先去调用父类的构造方法

范例：

记住主类中的抽象方法只是声明 要在继承类中实现该抽象方法的具体内容

abstract class Person{
	public  Person() {
		System.out.println("****************");
		
	}
	public  abstract String getInfo();//抽象方法
}
class Student extends Person{
public Student() {
	System.out.println("###############");
}
public String getInfo() {
	return null; 
}
} 
public class TestDemo {

	public static void main(String[] args) {
	new Student();

	}

}*******************

###################  

如果说现在父类中没有无参构造，那么子类就必须通过super()指明要调用的父类构造方法

abstract class Person{
	private String name;
	private int age;
	public  Person(String name,int age){
		this.name=name;
		this.age=age;		
	}
	public String getName() {
		return this.name;
	}
	public int getAge() {
		return this.age;
		
	}
	public  abstract String getInfo();//抽象方法
}
class Student extends Person{
private String school;

public Student(String name,int age,String school) {
	super(name,age);//子类构造必须明确的调用父类构造
	this.school=school;
}
public String getInfo() {
	return "【Student】name="+super.getName()+"  age="+super.getAge()+"  school="+this.school; 
}
} 
public class TestDemo {

	public static void main(String[] args) {
	Person per=new Student("张三",19,"北大") ;
	System.out.println(per.getInfo());

	}

}

其实抽象类中存在有构造方法也很好理解，毕竟抽象类中还有属性 

所有的属性要在对象实例化的时候进行空间的开辟 

对象实例化必须要使用构造方法。（所以抽象类必须有构造）

额外话题：关于对象实例化

   对象实例化操作需要以下几个核心步骤

       ·进行类的加载

       ·进行类对象的空间开辟

       ·进行类对象中的属性初始化（构造方法） 

构造方法如果还没执行的话，所有的属性都是其对应数据类型的默认值

abstract class A{
	public A() {//3 调用父类构造方法
		this.print();//4 调用被子类覆写过的方法
	}
	public abstract void print();//抽象方法
}
class B extends A{
	private int num=100;
	public B(int num) {//2.调用子类实例化对象
		super();//3.隐含一行语句，实际要想调用父类构造
		//但是此时此类构造没执行 但是所有的内存空间会开辟但是没有值 num的值等于0	
		this.num=num;// 7 为类中的属性初始化 
	}
	public void print() {//5此时子类对象的属性还没有被初始化
		System.out.println(this.num);//6、内容其对应数据内容的默认值
	}
}
public class TestDemo {

	public static void main(String[] args) {
		new B(30);//1实例化子类对象	

	}

}

二。抽下类中允许不定义任何的抽象方法，但是此时抽象类对象依然无法进行直接实例化处理。

abstract class A{
	public void print() {
		
	}
}
public class TestDemo {
	public static void main(String[] args) {
		A a=new A();//错误，A是抽象的，无法实例化
	}
}

三。抽象类一定不能够使用final进行声明，因为使用final定义的类必须有子类，而抽象类必须有子类

        ·抽象方法不能够使用private进行定义，因为抽象方法必须被覆写；（private就封装了）

四。（抽象类能不能用static定义呢？）

抽象类也分为内部抽象类和外部抽象类，内部抽象类中可以使用static定义，描述为外部抽象类。

范例：观察内部抽象类

abstract class A{//此类结构出现的机率很低
	public abstract void printA();
	abstract class B{
		public abstract void printB();
	}
}
class X extends A{
	public void printA() {}
	class Y extends B{
		public void printB() {
			
		}}}
public class TestDemo {
	public static void main(String[] args) {
	
	}
}

而如果现在外部抽象类上使用了static,那么就是语法错误，可内部抽象类上允许使用static

 abstract class A{//此类结构出现的机率很低
	public abstract void printA();
	static abstract class B{//现在表示外部抽象类
		public abstract void printB();
	}
}
class X extends A.B{
	public void printB() {}

	}
public class TestDemo {
	public static void main(String[] args) {
	
	}
}

从一般的设计角度来讲，以上的问题很多时候并不会出现。