java-接口，接口和抽象类的区别

接口的特点：
  1- 接口用interface表示：
       格式:
           interface 接口名：
    2-类实现接口用implements表示：
     class 类名 implements 接口名
   3- 接口不能实例化
       实现接口的方法——通过多态方式(下面三种)。
    接口的子类：
        可以是抽象类，但是意义不大
        具体类实现接口，要重写接口中的所有抽象方法（推荐）
    1-具体类多态（几乎不用）
    2-抽象类多态（常用）
    3- 接口多态（经常用）

  接口的常用特点：
     1-  成员变量：默认修饰符：public static final
           例如：一般：public int a=0;
           实际：public static final int a=0;
     2- 构造方法：接口没有构造方法（值得注意的是当一个类实现一个接口时，这个类会默认继承一个Object类，从而该类的构造方法会首先访问父类构造方法进行数据初始化。）

     3-成员方法：接口方法不能有方法体，说明接口方法必须是抽象方法。默认修饰符是public abstract建议每次自己给出。

总结：
1-类与类：
   继承关系，只能单继承，可以多层继承
2-类与接口：
   实现关系，可以单实现，可以多实现，也可以在继承类的同时实现单个或多个接口。
    class son extends Object implements Father，Mather（）{}
3-接口与接口：
    继承关系，可以单继承和多继承
例如：interface Sister extends Father, Mather(){};
抽象类和接口的区别：
1-成员区别：
    接口：
      成员变量：可以变量也可以常量
      构造方法：有构造方法，用于子类访问父类数据的初始化。
      成员方法：可以抽象也可以非抽象
    抽象类：
      成员变量：只能常量public static final
      构造方法：没有构造方法
      成员方法：只能抽象 public abstract
2-关系区别：
  1- 类与类：
   继承关系，只能单继承，可以多层继承  

   2-类与接口：
   实现关系，可以单实现，可以多实现，也可以在继承类的同时实现单个或多个接口。
   例如：class son extends Object implements Father，Mather{}

   3-接口与接口：
    继承关系，可以单继承和多继承
    例如：interface Sister extends Father, Mather{};
3-设计理念不同：
      抽象类被继承的体现是is a的关系，该继承体系中共性的功能
      接口被实现体现的是like a 的关系，该继承体系中拓展功能。

案例：

接口Jump

package day09;

public interface Jump {
      public void jump();
}

案例：定义一个动物类：

[java]  view plain  copy

1. package day09;  
2.   
3. public abstract class AnimalDe1 {  
4.     private String name;  
5.     private int age;  
6.       
7.     public AnimalDe1(){};  
8.     public AnimalDe1(String name,int age){  
9.         this.name=name;  
10.         this.age=age;  
11.     }  
12.       
13.     public String getName(){  
14.         return name;  
15.     }  
16.     public void setName(String name){  
17.         this.name=name;  
18.     }  
19.     public int getAge() {  
20.         return age;  
21.     }  
22.     public void setAge(int age) {  
23.         this.age = age;  
24.     }  
25.     public abstract void eat();  
26.       
27. }  

定义一个狗类：

[java]  view plain  copy

1. package day09;  
2.   
3. public class DogDe1 extends AnimalDe1 {  
4.       
5.     public DogDe1(){}  
6.     public DogDe1(String name,int age){  
7.         super(name,age);  
8.     }  
9.     public void eat() {  
10.         System.out.println("狗吃肉！！！");  
11.     }  
12.   
13. }  

定义一个猫类：

[java]  view plain  copy

1. package day09;  
2.   
3. public class CatDe1 extends AnimalDe1 {  
4.     public CatDe1(){}  
5.     public CatDe1(String name,int age){  
6.         super(name,age);  
7.     }  
8.     public void eat() {  
9.         System.out.println("猫吃鱼！！！");  
10.     }  
11.   
12. }  

跳高猫类：

package day09;

public class JumpCat extends CatDe1 implements Jump {
	public JumpCat(){}
	public JumpCat(String name,int age){
		super(name,age);
	}
	public void jump() {
		System.out.println("跳高猫咪@");

	}

}

跳高狗类：

package day09;

public class JumpDog extends DogDe1 implements Jump {
	public JumpDog(){}
	public JumpDog(String name,int age){
		super(name,age);
	}
	public void jump() {
		System.out.println("跳高狗狗！");

	}

}

测试类：

package day09;


public class MainDe1 {


	/**
	 * @param args
	 */
	public static void main(String[] args) {
		JumpDog dd = new JumpDog();//调用无参构造实现
		dd.setName("狗狗1");
		dd.setAge(2);
		System.out.println(dd.getName()+"年龄："+dd.getAge());
		dd.eat();
		dd.jump();
		System.out.println("------------------");
		JumpDog dd1 = new JumpDog("狗狗2",3);//通过调用有参构造方法实现
		System.out.println(dd1.getName()+"年龄："+dd1.getAge());
		dd1.eat();
		dd1.jump();
	}
	//猫类同理！！


}

输出：

狗狗1年龄：2
狗吃肉！！！
跳高狗狗！
------------------
狗狗2年龄：3
狗吃肉！！！
跳高狗狗！

案例2：

定义一个老师类和学生类，吸烟学生类吸烟老师类实现一个吸烟接口

吸烟接口：

package day09;

public interface Smoking {
	public void smoke();

}

老师类：

package day09;

public class Teacher1 {
	private String name;
	private int age;
	
	public Teacher1(){}
	public Teacher1(String name, int age){
		this.name=name;
		this.age=age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

}

学生类：

package day09;

public class Student {
	private String name;
	private int age;
	
	public Student(){}
	public Student(String name, int age){
		this.name=name;
		this.age=age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

}

抽烟老师类：

package day09;

public class Teacher1Smoke extends Teacher1 implements Smoking{
	public Teacher1Smoke(){}
	public Teacher1Smoke(String name, int age){
		super(name,age);
	}
	public void smoke() {
		System.out.println("老师抽烟@");
		
	}

}

抽烟学生类：

package day09;

public class StudentSmoke extends Student implements Smoking {
	public StudentSmoke(){}
	public StudentSmoke(String name, int age){
		super(name,age);
	}
	public void smoke() {
		System.out.println("学生抽烟！");
		
	}

}

测试类：

package day09;

public class SmokeMain {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//创建抽烟学生对象
		StudentSmoke ss = new StudentSmoke();
		ss.setName("李春男");
		ss.setAge(24);
		System.out.println(ss.getName()+ss.getAge());
		ss.smoke();
        System.out.println("-----------------------------");
        StudentSmoke ss1 = new StudentSmoke("杨莉",24);
        System.out.println(ss1.getName()+ss1.getAge());
		ss.smoke();
		
		//老师类同理：
		
	}

}

输出：

李春男24
学生抽烟！
-----------------------------
杨莉24
学生抽烟！