当多个类中出现相同功能，但是功能主题不同，
这时可以进行向上抽取。这时只抽取功能定义，而不抽取功能主体。
抽象：看不懂。
1， 抽象方法一定定义在抽象类中。
2， 抽象方法和抽象类都必须被abstract关键字修饰。
3， 抽象类不可以用new创建对象。因为调用抽象方法没有意义。
4， 抽象类中的方法要被使用，必须由子类复写所有的抽象方法后，建立子类对象调用。
如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
抽象类和一般类没有太大的不同。
该如何描述事物，就如何描述事物，只不过该事物出现了一些看不懂的东西。
这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体。
通过抽象方法来表示。
抽象类比一般类多了抽象函数，就是在类中可以定义抽象方法。
抽象类不可以实例化。
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
abstract class Student
{
abstract void study(); } class BaseStudent extends Student
{
void study()
{
System.out.println("bass study");
}
} class AdvStudent extends Students
{
void study()
{
System.out.println("adv study");
}
} class AbstractDemo
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
/*
加入我们在开发一个系统时需要员工进行建模，员工包含3个属性：
姓名、工号以及工资。经理也是员工，除了含有员工属性外，另外还有一个奖金属性。请使用继承的思想设计员工类和经理类。需要类中提供必要的方法
进行属性访问。 员工类：name, id, pay
经理类：继承了员工，他有自己特有的bonus */ class Emloyee
{
private String name;
private String id;
private double pay; Emplotee(String name, String id, double pay)
{
this.name = name;
this.id = id;
this.pay = pay;
} public abstract void work(); } class Professional extends Employee
{
Emplotee(String name, String id, double pay)
{
super(name, id, pay);
}
public 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()
{ }
}
class
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
final:最终。 作为一个修饰符。
1， 可以修饰类，函数，变量。
2， 被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
3， 被final修饰的方法不可以被复写。
4， 被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。
当在描述事物时，一些数据的值是固定的，那么这时为了增强阅读性，都给这些值起一个名字。方便阅读。
而这个值不需要改变，所以加final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。
单词通过 _ 连接
5， 内部类定义在类中的局部位置上时，只能访问局部被final修饰的局部变量。
final class Demo
{
void show() {
}
}
class Students extends Demo
{ } class FinalDemo
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
/*
需求：获取一段程序运行的时间。
原理： 获取程序开始和结束的时间并相减。 获取时间：System.currentTimeMillis(); 当代码完成优化后，就可以解决这类问题。 这种方式，模板方式设计模式。 什么是模板方法呢？
定义方法时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用
不确定的部分，那么这时将不确定的部分暴露出去，由该类的子类去完成。 */ abstract class GetTime
{
public final void getTime()
{
long start = System.currentTimeMillis(); /*for(int x = 0; x<1000; x++)
{
System.out.print(x);
}
*/ 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<4000; x++)
{
System.out.print(x);
}
}
} class TemplateDemo
{
public static void main(String[] args)
{
SubTime gt = new SubTime();
gt.getTime();
}
}