java语言的继承是单一继承，一个子类只有一个父类
java语言提供了一种机制，用于处理继承单一的局限性：接口
接口：接口是一个比抽象类还抽象的类，接口里面的所有方法都是抽象方法，接口和类的关系是实现：implement

接口的格式：

interface 接口名{
}

接口的描述

接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。
接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。
这样将功能的定义与实现分离，优化了程序设计

接口的成员特点：

只有抽象方法
只能有常量，默认使用修饰符public static final 修饰常量
只能使用public&abstract修饰方法

注：

接口不能创建对象（即不能被实例化）
类与接口的关系是实现关系，一个类实现一个接口必须实现她的所有方法

接口和类之间的关系

类与类：继承关系，单一继承，多层继承
类与接口：实现关系，多实现
接口与接口：继承关系，多层继承

public class InterfaceDemo3 {
	public static void main(String[] args) {
		
	}
}

interface InterA extends InterB {
	public abstract void method();
}

interface InterB {
	public abstract void function();
}

interface InterC extends InterA {
	
}

class Demo implements InterC {

	@Override
	public void method() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void function() {
		// TODO Auto-generated method stub
		
	}
}

接口的优点

1、打破了继承的局限性
2、对外提供规则
3、降低了程序的耦合性，可以实现模块化开发，提高了开发的效率

接口与抽象类的区别

共性：不断的抽取出抽象的概念
区别：
	1、与类的关系
		类与接口是实现关系，而且是多实现，一个类可以实现多个接口
		类与抽象类是继承关系，java的继承是单一继承，一个类只能有一个父类，java中的继承是多层继承
	2、成员
		成员变量：
			抽象类可以有成员变量，也可以有常量
			接口只能有常量
		成员方法：
			抽象类可以有抽象方法，也可以有非抽象方法
			接口只能有抽象方法，而且方法默认修饰符public  abstract
		构造方法：
			抽象类有构造方法
			接口没有构造方法

案例分析：

java中接口之间只允许单一继承 java只允许实现单一接口_java

public class InterfaceTest {
	public static void main(String[] args) {
		//创建篮球运动员对象
		BasketBallPlayer bbp = new BasketBallPlayer();
		bbp.name = "女兆月日";
		bbp.age = 35;
		bbp.gender = "男";
		bbp.sleep();
		bbp.study();
		bbp.speak();
		System.out.println("-------------");
		//创建乒乓球教练对象
		PingpangCoach ppc = new PingpangCoach();
		ppc.name = "刘胖子";
		ppc.age = 40;
		ppc.gender = "男";
		ppc.sleep();
		ppc.teach();
		//ppc.speak();
		
		
		
	}
}

class Person {
	String name;//姓名
	int age;//年龄
	String gender;//性别
	
	//无参构造
	public Person() {}
	
	//有参构造
	public Person(String name,int age,String gender) {
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	
	//吃
	public void eat() {
		System.out.println("吃饭");
	}
	
	//睡
	public void sleep() {
		System.out.println("睡觉");
	}
}

//学习说英语
interface SpeakEnglish {
	public abstract void speak();
}

//运动员
abstract class Player extends Person {
	//学习
	public abstract void study();
}

//教练
abstract class Coach  extends Person {
	//教
	public abstract void teach();
}

//篮球运动员
class BasketBallPlayer extends Player  implements SpeakEnglish{

	@Override
	public void study() {
		System.out.println("学扣篮");
	}

	@Override
	public void speak() {
		System.out.println("说英语");
	}
	
}
//乒乓球运动员
class PingpangPlayer extends Player {

	@Override
	public void study() {
		System.out.println("学抽球");
	}
	
}
//篮球教练
class BasketBallCoach extends Coach implements SpeakEnglish {

	@Override
	public void teach() {
		System.out.println("教扣篮");
	}

	@Override
	public void speak() {
		System.out.println("说英语");
	}
	
}
//乒乓球教练
class PingpangCoach extends Coach {

	@Override
	public void teach() {
		System.out.println("教抽球");
	}
	
}

匿名对象的概述和应用场景

匿名对象：即无名对象,直接使用new关键字来创建对象
匿名对象的应用场景：

当方法只调用一次的时候可以使用匿名对象
	可以当作参数进行传递，但是无法在传参之前做其他的事情
public class AnonymousObejctDemo {
	public static void main(String[] args) {
		//Student s = new Student();
		//s.study();
		//s.study();
		//s.study();
		
		//new Student();//匿名对象，没有变量引用的对象
		//new Student().study();
		//new Student().study();
		//new Student().study();
		
		//new Student().age = 18;
		//System.out.println(new Student().age);
		
		//Student s = new Student();
		//s.age = 18;
		//s.name = "张三";
		//method(s);

		method(new Student());
		
	}
	public static void method(Student s) {
	
	}
}

class Student {
	String name;
	int age;
	
	public void study() {
		System.out.println("好好学习，高薪就业");
	}
}

final的概述和作用

final：修饰符，可以用于修饰类、成员方法、成员变量
final所修饰的类，不能被继承，不能有子类
final所修饰的方法：不能被子类重写
final所修饰的变量：不能被修改，是常量

常量：

字面值常量：1、2、3
自定义常量：被final所修饰的成员变量，一旦被初始化就不可改变，一般使用英文大写

注：自定义常量必须初始化，可以选择显示初始化或者构造初始化