抽象类、接口(特殊抽象类)之张三抽烟【JAVA基础】

abstract 抽象关键字

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

举个栗子

package 黑马;
/*
 * 需求：获取一段程序运行的时间
 * 原理：获取程序开始和结束的时间并相减即可
 * 获取时间：System.currentTimeMillis();
 * */
public class ChouXiang {
	public static void main(String[] args) {
		SubTime gt=new SubTime();
		gt.getTime();

	}
}
abstract class GetTime
{
	public final void getTime() //final方法,不会发生改变
	{
		long start=System.currentTimeMillis();
		runCode() ;
		long end=System.currentTimeMillis();
		System.out.println("毫秒: "+(end-start));		
	}
	abstract public void runCode();//抽象方法
}
class SubTime extends GetTime
{
	public void runCode()
	{
		for(int x=0;x<4000;x++)
		{
			System.out.println(x);
		}
	}
}

运行结果

以上抽象类中的fianl关键字

）.1.final修饰变量，成为常量，值不能再变化
）.2.final修饰方法，不能被子类重写
）.3.final修饰类，不能再有子类(final中的方法即使不使用final修饰，也不能被重写)

抽象实际应用中的设计

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

abstract class Employee//员工类
	{
        String name;
		String id;
		double pay;
		Employee(String name,String id,double pay)
		{//有参的构造函数
			this.name=name;
			this.id=id;
			this.pay=pay;			
		}
		public abstract void 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 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"+bonus);
		}
	}

接口

接口：初期理解，可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示
class 用于定义类
interface 用于定义接口

接口定义格式：

1.接口中常见定义：常量，抽象方法。
2.接口中的成员都有固定修饰符(成员都是public类型)，java运行时自动补上
常量：public static final
方法：public abstract

interface Inter//接口
{
	public static final int NUM=3;
	public abstract void show();
}

implements -实现接口

关键字implements是实现一个接口用的关键字，它是用来实现接口中定义的抽象方法，扩展类的功能。
实现一个接口，必须实现接口中的所有方法。

package 黑马;

public class InterFaceDemo2 {

	public static void main(String[] args) {
		ZhangSan zs=new ZhangSan();
		zs.smoke();

	}

}
abstract class Student
{
	abstract void study();
	void sleep()
	{
		System.out.println("sleep");
	}	
}
interface Smoking
{
	void smoke();
}
class ZhangSan extends Student implements Smoking
{
	void study() {}
	public void smoke() {
		System.out.println("张三抽口烟");
	}
}

赠送一个关键字哈哈哈

instanceof 关键字

x instanceof int 判断x是否是int类型

经典面试：抽象类和接口的区别

• 抽象类可以存在普通成员函数，而接口中只能存在public abstract 方法。
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的
• 抽象类只能继承一个，接口可以实现多个。

接口设计的目的，是对类的行为进行约束(更准确的说是一种"有"约束，因为接口不能规定类不可以有什么行为)，也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，但不对如何实现功能进行限制。

而抽象类的设计目的，是代码复用。当不同的类具有某些相同的行为,且其中一部分行为的实现方式一致时，可以让这些类都派生于一个抽象类。达到代码复用的目的，而剩余的不相同的行为留给各个子类自己实现。

抽象类是对类本质的抽象，包含了实现子类的通用特性。
而接口是对行为的抽象，实现类是谁，接口并不关心。

抽象类的功能要远超过接口，但是，定义抽象类的代价高，每个类只能继承一个类。