面向对象—10—继承、抽象类、模板设计模式

 

/*
当多个类中出现相同功能，但是功能主体不同。
这时可以进行向上抽取，这时，只抽取功能定义，而
不抽取功能主体。

抽象类的特点：
1，抽象方法一定定义在抽象类中，
2，抽象方法和抽象了都必须被abstract关键字修饰。
3，抽象类不可以用new创建对象，因为调用抽象方法没有意义
4，抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类调用
  如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

抽象类和一般类没有太大的不同。
该怎么样描述就怎么样描述事物，只不过该事物中出现
了看不懂的东西，这些不确定的部分，也是该事物的功能。
需要明确出来，但是无法定义主体。
通过抽象方法来表示。

抽象类比一般类多了抽象方法。就是在类中可以定义抽象方法。
抽象类不可以实例化

特殊：抽象类中可以不定义抽象方法。这样做仅仅是不让该类建立对象。
*/

abstract class Student //抽象的，无法实例化
{
 abstract void study();
 void sleep()
 {
  System.out.println("躺着睡"); 
 }
}
class ChongCiStudent extends Student
{
 void Student()
 {
  System.out.println("chongci study") 
 } 
}
class BaseStudent extends Student
{
 void study()
 {
  System.out.println("base study"); 
 }
}
class AdvStudent extends Student
{
 void study()
 {
  System.out.println("adv study"); 
 }
}
class AbstractDemo
{
 public static void main(String[] args)
 {
  new BaseStudent().study();
 } 
}

----------------------------------------------------------------------------------------------------------------

/*
假如我们在开发一个系统时需要对员工进行建模，员工包含
3个属性：姓名，工号以及工资。经理也是员工，除了含有
员工的属性外，另外还有一个奖金属性。请使用继承的思想
设计出员工类和经理类。要求类中提供必要的方法进行属性
访问

员工类：name id pay
经理类：继承了员工，并有自己特有的bonus
*/
class Employee //普通员工和经理向上抽取的共性
{
 private String name;
 private String id;
 private double pay;
 
 Employee(String name, String id, double pay)
 {
  this.name = name;
  this.id = id;
  this.pay = pay; 
 }
 public abstract void work();
}

class Manager extends Employee
{
 private int bonus;
 Manager(String name, String id, double pay,int bonus)
 {
  super(name,id,pay);
  this.bonus = bonus;
 } 
 public void work()
 {
  System.out.println("manager work");
 }
}
class Pro extends Employee
{
 Pro(String name, String id, double pay) 
 {
  super(name,id,pay);
  public void work()
  {
   System.out.println("pro work"); 
  }
 }
}
class AbstractTest
{
 public static void main(String[] args)
 {
  
 }
}

---------------------------------------------------------------------------------------------------------

/*
需求：获取一段程序运行的时间
原理：获取程序开始和结束的时间相减即可。
获取时间：System.currentTimeMillis();

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

这种方式，叫模板方法设计模式

什么是模板方法呢？
在定义功能时，功能的一部分是确定的，但是有一部分
是不确定，而确定的部分在使用不确定的部分，那么这时
就将不确定的部分暴露出去。由该类的子类去完成。
*/
abstract class GetTime
{
 public final void getTime()//加上final，不让复写
 {
  long start = System.currentTimeMillis();
  
  runCode();
  
  long end = System.currentTimeMillis();
  
  System.out.println("毫秒："+(end-start)); 
 } 
 
 public abstract void runCode();
 
}

class SubTime extends GetTime
{
 public void runCode()
 {
  for(int x=0; x<3000; x++) 
  {
   System.out.print(x); 
  }
 } 
}

class TemplateDemo
{
 public static void main(String[] args)
 {
  
   new SubTime().getTime();
 }
}

-------------------------------------------------------------------------------------------------------------------

（1）抽象类中可以有构造函数。

        子类对象实例化的时候默认会先去调用父类中的无参构造方法，如果父类中没有无参构造，

        则可以通过super指定调用父类中的其他构造方法。

       抽象类有构造方法。抽象类不能被实例化。 抽象类中的构造方法供子类实例化调用。

例：

abstract class Person
{   //定义一个抽象类，必须被继承 
  Person(int i)
  { 
     System.out.println("hah");  
  } 
} 
class Student extends Person
{ 
  Student()
  { 
    super(3);//必须显示的调用父类构造方法 ,super代表父类对象 
  } 
}
class Demo
{
 public static void main(String[] args)
 {
   new Student();
 } 
}

（2）**private:
                        私有内容子类继承不到，所以，不能重写。
                        但是，abstract修饰的方法，要求被重写。两者冲突。
           **final
                        final修饰的方法不能被重写。
                        而abstract修饰的方法，要求被重写。两者冲突。                       
                **static
                        假如一个抽象方法能通过static修饰，那么这个方法，就可以直接通过类名调用。
                        而抽象方法是没有方法体的，这样的调用无意义。所以，不能用static修饰。
（3）可以，这样可以不让该类建立对象。

 

 

---------------------------------------------------------------------------------------------------------------------------------------------

个人总结：