接口

1、接口

• 行为标准，例如：USB接口
• Java中
• 为了限定某些类（这些类之间可能没有继承关系，甚至都不是一个派系里的）但是这些类都具有相同的行为特征
• 例如JDBC
• Java中设计了很多接口，Connection（连接数据库），Statement（执行SQL语句），ResultSet（返回结果）

*2、如何去声明接口
*【权限修饰符】 interface 接口名{

• 接口的成员列表}
  *使用者如何去使用接口

*2、接口的实现

• 【修饰符】 class 实现类 extends 父类 implements 接口们{
• }
• 2、接口的特点
• 接口是标准，就是用来被实现的，那么要求实现类在实现接口时，必须实现/重写所有抽象方法，否则这个类就得是一个抽象类
• 接口不能创建对象,但是接口类型的变量与实现类的对象构成多态
• 一个类继承父类时，Java只支持单继承，但是一个类在实现接口时可以同时实现多个接口
• 一个类如果同时继承父类，又实现接口，要求继承在前，实现在后
• 在Java中接口可以继承接口（标准累加）
• 【修饰符】 interfance 子接口 extends 父接口们{}

public class TestInterface {

	public static void main(String[] args) {
		//Flyable f = new Flyable();  接口不能创建对象
		Flyable[] sky = new Flyable[3];
		sky[0]=new Bird();
		sky[1]=new Bird();
		sky[2]=new Plane();
		
		for(int i=0;i<sky.length;i++){
			sky[i].fly();
		}

	}

}
interface Flyable{
	long MAX_SPEED=790000;
	void fly();// public abstract void fly();只能是抽象方法，因为标准中之规定有什么行为标准，行为特征，怎么去实现，有自己决定
}
interface Jumpable{
	void jump();
}
class Bird implements Flyable,Jumpable{

	@Override
	public void fly() {
	   System.out.println("小鸟使用翅膀飞");
	}

	@Override
	public void jump() {
		System.out.println("双脚跳");
		
	}

}
class Plane implements Flyable{

	@Override
	public void fly() {
		System.out.println("飞机使用发动机");
		
	}
	
}

java.util.Comparator接口

• java.util.Comparator接口：
• 是泛型，还没有讲，换成Object
• 抽象方法：int compara(Object o1,Object o2)
• 这个接口是代表Java中比较两个对像的大小。而且是一种定制的比较的标准。 没有规定如何比较两个对象的大小
• 如果你认为o1大于o2，就返回正整数，反之负整数，相等返回0

练习01：按成绩比较大小

public class TestComparator {

	public static void main(String[] args) {
		Student t1 = new Student("V",25,80);
		Student t2 = new Student("JK",23,90);
		
		//比较t1和t2的大小
		//对象无法直接比较大小if(t1>t2)
		
		AgeComparator c = new AgeComparator();
		
		System.out.print("t1和t2的年龄比较：");
		if(c.compare(t1, t2)>0){
			System.out.println("t1>t2");
			
		}else if(c.compare(t1, t2)<0){
			System.out.println("t1<t2");
		}else{
			System.out.println("t1=t2");
		}
		
			
		
		
	}

}
//实现Comparable接口，来定制两个学生比较多的具体实现方式

//例如按照年龄来比较
class AgeComparator implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		//向下转型
		Student t1=(Student) o1;
		Student t2=(Student) o2;
		
		//开始比较
		if(t1.getAge()>t2.getAge()){
			return 1;
		}else if(t1.getAge()<t2.getAge()){
			return -1;
		}
		
		return 0;
	}



	
	
}
class Student{
	private String name;
	private int age;
	private int score;
	public Student() {
		super();
	}
	public Student(String name, int age, int score) {
		super();
		this.name = name;
		this.age = age;
		this.score = score;
	}
	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;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	};
	
}

t1和t2的年龄比较：t1>t2

练习02
接口的练习2：
（1）声明一个员工类Employee，有属性：编号、姓名、年龄、薪资
（2）让Employee员工类实现java.lang.Comparable接口，
重写抽象方法，按照编号从小到大排序
（3）在测试类中创建Employee[]数组，调用java.util.Arrays的sort方法进行排序，遍历结果
（4）声明SalaryComparator类，实现java.util.Comparator接口，
重写抽象方法，按照薪资从高到低排序
用SalaryComparator对象重新对Employee[]数组进行排序，遍历结果

