接口、匿名内部类

接口、匿名内部类

接口

概述

• 一方面，有时必须从几个类中派生出一个子类，继承它们所有的方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
• 另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。
• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。has-a
  • 例如：你想要会飞，那么必须拥有fly()方法
  • 例如：你想要连接USB，那么必须拥有read()/in()和write()/out()等
  • 例如：你的数据库产品想要被Java连接，那么你需要实现Connection, Statement等
• 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

定义格式

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。

接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组，类，接口。

接口的声明格式

【修饰符】 interface 接口名{
    
    
    //接口的成员列表：
    // 静态常量
    // 抽象方法
    // 默认方法
    // 静态方法
    // 私有方法
}

示例代码：

interface Flyable{
    
    
    //静态常量
	long MAX_SPEED = 7900000;//这里单位是毫米/秒，7.9千米/秒，超过这个速度，就变成卫星
    
    //抽象方法
	void fly();
    
    //默认方法
    public default void start(){
    
    
        System.out.println("开始");
    }
    public default void stop(){
    
    
        System.out.println("结束");
    }
    
    //静态方法
    public static void broken(){
    
    
        System.out.println("飞行中遇到物体就坏了");
    }
}

在JDK8之前，接口中只运行出现：

（1）公共的静态的常量：其中public static final可以省略

（2）公共的抽象的方法：其中public abstract可以省略

在JDK1.8时，接口中允许声明默认方法和静态方法：

（3）公共的默认的方法：其中public 可以省略，建议保留

默认方法相当于允许给接口的抽象方法给出默认实现了，这样实现类（子类）既可以选择使用默认实现，还可以选择重写，更灵活了

（4）公共的静态的方法：其中public 可以省略，建议保留

静态方法：因为之前的标准类库设计中，有很多Collection/Colletions或者Path/Paths这样成对的接口和类，后面的类中都是静态方法，而这些静态方法都是为前面的接口服务的，那么这样设计一对API，不如把静态方法直接定义到接口中使用和维护更方便。

默认方法：我们要在已有的老版接口中提供新方法时，如果添加抽象方法，就会涉及到原来使用这些接口的类就会有问题，那么为了保持与旧版本代码的兼容性，只能允许在接口中定义默认方法实现。比如：Java8中对Collection、List、Comparator等接口提供了丰富的默认方法。

实现接口

接口的使用，它不能创建对象，但是可以被实现（implements ，类似于被继承）。

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

1.实现接口语法格式

【修饰符】 class 实现类  implements 接口{
    
    
	// 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
  	// 重写接口中默认方法【可选】
}

【修饰符】 class 实现类 extends 父类 implements 接口{
    
    
    // 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
  	// 重写接口中默认方法【可选】
}

非抽象子类实现接口：

1. 必须重写接口中所有抽象方法。

2. 继承了接口的默认方法，即可以直接调用，也可以重写。

   重写时，default单词就不要再写了，它只用于在接口中表示默认方法，到类中就没有默认方法的概念了

3. 不能重写静态方法

示例代码：

class Bird implements Flyable{
    
    

	//重写/实现接口的抽象方法，【必选】
	public void fly() {
    
    
		System.out.println("展翅高飞");
	}
	
	//重写接口的默认方法，【可选】
	//重写默认方法时，default单词去掉
	public void start(){
    
    
        System.out.println("先扇两下翅膀，一蹬腿，开始飞");
    }
}

2.如何调用对应的方法

• 对于接口的抽象方法、默认方法，通过实现类对象就可以调用
• 但是对于静态方法，必须使用接口名才能调用。

public class TestInteface {
    
    
	public static void main(String[] args) {
    
    
		//创建实现类对象
		Bird b = new Bird();
		
		//通过实现类对象调用重写的抽象方法，以及接口的默认方法，如果实现类重写了就执行重写的默认方法，如果没有重写，就执行接口中的默认方法
		b.start();
		b.fly();
		b.stop();
		
		//通过接口名调用接口的静态方法
		Flyable.broken();
	}
}

接口的多实现

之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

实现格式：

【修饰符】 class 实现类  implements 接口1，接口2，接口3。。。{
    
    
	// 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
  	// 重写接口中默认方法【可选】
}

