笔记15 接口

package test0909;


import java.lang.Comparable;		//	1导入接口； 由于java.lang包可以默认导入，顾可省略此步；
import java.util.Arrays;
/*
 * 		1、什么是接口？
 * 			是一套标准、是一套规则、是一套对所有类的统一的要求。
 * 
 * 		2、为什么会出现接口？
 * 			原因: 在java语言中规定，只支持单继承，不支持多继承。	
 * 				但是，为了实现多继承的现象，java专家提出接口。
 * 			因此，接口是为了实现多继承的功能而出现的；也可以说是为了让所有的类遵守一种统一的标准，一套统一的规则。
 * 
 * 		3、如何使用接口？
 * 			关键字：	implements
 * 			使用方式为:  public class 子类 [ extends 父类 ]  implements  接口 {......}
 * 
 * 		4、在java语言中，接口包含的成份只有两种:
 * 			1) 公共的静态的符号常量。 即: public static final 类型名 符号常量名 = 值;
 * 				例如: public static final double PI = 3.14;
 * 
 * 			2) 接口中的所有方法均为抽象的。
 * 				即: public abstract 类型名 方法名(参数列表) ;
 * 				例如:  public abstract int add( int x, int y );
 * 
 * 			注意: 接口中也可以什么都没有。
 * 
 * 		5、自定义一个接口
 * 			格式:  [ public ] interfact 接口名 { ...... }		//接口和类是一个数量级的；
 * 
 * 		6、在java语言，接口有两种：
 * 			1) 现存的接口（由专家制定好的，提供给程序员使用）。
 * 
 * 			2) 自定义接口（由程序员自已定义）。
 * 
 * 		7、如何使用现存的接口？
 * 			1) 导入( import )接口。
 * 			2) 编写一个类去实现( implements )该接口。
 * 			3) 要求在实现类中必须对继承自接口的所有抽象方法一一实现其功能（重写它们）。 
 * 			4) 编写一个测试类测试它。
 * 
 * 		典型案例：通过此案例理解并掌握接口的应用。
 * 			例如: 有许多学生，现要求他们按成绩由小到大排序。
 * 
 * 		8、自定义接口如何使用？
 * 			1) 定义（ interface ）一个接口；
 * 			2) 导入（ import ）该自定义的接口；
 * 			3) 编写一个类去实现（ implements ）该接口；
 * 			4) 在该实现类中重写来自接口的所有抽象方法；
 * 			5) 编写一个测试类并且在测试类需要人为调用重写后的方法。
 * 
 * 		9、接口与抽象类作一个对比？
 * 			1) 抽象类必须由 abstract 关键字修饰。
 * 			2) 抽象类一定有父类且仅有一个父类。
 * 			3) 抽象类包含零个或一个或多个抽象方法。
 * 			4) 抽象类必须被继承且其子类中必须重写来自父类的所有抽象方法。
 * 			
 * 			5) 接口必须由interface关键字生成。
 * 			6) 接口中只有两种成份: 公共的静态的符号常量 和 公共的抽象方法。
 * 			7) 接口可以被所有类实现，且该类必须重写来自接口的所有抽象方法。
 * 			8) 一个接口可以没有父接口，也可以只有一个父接口，还可以有多个父接口。
 * 				即： public interface 接口 [extends 父接口1 [, 父接口2 [, ...]]] { .......}
 */
public class InterfaceTest {
	public static void main(String[] args) {
	
		Students[] ss = new Students[5];
		
		ss[0] = new Students("张3" , false, 21, "尚学堂" , 650 );
		ss[1] = new Students("张5" , true, 20, "尚学堂" , 675 );
		ss[2] = new Students("张4" , false, 22, "北京大学" , 720 );
		ss[3] = new Students("张1" , true, 24, "尚学堂" , 630 );
		ss[4] = new Students("张2" , false, 23, "清华大学" , 750 );
	
		System.out.println("五个学生的基本信息如下： ");
		for( Students tem : ss ){
			System.out.println( tem  );
			System.out.println( "------------------------------");
		}
		
		//排序: 要排序，就必须比较大小。  
		//专家规定：凡是对象要比较大小，就必须使用统一的方法名，统一的返回值类型.
		//因此，这个方法就为 public abstract  int  compareTo(Object obj);
		//这一个抽象方法放置于 接口中最恰当。因为，接口可以被所有类实现。
		//此接口，专家制定好了。它为  Comparable 并存放于 java.lang.Comparable包中。
		Arrays.sort( ss ); //说明: sort()方法依赖 compareTo()方法。
		
		System.out.println("\n\n以上五个学生排序如下： ");
		for( Students tem : ss ){
			System.out.println( tem  );
			System.out.println( "------------------------------");
		}
	}
}
/*
 * 		结论:  凡是对象要比较大小，就需要实现Comparable接口，重写compareTo()方法，为
 * 			对象比较大小提供依据。
 *   
 */
