java笔记--接口和内部类

1、接口
（1）、接口的定义
定义一个接口使用interface关键词，它只能被默认或者public修饰，使用其他修饰符都将报错。一般来讲，接口的内部定义了一些被隐式指定为public abstract的方法，也可以定义（很少这样定义）一些变量（只能被public static final修饰）。接口内部定义的方法不能有具体的实现，也就是说接口中的方法只能是抽象方法。
[public] interface InterfaceName
{
void method();//该方法为抽象方法，没有具体的实现
}
那么如何使用接口呢？要使用一个接口，需要定义一个类，让该类实现这个接口。
class ClassName implements InterfaceName1,InterfaceName2...
{
//具体实现接口中定义的抽象方法
public void method();
...
}
由此可以看出，虽然java不支持多继承，但是支持多实现，一个类可以实现多个接口。
（2）接口与抽象类的区别
（a）抽象类中可以定义非抽象的方法（有具体实现），而接口中只能有抽象方法。
（b）抽象类中定义的成员变量可以是多类型的，而接口中的变量只能是public static final。
（c）一个类可以实现多个接口，而一个类只能继承一个抽象类。
（d）抽象类是对类的抽象，接口是一种行为规范，是对行为的抽象，它是类的附加的功能，是作为类的补充而设计的。接口比抽象类更加抽象
一个实例：
现在有一个门类（Door）它有打开（open）、关闭（close）的功能，这是门固有的属性，则可以定义一个类Door：
class Door
{
void open();
void close();
}
假如还需要加入一个报警的功能（Alarm），则这个报警的方法应该定义为抽象方法还是接口呢？答案是定义为接口较好。原因是，如果定义为抽象方法放进Door类中，则继承于Door的所有子类都需要实现这个报警的方法，然而，并不是所有门都有报警的功能。相反，如果定义为接口，就可以让那些具有报警的功能的门去自己实现接口。


2、内部类
（1）成员内部类
这种内部类可以理解为非静态的成员变量，成员内部类既可以访问本内部类的成员，还可以访问外部类的成员，这是因为内部类存在一个指向外部对象的引用
OuterClass.this。创建成员内部类时使用(new Outerclass()).new Innerclass();的方式创建。
例子：
class MemberInnerTest
{
public static void main(String[] args)
{
MemberInner.Inner Mii=new MemberInner().new Inner();
Mii.doSomething();
}
}
class MemberInner
{
private int a=1;
private int b=3;
//成员内部类
class Inner
{
private int a=2;
public void doSomething()
{
System.out.println(a);   //这里的a实际上是this.a
System.out.println(b);   //这里的b实际上是MemberInner.this.b，因为内部类没有变量b，继续向外搜索。
System.out.println(MemberInner.this.a);
}
}
}


（2）静态内部类
那么静态内部类可以理解为静态的成员变量，静态内部类只能访问外部的静态成员和静态方法。若要访问外部类的非静态成员，则需要先创建外部类的对象，用对象进行访问。
创建静态内部类对象使用OuterClass.InnerClass inner = new OuterClass.InnerClass();的方式创建。
例子：
class StaticInnerTest
{
public static void main(String[] args)
{
StaticInner.Inner Mii=new StaticInner.Inner();
Mii.doSomething();
}
}
class StaticInner
{
    private static int a=1;
    private int b=3;
//静态内部类
static class Inner
{
public void doSomething()
{
System.out.println(a); //这里的a相当于MemberInner.a
System.out.println(new MemberInner().b);//非静态成员需要先创建外部对象再访问。
}
}
}


（3）局部内部类
局部内部类定义在方法中，比方法的范围还小。是内部类中最少用到的一种类型。像局部变量一样，不能被public, protected, private和static修饰。只能访问方法中定义的final类型的局部变量（jdk1.8没问题）。局部内部类在方法中定义，所以只能在方法中使用，即只能在方法当中生成局部内部类的实例并且调用其方法。
例子：
class LocalInnerTest
{
public static void main(String[] args)
{
LocalInner mi=new LocalInner();
mi.Test();
}
}
class LocalInner
{
    private static int a=1;
    private int b=3;
    public void Test()
    {
    int c=3;
    final int d=3;
    class Inner
{
public void doSomething()
{
System.out.println(c); //error，jdk1.8没问题
System.out.println(d);
}
}
new Inner().doSomething();
    }

}
（4）匿名内部类
匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。匿名内部类隐式地继承了一个父类或者实现了一个接口。匿名内部类使用得比较多，通常是作为一个方法参数。
例子：
class AnonymouseInnerTest
{
public static void main(String[] args)
{
//Person p=new Child();//常规做法
//使用匿名内部类
Person p=new Person()
{
public void eat()
{
System.out.println("eat");
}
};
p.eat();


}
}
interface Person
{
void eat();

}

/*

class Child implements Person
{
public void eat()
{
System.out.println("eat");
}

}

*/