java abstract类如何调用 java abstract class

抽象类（abstract class）

一、概念

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

二、抽象类的特征

1、用abstract关键字来修饰一个类时，这个类叫做抽象类

2、用abstract来修饰一个方法时，该方法叫做抽象方法

抽象方法：只有方法的声明，没有方法的实现。以分号结束。

• abstract int abstractMethod(int a);

3、含有抽象方法的类必须被声明为抽象类。

4、抽象类不能被实例化。

抽象类是用来作为父类被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类

• 只要类中有一个抽象的方法，那么这个类就必须是一个抽象类

5、不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法

三、抽象类举例

//Animal.java
public abstract class Animal{
	public abstract void test();//只要类中有一个抽象方法，类就必须是一个抽象类

	public abstract void move();
}

class Dog extends Animal{
	@Override
	public void test(){
	}
	
	@Override
	public void move(){
		System.out.println("狗的移动方式是跑");
	}
}

class Fish extends Animal{
	@Override
	public void test(){
	}
	
	@Override
	public void move(){
		System.out.println("鱼的移动方式是游");
	}
}

abstract class Bird extends Animal{//抽象类可以继承抽象类
	@Override
	public void move(){
	}
	
	@Override
	public abstract void test();//只要类中有一个抽象方法，类就必须是一个抽象类
}

//Test.java
public class Test{
	public static void main(String[] args){
		Dog d = new Dog();
		d.move();
	}
}

四、抽象类应用

抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。

五、思考

1、为什么抽象类不可以使用final关键字声明

• final是最终，它修饰的类是最终的类，不能被继承 。
• 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。
• 抽象类如果想要使用，必须继承抽象类，实现那些抽象的方法

2、一个抽象类中可以定义构造器吗

抽象类可以有构造方法，只是不能直接创建抽象类的实例对象
抽象类不能实例化。new Vihicle（）是非法的

六、练习

编写一个Employee类，声明为抽象类，包含如下三个属性：name，id，salary。提供必要的构造器和抽象方法：work（）。
对于Manager类来说，他既是员工，还具有奖金（bonus）的属性。
请使用继承的思想，设计CommonEmployee类和Manager类。要求类中提供必要的方法进行属性访问。

//Employee.java
public abstract class Employee{
	public Employee(){
	}

	int id;
	String name;
	double salary;

	public abstract void work();
}

class CommonEmployee extends Employee{
	
	public void setCommonEmployeeInfo(int id,String name,double salary){
		super.id = id;
		super.name = name;
		super.salary = salary;
	}

	public void getCommonEmployeeInfo(){
		System.out.println("super.id");
		System.out.println("super.name");
		System.out.println("super.salary");
	}

	@Override
	public void work(){
		System.out.println("这是一个普通员工");
	}

	class Manager extends Employee{
		double bonus;
	
		public void setManagerInfo(int id,String name,double salary,double bonus){
			super.id = id;
			super.name = name;
			super.salary = salary;
	
			this.bonus = bonus;
	}

		public void getCommonEmployeeInfo(){
			System.out.println(super.id);
			System.out.println(super.name);
			System.out.println(super.salary);
			System.out.println(this.bonus);
	}

		@Override
	public void work(){
		System.out.println("这是领导");
	}
	}
}

//Test.java
public class Test{
	public static void main(String[] args){
		CommonEmployee ce = new CommonEmployee();
		ce.work();
		ce.setCommonEmployeeInfo(123,"张三"，6354.31);
		ce.getCommonEmployeeInfo();
	}
}

模板设计模式

一、概念

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式

二、解决的问题

1. 当功能内部一部分实现是确定、一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现
2. 编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式

三、示例

//Template.java
public abstract class Template{
	public abstract void code();

	public final void getTime(){
		long start = System.currentTimeMillis();
		code();
		long end = System.currentTimeMillis();

		System.out.println("code方法执行的时间：" + (end - start));
	}
}

class TestTmp extends Template{
	@Override
	public void code(){
		int k = 0;
		for(int i = 0; i < 50000; i++){
			k += 1;
		}
		System,out.println(k);
	}
}

//Test.java
public class Test{
	public static void main(String[] args){
		TestTmp t = new TestTmp();
		t.getTime();
	}
}