JAVA接口

最新推荐文章于 2022-08-27 10:40:05 发布

lyxnb_

最新推荐文章于 2022-08-27 10:40:05 发布

阅读量94

点赞数

文章标签： java

本文链接：https://blog.csdn.net/lyxnb_/article/details/112850796

版权

今天学习了java面向对象的接口，在Java中不直接支持多继承，因为会出现调用的不确定性，所以Java将多继承机制进行改良，在Java中变成了多实现。一个类只能有一个直系双亲类，一个类可以实现多个接口，一个接口可以继承多个接口。现在通过一些实例为大家展示。

需求：需要飞到北京出差
飞机、鸟和超人不能归于一个类属，但是具备有相同的特性：会飞的。所以引入了一个新概念叫做接口，可以用于规范实现接口的类中必须实现接口中抽象方法。接口可以理解为一种契约
使用关键字interface定义接口

public interface 会飞的 {
 public void 起飞(); //没有具体实现，也无法定义具体实现，这里是抽象方法
 public void 巡航飞行(); 
 public void 降落(); }

抽象类中的抽象方法不能省略abstract关键字，但是接口中的方法声明可以添加abstract，也可以不写

接口不能直接使用，必须有对应的实现类

public class 飞机类 implements 会飞的 { //共性是通过实现接口来表示的
private String name; //名称，这是类属的属性，这里可以
//如果当前类不是抽象类，则必须实现接口中的所有抽象方法定义字节类的成员，和接口无关
public void 起飞() {
System.out.println("使劲的跑，一抬头就飞起来了");
}public void 巡航飞行() { 
System.out.println("使劲的烧油...")
}
public void 降落() {
 System.out.println("我对准...");
  }
   }

通过接口定义变量，使用具体类的实例，进行调用


  会飞的 obj = new 飞机类(); //飞机类中必须提供接口中的所有抽象方法的实现，否则类只能是抽象类 
  obj.起飞();  //因为变量是通过接口进行声明的，所以只能调用接口中声明的方法，不能直接调用实现类中的没 有在接口中声明过的方法 
  obj.巡航飞行();
    obj.降落();

引入接口的目的在于隔离实现

public void 出差(飞机 obj){}
 这种写法当前类和飞机是耦合的，如果需要坐超人出差，则必须修改源代码 public void 出差(会飞的 obj){} 
当前类只是和接口耦合，任何实现了接口的对象都可以作为参数进行传入

使用接口而不是使用具体的类，则可以实现在实现接口的多个具体实现类之间进行更换,例如定义出超人类

interface IA{}
 interface IB{}
  interface IC extends IA,IB{} 正确的，其中IC中的方法等于IA+IB
 class A implements IA,IB{}
  IA a=new A();
   IB b=new A();

没有构造器方法，不能定义静态或者非静态代码块

public interface IA{ 
public IA(){} //语法报错 
}

没有属性，只能定义常量

public class Test {
public static void main(String[] args) {
System.out.println(IA.name); //常量可以直接使用
System.out.println(B.name); //实现类也可以直接访问常量
}
}
interface IA {
//private int age;语法报错，提示信息为Illegal modifier for the interface field IA.name; only public, static & final are permitted
String name = "yanjun";// 接口中只能定义常量，不能定义属性，默认限定词public static final，自定义限定词不能冲突
}
class B implements IA{} //访问常量既可以通过接口IA和实现类B名称的方式直接访问，例如 B.name。也可以通过B对象的方式进行访，例如new B().name

可以包含抽象方法，也可以没有抽象方法

interface IA1 { }// 这个接口中没有包含任何抽象方法。如果一个接口中没有定义抽象方法，这种接口也叫做旗标接口标志接口 
class A1Impl implements IA1 {
 }