【修饰符】 class 实现类 extends 父类 implements 接口1，接口2，接口3。。。{
    
    
    // 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
  	// 重写接口中默认方法【可选】
}

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。

定义多个接口：

interface A {
    
    
    public abstract void showA();
    public abstract void show();
}

interface B {
    
    
    public abstract void showB();
    public abstract void show();
}

定义实现类：

public class C implements A,B{
    
    
    @Override
    public void showA() {
    
    
        System.out.println("showA");
    }

    @Override
    public void showB() {
    
    
        System.out.println("showB");
    }

    @Override
    public void show() {
    
    
        System.out.println("show");
    }
}

冲突问题

1.亲爹优先原则

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的抽象方法重名，子类就近选择执行父类的成员方法。代码如下：

定义接口：

interface A {
    
    
    public default void methodA(){
    
    
        System.out.println("AAAAAAAAAAAA");
    }
}

定义父类：

class D {
    
    
    public void methodA(){
    
    
        System.out.println("DDDDDDDDDDDD");
    }
}

定义子类：

class C extends D implements A {
    
    
  	// 未重写methodA方法
}
class B extends D implements A{
    
    
    //当然也可以选择重写
    public void methodA(){
    
    
        System.out.println("BBBBBBBBBBBB");
    }
}

定义测试类：

public class Test {
    
    
    public static void main(String[] args) {
    
    
        C c = new C();
        c.methodA(); 
        
        B b = new B();
        b.methodA();
    }
}
输出结果:
DDDDDDDDDDDD
BBBBBBBBBBBB

其他成员特点

• 接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
• 接口中，没有构造方法，不能创建对象。
• 接口中，没有静态代码块。

接口与实现类对象的多态引用

实现类实现接口，类似于子类继承父类，因此，接口类型的变量与实现类的对象之间，也可以构成多态引用。通过接口类型的变量调用方法，最终执行的是你new的实现类对象实现的方法体。

public class TestInterface {
    
    
	public static void main(String[] args) {
    
    
		Flyable b = new Bird();
		b.fly();
		
		Flyable k = new Kite();
		k.fly();
	}
}
interface Flyable{
    
    
    //抽象方法
	void fly();
}
class Bird implements Flyable{
    
    

	@Override
	public void fly() {
    
    
		System.out.println("展翅高飞");
	}
	
}
class Kite implements Flyable{
    
    

	@Override
	public void fly() {
    
    
		System.out.println("别拽我，我要飞");
	}
	
}

经典接口介绍

1、java.lang.Comparable

我们知道基本数据类型的数据（除boolean类型外）需要比较大小的话，之间使用比较运算符即可，但是引用数据类型是不能直接使用比较运算符来比较大小的。那么，如何解决这个问题呢？

Java给所有引用数据类型的大小比较，指定了一个标准接口，就是java.lang.Comparable接口：

package java.lang;

public interface Comparable{
    
    
    int compareTo(Object obj);
}

那么我们想要使得我们某个类的对象可以比较大小，怎么做呢？步骤：

第一步：哪个类的对象要比较大小，哪个类就实现java.lang.Comparable接口，并重写方法

• 方法体就是你要如何比较当前对象和指定的另一个对象的大小

第二步：对象比较大小时，通过对象调用compareTo方法，根据方法的返回值决定谁大谁小。

• this对象（调用compareTo方法的对象）大于指定对象（传入compareTo()的参数对象）返回正整数
• this对象（调用compareTo方法的对象）小于指定对象（传入compareTo()的参数对象）返回负整数
• this对象（调用compareTo方法的对象）等于指定对象（传入compareTo()的参数对象）返回零

代码示例：

public class TestComparable {
    
    
	public static void main(String[] args) {
    
    
		Student s1 = new Student(1,"张三",89);
		Student s2 = new Student(2,"李四",89);
		if(s1.compareTo(s2)>0){
    
    
			System.out.println("s1>s2");
		}else if(s1.compareTo(s2)<0){
    
    
			System.out.println("s1<s2");
		}else{
    
    
			System.out.println("s1 = s2");
		}
	}
}
class Student implements Comparable{
    
    
	private int id;
	private String name;
	private int score;
	
	//省略了构造器、get/set、toString等方法

