java学习——abstract 和 final

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

抽象：看不懂。
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();
    }
}