java入门学习（11）—接口定义（interface）及使用（implements）
1、接口：一种把类抽象的更彻底，接口里只能包含抽象方法的“特殊类”。接口不关心类的内部状态数据，定义的是一批类所遵守的规范。（它只规定这批类里必须提供某些方法，提供这些方法就可以满足实际要求）。
定义：【修饰符】 interface 接口名 extends 父接口1，赋接口2，.......//不用extends 父接口1...就是定义接口
//零到多个常量定义......
//零到多个抽象实例方法定义.....
【语法说明】：1、修饰符可以是public或者省略，如果省略public访问控制符，则是包访问权限。
2、接口里所有的成员都是public修饰，因为接口是公共的，所有类都能访问的。接口里属性默认的修饰为：public static final，不管属性前面写没写都会默认加上，同样方法的默认修饰为：public abstract，内部类：public static。都会默认加上。
3、成员里面不能有构造器，不能有初始化块。
4、一个java源文件里最多只能定义一个接口，因为其是public修饰的，存储的名字必须和public修饰的类的名字一样，而接口可以看成一个特殊的类。
2、接口的继承：一个接口可以有多个直接父接口，接口只能继承接口，不能继承类。
【注意点】：a、子接口继承父接口，将会获得父接口里定义的所有抽象方法，常量属性，内部类等定义。
3、接口的使用：语法：【修饰符】class
extends 父类 implements 接口1，接口2......{类体}。
【注意事项】
a、说明：一个类可以同时继承一个父类，和多个接口，只是extends必须放置implements之后。
b、接口不能创建实例，但是可以声明变量，但其一定是引用到了其实现类的对象。
c、主要用途就是被类实现。
d、实现的方法：利用implements关键字
e、一个类继承了一个接口之后，必须完全实现这些接口里所定义的全部抽象方法（也就是要在子类里面重写这些类方法），否则，如果没有完全实现，那么此类也只能定义成抽象类。
f、重写接口方法时，修饰符只能比父类更大，或者相等，所以其也必须是public修饰符。
g、所有接口类型的变量都可以直接赋给Object类型的变量。
贴上示例代码（引用于李刚的疯狂java）：
//定义一个接口Output
interface Output
//接口里只能把属性定义成常量
int MAX_CACHE_LINE = 50;//主要是定义存储空间
//接口里定义的只能是public的抽象方法
void out();
void getData(String msg);
//定义一个接口Product
interface Product
int getProduceTime(int a);
//让printer类实现定义的接口
public class Printer implements Output,Product
private String [] printData = new String[MAX_CACHE_LINE];
private int dataNum =0;
public void out()//重写父接口Output的方法
while(dataNum&0)
System.out.println("打印机打印"+printData[0]);
System.arraycopy(printData,1,printData,0,--dataNum);
public void getData(String msg)//重写父接口Output的方法
if(dataNum&=MAX_CACHE_LINE)
System.out.println("已满");
printData[dataNum++] =
public int getProduceTime(int a)//重写父接口Product的方法
return a =
public static void main(String[] args)
//父接口可声明变量，但是不能创建实例，多态：声明的是Output，但是创建的实例是Printer
Output O= new Printer();
O.getData("xiuxiu");
O.out();//直接调用输出的方法
//父接口可声明变量，但是不能创建实例，多态：声明的是Output，但是创建的实例是Printer
Product p = new Printer();
System.out.println(p.getProduceTime(82));
//所有接口类型的引用变量都可以直接赋值给Object类型的变量
Object obj =
Object obj1 = O;
4、抽象类和接口的异同：
相同：1、都有抽象方法。
2、都不能创建实例。
3、子类继承其后都必须全部实现其内的抽象方法，如果没有全部实现的话，类只能定义成抽象类。
不相同：1、接口里只能有抽象方法，抽象类里可以有普通方法。
2、接口类里的属性默认有修饰语public static final ，但是抽象类中的属性可以是普通的。
3、接口没有初始化块，抽象类里有。
4、接口可以有多个父接口，但是抽象类只能有一个父类。
没有更多推荐了，其他回答(1)
指定了具体的类型后就不是泛型了
园豆：17378
清除回答草稿
&&&您需要以后才能回答，未注册用户请先。博客分类：
@interface是用来自定义JAVA Annotation的语法，普通的开发人员可能很少用到它，但是它的功能很强大，本文将具体介绍@interface的用法！
@interface是用来自定义注释类型的，如果你不了解Java注释，可以参阅上一篇文章："JDK5.0注释(Annotation)的用法"。
一般的应用程序开发人员可能从不需要定义一个注释类型，但定义我们自己的注释类型并不复杂。注释类型的定义跟定义一个接口相似，我们需要在 interface这个关键字前面加上一个@符号，即@interface。注释中的每一个方法定义了这个注释类型的一个元素，注释中方法的声明中一定不能包含参数，也不能抛出异 常；方法的返回值被限制为简单类型、String、Class、emnus、注释，和这些类型的数组。方法可以有一个缺省值。这里是一个注释类型定义的例 子：　/**
　　* Describes the Request-For-Enhancement(RFE) that led
　　* to the presence of the annotated API element.
　　*/ 　　public @interface RequestForEnhancement {
　　 int id();
　　 String synopsis();
　　 String engineer() default "[unassigned]";
　　 String date(); default "[unimplemented]";
　　} 　一旦定义好了一个注释类型，你就可以用来作注释声明。注释一中特殊的修饰符，在其他修饰符（比如public，static，或者final等） 使用地方都可以使用。按照惯例，注释应该放在其他修饰符的前面。注释的声明用@符号后面跟上这个注释类型的名字，再后面跟上括号，括号中列出这个注释中元 素/方法的key－value对。值必须是常量。这里是一个例子，使用上面定义的注释类型：@RequestForEnhancement(
　　 id = 2868724,
　　 synopsis = "Enable time-travel",
　　 engineer = "Mr. Peabody",
　　 date = "4/1/3007" 　　)
　　public static void travelThroughTime(Date destination) { ... } 没有元素/方法的注释被成为标记（marker）注释类型，例如/**
　　* Indicates that the specification of the annotated API element
　　* is preliminary and subject to change.
　　*/ 　　public @interface Preliminary { } 　标记注释在使用的时候，其后面的括号可以省略，例如@Preliminary public class TimeTravel { ... } 如果注释中仅包含一个元素，这个元素的名字应该为value，例如：/**
　　* Associates a copyright notice with the annotated API element.
　　*/ 　　public @interface Copyright { String value(); } 如果元素的名字为value，使用这个注释的时候，元素的名字和等号可以省略，如：@Copyright("2002 Yoyodyne Propulsion Systems")
public class OscillationOverthruster { ... } 为了将上面提到的东西结合在一起，我们创建了一个简单的基于注释的测试框架。首先我们需要一个标记注释类型用以说明一个方法是一个测试方法，并被测试工具执行。import java.lang.annotation.*;
　　* Indicates that the annotated method is a test method.
　　* This annotation should be used only on parameterless static methods.
　　*/ 　　@Retention(RetentionPolicy.RUNTIME)
　　 @Target(ElementType.METHOD)
　　public @interface Test { }
　　我们可以注意到这个注释类型本省也被注释了，这种注释叫做元注释。第一注释 (@Retention(RetentionPolicy.RUNTIME))表示这种类型的注释被VM保留从而使其能够通过反射在运行时读取；第二个注 释@Target(ElementType.METHOD)表示这种注释只能用来注释方法。下面是一个简单的类，其中的几个方法被加了上面的注释：　　public class Foo {
　　 @Test public static void m1() { }
　　 public static void m2() { }
　　 @Test public static void m3() {
　　 throw new RuntimeException("Boom");
　　 public static void m4() { }
　　 @Test public static void m5() { }
　　 public static void m6() { }
　　 @Test public static void m7() {
　　 throw new RuntimeException("Crash");
　　 public static void m8() { }
　　} 　　这里是测试工具：　　import java.lang.reflect.*;
　　public class RunTests {
　　 public static void main(String[] args) throws Exception {
　　 int passed = 0, failed = 0;
　　 for (Method m : Class.forName(args[0]).getMethods()) {
if (m.isAnnotationPresent(Test.class)) {
m.invoke(null);
} catch (Throwable ex) {
System.out.printf("Test %s failed: %s %n", m, ex.getCause());
　　 System.out.printf("Passed: %d, Failed %d%n", passed, failed);
　　} 　　这个工具用一个类名作为参数，遍历这个类中的所有方法，并调用其中被加了@Test注释的方法。如果一个方法抛出了一个异常，那么这个测试就失败了，最终的测试结果被打印了出来。下面是程序运行的结果：　　$ java RunTests Foo
　　Test public static void Foo.m3() failed: java.lang.RuntimeException: Boom
　　Test public static void Foo.m7() failed: java.lang.RuntimeException: Crash
　　Passed: 2, Failed 2 　　虽然这个测试工具只是一个玩具，但他显示了注释的强大的功能。
浏览 23989
wutheringsea
浏览: 200700 次
来自: 成都
整体思路还是正确的，请问1F何处有问题？我稍微看了下，没发现什 ...
总结的不错
好好看看你的代码的真确性，再贴出来。。
--查询预受理申请审计表中按照业务类别分类的最新创建（最近修改 ...
这种方式足够既能直接分组，又能筛选分组中的最大Id，足够用了。 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'Java中的内部接口 - 风一样的码农 - 博客园
随笔 - 192, 文章 - 8, 评论 - 231, 引用 - 0
什么是内部接口
内部接口也称为嵌套接口，即在一个接口内部定义另一个接口。举个例子，Entry接口定义在Map接口里面，如下代码：
public interface Map {
interface Entry{
int getKey();
void clear();
为什么要使用内部接口
如下是一些强有力的理由：
一种对那些在同一个地方使用的接口进行逻辑上分组；
封装思想的体现；
嵌套接口可以增强代码的易读性和可维护性；
在Java标准库中使用内部接口的一个例子是java.util.Map和Java.util.Map.Entry。这里java.util.Map同样被当成命名空间使用。Entry并不属于全局作用域范围.
内部类如何工作
为了弄清楚内部接口是如何工作的，我们可以拿它与内部类作比较。内部类可以被认为是一个外部类内部定义的一个常规方法。因为一个方法可以被声明为静态和非静态，类似的内部类也可以被声明为静态和非静态。静态类类似于静态方法，它只能访问外部类的静态成员属性。非静态方法可以访问外部类的所有成员属性。
因为接口是不能实例化的，内部接口只有当它是静态的才有意义。因此，默认情况下，内部接口是静态的，不能你是否手动加了static关键字。
内部接口例子
public interface Map {
interface Entry{
int getKey();
void clear();
MapImpl.java
public class MapImpl implements Map {
class ImplEntry implements Map.Entry{
public int getKey() {
public void clear() {随笔- 875&
&&&&&&&&&&&
java用&&@interface Annotation{ }&定义一个注解 @Annotation，一个注解是一个类
@Override，@Deprecated，@SuppressWarnings为常见的3个注解。注解相当于一种标记，在程序中加上了注解就等于为程序加上了某种标记，以后，JAVAC编译器，开发工具和其他程序可以用反射来了解你的类以及各种元素上有无任何标记，看你有什么标记，就去干相应的事
注解@Override用在方法上，当我们想重写一个方法时，在方法上加@Override，当我们方法的名字出错时，编译器就会报错，如图：
&&&&&& 注解@Deprecated，用来表示某个类的属性或方法已经过时，不想别人再用时，在属性和方法上用@Deprecated修饰，如图：
& 注解@SuppressWarnings用来压制程序中出来的警告，比如在没有用泛型或是方法已经过时的时候，&如图：
注解@Retention可以用来修饰注解，是注解的注解，称为元注解
Retention注解有一个属性value，是RetentionPolicy类型的，Enum RetentionPolicy是一个枚举类型，这个枚举决定了Retention注解应该如何去保持，也可理解为Rentention 搭配 RententionPolicy使用。RetentionPolicy有3个值：CLASS& RUNTIME&& SOURCE用@Retention(RetentionPolicy.CLASS)修饰的注解，表示注解的信息被保留在class文件(字节码文件)中当程序编译时，但不会被虚拟机读取在运行的时候；用@Retention(RetentionPolicy.SOURCE )修饰的注解,表示注解的信息会被编译器抛弃，不会留在class文件中，注解的信息只会留在源文件中；用@Retention(RetentionPolicy.RUNTIME )修饰的注解，表示注解的信息被保留在class文件(字节码文件)中当程序编译时，会被虚拟机保留在运行时，所以他们可以用反射的方式读取。RetentionPolicy.RUNTIME 可以让你从JVM中读取Annotation注解的信息，以便在分析程序的时候使用.
package com.
import java.lang.annotation.R
import java.lang.annotation.RetentionP
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTarget
定义个一注解@MyTarget，用RetentionPolicy.RUNTIME修饰；
package com.
import java.lang.reflect.M
public class MyTargetTest
public void doSomething()
System.out.println("hello world");
public static void main(String[] args) throws Exception
Method method = MyTargetTest.class.getMethod("doSomething",null);
if(method.isAnnotationPresent(MyTarget.class))//如果doSomething方法上存在注解@MyTarget，则为true
System.out.println(method.getAnnotation(MyTarget.class));
上面程序打印：@com.self.MyTarget()，如果RetentionPolicy值不为RUNTIME,则不打印
@Retention(RetentionPolicy.SOURCE )
public @interface Override
@Retention(RetentionPolicy.SOURCE )
public @interface SuppressWarnings
@Retention(RetentionPolicy.RUNTIME )
public @interface Deprecated
由上可以看出，只有注解@Deprecated在运行时可以被JVM读取到 &
注解中可以定义属性，看例子：
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation
String hello() default "gege";
String world();
int[] array() default { 2, 4, 5, 6 };
EnumTest.TrafficLamp lamp() ;
TestAnnotation lannotation() default @TestAnnotation(value = "ddd");
Class style() default String.class;
上面程序中，定义一个注解@MyAnnotation，定义了6个属性，他们的名字为：&&
hello,world,array,lamp,lannotation,style.&&
属性hello类型为String,默认值为gege&&
属性world类型为String,没有默认值&&
属性array类型为数组,默认值为2，4，5，6&&
属性lamp类型为一个枚举,没有默认值&&
属性lannotation类型为注解,默认值为@TestAnnotation，注解里的属性是注解&&
属性style类型为Class,默认值为String类型的Class类型&&
看下面例子:定义了一个MyTest类，用注解@MyAnnotation修饰，注解@MyAnnotation定义的属性都赋了值
@MyAnnotation(hello = "beijing", world="shanghai",array={},lamp=TrafficLamp.RED,style=int.class)
public class MyTest
@MyAnnotation(lannotation=@TestAnnotation(value="baby"), world = "shanghai",array={1,2,3},lamp=TrafficLamp.YELLOW)
@Deprecated
@SuppressWarnings("")
public void output()
System.out.println("output something!");
接着通过反射读取注解的信息： &
public class MyReflection
public static void main(String[] args) throws Exception
MyTest myTest = new MyTest();
Class&MyTest& c = MyTest.class;
Method method = c.getMethod("output", new Class[] {});
//如果MyTest类名上有注解@MyAnnotation修饰，则为true
if(MyTest.class.isAnnotationPresent(MyAnnotation.class))
System.out.println("have annotation");
if (method.isAnnotationPresent(MyAnnotation.class))
method.invoke(myTest, null); //调用output方法
//获取方法上注解@MyAnnotation的信息
MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);
String hello = myAnnotation.hello();
String world = myAnnotation.world();
System.out.println(hello + ", " + world);//打印属性hello和world的值
System.out.println(myAnnotation.array().length);//打印属性array数组的长度
System.out.println(myAnnotation.lannotation().value()); //打印属性lannotation的值
System.out.println(myAnnotation.style());
//得到output方法上的所有注解，当然是被RetentionPolicy.RUNTIME修饰的
Annotation[] annotations = method.getAnnotations();
for (Annotation annotation : annotations)
System.out.println(annotation.annotationType().getName());
上面程序打印： &
have annotation
output something!
gege, shanghai
class java.lang.String
com.heima.annotation.MyAnnotation
java.lang.Deprecated
如果注解中有一个属性名字叫value,则在应用时可以省略属性名字不写。&&
可见，@Retention(RetentionPolicy.RUNTIME&)注解中，RetentionPolicy.RUNTIME是注解属性值，属性名字是value,&&
属性的返回类型是RetentionPolicy，如下：
public @interface MyTarget
String value();
可以这样用： &
@MyTarget("aaa")
public void doSomething()
System.out.println("hello world");
注解@Target也是用来修饰注解的元注解，它有一个属性ElementType也是枚举类型，&&
值为：ANNOTATION_TYPE&CONSTRUCTOR&&FIELD&LOCAL_VARIABLE&METHOD&PACKAGE&PARAMETER&TYPE&&
如@Target(ElementType.METHOD)&修饰的注解表示该注解只能用来修饰在方法上
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTarget
String value() default "hahaha";
如把@MyTarget修饰在类上，则程序报错，如：
public class MyTargetTest
阅读(...) 评论()