	@Override
	public int compareTo(Object o) {
    
    
		//这些需要强制，将o对象向下转型为Student类型的变量，才能调用Student类中的属性
		Student stu = (Student) o;
		if(this.score != stu.score){
    
    
			return this.score - stu.score;
		}else{
    
    //成绩相同，按照学号比较大小
			return this.id - stu.id;
		}
	}
	
}

java.util.Comparator

思考：

（1）如果一个类，没有实现Comparable接口，而这个类你又不方便修改（例如：一些第三方的类，你只有.class文件，没有源文件），那么这样类的对象也要比较大小怎么办？

（2）如果一个类，实现了Comparable接口，也指定了两个对象的比较大小的规则，但是此时此刻我不想按照它预定义的方法比较大小，但是我又不能随意修改，因为会影响其他地方的使用，怎么办？

JDK在设计类库之初，也考虑到这种情况了，所以又增加了一个java.util.Comparator接口。

package java.util;

public interface Comparator{
    
    
    int compare(Object o1,Object o2);
}

那么我们想要比较某个类的两个对象的大小，怎么做呢？步骤：

第一步：编写一个类，我们称之为比较器类型，实现java.util.Comparator接口，并重写方法

• 方法体就是你要如何指定的两个对象的大小

第二步：比较大小时，通过比较器类型的对象调用compare()方法，将要比较大小的两个对象作为compare方法的实参传入，根据方法的返回值决定谁大谁小。

• o1对象大于o2返回正整数
• o1对象小于o2返回负整数
• o1对象等于o2返回零

代码示例：一个没有实现Comparable接口的学生类

class Student{
    
    
	private String name;
	private int score;
	public Student(String name, int score) {
    
    
		super();
		this.name = name;
		this.score = score;
	}
	public Student() {
    
    
		super();
	}
	public String getName() {
    
    
		return name;
	}
	public void setName(String name) {
    
    
		this.name = name;
	}
	public int getScore() {
    
    
		return score;
	}
	public void setScore(int score) {
    
    
		this.score = score;
	}
	@Override
	public String toString() {
    
    
		return "Student [name=" + name + ", score=" + score + "]";
	}
	
}

代码示例：定义定制比较器类

class StudentScoreCompare implements Comparator{
    
    

	@Override
	public int compare(Object o1, Object o2) {
    
    
		Student s1 = (Student) o1;
		Student s2 = (Student) o2;
		return s1.getScore() - s2.getScore();
	}
	
}

代码示例：测试类

import java.util.Comparator;

public class TestComparator {
    
    
	public static void main(String[] args) {
    
    
		Student stu1 = new Student("张三",89);
		Student stu2 = new Student("李四",78);
		
		StudentScoreCompare ssc = new StudentScoreCompare();
		if(ssc.compare(stu1, stu2)>0){
    
    
			System.out.println(stu1 + ">" + stu2);
		}else if(ssc.compare(stu1, stu2)<0){
    
    
			System.out.println(stu1 + "<" + stu2);
		}else{
    
    
			System.out.println(stu1 + "=" + stu2);
		}
	}
}

java.lang.Cloneable

在java.lang.Object类中有一个方法：

protected Object clone()throws CloneNotSupportedException 

所有类型都可以重写这个方法，它是获取一个对象的克隆体对象用的，就是造一个和当前对象各种属性值一模一样的对象。当然地址肯定不同。

我们在重写这个方法后时，调用clone()，发现报异常CloneNotSupportedException，因为我们没有实现java.lang.Cloneable接口。

