抽象方法与抽象类和接口的区别
主要内容
包括抽象类与抽象方法和接口的定义和特性，以及两者之间的使用区别
1. 抽象方法与抽象类
只声明而不提供任何实现的方法称为抽象方法，含有抽象方法的类必须声明为抽象类

抽象方法、抽象类都必须必须使用abstract修饰
抽象类不能new对象，必须被继承，且必须实现其中的抽象方法才能使用
抽象类中不是所有的方法都是抽象方法，可以在抽象类中声明并实现方法
抽象类的子类必须在实现父类所有的抽象方法才能实例化，否则这个子类也是一个抽象类
若多个类具有相同的方法声明，而方法的实现不一样，这时就可以抽象出父类，将方法在父类中声明

package inter;
//抽象类
public abstract class AbstractTest {

	public AbstractTest() {
		System.out.println("执行父类构造方法");
		// TODO Auto-generated constructor stub
	}
//	非抽象方法
	public void display() {
		System.out.println("AbstractTest.display()");
	}
//	声明抽象方法
	public abstract void abstractMethod();
	public static void main(String[] args) {
		TestExemple p = new TestExemple();
		p.abstractMethod();
	}
}
//继承并实现抽象父类
class TestExemple extends AbstractTest{
	TestExemple(){
		System.out.println("执行子类构造方法");
	}
//	实现抽象方法
	@Override
	public void abstractMethod() {
		System.out.println("实现的抽象方法");
		// TODO Auto-generated method stub
		
	}
}

运行结果
执行父类构造方法
执行子类构造方法
实现的抽象方法


2. 接口
若一个抽象类中所有的方法都是抽象方法，而且这个抽象类中的数据成员都是final常量，那么这个抽象类就是一个接口，接口是一种特殊的抽象类，从Java8开始允许在接口中定义方法，并实现默认方法和静态方法
接口的特性

接口中的常量默认为public static final，并且也只能是public static final
接口中的抽象方法默认为public abstract，并且也只能是public abstract类型
接口通过implements可以继承其他接口，并添加新的属性和抽象方法
接口不能继承抽象类，Java中不允许类的多继承，但允许接口的多继承
在接口中声明方法时，不能使用native、final、synchronized、private、protected等修饰符
不允许创建接口的实例，但允许定义接口类型的引用变量，该变量可引用实现了该接口的类的实例
一个类只能继承另外一个类，但能同时实现多个接口，并且重写的方法必须显式声明为public
Java8允许在接口中定义默认方法，默认方法必须使用default修饰，且不能使用static修饰，无论是否显式指定，默认方法总是使用public修饰
不能直接使用接口来调用默认方法，需要使用接口的实现类的实例来调用默认方法
java8中还允许在接口中定义static修饰的静态方法，无论是否显式指定，静态方法总是使用public修饰
接口中的变量、静态方法可以直接使用接口名来调用

package intfs;

/**
 * @author wonzeng
 * 2020年7月10日
 */
//定义一个接口，还可以使用extends继承一个多个接口
public interface InterfaceTest {
	int Default_Number = 300;
//	在接口中定义的常量默认具有public, static, final的属性
//	接口的实现类中不能修改，只能读取
//	接口中的变量定义时就必须初始化
	
	
//	default关键字，声明默认接口，实现类中可以不用重写
	public default void defaultMethod() {
		System.out.println("接口中的默认方法");
	}
	
//	静态方法
	public static void staticMethod() {
		System.out.println("接口中的静态方法");
	}
	
//	没有实现的方法
	public void waitAchieve();
//	main方法
	public static void main(String[] args) {

//		接口名调用静态方法
		InterfaceTest.staticMethod();
//		接口名调用静态变量
		System.out.println(InterfaceTest.Default_Number);
		
//		实现接口方式1
		AcheiveImp imp = new AcheiveImp();
		imp.waitAchieve();
		
//		实现接口方式2
		InterfaceTest p = new InterfaceTest() {

			@Override
			public void waitAchieve() {
				System.out.println("匿名内部类实现接口");
				// TODO Auto-generated method stub
				
			}
			
		};
		p.waitAchieve();
		
//		实现接口方式3
		InterfaceTest p2=()->{
			System.out.println("lambda实现接口中的方法");
		};
		p2.waitAchieve();
	
	}


}
// 实现接口
class AcheiveImp implements InterfaceTest{

	public AcheiveImp() {
		// TODO Auto-generated constructor stub
	}

//实现接口中的方法
	@Override
	public void waitAchieve() {
		System.out.println("通过创建类实现接口中的方法");
		// TODO Auto-generated method stub
		
	}
}


运行结果
接口中的静态方法
300
通过创建类实现接口中的方法
匿名内部类实现接口
lambda实现接口中的方法

抽象类和接口的区别

抽象类中可以有不抽象的方法，接口中全是抽象的方法
抽象类用extends继承，接口用implements实现
抽象类中的变量和方法没有默认修饰符，接口中的变量默认为public static final的，接口中的方法默认为public abstract
一个类只能继承一个抽象类，一个类可以实现多个接口