public class Employee implements Comparable{
	private int id;
	private String name;
	private int age;
	private double salary;
	public Employee(int id, String name, int age, double salary) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	public Employee() {
		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;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	
	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", age=" + age
				+ ", salary=" + salary + "]";
	}
	@Override
	public int compareTo(Object o) {
		
		return this.id-((Employee)o).id; //对int类型直接排序
	}
	

}

import java.util.Comparator;

/*
 * 4）声明SalaryComparator类，实现java.util.Comparator接口，
		重写抽象方法，按照薪资从高到低排序
	用SalaryComparator对象重新对Employee[]数组进行排序，遍历结果
 */

public class SalaryComparator implements Comparator {

	@Override
	public int compare(Object o1, Object o2) {
		Employee e1=(Employee)o1;
		Employee e2=(Employee)o2;
		
		if(e1.getSalary()>e2.getSalary()){
			return -1;
		}else if(e1.getSalary()<e2.getSalary()){
			return 1;
		}
		
		return 0;
	}

}

import java.util.Arrays;

//需求：编写一个Arrays的数组工具类，这个工具类，想要为任意的对象数组，进行升序排列
/*
 * 接口的练习2：
（1）声明一个员工类Employee，有属性：编号、姓名、年龄、薪资
（2）让Employee员工类实现java.lang.Comparable接口，
		重写抽象方法，按照编号从小到大排序
（3）在测试类中创建Employee[]数组，调用java.util.Arrays的sort方法进行排序，遍历结果
（4）声明SalaryComparator类，实现java.util.Comparator接口，
		重写抽象方法，按照薪资从高到低排序
	用SalaryComparator对象重新对Employee[]数组进行排序，遍历结果
 */
public class TestComparator2 {

	public static void main(String[] args) {
		Employee[] all = new Employee[3];
		all[0]=new Employee(2,"Rm",26,2000);
		all[1]=new Employee(3,"jk",23,3000);
		all[2]=new Employee(1,"v",25,2500);
		Arrays.sort(all);
		for(int i=0;i<all.length;i++){
			System.out.println(all[i]);
		}
		System.out.println("-----------------------");
		
		Arrays.sort(all, new SalaryComparator());
		for(int i=0;i<all.length;i++){
			System.out.println(all[i]);
		}
	}

}

Employee [id=1, name=v, age=25, salary=2500.0]
Employee [id=2, name=Rm, age=26, salary=2000.0]
Employee [id=3, name=jk, age=23, salary=3000.0]

---

Employee [id=3, name=jk, age=23, salary=3000.0]
Employee [id=1, name=v, age=25, salary=2500.0]
Employee [id=2, name=Rm, age=26, salary=2000.0]

String类型的排序

public class TestString {

	public static void main(String[] args) {
	      String s1="hello";
	      
	      String s2="chai";
	      
	      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");
	      }
	}

}

s1>s2

将ID改为String类型是时

@Override
	public int compareTo(Object o) {
		Employee other = (Employee) o;
		
		return id.compareTo(other.id); //对int类型直接排序
	}

匿名内部类
匿名内部类

• 语法格式：
• new 父类名（【实参】）{

•  类的成员列表
  

• }
• 或
• new 父接口名（）{

•   类的成员列表
  

• }
• 特殊：声明匿名内部类与创建它的对象是一起完成的。即匿名内部类只有唯一的对象

public class TestAnonymousInner {

	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
	   //需求：要声明一个Object的子类，匿名子类
		//并在子类中声明一个方法public void test(){}打印“hello匿名内部类”
		
		//下面这段代码，声明了匿名内部类，也创建了它的对象，但是没哟有说这个对象干什么，编译不通过
		/*new Object(){
			public void test(){
				System.out.println("hello匿名内部类");
			}
		}*/
		//我们可以把这个对象赋值给一个变量
		//多态引用（是Object子类的对象）
		Object obj=new Object(){
			public void test(){
				System.out.println("hello匿名内部类");
			}
	};
	
	/*Comparator c=new Comparator(){

		@Override
		public int compare(Object o1, Object o2) {
			Circle c1=(Circle)o1;
			Circle c2=(Circle)o2;
			if(c1.getRadius()>c2.getRadius()){
				return 1;
			}else if(c1.getRadius()<c2.getRadius()){
				return -1;
			}
			return 0;
		}
		
	};
	System.out.println(c.compare(new Circle(1), new Circle(2)));*/
	
	
	
