java抽象类和接口

一、抽象类

.抽象类没有方法体
·有抽象方法的类只能被定义成抽象类，抽象类里可以没有抽象方法。
·抽象类和抽象方法必须用abstract修饰符来修饰。
·抽象类不能被实例化。

定义一个抽象类：

abstract class A{//定义一个抽象类
	
	public void fun(){//普通方法
		System.out.println("存在方法体的方法");
	}
	
	public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
	
}

·抽象类的作用：作为其子类的模板，从而避免了子类设计的随意性。
·抽象类的抽象方法必须在子类中全部得到实现。

定义一个抽象行为类：

package com.wz.abstractdemo;

public abstract class Action{
	
	public static final int EAT = 1 ;
	public static final int SLEEP = 3 ;
	public static final int WORK = 5 ;
	
	public abstract void eat();
	public abstract void sleep();
	public abstract void work();
	
	public void commond(int flags){
	  switch(flags){
		case EAT:
			this.eat();
			break;
		case SLEEP:
			this.sleep();
			break;
		case WORK:
			this.work();
			break;
		case EAT + SLEEP:
			this.eat();
			this.sleep();
			break;
		case SLEEP + WORK:
			this.sleep();
			this.work();
			break;
		default:
			break;
		}
	}
}

定义一个机器人的类：

package com.wz.abstractdemo;

public class Robot extends Action{

	@Override
	public void eat() {
		System.out.println("机器人充电");
		
	}

	@Override
	public void sleep() {
		
	}

	@Override
	public void work() {
		System.out.println("机器人工作");
		
	}
	

定义一个人的类：

package com.wz.abstractdemo;

public class Human extends Action{

	@Override
	public void eat() {
		System.out.println("人吃饭");
		
	}

	@Override
	public void sleep() {
		System.out.println("人睡觉");
		
	}

	@Override
	public void work() {
		System.out.println("人工作");
		
	}
	
}

定义一个🐖的类：

package com.wz.abstractdemo;

public class Pig extends Action{

	@Override
	public void eat() {
		System.out.println("猪进食");
		
	}

	@Override
	public void sleep() {
		System.out.println("猪睡觉");
		
	}

	@Override
	public void work() {
		
		
	}
	
}

测试主类：

package com.wz.abstractdemo;

public class AbstractDemo {

	public static void main(String[] args) {
		
		fun(new Robot());
		
		fun(new Human());
		
		fun(new Pig());

	}
	
	public static void fun(Action act){
		act.commond(Action.EAT);
		act.commond(Action.SLEEP);
		act.commond(Action.WORK);
	}

}

运行结果：

机器人充电
机器人工作
人吃饭
人睡觉
人工作
猪进食
猪睡觉

二、接口

·特殊的抽象类——接口。
接口定义：

 [修饰符] interface 接口名 extends 父接口1，父接口2...
 {
 零个到多个常量定义...

·接口不可实例化
·修饰符可以是public或者省略。
·一个接口可以继承多个父接口，但不能继承类
·接口里包含成员变量、方法、内部类，不包含构造器和初始化块定义。
·接口里的成员变量只能使用public static final来修饰。
·接口里的方法只能是抽象方法、类方法或默认方法
·接口里，默认方法用default修饰，类方法用static修饰，无论开发者是否指定，这两种方法系统都会自动添加public修饰符。
·接口的作用：1.java不像c++一样支持多继承，所以用接口来弥补 2.用来实现抽象（和抽象类有所区别）。

使用接口：

[修饰符] class 类名 extends 父类 implements 接口1，接口2...
{
	类体部分
}

·继承使用extends，实现使用implements，一个类可以实现多个接口

定义usb接口：

interface USB {
    void read();

    void write();
}

实现U盘类：

class YouPan implements USB {
    @Override
    public void read() {
        System.out.println("U盘正在通过USB功能读取数据");
    }
    @Override
    public void write() {
        System.out.println("U盘正在通过USB功能写入数据");
    }
}

实现键盘类：

class JianPan implements USB {
    @Override
    public void read() {
        System.out.println("键盘正在通过USB功能读取数据");
    }
    @Override
    public void write() {
        System.out.println("键盘正在通过USB功能写入数据");
    }
}

测试主类：

public class Main {
    public static void main(String[] args) {
        //生成一个实现可USB接口（标准）的U盘对象
        YouPan youPan = new YouPan();
        //调用U盘的read( )方法读取数据
        youPan.read();
        //调用U盘的write( )方法写入数据
        youPan.write();
        //生成一个实现可USB接口（标准）的键盘对象
        JianPan jianPan = new JianPan();
        //调用键盘的read( )方法读取数据
        jianPan.read();
        //调用键盘的write( )方法写入数据
        jianPan.write();
    }
}

运行结果：

键盘正在通过USB功能读取数据
键盘正在通过USB功能写入数据
键盘正在通过USB功能读取数据
键盘正在通过USB功能写入数据

三、接口&抽象类

区别：
1.接口里只包含抽线方法和默认方法，不能为普通方法提供方法实现；抽象类可以包含普通方法。
2.接口里不能定义静态方法，抽象类可以定义静态方法。
3.接口里只能定义静态常量，不能定义普通成员变量；抽象可以定义静态常量和普通成员变量。
4.接口里不包含构造器，抽象类里可以包含构造器。
5.接口里不能包含初始化块，抽象类里可以包含初始化块。
6.一个类只能有一个直接父类，可以有多个接口。