抽象类与接口的选择


如果能用接口，就不用抽象类，因为别人实现接口可以不占用继承的位置


如果定义一个抽象的父类，其中所有方法都是抽象的，那么就定义为接口


如果定义一个抽象的父类的时候，需要有不抽象的方法，那么只能定义为抽象类

1.定义
① 抽象类：
任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。
 
定义为抽象的类不能被实例化。抽象类必须有abstract关键字修饰。
例子：
 

abstract class Person{}

 
 
 
 
 
②抽象方法：


使用abstract关键字修饰的类就是抽象类。抽象方法没有具有的方法体
例子：

abstract function say();

 
抽象类的注意事项：
① 抽象类可以包含非抽象方法；
② 包含抽放方法的类。必须是抽象类；
抽象类，并不一定必须包含抽象方法；
③ 抽象类，不能实例化；
(抽象类中可能包含抽象方法，抽象方法没有方法体，实例化调用没有意义)
 
 
抽象类的作用：
① 限制实例化。(抽象类是一个不完整的类，里面的抽象方法没有方法体，所以不能实例化)
② 抽象类为子类的继承提供一种规范。子类继承一个抽象类，则必须包含并且实现抽象类中已定的抽象方法。
 
注意：子类继承抽象类，那么子类必须重写父类的所有抽象方法，除非子类也是抽象类！
 
转载于:https://www.cnblogs.com/Xuedz/p/6987011.html

抽象方法是没有主体的方法签名声明。 例如：
public abstract class Shape {
. . .
public abstract double getArea();
public abstract double getPerimeter();
}
方法Shape和getPerimeter()是抽象的。 由于Shape类具有抽象方法，因此也必须将其声明为abstract。 也可以在没有任何抽象方法的情况下将类声明为abstract。 当一个类是抽象的时，就不能创建它的一个实例。 一个人只能创建(具体)子类的实例。 具体类是未声明为抽象的类(因此没有抽象方法，并且实现了所有继承的抽象方法)。 例如：
public class Circle extends Shape {
public double radius;
. . .
public double getArea() {
return Math.PI * radius * radius;
}
public double getPerimeter() {
return 2.0 * Math.PI * radius;
}
}
这样做有很多原因。 一种方法是编写一种对于所有形状都相同的方法，但该方法取决于在Shape级别未知的特定于形状的行为。 例如，可以编写该方法：
public abstract class Shape {
. . .
public void printArea(PrintStream out) {
out.println("The area is " + getArea());
}
}
诚然，这是一个人为的示例，但它显示了基本思想：根据未指定的行为定义具体的行为。
拥有抽象类的另一个原因是，您可以部分实现接口。 接口中声明的所有方法均由实现该接口的任何类继承为抽象方法。 有时，您想在类中提供接口的部分实现，而将细节留给子类。 部分实现必须声明为抽象。

抽象类是什么
JAVA可以定义没有方法体的方法，该方法可以由子类来实现。没有方法体的方法足够抽象所以我们叫它 抽象方法，而具有抽象方法的类我们一般称之为抽象类；抽象类甚至可以是一个没有任何方法体的纯方法声明的特殊类。我们举个例子：
抽象类的特点
1、必须通过abstract来实现。

2、可以修饰类或方法。

3、有抽象方法的类必须定义为抽象类。

对于这三个特点我们举个例子：
abstract class A{
	abstract void print();
}

4、抽象类中可以没有抽象方法。
abstract class A{
//	abstract void print();
	void chage() {
		
	}
}

5、子类在继承抽象类后，如果没有将所有抽象类的方法重写，则还是一个抽象类。

6、无法被实例化。
public class abstractclass {
	public static void main(String[] args) {
		B  b = new B();
	}
}
abstract class A{
	abstract void print();
	void chage() {
		
	}
}
abstract class B extends A{
//	void print() {
//		
//	}
}

首先这个代码无法运行，因为B是个抽象类，抽象类无法被实例化，这两个特点也被证实了。

7、多用于多态。

抽象的类与方法就是为了让子类去实现，不同的子类实现方式不一样自然就是多态了。
抽象类的用处
1.抽象类虽然不能被实例化，但是它也有他的构造方法，他的构造方法的目的是为了去给子类实例化。在继承那里我们曾经说过（在实例化子类的时候，我们需要先去实例化它的父类）。

2.抽象类的成员变量可以是变量也可以是常量。
public class abstractclass {
	public static void main(String[] args) {
		B  b = new B();
		C  c = new C();
		b.print();
		c.print();
	}
}
abstract class A{
	abstract void print();
}
class B extends A{
	void print() {
		System.out.println("B");
	}
}
class C extends A{
	void print() {
		System.out.println("C");
	}
}

拿百度百科的话做个总结：

“抽象类是用来捕捉子类的通用特性的，是被用来创建继承层级里子类的模板。现实中有些父类中的方法确实没有必要写，因为各个子类中的这个方法肯定会有不同；而写成抽象类，这样看代码时，就知道这是抽象方法，而知道这个方法是在子类中实现的，所以有提示作用。”