	Circle[] all=new Circle[3];
	all[0]=new Circle(3);
	all[1]=new Circle(2);
	all[2]=new Circle(1);
	
	//Arrays.sort(all, c);需要一个Comparable对象
    Arrays.sort(all, new Comparator(){

		@Override
		public int compare(Object o1, Object o2) {
			Circle c1=(Circle)o1;
			Circle c2=(Circle)o2;
			if(c1.getRadius()>c2.getRadius()){
				return 1;
			}else if(c1.getRadius()<c2.getRadius()){
				return -1;
			}
			return 0;
		}
		
	});
}
}
/*class RadiusComparator implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		Circle c1=(Circle)o1;
		Circle c2=(Circle)o2;
		if(c1.getRadius()>c2.getRadius()){
			return 1;
		}else if(c1.getRadius()<c2.getRadius()){
			return -1;
		}
		return 0;
	}
	
}*/
class Circle{
	private double radius;
	

	public Circle() {
		super();
	}

	public Circle(double radius) {
		super();
		this.radius = radius;
	}

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}
	
}

练习01
1、匿名内部类练习1
（1）声明一个抽象类Father，包含抽象方法：public abstract void method();
（2）用匿名内部类继承Father，并重写抽象方法，打印“hello 孩子"
并调用子类对象的method方法

public class lianxi03 {

	public static void main(String[] args) {
		new Father(){

			@Override
			public void method() {
				System.out.println("hello孩子");
				
			}
			
		}.method();//并调用子类对象的method方法
		

	}

}
abstract class Father{
	public abstract void method();
	
}

hello孩子

2、匿名内部类练习2
（1）声明一个员工类Employee，有属性：编号、姓名、薪资
（2）在测试类中创建Employee数组
（3）分别调用Arrays.sort(数组，Comparator)，用匿名内部类实现按照编号升序排列
（4）分别调用Arrays.sort(数组，Comparator)，用匿名内部类实现按照薪资升序排列

package lianxi04;
//（1）声明一个员工类Employee，有属性：编号、姓名、薪资

public class Employee {
	private int id;
	private String name;
	private int salary;
	public Employee(int id, String name, int salary) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	public Employee() {
		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;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", salary=" + salary
				+ "]";
	}
	

}

package lianxi04;

import java.util.Arrays;
import java.util.Comparator;

/*
 * 2、匿名内部类练习2
（1）声明一个员工类Employee，有属性：编号、姓名、薪资
（2）在测试类中创建Employee数组
（3）分别调用Arrays.sort(数组，Comparator)，用匿名内部类实现按照编号升序排列
（4）分别调用Arrays.sort(数组，Comparator)，用匿名内部类实现按照薪资升序排列
 */
public class TestEmployee {

	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		Employee[] all=new Employee[3];
		all[0]=new Employee(2,"V",2000);
		all[1]=new Employee(3,"jk",1800);
		all[2]=new Employee(1,"suga",3999);
		
		Arrays.sort(all, new Comparator(){

			@Override
			public int compare(Object o1, Object o2) {
				Employee e1=(Employee)o1;
				Employee e2=(Employee)o2;
				if(e1.getId()>e2.getId()){
					return 1;
				}else if(e1.getId()<e2.getId()){
					return -1;
				}
				return 0;
			}
			
		});
		for(int i=0;i<all.length;i++){
			System.out.println(all[i]);
		}
		
		System.out.println("---------------------------------");
		
		Arrays.sort(all, new Comparator(){

			@Override
			public int compare(Object o1, Object o2) {
				Employee e1=(Employee)o1;
				Employee e2=(Employee)o2;
				if(e1.getSalary()>e2.getSalary()){
					return 1;
				}else if(e1.getSalary()<e2.getSalary()){
					return -1;
				}
				return 0;
			}
			
		});
		for(int i=0;i<all.length;i++){
			System.out.println(all[i]);
		}
	
	}

}

Employee [id=1, name=suga, salary=3999]
Employee [id=2, name=V, salary=2000]
Employee [id=3, name=jk, salary=1800]

---

Employee [id=3, name=jk, salary=1800]
Employee [id=2, name=V, salary=2000]
Employee [id=1, name=suga, salary=3999]

或者：将
if(e1.getId()>e2.getId()){
return 1;
}else if(e1.getId()<e2.getId()){
return -1;
}
return 0;
改为
return e1.getSalary()-e2.getSalary();