1.接口
　通过interface关键字修饰的java元素就是接口。
　格式:public interface 接口名{}
　　 interface 接口名{}
2.为什么要有接口？
　为了克服java的单继承，接口可以被实现多个
　例如:收费，出租车有收费功能【1元/公里】，飞机有收费功能【全程1000元】
　出租车与飞机不是同一类事物，但是有相同的功能
　接口实际上就是提供不同类型事物的公共内容，由接口的子类根据自身的实际情况，来实现这个接口提供的公共内容。这样子类就不需要创建这个公共内容，只需要继承来重写一下就好。

3.接口中的元素
接口中可以有常量、静态方法、抽象方法。
1、接口中变量一定是 public static final修饰的常量。
2、接口中的静态方法一定是public修饰的，public可以被省略。
3、接口中的抽象方法一定是public abstract修饰的，public abstract可以省略
例如:

package com.wangxing.zyb5;
public interface  TestInterface {
	//静态成员变量
	//接口中变量一定是 public static  final修饰的常量。
	int id=1001;
	static String name="zhangsan";
	public int age=23;
	//静态方法
	//接口中的静态方法一定是public修饰的，public可以被省略。
	static void staticMethod(){}
	//抽象方法
	//接口中的抽象方法一定是public  abstract修饰的，public  abstract可以省略
	void abstractMehod();
}

package com.wangxing.zyb5;
public class Main {
	public static void main(String[] args) {
		System.out.println(TestInterface.id);
		System.out.println(TestInterface.name);
		System.out.println(TestInterface.age);
		TestInterface.staticMethod();
	}
}

4.接口的用法
　　1.接口不能new，如果需要访问抽象方法需要借助接口子类
　　2.类可以通过implements关键字去实现一个/多个接口
　　3.普通的类去实现一个/多个接口，就需要将每一个接口中的抽象方法重写，否则就需要将这个普通的类改成抽象类.
　　4.抽象类去实现一个/多个接口，不需要重写接口中的抽象方法。
　　5.接口可以继承接口，并且可以继承父接口中的所有元素.
　　6.利用接口回调对象创建出接口对象
　　7.当某一个普通的java类中的方法参数是接口类型的时候，可以传递接口回调对象，也可以是接口的子类对象。

package com.wangxing.zyb5;
public class Person implements TestInterface,DoxInterface{
	//重写DoxInterface中的抽象方法
	@Override
	public void docinfo() {
	}
	//重写TestInterface中的抽象方法
	@Override
	public void abstractMehtod() {
	}
}

public interface DoxInterface extends TestInterface{
	//抽象方法
	void docinfo();
}

package com.wangxing.zyb6;
public class Person {
	public static void Test(TestInterface hello) {
		hello.info();
	}	
}

package com.wangxing.zyb6;
public class Main {
	public static void main(String[] args) {
		//接口不能new
		//new TestInterface();
		//接口回调对象--接口的子类对象赋值给接口变量
		TestInterface  ti1=new TestSunClass();
		//接口回调对象只能访问接口的抽象方法，实际上访问子类重写以后的抽象方法
		ti1.info();
		//接口回调对象不能访问子类本身的方法，如果要访问就需要强制类型转换
		ti1.test1();
		TestSunClass tc=(TestSunClass)ti1;
		tc.test1();
	}
}

5.接口回调对象
　接口回调对象与上转型对象很相似
　接口回调对象–接口的子类对象赋值给接口变量
　　1.接口回调对象只能访问接口的抽象方法，实际上访问子类重写以后的抽象方法
　　2.接口回调对象不能访问子类本身的方法，如果要访问就需要强制类型转换
例如:

package com.wangxing.zyb6;
public class TestSunClass2 implements TestInterface{
	@Override
	public void info() {
		System.out.println("ceshi");
	}
}

package com.wangxing.zyb6;
public class Main {
	public static void main(String[] args) {
		Person Person1=new Person();
		Person1.Test(new TestSunClass());
		Person1.Test(new TestSunClass2());	
	}
}

抽象类与接口的区别?

抽象类 接口
abstract class interface
extends 一个 implments 一个/多个
提供同类型事物的公共内容 提供不同类型事物的公共内容
抽象类中的元素实例变量、类变量、构造方法、实例方法、类方法、【抽象方法】 接口中可以有类变量、JDK8.0类方法、抽象方法。且都是public修饰符修饰的
抽象方法可以有页可以没有 接口中大部分都是抽象方法
关键字
1.static 静态修饰符
　　1.被static修饰的变量是静态成员变量，可以类名访问，也可以对象访问
　　2.被static修饰的访问是静态方法，可以类名访问，也可以对象访问
　　3.同一个类中静态方法不能访问实例元素，this不能出现。
2.this 当前类对象
　　1.出现在哪个类中就表示哪个类的对象
　　2.在当前类中的构造方法/实例方法中访问当前类中的变量和方法，可以省略。
　　3.在当前类中的构造方法/实例方法中访问被隐藏的成员变量时不能省略。
3.super 父类的对象
　　1.出现在子类中的构造方法第一句时，super()父类无参数构造方法/super(参数)父类有参数构造方法。
　　2.出现在子类中的实例方法是，表示访问父类的变量/方法，访问被隐藏的父类变量，super.变量名称，此时这个super表示父类的对象，一般指访问没有重写之前的父类方法，super.方法名称([参数])，此时这个super表示父类的对象
4.final 终极修饰符
1.被fianl修饰的类，不能被继承，没有子类

public final class TestClass {
}
//错误：The type TestSunClass cannot subclass the final class TestClass
public class TestSunClass extends TestClass{
}

2.被fianl修饰的变量，就是常量，不能被重新赋值

package com.wangxing.test7;
public class Main {
	public  static  void  main(String args[]){
		final String name="zhangsan"; //局部变量
		System.out.println("name=="+name);
		//错误：被fianl修饰的变量，就是常量，不能被重新赋值
		//name="lisi";
		System.out.println("name=="+name);
	}
}

3.被fianl修饰的方法，不能被重写。

public  class TestClass {
	public final void  info(){
		System.out.println("TestClass类的实例方法");
	}
}

public class TestSunClass extends TestClass{
	/*
	被fianl修饰的方法，不能被重写。
	public  void  info(){
		System.out.println("重写从父类继承的info方法");
	}
	*/	
}