class Persons {
	private String name;
	private final boolean SEX;
	private int age;
	
	public Persons() {
		int n = (int)( 2 * Math.random());
		this.SEX = n == 1;
	}

	public Persons(String name, boolean sex, int age) {
		this.name = name;
		SEX = sex;
		this.age = age;
	}
	
	public String toString() {
		return "" + name + "   " + (SEX ? "男":"女") + "   " + age;
	}
}

class Students extends  Persons  implements  Comparable  { 		//2 当前类实现接口Comparable为专家提供的接口
	
	//3 对继承自接口的抽象方法重写；目的是为对象比较大小提供依据。
	public int compareTo(Object obj) {
		Students st2 = (Students)obj;		//	强制将obj的类型转换为Students类；
		
		if( this.score > st2.score ){		//	按照成绩比较类的大小
			return 1; 
		}else if( this.score < st2.score ){
			return -1;
		}else{
			return 0;
		}
	}

	private String school;
	private int score ;
	
	public Students() {
		super();
	}
	public Students(String name, boolean sex, int age , String school, int score ){
		super( name, sex, age );
		this.school = school;
		this.score = score;
	}
	
	public String toString() {
		return super.toString() + "  " + school + "   " + score;
	}
}

 

package test0909;

public class DogInterfaceTest {
	public static void main(String[] args) {
		Dog d1 = new Dog("旺财", true, 2);
		Dog d2 = new Dog("小强", false, 1);
		Dog d3 = new Dog("大毛", true, 5);
		Dog d4 = new Dog("二黄", false, 3);
		Dog d5 = new Dog("小白", true, 4);
		
		Dog[] ds = { d1, d2, d3, d5, d4 };
		
		System.out.println("最初，五只小狗的信息如下：");
		for( int i = 0; i < ds.length; i++ ){
			System.out.println( ds[i] );
			System.out.println("-----------------");
		}
		
		//排序
		//Arrays.sort( ds ); //sort()方法与Comparable接口的compareTo()方法关联
		
		//自己编写代码实现排序
		for(int i = 0; i < ds.length; i++ ){
			for(int j = i+1;  j < ds.length;  j++ ){
				if( ds[i].compareTo(ds[j]) > 0 ){   //注意: 人为调用了重写的方法。
					
					Dog temp = ds[i];
					ds[i] = ds[j];
					ds[j] = temp;
				}
			}
		}
		
		System.out.println("\n按大小排序后，五只小狗的信息如下：");
		for( int i = 0; i < ds.length; i++ ){
			System.out.println( ds[i] );
			System.out.println("-----------------");
		}
	}
}

class Dog  implements  MyInterface {			//继承自己编写的MyInterface接口；

	//4 重写来自接口的所有抽象方法；让Dog类的对象拥有比较大小的功能。
	@Override
	public int compareTo(Object obj) {
		Dog d2 = (Dog) obj;
/*	
		if( this.age > d2.age ){
			return 1;
		}else if( this.age < d2.age ){
			return -1;
		}else{
			return 0;
		}
*/		
		return this.age - d2.age;		//比较dog的年龄属性；
	}
	
	private String name;
	private boolean sex;
	private int age;
	
	public Dog() {
	}

	public Dog(String name, boolean sex, int age) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	
	public String toString() {
		return name + "   " + (sex ? "公":"母") + "   " + age;
	}
	
}

interface  MyInterface {			//创建一个接口；
	
	//public abstract int compareTo(Object obj);		//专家给定的compareTo方法；
	public abstract int compareTo(Object obj);			//自己编写compareTo方法
	//其中public abstract这两个关键字可以省略，	//因为接口里面所有的方法都是公共的抽象方法
}