黑马程序员----抽象类

——- android培训、java培训、期待与您交流！ ———-

抽象类

        抽象：不具体的，模糊的，看不懂的；

        由不断向上抽取而来，分析完事物以后发现事物具备相同功能，但是功能主体却不一样。

        当多个类中出现相同的功能，但是功能主体不同

        这时可以进行向上抽取：只抽取功能定义，而不抽取功能主体，功能主体部分由子类来实现，强制子类去做一些事情。

 

        抽象类和一般类没有什么太大的不同，该如何描述事物就如何描述事物，只不过该事物出现了一些看不懂的东西；

        这些不确定的部分，也是该事物的功能，需要明确出现，但无法定义主体。

        抽象类比一般类多了抽象方法（抽象函数），即使在抽象类中定义抽象方法（抽象只修饰类和方法，不修饰变量）。

        抽象类不可以实例化，作用就是不让该类建立对象。

 

        抽象类的特点：

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

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

                 3.抽象类不可以用new创建对象，因为调用抽象方法没有意义；

                 4.抽象类中抽象方法要被使用，必须由子类复写其所有的抽象方法后建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

                 5.抽象类中即可以有抽象方法，也可以有非抽象类方法；

abstract class Student //抽象方法必须放在抽象类中；
{
abstract void study();//抽取不具体的方法，没有方法体；
abstract void study1();
void sleep()	//非抽象方法；
{
System.out.println("I am a sleepy girl.");
}
}

abstract class BaseStudent extends Student//继承了抽象类Student，因为没有覆盖所有的抽象方法，所以要加abstract；
{
void study() //相同定义的功能；
{
System.out.println("study");
}

}
class AdvStudent extends Student
{
void study() //相同定义的功能；
{
System.out.println("study");
}
void study1(){};//复写所有的抽象方法；
}

         假如我们在开发一个系统的时候，需要随员工进行建模，员工包含3个属性： 1.姓名；2.工号；3.工资。

         经理也是员工，但是除了以上员工的属性以外还有一个属性：奖金；

         请使用继承的思想设计员工类和经理类，要求类中提供必要的方法进行属性访问。

abstract class Employee
{
private  String name;
private  String  id;
private  double  salary;
Employee(String name,String id,double salary)
{
this.name=name;
this.id=id;
this.salary=salary;
}

public abstract void work();//抽象方法；

}

class Ordinary extends Employee
{

Ordinary(String name, String id, double salary)
{
super(name, id, salary);

}
public void work() //方法复写；
{
System.out.println("the work of ordinary");
}

}
class Manager extends Employee
{
private int bonus;
Manager(String name,String id,double salary,int bonus)
{
super(name,id,salary);
this.bonus=bonus;
}
public void work() //对work方法进行复写；
{
System.out.println("the work of manager");
}
}

        需求:获取一段程序运行的时间

        原理:获取程序开始和结束的时间并相减

 

        获取时间的方法：System.currentTimeMillis();

        当代码完成优化后，就可以解决问题了

        这种方式叫做模板设计方法模式
        什么是模板方法呢？其实就是在定义功能时，功能的一部分是确定的，一部分是不确定的，确定的部分在使用不确定的部分，这时就将不确定的部分暴露出去，由该类的子类去完成。

        提高扩展性和复用性

abstract class GetTime
{
public final void getTime()//该功能不能复写；
{
long start=System.currentTimeMillis();

//需要检测的程序，但是这段代码不确定；
/*
for(int x=0;x<1000;x++)
{
System.out.println(x);
}
*/
runcode();//功能调用；走的是子类的方法。
long end=System.currentTimeMillis();
System.out.println("毫秒： "+(end-start));

}
public abstract void runcode();//抽象方法，由子类去实现；
}
class SubTime extends GetTime
{
/*
public void getTime()//加final关键字的父类方法不能被复写；
{

long start=System.currentTimeMillis();

for(int x=0;x<4000;x++)
{
System.out.println(x);
}

long end=System.currentTimeMillis();
System.out.println("毫秒： "+(end-start));

}
*/
public void runcode()
{
for(int x=0;x<4000;x++)
{
System.out.println(x);
}
}
}

public class GetTimeDemo
{
public static void main(String[] args)
{
//GetTime g=new GetTime();
//g.getTime();

SubTime gt=new SubTime();//创建子类对象；
gt.getTime();//调用父类的getTime方法；
}
}