接口和抽象类的区别

一.抽象类：

1.什么是抽象方法？

   就是只有方法的声明，没有方法体实现，即在小括号后面直接分号，没有大括号。public abstract void eat();

   抽象方法定义的语法：abstract关键字，在返回值得声明之前。

2.为什么？何时需要有抽象方法？

   1）我们创建一个类，但是并不知道这个类的某个行为如何实现；

   2）创建一个类之后，方法的实现并不需要本类实现，而是需要在子类中实现；

   3）某个行为在本类中不方便实现，或者暂时无法实现；

3.抽象类：如果一个类的定义前面有abstract关键字修饰，name这个类就是抽象类；

    抽象类除了不能创建实例外，其它和普通类的特性一致；

4.抽象类的特点：

   1）无法创建抽象类的实例；

   2）一个类中如果存在一个或多个抽象方法的话，那么这个类必须是抽象方法；

   3）如果将一个类定义为抽象类，这个类中可以没有抽象方法；

5.抽象类的作用：由于抽象不能定义实例，通常情况下，需要由子类来继承抽象类，自诶继承抽象类之后，必须实现（重写）

   抽象类的全部抽象方法，如果仍然不能全部提供 实现的话，则其也必须定义为抽象类，

 

二.接口：

1.接口不是类，接口是使用关键字interface定义；

2.接口特点：

   1）接口中的方法全都是公有的抽象方法；

   2）接口中不允许存在成员属性；

   3）接口不能实例化；

   4）定义静态常量（final属性）；

   5）抽象类是类，一个类最多只能继承一个抽象类，接口不是类，一个类可以实现多个接口，当实现多个接口的时候就需要对

         所实现的接口中的所有抽象方法都提供实现；

3.一个类实现一个接口使用implements关键字，实现一个接口之后，就必须对接口中的所有抽象方法提供实现，如果不能全部

  提供实现的话，则只能作为一个抽象类；

4.多态的实现可以使用抽象类指向子类的实现，也可以使用接口来指向子类的实现；

5.一个接口可以继承另一个或多个接口，继承接口时使用extends关键字；

6.面向接口编程，使用接口来指向一个具体的实现类，在程序中仅使用接口，而不关注其具体实现；

 

抽象类：

package com.shsxt.abstract02;
/*
 * 抽象类    : 被abstract修饰的类
 * 抽象方法 : 被abstract修饰的方法
 * 	没有方法体
 *  必须存在抽象类中
 * 
 * 定义开发部:
 * Develop开发部    功能:工作
 * 	Java工程师  功能:工作
 * 	web工程师     功能:工作
 * 
 * 注意:
 * 	1.抽象类不能实例化
 * 	2.抽象方法必须存在于抽象类中
 * 	3.抽象类中可以存在抽象方法,可以存在具体方法(有方法体的方法)
 * 	4.通过子类使用抽象类:
 * 		具体子类:重写抽象父类中的所有抽象方法+按需新增
 * 		抽象子类:按需重写抽象方法+按需新增
 *  5.一个抽象方法如果已经被冲写过,就可以不需要再次重写
 *  6.抽象方法必须被重写
 *  7.abstract不能和static, final,private,native一起使用
 */
public abstract class Develop {
	//不知道怎么定义方法体,就不写,没有方法体的方法只能为抽象方法
	public abstract void work();
	public abstract void sleep();
	
	public void haha(){
		System.out.println("哈哈一笑");
	}
}

 

接口：

package com.shsxt.interface03;
/*
 * 接口:  interface定义
 * 	特殊的抽象类
 * 	
 *  能用接口就是用接口
 *  
 *  在1.7及之前:
 *  	静态的公共的常量+公共的抽象的方法
 *  	属性:
 *  		public static final默认修饰符,可以选择性的省略
 *  	功能:
 *  		public abstract 默认修饰符,可以选择性的省略
 *  
 *  1.8及之后版本:
 *  	1.静态方法:接口名字. 使用
 *  	2.默认方法:实现类的对象使用
 *  注意:
	 *  1.类的继承,接口需要实现
	 *  2.抽象方法必须被重写
	 *  3.使用接口中的内容:接口需要实现implements,类要使用extends继承
	 *  	具体的实现类: 重写接口中的所有抽象方法+按需新增
	 *  	抽象的实现类: 按需重写抽象方法+按需新增
	 *  
	 *  4.单继承,一个类只能继承一个类,接口可以多实现,实现了接口,就拥有了接口中定义的功能
	 *  5.一个类及继承父类又实现接口,先继承后实现
	 *  6.避免实现的多个接口中定义了相同的功能
	 *  7.接口可以多继承其他接口,不能是实现接口的(实现:对抽象方法方法体的实现)
	 *  8.接口不能实例化
	 *  		
	 *  
 * 接口的优点:
 * 	避免单继承的局限性  (推荐使用接口)
 *  提高代码的复用性
 *  解耦:高内聚低耦合  
 *  定义规范
 *  
 *  根据不同的需求:定义类,抽象类,接口,推荐使用接口
 */
public abstract class InterfaceDemo implements MyIn{
	public static void main(String[] args) {
		System.out.println(MyIn.A);
	
		//new InterfaceDemo().haha();
		
		MyIn.heihei();
		new Demo().houhou();
	}

	@Override
	public int haha() {
		System.out.println("我是重写的抽象方法");
		return 0;
	}
	
	//public abstract  void hehe();
}

class Demo implements MyIn{

	@Override
	public int haha() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public void hehe() {
		// TODO Auto-generated method stub
		
	}
	
}
//自定义的接口
interface MyIn{
	//公共的静态的常量
	int A=5;
	//定义了有这个功能  
	int haha();
	void hehe();
	//静态方法
	public static void heihei(){
		System.out.println("heihei..........");
	}
	
	//默认方法
	public default void houhou(){
		System.out.println("嘤嘤怪...");
	}
}

interface A{
	void a();
}
interface B{
	void b();
}

//一个接口继承其他的接口   
interface D extends A,B{}

class O{}

class C extends O implements D {

	@Override
	public void b() {
		
	}

	@Override
	public void a() {
		
	}
	
}