JavaSE之面向对象编程—抽象类与接口—— 3（接口的定义与使用）

                                                                                        接口的定义与使用
抽象类和普通类相比最大的特调就是抽象类里面含有抽象方法（也可以不含），但是普通类中一定不会有抽象方法。抽象类的实现必须通过子类才可以实例化，但是对于抽象类是局限的，它只能单继承。接口，在java开发中非常的重要，它可以和我们的抽象类结合使用。
接口的定义：接口就是抽象方法和全局常量的集合。定义接口的关键字是interface。
注意：我们在java程序设计中优先选择接口进行程序设计。

// //定义一个简单的接口
// interface Message{
	// public static final String MSG = "I am a Student";//在接口中定义变量必须用static、fainal关键字修饰，当用它们修饰以后就成了全局常量了。
	// public abstract void print();//抽象方法
// }
// //实现接口
 // class News implements Message{
	// public void print(){
		// System.out.println("这是子类实现接口中的方法");
	// }
	// public String getNews(){
		// return Message.MSG;//这个是父接口的常量，所以可以直接通过类名访问
	// }
// }
// public class Jiekou {
	// public static void main(String[] args){
	// Message message=new News();//父接口要想实现实例化只能通过子类——》向上转型
	// message.print();//被子类覆写后的方法
	// News n=(News)message;
// System.out.println(n.getNews());	
	
	// }
// }
//通过上面的代码我们可以看到我们的接口和实现它的子类之间的关系和我们的子类和父类相似的，父接口和父类
//都是依靠子类去实现的。


//2.接口使用权限
//我们知道在继承关系中也有权限的限制，在接口中同样也有，并且我们的接口中还没有继承中
//那么复杂，在接口中不管是属性还是方法都只能使用public权限，并且需要他被注意的是：
//在类中如果我们不写权限修饰符，那么这个类的权限是默认权限，但是在我们的接口中如果我们
//没有使用权限修饰符，那么我们的权限将默认为public。


// //（1）当一个子类即需要实现接口又需要继承抽象类时，先继承后实现——》extends->implements
// //子类继承抽象类和实现接口
// interface Message{
	// public void print();//在抽象类中的方法不需要用abstract修饰
// }
// abstract class News{
	// public abstract void getNews();
// }
// //下面这个子类即实现抽象方法又实现了接口
// class MN extends News implements Message{
	// public void print(){
		// System.out.println("这是子类实现接口中的方法");
	// }
	// public void getNews(){
		// System.out.println("这是子类实现抽象类的方法");
	// }
	// public void getPrint(){
		// System.out.println("这是子类中自己的方法");
	// }
// }
// public class Jiekou{
	// public static void main(String[] args){
		// Message message=new MN();//实现向上转型
		// News news=(News)message;//由于MN这个类即实现了接口又继承了抽象类，所以让两个毫无关系的Message和News联系起来，可以通过强转来实现；
		                          //因为对于New news也可以是new MN();这才是关键点
		// message.print();
		// news.getNews();
		// System.out.println("-------------");
		// MN mn = (MN)message;//由于这个message在编译的时候编译器无法知道它到底是什么类型，编译器只按照修饰它的那个类型类编译，所以时大类型转小类型，需要强转。
		// mn.getPrint();
	// }
// }

// //（2）一个抽象类可以使用implements实现多个接口，但是接口不能继承抽象类。
// //抽象类实现接口
// interface Message{
	// public void print();//在抽象类中的方法不需要用abstract修饰
// }
// abstract class News implements Message{//抽象类中可以放抽象方法，所以我们不需要实现抽象方法
	// public abstract void getNews();
// }
// class MN extends News {
	// public void print(){
		// System.out.println("这是子类父类中实现接口的方法");
	// }
	// public void getNews(){
		// System.out.println("这是子类实现抽象类的方法");
	// }
	// public void getPrint(){
		// System.out.println("这是子类中自己的方法");
	// }
// }
// public class Jiekou{
	// public static void main(String[] args){
		// Message message=new MN();//实现向上转型
		// News news=(News)message;//由于MN这个类即实现了接口又继承了抽象类，所以让两个毫无关系的Message和News联系起来，可以通过强转来实现；
		                         // //因为对于New news也可以是new MN();这才是关键点
		// message.print();
		// news.getNews();
		// System.out.println("-------------");
		// MN mn = (MN)message;//由于这个message在编译的时候编译器无法知道它到底是什么类型，编译器只按照修饰它的那个类型类编译，所以时大类型转小类型，需要强转。
		// mn.getPrint();
	// }
// }


// //(3)一个接口可以使用extends继承多个父接口。
 // interface A{
	 // public void printA();
 // }
 // interface B{
	 // public void printB();
 // }
 // interface C implements A,B{//注意：在接口实现的时候，我们只需要一个关键字implements，多个接口之间用逗号隔开
	 // public void printA(){
		 // System.out.println("这是接口A中的方法");
	 // }
	 // public void printB(){
		 // System.out.println("这是接口B的方法");
	 // }
	 // public void printC(){
		 // System.out.println("这是C自己的方法");
	 // }
 // }

// //用static修饰内部接口（它的使用方法和静态内部类是一样的，在使用的时候它的名字是外部接口.内部接口）
// interface A{
	// public void printA();
	// static interface B{
		// public void printB();
	// }
// }
// class Imp implements A.B{//实现静态内部类接口
	// public void printB(){
		// System.out.println("这是静态内部接口的方法");
	// }
// }
// public class Jiekou{
	// public static void main(String[] args){
		// Imp imp=new Imp();
		// imp.printB();
	// }
// }

// //3.接口的应用
// //停车场——》车《————公交车、大卡车、摩托车、小轿车
// //在积极而口中我们一般只定义方法，在这个例子中我们定义了获得长、宽的方法
// //在类中我们定义了一个方法进行计算是否可以停下
// //这样的好处是，它们之间可以同时使用。
// interface Car{
	// public int getLength();
	// public int getWidth();
// }
// class Parking{
	// int standLength=4;//标准的长
	// int standWidth=2;//标准的宽
	// public void Compare(int length,int width){
		// if((length<=standLength)&&(width<=standWidth)){
			// System.out.println("可以停下");
		// }else{
			// System.out.println("停不下");
		// }
	// }
	
// }
// class Bus extends Parking implements Car{
	// public int getLength(){
		 // return 6;
	// }
	// public int getWidth(){
		// return 4;
	// }
// }

// class Auto extends Parking implements Car{
	// public int getLength(){
		 // return 5;
	// }
	// public int getWidth(){
		// return 3;
	// }
// }

// class Motory extends Parking implements Car{
	// public int getLength(){
		 // return 2;
	// }
	// public int getWidth(){
		// return 1;
	// }
// }

// class SCar extends Parking implements Car{
	// public int getLength(){
		 // return 5;
	// }
	// public int getWidth(){
		// return 3;
	// }
// }
// public class Jiekou{
	// public static void main(String[] argd){
		// //实例化对象
		// Bus bus=new Bus();
		// int length=bus.getLength();
		// int width=bus.getWidth();
		// bus.Compare(length,width);
		
		// Auto auto=new Auto();
		 // length=auto.getLength();
		 // width=auto.getWidth();
		// auto.Compare(length,width);
		
		// Motory motory=new Motory();
		 // length=motory.getLength();
		 // width=motory.getWidth();
		// motory.Compare(length,width);

		
		// SCar scar=new SCar();
		 // length=scar.getLength();
		 // width=scar.getWidth();
		// scar.Compare(length,width);


	// }
// }