JAVA小计3（第三周）

这是学习java的第三周了，随着学习的深入，也越发体会了java这门语言的魅力。

本周我学习的内容是接口，学习成果如下。

接口

一，接口是什么

接口是我在C++上还没有涉及到的概念，故理解起来有些难度。

接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。

抽象类还提供某些具体实现，接口不提供具体实现，接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范。

从接口的实现者角度看，接口定义了可以向外部提供的服务。

从接口的调用者角度看，接口定义了实现者能提供的哪些服务。

接口和实现类不是父子关系，是实现规则的关系。

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。

public interface MyInterface{
      /*public static */int Max_Age=100;    
      /*public abstract */ void test01（）；
}
calss MyClass implements MyInterface{
     public void test01(){
     System.out.println(Max_Age);
     System.out.println("MyClass.test01()");
}
}

二，声明格式

【访问修饰符】 Interface 接口名    [extends 父接口1，父接口2]   {

常量定义；

方法定义；

}

1.访问修饰符：只能是public或默认

2.接口名：和类名采用相同命名机制

3.extends：接口可以多继承

4.常量：接口中的属性只能是常量，总是：public static final修饰，不写也是

5.方法：接口中的方法只能是：public abstract，如果省略的话，也是public abstract

三，要点：

1.子类通过implements来实现接口中的规范

2.接口不能创建实例，但是可用于声明引用变量类型

3.一个类实现了接口，必须实现接口中的所有方法，并且这些方法只能是public的

4.JDK1.7之前，接口中只能包含静态常量，抽象方法，不能有普通属性，构造方法，普通方法

5.JDK1.8之后，接口中包含普通的静态方法

四，接口的多继承

接口完全支持多继承，和类的继承类似，子接口拓展某个父接口，将会获得父接口中所定义的一切。

interface A{
     void testa();
}
interface B{
     void textb();
}
interface C extends A,B {
     void textc();
}
public class Test implements C{
     public void testc(){
     }
     public void testa(){
     }
     public void testb(){
     }
}

四.内部类

在java中内部类主要分为成员内部类（非静态内部类，静态内部类）、匿名内部类、局部内部类

成员内部类（可以使用private、default、protected、public任意进行修饰。类文件：外部类$.class）

1.非静态内部类（外部类里使用非静态内部类和平时使用其他类没什么不同）

a.非静态内部类必须寄存在 一个外部类对象里。因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。

b.非静态内部类不能有静态方法、静态属性和静态初始化块。

c.外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例。

d.成员变量访问要点：

内部类里方法的局部变量：变量名

内部类属性：外部类名.this.变量名

public class TestInnerClass{
   public static void main(String[] args){
      Outer.Inner inner=new Outer().new Inner();
      inner.show();
}

}

class Outer{
   private int age=10;
   public void testOuter(){
      System.out.println("Outer.testOuter()");
}

class Inner{
    int age=20;
    public void show(){
       int age=30;
       System.out.println("外部类的成员变量age:"+Outer.this.age);
       System.out.println("内部类的成员变量age:+this.age);
       System.out.println("局部变量age:"+age);
}

}

2.静态内部类

a.定义方式：

static class ClassName{

//类体

}

b.使用要点：

1.当一个静态内部类对象存在，并不一定存在对应的外部类对象。因此，静态内部类的实例方法不能直接访问外部类的实例方法。

2.静态内部类看做外部类的一个静态成员。因此。外部类的方法中可以通过：“静态内部类.名字”的方式访问静态内部类的静态成员，通过new静态内部类（）访问静态内部类的实例。

class Outer{
    static class Inner{
   }
}
public class TestStaticInnerClass() {
    public static void main (String[] args) {
        Outer.Inner inner =new Outer.Inner();
  }
}

3.匿名内部类

适合那种只需要使用一次的类。

a.语法

new 父类构造器（实参类表 ）\实现接口 （） {

           //匿名内部类类体

}

this.addWindowListenner(new WindowAdapter(){
         public void windowClosing(WindowEvent e) {
              System.exit(e);
         }
      }
};
this.addKeyListener(new KeyAdapter()){
         public void keyPressed(KeyEvent e) {
                myTank.keyPressed(e);
         }
         public void keyReleased(KeyEvent e) {
                myTank.keyPeleased(e);
         }
     }
 };

 注意：

     1.匿名内部类没有访问修饰符

     2.匿名内部类没有构造方法，因为它连名字都没有那又何来构造方法呢