接口和抽象类区别与联系-CSDN博客

本文链接：https://blog.csdn.net/weixin_46140377/article/details/123412230

本文详细介绍了Java中的抽象类和接口的概念、特点及用途。抽象类主要用于抽象共同特征，提供模板设计，而接口则侧重于行为规范，实现多继承。通过实例展示了如何使用抽象类和接口，并探讨了它们之间的区别。最后，强调了抽象类和接口在降低耦合度和提高程序可扩展性方面的重要性。

摘要由CSDN通过智能技术生成

一、什么是抽象类

抽象类是为了把相同的但不确定的东西的提取出来，为了以后的重用。定义成抽象类的目的，就是为了在子类中实现抽象类。

了解抽象类前，先了解一下抽象方法，抽象方法必须用abstract修饰，例如：abstract void run()；抽象方法是没有方法体的，只有声明，不能具体实现。

含有抽象方法的类称为抽象类，但并不是抽象类中只能有抽象方法，抽象类中也可以有普方法抽象类要用abstract修饰。

public abstract class Animal {
     private void getRun() 
     {
		System.out.println("我是一个普通的跑方法。。。。。。");
	  }
	 abstract  void  run();
}

抽象类就是用来继承的，如果定义了一个抽象类，却不去继承它，那么等于白白创建了这个抽象类。对于一个父类，如果它的某个方法在父类中实现出来没有任何意义，必须根据子类的实际需求来进行不同的实现，那么就可以将这个方法声明为abstract方法，此时这个类也就成为abstract类了。

抽象类的特点：

1.抽象类由abstract修饰，抽象类不一定包含抽象方法（但是这样设计就没有意义了），有抽象方法的类一定是抽象类。

2.抽象类中的抽象方法一定要在子类中重写并实现。

3.只有抽象类当中才能有抽象方法，普通类当中不能有抽象方法

4.抽象类当中不一定全是抽象方法，也可以使用普通方法，普通方法可以不用重写

5.抽象类不能被实例化,但是可以使用多态。（抽象类不能用来创建对象）实例化：new内存空间

6.final 不能和abstract同时使用，fianl修饰的方法禁止重写（被继承）， abstract修饰的方法要求重写（被继承），会冲突

7.private修饰的方法时子类不可见的， abstract修饰的方法要求重写，冲突，所以abstract修饰的方法只能被public和protected修饰

8.抽象方法不能使用static，static是针对类层次，抽象方法是针对对象层次的，所以不能一起使用.

9.抽象类可以有构造方法，目的是子类在初始化之前先初始化父类，既在new子类构造器之前先new父类构造器()

10.子类继承抽象类后，如果不想实现抽象类中的抽象方法，那么该子类必须是个抽象类

二、接口

接口泛指供别人调用的方法或者函数

为什么java使用接口？

有时候必须从几个类当中派生出一个子类，继承他们所有的属性和方法，但是java不支持多重继承于是就有了接口

1.关于接口的多态：

//定义一个run接口
public interface Run {
	void run();
}

//定义一个eat接口
public interface Eat {
	void eat();
}

//定义一个父类（抽象）
public abstract class Anminal {
	public void jump() {};
	public  void drunk() {};
}

//定义类本身--继承父类，实现接口
public class Cow extends Anminal implements Eat,Run{

	@Override
	public void run() {
		System.out.println("牛在跑。。。。");
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("牛在吃草。。。。。。");
	}

	public void jump() {
		System.out.println("牛在跳。。。。");
	}
	
	public void drunk() {
		System.out.println("牛在喝水。。。。");
	}
	
	public void flay() {
		System.out.println("牛在飞。。。。。");
	}
	
}

//定义测试类
public class Test{
	public static void main(String[] args) {
		//父类只能调用父类的方法
		Anminal cowAnminal = new Cow();
		cowAnminal.drunk();
		cowAnminal.jump();
		
		//eat接口只能调用eat接口的方法
		Eat Coweat = new Cow();
		Coweat.eat();
		
		//run接口只能调用run接口的方法
		Run cowRun = new Cow();
		cowRun.run();
		
		//cow自身可以调用所有方法
		Cow cow = new Cow();
		cow.drunk();
		cow.eat();
		cow.jump();
		cow.flay();
	}
}

2.接口支持多继承

public interface A {
    void test1();
}

public interface B {
    void test2();
}

public interface C extends A,B {
    void test3();
}

//实现类要是实现C接口的话，需要把C，A，B接口中所有的方法都是实现
public class D implements C {
    @Override
    public void test3() {

    }

    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}

3.接口回调

接口回调：先有接口的使用者，后有接口的实现者

//首先定义一个usb接口
public interface Usb {
	void service();
}
//定义接口的实现者Computer
public class Computer {
	Usb usb1;
	Usb usb2;
	Usb usb3;
	
	public void run() {
		System.out.println("电脑开始正常工作。。。");
		if (usb1 !=null) {
			usb1.service();
		}
		if (usb2 !=null) {
			usb2.service();
		}
		if (usb3 !=null) {
			usb3.service();
		}
	}
	
}


//定义三个实现接口的类
public class Upan implements Usb{

	@Override
	public void service() {
		System.out.println("U盘正常启动。。。");
		
	}

}

public class Mouse implements Usb{

	@Override
	public void service() {
		System.out.println("鼠标正常使用。。。");
		
	}

}

public class Feng implements Usb{

	@Override
	public void service() {
		System.out.println("风扇正常使用。。。");
	}
	
}

//测试类
public class Test{
	public static void main(String[] args) {
	Computer computer = new Computer();
    computer.usb1 = new Mouse();
    computer.usb2 = new Upan();
    computer.usb3 = new Feng();
    computer.run();	
	}
}