interface IA2{//接口的限定词同类定义一致
int ee();//抽象方法，默认public abstract int ee();
public void pp();//方法的限定词可以是public, abstract, default, static,前面的public 可以省略，如果不写默认public
public abstract void cc();//这里abstract可以省略,默认就是abstract
//在JDK1.8中引入特殊关键字default，允许在接口中提供方法的默认实现 public default void dd(){ //这个方法的调用时必须有实现类，否则无法创建对象，例如new IA2()语法错误，也允许在实现类中覆盖定义
System.out.println("dddd....");
}
//在JDK1.8中允许在接口中定义静态方法 public static void ff(){ //这个静态方法可以通过接口名称直接调用 IA2.ff(),同时允许 在实现类中重新定义，但是不能通过IA2 a=new AImpl(); a.ff()的方式进行调用
System.out.println("ffffff");
}
}

接口允许多重继承，也允许一个类实现多个接口

public class Person { 
public static void main(String[] args) {
 IC cc=new CImpl(); 
 cc.pp();
 }
 }
 interface IA{ 
 public default void pp() {
  System.out.println("this is IA.pp() default");
  }
  }
  interface IB{ 
  public default void pp() {
   System.out.println("this is IB.pp() default");
   }
   }
   //因为在两个父接口中都定义了pp方法的默认实现，则在子接口无法确定到底使用哪个，所以要求子接口必 须明确说明 
   interface IC extends IA,IB{
   @Override 
   default void pp() { //在子接口中覆盖定义
   System.out.println("this is IC.pp() default");
    IA.super.pp();//调用IA接口所定义的pp方法 IB.super.pp(); 
    }
     }
     class CImpl implements IC{}

public class Person {
 public static void main(String[] args) { 
 IA cc=new CImpl();
  cc.pp(); 
 }
 }
 interface IA{
  public default void pp() {
   System.out.println("this is IA.pp() default");
    }
     }
     interface IA{
      public default void pp() {
       System.out.println("this is IA.pp() default");
       }
       }
       interface IB{
        public default void pp() { 
        System.out.println("this is IB.pp() default"); 
       }
       }
       //报错的原因是IA和IB接口中有相同的方法定义，同时又有默认实现，则CImpl类不知道使用哪个默认实 现，所以要求类中必须明确说明 
      class CImpl implements IA,IB{
      @Override 
      public void pp() {
       System.out.println("可以定义自己的逻辑"); IA.super.pp();//也允许调用某个接口中的默认实现 IB.super.pp();
        }
         }

抽象方法必须在实现类中提供实现

class A2Impl implements IA2{ //在实现类中必须实现接口中的所有抽象方法，否则当前类只能是抽象类
 public int ee() {
  return 0;
   }
  public void pp() {
   System.out.println("A2Impl...."); }
   public void cc() {
    System.out.println("A2Impl....."); }//dd方法由于在接口中有默认实现，所以可以不用重新定义，也允许重新定义
     }

可以使用default关键字给抽象方法提供默认实现，有默认实现的方法在实现类中可以重新定义，也可以不重新定义
报错原因：Java中不支持类的多重继承，一个类只能有一个双亲类

接口允许多重继承
一个类在继承另一个类的同时，还可以实现多个接口

public class Person {
	public static void main(String[] args) {
		IA a1 = new AImpl();
		B a2 = new AImpl();
		a1.pp();
	}
}

interface IA {
	public void pp();
}

class B {
	public void pp() {
		System.out.println("this is B.pp()");
	}
}class AImpl

public class Person {
	public static void main(String[] args) {
		IA a1 = new AImpl();
		a1.pp();
		IB a2 = new AImpl();
		a2.pp();
	}
}

interface IA {
	public void pp();
}

interface IB {
	public default void pp() {
		System.out.println("this is B.pp()");
	}
}class AImpl implements IA,IB{ //不能因为IB中针对pp方法提供了默认实现，所以不在实现类中定义pp方 法 @Override public void pp() { System.out.println("添加的新的处理逻辑"); // IA.super.pp(); 因为IA接口中并没有提供pp的默认实现，所以不允许这样调用 
			IB.super.pp(); 
			}
}
}

接口允许多重继承

interface IA1 {
	public void p1();
}

interface IA2 {
	public void p2();
}

