java抽象类

package object;
/*
 * 		抽象类(abstract)模板
 * 从定义上看：抽象类就是有抽象方法的类
 * 			  抽象方法就是没有方法主体的类
 * 			  抽象类是一种特殊的类，它不能被实例化，只能被继承。
 * 
 * 从封装中理解抽象类：
 * 			  隐藏了方法体
 * 
 * 从继承中理解抽象类：
 * 			  把自己当成模板供人参考（模板）
 * 			  所以要有子类继承他（不然就没意义了）
 * 
 * 从多态中理解抽象类：
 * 			  不能进行实例化
 * 			  需要进行向上转型得到实例对象
 * 
 * 1、可以修饰方法、类
 * 
 * 						2、修饰类(抽象类)
 * 1.1不能实例化(只能由子类进行实例化)
 * 理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
 * 
 * 1.2可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
 * 理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
 *  
 * 1.3抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
 * 理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设 计。
 *   
 * 1.4抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
 * 理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。
 */



/*
 * 						3、抽象方法（没有方法体）
 * 2.1抽象方法只有方法的声明，没有方法体
 * 2.2由抽象方法则必有抽象类。反之抽象类可以没有抽象方法
 * 2.3若子类重写了父类中所有抽象方法，此子类可实例化
 * 若没有重写父类所有抽象方法，此子类也是抽象类
 * 
 * 
 * 
 * 
 * PS:				注意点
 * 3.1 abstract不能用来修饰属性、构造器等结构
 * 修饰构造器，则构造器没有方法体，子类无法获取对象与初始化
 * 
 * 3.2abstract不能修饰私有方法、静态方法、finnal方法、final类
 * 修饰私有方法：需要重写私有方法而子类无法调
 * 修饰静态方法：静态方法不被认为是重写
 * 修饰finnal方法：finnal方法不能被重写
 * 修饰finnal类：不能被继承则不能重写
 * 
 * 
 */
/*
 * 
 */






public abstract class Abstract {
//	1.1不能实例化 Abstract p=	new Abstract();
//  构造器	
	public static void main(String args[])
	{
		Template Q=new SubTemplate();
		Q.code();
	}
	public Abstract()
	{
		
	}

//  抽象方法
	public abstract void Test01();

}
// 1.2提供抽象类子类
class AbstractTest extends Abstract
{
	//子类实例化	
	Abstract P=new AbstractTest();
	@Override//重写父类所有抽象方法
	public void Test01() {
		
		
	}
}
//abstract class RewriteStatic
//{
//	 public abstract static void Rewrite();
//	
//}
//class RewriteStaticSon extends RewriteStatic
//{
//	 public  static void Rewrite()
//	 {
//		 System.out.print("我是重写的");
//	 }  修饰静态方法：静态方法不被认为是重写
/*
 * 静态方法不具有多态性。
 * 子类可以继承父类中的静态方法，但是不能重写父类中的静态方法。
子类中的实例方法不能隐藏父类中的静态方法，子类中的静态方法也不能隐藏父类中的实例方法。
如果尝试用静态方法隐藏实例方法 或 用实例方法隐藏静态方法，则会在编译时报错。

 */
//}
abstract class RewriteStatic02
{
	 public abstract  void Rewrite();
	
}
class RewriteStaticSon02 extends RewriteStatic02
{
	 public  void Rewrite()
	 {
		 System.out.print("我是重写的");
	 }
}

/*
 * 									Java模板方法模式(设计模式)
 * 1.核心思想是将算法的实现细节推迟到子类中，以便让子类可以重新定义算法的某些特定步骤，同时保持算法的整体结构不变。
 * 
 * 2.抽象类定义了算法的骨架，包含一个模板方法但是它们都是保护级别，只能在模板方法内部使用
 * 
 * 3.子类通过继承抽象类并实现其中的抽象方法来提供算法的实现细节。只能覆盖不能修改
 * 
 * 4.Java模板方法模式的优点
 * 是可以提高代码的重用性和扩展性，同时也能够保证算法的稳定性和一致性。
 * Java模板方法模式的缺点是
 * 可能会增加类的数量，增加代码的复杂度。
 */


//计算某段代码执行所需时间
abstract class Template
{
	public void spendTime()
	{
		 long start=System.currentTimeMillis();
		 
		 code();//不确定的部分易变的
		 
		 long end=System.currentTimeMillis();
		 
		 System.out.println("花费的时间为： "+(end-start));
	}
	public abstract void code();
	
}
class SubTemplate extends Template
{
	public static void main(String args[])
	{
		Template Q=new SubTemplate();
		Q.spendTime();;
		
	}

	@Override
	public void code() {
		// TODO Auto-generated method stub
		
	}
	
	
}