class Teacher implements Cloneable{
    
    
	private int id;
	private String name;
	public Teacher(int id, String name) {
    
    
		super();
		this.id = id;
		this.name = name;
	}
	public Teacher() {
    
    
		super();
	}
	public int getId() {
    
    
		return id;
	}
	public void setId(int id) {
    
    
		this.id = id;
	}
	public String getName() {
    
    
		return name;
	}
	public void setName(String name) {
    
    
		this.name = name;
	}
	@Override
	public String toString() {
    
    
		return "Teacher [id=" + id + ", name=" + name + "]";
	}
	@Override
	public Object clone() throws CloneNotSupportedException {
    
    
		return super.clone();
	}
	@Override
	public int hashCode() {
    
    
		final int prime = 31;
		int result = 1;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
    
    
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Teacher other = (Teacher) obj;
		if (id != other.id)
			return false;
		if (name == null) {
    
    
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}

public class TestClonable {
    
    
	public static void main(String[] args) throws CloneNotSupportedException {
    
    
		Teacher src = new Teacher(1,"柴老师");
		Object clone = src.clone();
		System.out.println(clone);
		System.out.println(src == clone);
		System.out.println(src.equals(clone));
	}
}

匿名内部类

引入

当我们在开发过程中，需要用到一个抽象类的子类的对象或一个接口的实现类的对象，而且只创建一个对象，而且逻辑代码也不复杂。那么我们原先怎么做的呢？

（1）编写类，继承这个父类或实现这个接口

（2）重写父类或父接口的方法

（3）创建这个子类或实现类的对象

例如：

public interface Runnable{
    
    
    public abstract void run();
}

//声明接口实现类
public class MyRunnable implements Runnable{
    
    
    public void run(){
    
    
        while(true){
    
    
            System.out.println("大家注意安全");
            try
            	Thread.sleep(1000);
            }catch(Exception e){
    
                    
            }
        }
    }
}

public class Test{
    
    
    public static void main(String[] args){
    
    
        //如果MyRunnable类只是在这里使用一次，并且只创建它的一个对象
        //分开两个.java源文件，反而不好维护
        Runnable target = new MyRunnable();
        Thread t = new Thread("安全提示线程",target);
        t.start();
    }
}

这里，因为考虑到这个子类或实现类是一次性的，那么我们“费尽心机”的给它取名字，就显得多余。那么我们完全可以使用匿名内部类的方式来实现，避免给类命名的问题。

可以修改为如下形式：

public class Test{
    
    
    public static void main(String[] args){
    
    
        //MyRunnable类只是在这里使用一次，并且只创建它的一个对象，那么这些写代码更紧凑，更好维护
        Runnable target = new Runnable(){
    
    
            public void run(){
    
    
                while(true){
    
    
                    System.out.println("大家注意安全");
                    try
                        Thread.sleep(1000);
                    }catch(Exception e){
    
                    
                    }
                }
            }
        };
        Thread t = new Thread("安全提示线程",target);
        t.start();
    }
}

语法格式

new 父类(【实参列表】){
    
    
    重写方法...
}

new 父接口(){
    
    
    重写方法...
}

匿名内部类是没有名字的类，因此在声明类的同时就创建好了唯一的对象

思考：这个对象能做什么呢？

答：（1）调用某个方法（2）赋值给父类/父接口的变量，通过多态引用使用这个对象（3）作为某个方法调用的实参

使用方式一：匿名内部类的对象直接调用方法

interface A{
    
    
	void a();
}
public class Test{
    
    
    public static void main(String[] args){
    
    
    	new A(){
    
    
			@Override
			public void a() {
    
    
				System.out.println("aaaa");
			}
    	}.a();
    }
}

class B{
    
    
	public void b(){
    
    
		System.out.println("bbbb");
	}
}
public class Test{
    
    
    public static void main(String[] args){
    
    
    	new B(){
    
    
    		public void b(){
    
    
    			System.out.println("ccccc");
    		}
    	}.b();
    	
    }
}

使用方式二：通过父类或父接口的变量多态引用匿名内部类的对象

interface A{
    
    
	void a();
}
public class Test{
    
    
    public static void main(String[] args){
    
    
    	A obj = new A(){
    
    
			@Override
			public void a() {
    
    
				System.out.println("aaaa");
			}
    	};
    	obj.a();
    }
}

class B{
    
    
	public void b(){
    
    
		System.out.println("bbbb");
	}
}
public class Test{
    
    
    public static void main(String[] args){
    
    
    	B obj = new B(){
    
    
    		public void b(){
    
    
    			System.out.println("ccccc");
    		}
    	};
    	obj.b();
    }
}

使用方式三：匿名内部类的对象作为实参

interface A{
    
    
	void method();
}
public class Test{
    
    
    public static void test(A a){
    
    
    	a.method();
    }
    
    public static void main(String[] args){
    
    
    	test(new A(){
    
    

			@Override
			public void method() {
    
    
				System.out.println("aaaa");
			}
    		
    	});
    }   
}