interface IC extends IA1, IA2 {
	public void p3();
	// 继承父接口的同时也允许自定义方法 }//可以继承多个父接口,此时IC中实际有3个抽象方法

类是单根继承,不允许继承多个父类

允许一个类实现多个接口,但是每个接口的抽象方法都必须提供实现，否则是抽象类。提供的实现也可以是继承

public class A1 {
	public void p1() {
	}
}

public class A2 extends A1 implements IA1, IA2 {
	public void p2() {
	}
}

public abstract class A3 extends A1 implements IA1, IA2 {
}// 因为p2方法没有实现

接口的出现避免了单继承的局限性，这样定义C接口则拥有A+B的所有定义，可以使用A和B接口以及父类D声明变量类型，直接new T。但是约束时，用谁声明变量编译器系统识别就是谁这种类型，也就意味只能调用识别类型中的方法，不能调用其他方法

interface A {
	public void p1();
}

interface B {
	public void p2();
}

interface C
extents A,B
{
	}

	class D {
		public void abc() {
		}
	}class T extends D implements C{ public void p1(){} public void p2(){} }

D d = new T();这里只能直接调用abc方法，如果使用其他方法则需要进行类型转换 A a=new T();
这里只能直接调用A接口中声明的方法p1 B b=new T();
这里只能直接调用B接口中声明的方法p2 C c=new T()
;

声明接口的语法

访问修饰符 interface 接口名{ } 一般建议接口名称使用形容词

如果定义public接口，则规则和定义public类一致，

要求接口名称和文件名称一致外部的接口只能使用public、默认这两个范围限定词；
如果定义内部接口则可以使用4大范围限定词接口实际上提供了同一的操作界面（方法），如果是JDK1.8-版本则一个方法也不实现，等待某类或某几个类去实现它的方法【接口中的所有方法必须是抽象的】。如果使用的是JDK1.8+允许使用default在接口中定义默认实现，这个实现允许在实现类中重新定义覆盖

public class Test1 {
	public static void main(String[] args) {
		IA2 a2 = new A2Impl();
		a2.pp();
	}
}

interface IA2 {
	default void pp(){ //通过defaul在接口中定义方法的默认实现，则在实现类中可以覆盖定义，也可以继承使用
	System.out.println("this is pp...."); 
	this.ff();
	}void ff();
	 }
	class A2Impl implements IA2{
	 public void ff() {
	  System.out.println("this is ff..."); 
	  }
	   }

default默认方法实现使用的限制

public class Test1 {
	public static void main(String[] args) {
		IA2 a2 = new A2Impl();
		a2.pp();
	}
}

interface IA2 {
	default void pp() {
		System.out.println("this is No2 pp....");
	}
}

interface IA3 {
	default void pp() {
		System.out.println("this is No3 pp");
	}
}class A2Impl implements IA2, IA3 {//如果IA2中有一个default实现的方法和IA3中的方法一致，则 必须在实现类中重新定义 
public void pp() { 
IA2.super.pp();//调用IA2接口中的pp方法的默认实现 
IA3.super.pp(); 
}
 }

接口中没有属性，只能定义常量，它提供一些常量，实现它的类可以共享这些常量

接口可以给出访问控制符，用public修饰的是公共接口，到处可见；如果定义接口没有范围限定词，则只能在同包中访问

接口中只能定义常量和抽象方法
这是JDK1.8以前版本的规则，不是最新的接口中只能定义公共的常量，
接口中的属性默认是public static Õnal类型的，必须是public static Õnal类型的
接口中只能定义公共的抽象方法, 只有在JDK1.8+中可以使用default关键字定义方法实现。接口中的方法默认是public abstract类型的，而且必须是public abstract类型的。

只有在JDK1.8+中可以使用default关键字定义方法默认实现，同时允许在实现类中覆盖重新定义接口不能被实例化，只能通过实现类所实现，但是可以用于声明变量的类型。

接口变量名=new 实现接口类(); 接口没有构造函数接口中的抽象方法必须在非抽象子类中提供实现，这个实现可以是继承来的