abstract (抽象的) 与 interface（接口）的区别

1.abstract 抽象的
（1）类 抽象类
①抽象类编译之后会生成独立的 .class 文件
②只能声明引用, 不能创建对象。
③供子类去继承。
④生活中, 抽象类是从不同的子类中抽 象出的父类, 自身不存在对象 如:动物类, 交通工具类。
（2）方法 抽象方法
①只有方法声明, 没有方法实现 方法实现部分用 分号 代替。
②留给子类实现 (覆盖)。
③只声明了对象具有什么功能, 没有定义对象如何实现该功能。

（3）抽象类和抽象方法的关系
① 如果一个类具有抽象方法, 那么这个类就必须是抽象类。
②抽象类中未必有抽象方法。
③子类继承抽象类, 如果子类不希望也成为抽象类, 就必须实现父类中所有的抽象方法。

——引用可以调用其引用类型中声明的所有方法, 包括抽象方法

	Super s = XXXX; 
	s.method();
abstract class Super{
	public abstract void method();
}

——方法的声明和实现分离. 声明放在父类, 实现留给子类 ---- 子类的共性放在父类
（4）抽象类强制使用多态
抽象类类名 引用名 = new 子类类名（形参）;

public class TestAbstract{
	public static void main(String[] args){
		MyClass mc ;
		mc = new Sub(); // 强制使用多态
		mc.m1();
		mc.m2();
		mc.m3();
	}
}
//抽象类
abstract class MyClass{
	int a; // 属性
	public void m1(){
		System.out.println("m1()...");
	}	
	public abstract void m2();
	abstract public void m3();
}
// 子类
class Sub extends MyClass{
	public void m2(){
		System.out.println("m2()实现内容...");
	}
	public void m3(){
		System.out.println("m3()...实现内容.../");
	}
}

2.接口（interface）
接口：是一种标准、规范，接口的使用者和接口的实现者都必须遵循的约定。
语法：（基于 jdk7.0 版本） 【重点】
(1) 关键字： interface
interface 接口名{}
(2) 接口在编译之后会生独立 .class 文件
(3) 接口不能创建对象，但是可以声明引用。
接口名 变量名;
(4) 接口中没有构造方法
private、static、final可以组合使用。
(5) 接口中属性都是公开、静态、常量(默认被 public static
final 修饰)
(6) 接口中方法都是公开、抽象方法(默认被 public abstract
修饰)
注意：接口从语法角度是一个特殊的抽象类，是对抽象类进
一步的抽象。
但是接口 从 Java分类：不是类。

public class TestMyInter{
	public static void main(String[] args){
		MyInter mi ;
		//MyInter.n = 20;
		System.out.println(MyInter.n);
		System.out.println(MyInter.m);
		//MyInter.m = 50;
	}
}
// 抽象类
/*
抽象类不能单独new 对象，但是可以声明引用
抽象类：编译之后生成独立的 .class
*/
abstract class MyClass{
	int a = 3;  // 实例变量
	static int b = 7; // 静态变量

	public MyClass(){}
	public void m1(){}
	public abstract void m2();
}
// 接口:共语法角度，相当于 特殊的抽象类
interface MyInter{
	int m =0;  // 默认 被 static ,同是 被 final修饰
	static int n = 7; // 静态变量,默认 被 final修饰
	//public MyInter(){} // 接口中没有构造方法
	public void t1();// 默认的被 publicabstract 修饰
	public abstract void t2();
	void t3();// 被 public abstract 修饰
}

实现类【开发应用重点】
(1) 语法：
class 类名 implements 接口名{}
(2) 注意：
a. 如果实现类不想定义为 抽象类，则必须覆盖接口中所
有的抽象方法，同时给与实现；否则实现类必须定义为抽象类。
b. 接口中方法默认的访问权限为 public ，所以实现类覆盖接口中的方法时访问修饰符必须也是 public。因为 类中方法如果不谢访问修饰符。默认的访问权限为 default。
(3) 使用：接口类型的引用中可以存储 实现类的对象，多态的应用
语法：接口名 引用 = new 实现类类名(实参);
注意：如果以接口类型的引用调用方法，只能调用 接口
中有的方法。
(4) 案例：

public class TestInter{
	public static void main(String[] args){
		// 接口类型的引用 --》 实现类的对象
		MyInter mi = new MyClass();  // 多态
		mi.m1();
		mi.m2();
		//mi.m3();
	}

// 接口
interface MyInter{
	public void m1();// 默认 被 abstract
	void m2(); //默认 public abstract 修饰
}
// 接口的实现类 （从语法角度：类 继承一个 特殊的 抽象
类）
class MyClass implements MyInter{
	public void m1(){
		System.out.println("m1方法的实现....");
	}
	public void m2(){
		System.out.println("m2方法的实现....");
	}
	public void m3(){}
}

Java中接口的继承性 【开发应用重点】
(1) 接口与接口之间是多继承
语法：interface 接口名 extends 父类接口1,父接口2{}
(2) 类和接口是实现的关系：即一个类可以同时实现多个接口
① 语法： class 类名 implements 接口名1,接口名2{ }
}
② 注意：如果实现类不想成为抽象类,必须覆盖所有接口中
的所有方法
(3) 一个类继承一个父类的同时可以实现多个接口：
① 语法：class 类名 extends 父类 implements 接口1,接口
名2{}
② 注意：必须先定义继承，再定义实现

public class Test6{
 	public static void main(String[] args){
		MyClass mc = new MyClass();
		ClassA ca = mc;
 		ca.m6();
	}
}
interface IA{
	void m1();
	void m2();
}
interface IB{
	void m3();
}
interface IC extends IA,IB{
	void m4();
}
interface ID{
	void m5();
}
// 类和接口的多实现
class MyClass extends ClassA implements IC,ID {
	public void m1(){
		System.out.println("m1()...");
	}
	public void m2(){
		System.out.println("m2()...");
	}
	public void m3(){
		System.out.println("m3()...");
	}
	public void m4(){
		System.out.println("m4()...");
	}
	public void m5(){
		System.out.println("m5()...");
	}
}
class ClassA{
	public void m6(){
		System.out.println("m6()...");
	}
}

抽象类与接口区别：