java 抽象类学习_JAVA学习日志（7-3-抽象类）

final关键字：最终

1.可以修饰类，变量，函数，变量

2.被final修饰的类不可以被继承，用于避免被继承，被子类复写

final class Demo{

void show(){

}

}

class subDemo extends Demo

//无法编译：不能从最终类继承

3.被final修饰的方法不能被复写

final class Demo{

final void show(){

}

void show1(){

}

}

class subDemo extends Demo

//无法编译：无法覆盖final修饰的方法

4.被final修饰的变量是一个常量，只能赋值一次，即可以修饰成员，又可以修饰局部变量

final class Demo{

final int x=3;

void show(){

final int y=4;

int y=9;

}

}

class subDemo extends Demo

//无法编译：无法为最终变量赋值

当在描述事物时，一些数据出现的值是固定的，为了增强阅读性，都用final修饰

(作为常量，所有字母都大写，单词间通过“_”连接)

final double PI=3.14；

5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量

抽象类abstract

特点：1.抽象方法一定定义在抽象类中

2.抽象方法和抽象类必须被abstract修饰

3.抽象类不可以用new创建对象(调用抽象方法没意义)

4.抽象类中的方法要被使用，必须有子类复写其所有的抽象方法后 建立子类对象用

如果没有覆盖完全，则该子类仍是抽象类(无法对抽象类实例化)

/*

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

这时可以进行向上抽取，只抽取功能定义，不抽取功能主体

*/

abstract class Student{

abstract void study();

}

class BaseStudent extends Student{

void study(){

System.out.println("base study");

}

}

class AdvanceStudent extends Student{

void study(){

System.out.println("advanced study");

}

}

class AbstractDemo{

public static void main(String[] args){

new BaseStudent().study();

}

}

抽象类和一般类没有太大不同

该怎么描述事物就怎么描述事物，只是该事物中出现了一些抽象的东西

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

因此通过抽象(abstract)来表示

抽象类比一般类多了抽象方法

抽象类不可以实例化

**抽象类中可以不定义抽象方法，只为不让该类建立对象

抽象类练习：

/*

对员工进行建模，员工包含3个属性：姓名，工号，以及工资

经理也是员工，比员工多出一个奖金属性

利用继承思想设计员工类和经理类，并在勒种提供必要的方法进行属性访问

*/

abstract 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 Professional extends Employee{

Professional(String name,String id,double pay){

super(name,id,pay);

}

public void work(){

System.out.println("Professional 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");

}

}

模板方法模式

在定义功能时，功能的一部分是确定的，有一部分是不确定的

而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去

由该类的子类去完成

/*

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

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

获取时间：System.currentTimeMillis();

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

*/

abstract class getTime{

public final void GetTime(){

runcode();

long start=System.currentTimeMillis();

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<8000;x++){

System.out.print("x");

}

}

}

class TemplateDemo{

public static void main(String[] args){

getTime gt=new getTime();

gt.GetTime();

}

}