精华内容
下载资源
问答
  • java基础篇(13) 接口与嵌套接口

    万次阅读 2019-05-02 08:36:57
    一、接口 1. 接口简介 接口: 是java的一种抽象类型,是抽象方法的集合。接口比抽象类更加抽象的抽象类型。 接口语法: [修饰符] [abstract] interface 接口名 [extends 父接口名列表]{ [public] [static] [final] ...

    一、接口

    1. 接口简介

    接口: 是java的一种抽象类型,是抽象方法的集合。接口比抽象类更加抽象的抽象类型。

    接口语法

    [修饰符] [abstract] interface 接口名 [extends 父接口名列表]{
    [public] [static] [final] 常量;
    [public] [abstract] 方法;
    [public] [static] 方法{};//JDK1.8后
    [public] [static] 类/接口;
    }
    

    2. 接口成员的修饰符

    接口中的所有成员的访问权限默认强制是 public

    • 变量: 默认强制是public static final
    • 方法: 默认强制是public abstract,即抽象方法。但JDK1.8后,允许定义静态方法public static,接口存在非抽象方法;
    • 内部类/接口: 默认强制是 public static

    下面例子中的接口中定义了各种接口成员:

    public interface InterfaceTest {
        int a = 10;//全局变量默认强制是 public static final
         public static void staticMethod() {  //静态方法,JDK1.8下编译通过
             System.out.println("");
         }
          int abstractMethod(); //抽象方法
         public static abstract class InnerClass{//抽象内部类,默认强制 public static
             //......
         }
         enum MyEnum{RED,BLUE,GRREN} //枚举类,默认强制 public static
         interface InnerInteerface{ //嵌套接口,默认强制 public static
             void aa();
         }
    }
    class MyClass implements InterfaceTest{//实现上面的接口
        @Override
        public int abstractMethod() {//实现抽象方法
            return 0;
        }
    }
    

    注意一下,实现接口并不需要实现接口里面的内部抽象类成员、或者嵌套接口成员;

    3. 接口的多继承

    接口是可以继承多个接口(在类中,是不允许多继承的)。由于接口的实例成员方法都是抽象方法,所以多继承不会对接口造成太大影响(不同父接口可以定义相同的方法),但还是有一点要注意的,**多继承接口时,从父接口继承下来的方法,有相同的方法名,但不满足方法重载的条件,就会冲突。**如果出现这种情况,编译将失败,不允许多继承。

    interface A{
        void sameMethodA();
    }
    interface B{
        void sameMethodA();
        void sameMethodB(int a);//返回类型是void
    }
    interface C{
        int sameMethodB(int a);//返回类型是 int
    }
    interface D extends A,B{ //编译通过,即使A,B定义了相同方法
    }
    interface E extends B,C{//编译失败
    }
    

    字接口D多继承父接口A,B成功,但子接口E却多继承父接口B,C失败,就是因为两个接口定义的sameMethodB()除了返回类型外,方法名、参数列表都一样,这不满足方法重载,导致继承时方法冲突。

    如果非得要多继承,Java的解决方案是使用 内部类或嵌套接口;

    4. 接口与抽象类的区别

    接口与抽象类的区别:

    • 抽象级别不一样: 接口更加抽象,JDK1.8前只允许抽象方法,JDK1,8后才允许存在静态方法;抽象类的抽象基本低,允许存在具体方法,甚至抽象类中可以没有抽象方法。但有抽象方法的类就必须是抽象类;
    • 接口对成员的定义时的修饰符都有固定的限制,参考前面;抽象类定义成员与普通类是一样的;
    • 接口中不允许定义初始化块(静态或实例),但抽象类允许定义这两种初始化块;
    • 接口中不能定义构造方法,但抽象类允许定义构造方法。

    补充:抽象类中的抽象方法的访问权限是不能是private

    二、嵌套接口

    嵌套接口: 就是定义在类或接口中的接口。

    嵌套接口的修饰符限制:

    • 不论定义在接口,还是类中,嵌套接口默认强制是 static。这意味着,嵌套接口是没有局部的嵌套接口。
    • 接口定义在类中,可以使用四种访问权限,定义在接口种,则只有public

    作者:jinggod
    出处:http://www.cnblogs.com/jinggod/p/8503146.html

    展开全文
  • java中嵌套接口

    千次阅读 2017-05-28 12:25:03
    接口知识点  1、接口中定义的变量默认是public static final 型,且必须给其初值,所以实现类中不能重新定义,也不能改变其值  2、接口中的方法默认都是 public abstract 类型的:  3、接口默认也是abstract的的...

    接口知识点

          1、接口中定义的变量默认是public static final 型,且必须给其初值,所以实现类中不能重新定义,也不能改变其值
          2、接口中的方法默认都是 public abstract 类型的:
          3、接口默认也是abstract的的:public abstract interface xx ===public interface xx
    public interface AreaInterface{
         double pai=Math.PI;
         double area();
         interface Neibujiekou{
              viod menthod();
         }
    }
    public abstract interface AreaInterface{
         public static final double pai  = Math,.PI;
         public abstract double area();
    }

    嵌套接口

           在Java语言中,接口可以嵌套在类或其它接口中。由于Java中interface内是不可以嵌套class的,所以接口的嵌套就共有两种方式:class嵌套interface、interface嵌套interface。

            1. class嵌套interface
           这时接口可以是public,private和package的。重点在private上,被定义为私有的接口只能在接口所在的类被实现。可以被实现为public的类也可以被实现为private的类。当被实现为public时,只能在被自身所在的类内部使用。只能够实现接口中的方法,在外部不能像正常类那样上传为接口类型。
    class A {
        private interface D {
            void f();
        }
        private class DImp implements D {
            public void f() {}
        }
        public class DImp2 implements D {
            public void f() {}
        }
        public D getD() { return new DImp2(); }
        private D dRef;
        public void receiveD(D d) {
            dRef = d;
            dRef.f();
        }
    }
    
    public class NestingInterfaces {
        public static void main(String[] args) {
            A a = new A();
            //The type A.D is not visible
            //! A.D ad = a.getD();
            //Cannot convert from A.D to A.DImp2
            //! A.DImp2 di2 = a.getD();
            //The type A.D is not visible
            //! a.getD().f();        
            A a2 = new A();
            a2.receiveD(a.getD());
        }
    }
           其中语句A.D ad = a.getD()和a.getD().f()的编译错误是因为D是A的私有接口,不能在外部被访问。语句A.DImp2 di2 = a.getD()的错误是因为getD方法的返回类型为D,不能自动向下转型为DImp2类型。

            2. interface嵌套interface
          由于接口的元素必须是public的,所以被嵌套的接口自动就是public的,而不能定义成private的。在实现这种嵌套时,不必实现被嵌套的接口
    classCircle implements  AreaInterface{
        //只需实现area();不用实现menthod();
        double area(){}
    }
    class Circle implements AreaInterface,AreaInterface.Neibujiekou{
        double area(){}
        viod menthod(){}
    }
    
    
    
    
    
    
    展开全文
  • 一、接口 1. 接口简介 接口: 是java的一种抽象类型,是抽象方法的集合。接口比抽象类更加抽象的抽象类型。 接口语法: [修饰符] [abstract] interface 接口名 [extends 父接口名列表]{ [public] [static] ...

    ###一、接口
    ##1. 接口简介

    接口: 是java的一种抽象类型,是抽象方法的集合。接口比抽象类更加抽象的抽象类型。

    接口语法

    [修饰符] [abstract] interface 接口名 [extends 父接口名列表]{
    [public] [static] [final] 常量;
    [public] [abstract] 方法;
    [public] [static] 方法{};//JDK1.8后
    [public] [static] 类/接口;
    }
    

    ##2. 接口成员的修饰符

    接口中的所有成员的访问权限默认强制是 public

    • 变量: 默认强制是public static final
    • 方法: 默认强制是public abstract,即抽象方法。但JDK1.8后,允许定义静态方法public static,接口存在非抽象方法;
    • 内部类/接口: 默认强制是 public static

    下面例子中的接口中定义了各种接口成员:

    public interface InterfaceTest {
    
        int a = 10;//全局变量默认强制是 public static final
        
         public static void staticMethod() {  //静态方法,JDK1.8下编译通过
             System.out.println("");
         }
         
          int abstractMethod(); //抽象方法
         
         public static abstract class InnerClass{//抽象内部类,默认强制 public static
             //......
         }
         
         enum MyEnum{RED,BLUE,GRREN} //枚举类,默认强制 public static
         
         interface InnerInteerface{ //嵌套接口,默认强制 public static
             void aa();
         }
    }
    
    class MyClass implements InterfaceTest{//实现上面的接口
    
        @Override
        public int abstractMethod() {//实现抽象方法
            
            return 0;
        }
    }
    

    注意一下,实现接口并不需要实现接口里面的内部抽象类成员、或者嵌套接口成员;
    ##3. 接口的多继承

    接口是可以继承多个接口(在类中,是不允许多继承的)。由于接口的实例成员方法都是抽象方法,所以多继承不会对接口造成太大影响(不同父接口可以定义相同的方法),但还是有一点要注意的,**多继承接口时,从父接口继承下来的方法,有相同的方法名,但不满足方法重载的条件,就会冲突。**如果出现这种情况,编译将失败,不允许多继承。

    interface A{
        void sameMethodA();
    }
    
    interface B{
        void sameMethodA();
        void sameMethodB(int a);//返回类型是void
    }
    
    interface C{
        int sameMethodB(int a);//返回类型是 int
    }
    
    interface D extends A,B{ //编译通过,即使A,B定义了相同方法
        
    }
    
    interface E extends B,C{//编译失败
        
    }
    

    字接口D多继承父接口A,B成功,但子接口E却多继承父接口B,C失败,就是因为两个接口定义的sameMethodB()除了返回类型外,方法名、参数列表都一样,这不满足方法重载,导致继承时方法冲突。

    如果非得要多继承,Java的解决方案是使用 内部类或嵌套接口;
    ##4. 接口与抽象类的区别

    接口与抽象类的区别:

    • 抽象级别不一样: 接口更加抽象,JDK1.8前只允许抽象方法,JDK1,8后才允许存在静态方法;抽象类的抽象基本低,允许存在具体方法,甚至抽象类中可以没有抽象方法。但有抽象方法的类就必须是抽象类;
    • 接口对成员的定义时的修饰符都有固定的限制,参考前面;抽象类定义成员与普通类是一样的;
    • 接口中不允许定义初始化块(静态或实例),但抽象类允许定义这两种初始化块;
    • 接口中不能定义构造方法,但抽象类允许定义构造方法。

    补充:抽象类中的抽象方法的访问权限是不能是private
    ###二、嵌套接口

    嵌套接口: 就是定义在类或接口中的接口。

    嵌套接口的修饰符限制:

    • 不论定义在接口,还是类中,嵌套接口默认强制是 static。这意味着,嵌套接口是没有局部的嵌套接口。
    • 接口定义在类中,可以使用四种访问权限,定义在接口种,则只有public

    作者:jinggod
    出处:http://www.cnblogs.com/jinggod/p/8503146.html

    展开全文
  • Java之嵌套接口详解(附源码)

    千次阅读 2016-07-21 11:51:08
    接口可以嵌套在类或其他接口中。这揭示了许多非常有趣的特性: package com.mufeng.theninthchapter; class A { interface B { void f(); } public class BImp implements B { @Override public void ...

    示例源码


    接口可以嵌套在类或其他接口中。这揭示了许多非常有趣的特性:

    package com.mufeng.theninthchapter;
    
    class A {
    	interface B {
    		void f();
    	}
    
    	public class BImp implements B {
    
    		@Override
    		public void f() {
    			// TODO Auto-generated method stub
    
    		}
    	}
    
    	private class BImp2 implements B {
    
    		@Override
    		public void f() {
    			// TODO Auto-generated method stub
    
    		}
    	}
    
    	public interface C {
    		void f();
    	}
    
    	class CImp implements C {
    
    		@Override
    		public void f() {
    			// TODO Auto-generated method stub
    
    		}
    	}
    
    	private class CImp2 implements C {
    
    		@Override
    		public void f() {
    			// TODO Auto-generated method stub
    
    		}
    
    	}
    
    	private interface D {
    		void f();
    	}
    
    	private class DImp implements D {
    
    		@Override
    		public void f() {
    			// TODO Auto-generated method stub
    
    		}
    	}
    
    	public class DImp2 implements D {
    
    		@Override
    		public void f() {
    			// TODO Auto-generated method stub
    
    		}
    	}
    
    	public D getD() {
    		return new DImp2();
    	}
    
    	private D dRef;
    
    	public void receiveD(D d) {
    		dRef = d;
    		dRef.f();
    	}
    }
    
    interface E {
    	interface G {
    		void f();
    	}
    
    	public interface H {
    		void f();
    	}
    
    	void g();
    
    	// Cannot be private within an interface:
    	// private interface I{
    	// void f();
    	// }
    }
    
    public class NestingInterfaces {
    
    	public class BImp implements A.B {
    
    		@Override
    		public void f() {
    			// TODO Auto-generated method stub
    
    		}
    	}
    
    	class CImp implements A.C {
    
    		@Override
    		public void f() {
    			// TODO Auto-generated method stub
    
    		}
    	}
    
    	// Cannot implement a private interface except
    	// within that interface's defining class
    	// class DImp implements A.D {
    	// @Override
    	// public void f() {
    	// // TODO Auto-generated method stub
    	//
    	// }
    	// }
    
    	class EImp implements E {
    
    		@Override
    		public void g() {
    			// TODO Auto-generated method stub
    
    		}
    	}
    
    	class EGImp implements E.G {
    
    		@Override
    		public void f() {
    			// TODO Auto-generated method stub
    
    		}
    
    	}
    
    	class EImp2 implements E {
    
    		@Override
    		public void g() {
    			// TODO Auto-generated method stub
    
    		}
    
    		class EG implements E.G {
    
    			@Override
    			public void f() {
    				// TODO Auto-generated method stub
    
    			}
    
    		}
    	}
    
    	public static void main(String[] args) {
    		A a = new A();
    		// Can't access A.D
    		// !A.D ad=a.getD();
    
    		// Doesn't return anything but A.D
    		//!A.DImp2 di2 = a.getD();
    		
    		//Cannot access a member of the interface
    		//!a.getD().f();
    		
    		//Only another A can do anything with getD():
    		A a2=new A();
    		a2.receiveD(a.getD());
    	}
    
    }
    

    源码解析


           在类中嵌套接口的语法是相当显而易见的,就像非嵌套接口一样,可以拥有 public和“包访问”两种可视性。
           作为一种新添加的方式,接口也可以被实现为 private的,就像在 A.D中所看到的(相同的语法既适用于嵌套接口,也适用于嵌套类)。那么 private的嵌套接口能带来什么好处呢?读者可能会猜想,它只能够被实现为 DImple中的一个 private内部类,但是 A.DImp2展示了它同样可以被实现为 public类。但是, A.DImp2只能被其自身所使用。你无法说它实现了一个 private接口 D。因此,实现一个 private接口只是一种方式,它可以强制该接口中的方法定义不要添加任何类型信息(也就是说,不允许向上转型)。
            getD()方法使我们陷入了一个进退两难的境地,这个问题与 private接口相关:它是一个返回对 private接口的引用的 public方法。你对这个方法的返回值能做些什么呢?在 main()中,可以看到数次尝试使用返回值的行为都失败了。只有一种方式可成功,那就是将返回值交给有权使用它的对象。在本例中,是另一个 A通过 receiveD()方法来实现的。
           接口 E说明接口彼此之间也可以嵌套。然而,作用于接口的各种规则,特别是所有的接口元素必须是 public的,在此都会被严格执行。因此,嵌套在另一个接口中的接口自动就是 public的,而不能声明为 private
           NestingInterfaces展示了嵌套接口的各种实现方式。特别要注意的是,当实现某个接口时,并不需要实现嵌套在其内部的任何接口。而且, private接口不能在定义它的类之外被实现。


    展开全文
  • RxJava 嵌套调用接口

    千次阅读 2018-04-27 09:36:45
    我的标题写的很清楚是嵌套调用接口。比如你需求是要调用两个接口,只允许两个接口同时成功,只有一个成功就不算成功而不去更新UI,否则只有一个成功去更新UI会出现“bug”的感觉。所以你要嵌套来调用者两个接口,...
  • 如果不允许有 null,我建议 API 直接返回错误信息,而不是前端再做错误处理。 到底要不要返回默认值取决于该域的实际用途。如果该域的默认值是为了处理 View 层的问题,那么这个默认值就肯定只能是 View 自己去处理...
  • Java&&接口嵌套

    千次阅读 2014-10-24 10:53:36
    在Java语言中,接口可以嵌套在类或其它接口中。由于Java中interface内是不可以嵌套class的,所以接口嵌套就共有两种方式:class嵌套interface、interface嵌套interface。
  • 最近在做接口自动化测试,响应的内容大多数是多层嵌套的json数据,在对响应数据进行校验的时候,可以通过(key1.key2.key3)形式获取嵌套字典值的方法获取响应值,再和预期值比较 keys_list = keys.split('.') #...
  • Swagger返回嵌套json数据

    千次阅读 2020-04-14 19:58:28
    swagger中的数据展示四、多层嵌套1. 嵌入一层列表2. 返回分页信息3. 对象里有另外的对象五、总结 一、接口展示中的问题   现在大部分前后端的数据交互都是采用json格式,如我们经常用一个大的json包裹着数据发送...
  •  类(class)中是可以嵌套接口(nested interface)的,就是把接口写到类里,而且interface可以用public,package(默认),protected,及private来定义这个内部接口对于外界的可见性.public定义的内部接口就不多说了,和非内嵌...
  • Swagger 嵌套对象、嵌套json数据返回的写法

    万次阅读 热门讨论 2018-09-21 19:48:10
    上篇文章我们介绍了如何使用Swagger 自动生成api文档 ...我们在项目中需要返回这种数据 { "code": 200, "msg": "string", "result": { "curren...
  • Mybatis 返回结果多重嵌套List

    千次阅读 2020-03-17 16:24:12
    实际开发中,在定义接口返回格式时往往会遇到返回json多重嵌套的情况: 返回数据结构定义 我们可以在service层处理数据得到想要的格式。也可以在.xml文件中通过sql来做简单处理。 比如想得到上图格式(四层嵌套) ...
  • 多层嵌套Fragment监听返回

    千次阅读 2018-10-17 12:08:23
    上面就是多层Fragment嵌套监听返回键的代码,直接张贴过来用即可。来源:网络 --------------------------------------- 下面是广告 ------------------------------------------------ 个人微信:hll643435675...
  • 小程序for循环嵌套请求接口问题

    千次阅读 2018-07-31 19:25:35
    前段时间实现一个小程序...如果点击时没有数据状态改变那么可以直接使用onLoad方法可以轻松解决,因为要刷新数据,所以只能讲数据请求放在onShow方法中,这样便造成页面返回数据不能停留在离开时的位置 首先想到的是利...
  • 实现:动态加载后台管理项目菜单功能,并且json为三层嵌套对象 如图所示json返回: 解析如上所示多层json对象,一开始我直接用each方法解析,发现不是name就是url获取不到一直报错undefined $.each(json, ...
  • 前端A: 你们后端接口返回的json太复杂啦!我这例只需要用户的真实姓名和年龄就可以了,结果你们返回了我一大串,好几十个字段…… 前端B: 是呀!是呀!身份证信息是敏感的,这里也不需要用,你们竟然页返回了,...
  • 接口返回一组 jsonarray的数据(每个jsonobject的key数量都是一样的) ,现在有一个存储了 需要的展示的key的list 从返回的jsonarray中取出和list中的key匹配的数据 重新返回 jsonarray (过滤操作) ...
  • 我在学习layui的过程中遇到了table返回值的问题,如果服务器端返回给你的数据是多级嵌套的话,那你在前台是解析不了的,在table.js源码中 它渲染数据是用了 data = res[options.response.dataName] || [] 这个意味...
  • Android系统提供了NestedScrollingChild与NestedScrollingParent两个接口,用于实现嵌套滑动。本文主要介绍它们的原理与实现方法。
  • 1.如下图,服务端一直返回参数格式错误,但一直没找到原因 2.第二天偶然发现是因为少了引号,在python字典中,value的值一定需要引号(除了数字) 3.0000直接写会被识别成0,需要写成‘0000’ 转载于:...
  • 掌握泛型的嵌套设置 之前所有的操作都是在类中直接使用泛型操作的,那么,对于Java来说,也可以直接在接口中定义及使用泛型。 定义泛型接口 在JDK1.5之后,不仅仅可以声明泛型类,也可以声明泛型接口,声明泛型...
  • 页面嵌套iframe

    千次阅读 2017-11-28 17:50:37
    项目中带调用其他项目接口,iframe嵌套 对方接口数据页面,所以将iframe嵌套在本项目的页面,当接口返回数据,页面的标题,头部,和尾部依旧是本项目的,数据是调用接口的数据。 二、优点: 1、这是第一次写,直接...
  • //采用map嵌套返回Json格式 map1.put(name,text); map.put(bookName,map1); System.out.println("---"+name+":"+text); } System.out.println("============="+"表单"+bookName+"遍历结束========="); } }...
  • 前两天发布了个任务是追加...是一个嵌套的数据要把当前的嵌套的数据追加到当前数据的下面 其实很简单就是一个简单的数组的操作 下面是追加的代码 //你自己的接口和要传递的参数一般传递页码和当前页面条数 this.$axi...
  • 一直使用的是FastJson,感觉还不错,很方便。看了一段别人的分析,觉得很有道理。 [为什么要使用Fastjson,其实原因不...比如A有一个List,B对象里又有一个A对象,当然返回A对象的Json字符串时,如果是 Jackson就
  • "远程服务器返回错误,通知推送失败!" ); } else { //使用ajax调用后台方法,更改该推送信息的是否推送状态 $.ajax({ type : "POST" , url: "MGInfoPush_List.aspx/PostSuccess" , data: "{'RGuid': '...
  • 将API接口返回的数据直接转换成typescript支持的type类型 问题描述 在使用taro进行微信小程序的开发的时候,采用typescript可以很好地管理数据类型,但是接口数据类型要自己一个一个写,太麻烦了! 问题解决 下面的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 139,678
精华内容 55,871
关键字:

嵌套接口返回