API文档练习

 

API文档开发:

1.     需要定义一个类工具类:ArrayTool数组工具类:给该类写上文档注释(每一个静态方法都需要使用文档注释)

2.     需要将该类无参私有化,目的是为了让外界创建对象

3.     ArrayTool中的成员方法全部用static修饰

4.     测试完毕

5.     如何制作ApI文档

针对ArrayTool来制作

打开dosàjavadoc –d 目标名(文件名) –author –version ArrayTool.java

Eg: public class ArrayTool {

    private ArrayTool(){

    }

/*

 * 该方法是针对数组的遍历的方法,遍历的元素[元素1,元素2,...]

 * @param arr:需要被遍历的数组

 * */

public class ArrayTool {

//无参构造私有的目的:是为了不让外界创建对象

    private ArrayTool(){

    }

public static void printArray(int[]arr){

    System.out.print("[");

    for(int x=0;x<arr.length;x++){

       if(x==arr.length-1){

           System.out.println(arr[x]+"]");

       }else {

           System.out.println(arr[x]+",");

       }

    }

}

/*

 * 该方法是针对数组获取最大值得方法

 * @param arr:需要被遍历的数组,可以获取每一个元素

 * @return 返回的就是数组中最大值

 * */

public static int getMax(int[]arr){

    int max=arr[0];

    for(int x=1;x<arr.length;x++){

     //判断

     if(arr[x]>max){

        max=arr[x];

     }

    }

return max;

}

/*

 * 该方法是查询数组中的元素在数组中第一次出现的索引

 * @param arr:需要查询的数组

 * @param value:需要被查找的值

 * @return 如果查到了当前索引对应的元素,那么就直接返回当前索引,如果查不到,则返回0

* */

public static int getIndex(int[] arr,int value){

    int index = 0 ;

    for(int x = 0 ; x < arr.length ; x ++){

       if(arr[x]==value){

           index  = x ;

           break ;

       }

    }

    return index ;

}

}

//测试类

public class ArreyText{

public static void main(String[] args) {

int[]arr ={26,262,626,265,48,456};

ArrayTool.printArray(arr) ;    //遍历数组

         intresult = ArrayTool.getMax(arr) ;

         System.out.println("result:"+result);//获取最大值

int index = ArrayTool.getIndex(arr, 15) ;

                  System.out.println("index:"+index);  //查询元素15并打印出来

}

}

使用Javadoc来生成页面:

打开dos---->javadoc -d 目标名(文件名) -author -version ArrayTool.java

用火狐或者谷歌.

ApI使用:打开ApI:显示-à输入你查找的类  索引à搜索

找到一个类:对该类的描述看类结构: 看该类是否有字段(变量),构造方法(如何创建该类对象),方法(类的成员方法)

出现的该类版本号:

//单行注释不会被jvm解析出来

/**

*会被jvm识别

**/

形式参数和返回值问题:

形式参数:基本数据类型,要什么数据类型,在实际传参的时候就传什么数据类型

形式参数的改变对实际参数没有影响

(String是引用类型和基本数据类型的效果一样Strings ="abc")

形式参数是引用类型:

1.具体类类：如果形式参数是一个具体类,那么需要创建该类对象（才能调用该对象）

返回值:直接返回该类对象(开发中通常使用匿名对象)

2.抽象类: 如果形式参数是抽象类的情况,那么需要自定义一个抽象类的子类,来进行实例化(创建对象)!,创建对象的实质:抽象类多态!

返回值:返回值如果是抽象类,需要的返回时该抽象类的子类对象

eg: abstract class Person{

    public abstract void Work();

}

class PersonDemo{

    public void method(Person p){

       p.Work();

    }

}

class Student extends Person{

    @Override

    public void Work() {

    System.out.println("努力工作");

       }

}

public class PersonText {

public static void main(String[]args){

    //创建子类对象调用方法

    PersonDemo pd=new PersonDemo();

    Person p=new Student();

    pd.method(p);

   

    //链式编程

    new PersonDemo().method(new Student());

}

}

3.接口:如果形式参数是接口需要定义一个子实现类,通过接口多态来进行参数的传递.

返回值: 返回值如果是接口类型,需要的是返回该接口的子实现类对象

Eg: interface Inter{

    public abstract void teach();

}

class TeacherDemo{

    public void method(Inter i){  

       i.teach();

    }

}

//因为接口不能实例化,定义接口的子实现类

class Student1 implements Inter{

    @Override

    public void teach() {

    System.out.println("我们爱学习");

       }

    }

public class TeacherText {

public static void main(String[]args){

    //需要调用TeacherDemo类中的method()方法

    TeacherDemo td=new TeacherDemo();

    Inter i=new Student1();  //接口多态来实现

    td.method(i);

}

}

匿名内部类:在没有子实现类的情况下想要实现

Inter i1 = new Inter() {     //匿名内部类   

@Override

           publicvoid teach () {

              System.out.println("我们爱学习");

           }

       };

       i1.teach ();     

内部类:

在一个类中定义另一个类,把这种情况叫做内部类:

举例:在类A中定义一个类B,类B就是A的内部类,同理,类A是类B的外部类

内部类是直接可以访问外部类的成员,包括私有

外部类想要访问内部类的成员,必须通过创建内部类的对象访问该内部类的成员

Eg: class Outer{

         //外部类的成员变量

         privateint num = 20 ;

         //内部类

         classInner{

                  //内部类的成员方法

                  publicvoid show(){

                          System.out.println(num);

                  }

         }

         //外部类的成员方法

         publicvoid method(){

//              show();

                  //创建内部类对象

                  Inneri = new Inner() ;

                  i.show();

         }

}

//测试类

public class InnerDemo {

         publicstatic void main(String[] args) {

         }

}

内部类的分类:成员内部类:在外部类的成员位置

            局部内部类:在外部的局部变量位置定义这个类

成员内部类

  在测试类中需要访问成员内部类中的成员的方法:

  外部类名.内部类名对象名 = 外部类对象.内部类对象;

 

需求:现在需要访问Inner3成员内部类中的show()方法

需要建立内部类的一个成员.在通过它调用show方法.

成员内部类的修饰符:

Private:为了保证数据的安全性

Static修饰:为了方便调用

如果成员内部类被static修饰,那么要访问外部类的成员变量,这个变量必须被static修饰

.静态的成员内部类访问该类中的成员方法:

格式:外部类名.内部类名对象名 =new 外部类名.内部类名();

)

可以直接创建外部类对象Body b = new Body();      b.behivour();

外部类:

    结论:对于静态的成员内部类来说,无论静态成员内部类中的成员方法是静态还是非静态的,要访问外部类的成员变量,该变量必须被static修饰

class Outer4{

    //外部类的两个成员变量

    public  static int num = 10 ;

    public static int num2 = 20 ;

    //定义一个静态的成员内部类

    public static class Inner4{

       //非静态的内部类的成员方法

       public void show(){

           System.out.println(num);

           System.out.println(num2);

       }

           //静态的内部类的成员方法

       public static void show2(){

           System.out.println(num);

           System.out.println(num2);

       }

    }

}

//测试类

public class Outer {

    public static void main(String[] args) {

       //需求:要访问静态成员内部类Inner4里面的show(),show2()方法

       //格式:外部类名.内部类名对象名 = new 外部类名.内部类名() ;

       Outer4.Inner4 oi = new Outer4.Inner4() ;

       oi.show() ;

       oi.show2() ;//静态方法

       System.out.println("--------------");

       //show2()还有另外一种访问方式:

       Outer4.Inner4.show2() ;

    }

}

局部内部类:定义在外部类的局部变量

结论:无论是局部内部类还是成员内部类(非静态的)都可以直接访问外部类的成员,包括私有

面试题:局部内部类访问局部变量会出问题?

当前局部变量报错,必须用final修饰;

原因:是由于局部变量是随着方法调用而生成的,随着方法的调用完毕消失.局部位置有一个局部内部类它要在自己的成员方法位置访问当前的局部变量

必须把变量变成一个常量,(需要用final:自定义常量),这样的一个变量的值永远是固定的!

final修饰的变量的值永远是固定的.

Jdk1.7和1.8在这里的小区别:

//局部内部类中访问局部变量

Jdk1.7会报错  jdk1.8不会 封装好了

Eg: class Outer5{

    //外部类的成员变量

//  public int num = 100 ;

    private int num = 100 ;

    //外部类的成员方法

    public void method(){

       //局部变量

        final int num2 = 200 ;  //自定义常量(细节问题)

       //局部位置

       class Inner5{

           //局部内部类的成员方法

           public void show(){

              System.out.println(num);

              //局部内部类中访问局部变量(jdk版本不同)

              System.out.println(num2); //jdk1.7才会有这个错误!      jdk1.8---->封装好了,所以不会出现错误!

           }

       }

      

       Inner5 i = new Inner5() ;

       i.show() ;

    }

}

//测试类

public class InnerDemo5 {

    public static void main(String[] args) {

       Outer5 o = new Outer5() ;

       o.method();

    }

}                                 

匿名内部类:是内部类的简化版格式

前提条件:必须存在一个接口或者一个类(可以是具体类,也可以是一个抽象类);

书写的格式: new 接口名或者类名(){

       方法重写;

}

匿名内部类的实质:

继承了该类(抽象类)或者实现了该接口的子类对象

Eg: interface Inter{

    //抽象功能

    public abstract void show() ;

}

class Outer{

    //成员方法

    public void method(){    //一个方法的时候

       new Inter(){

@Override

           public void show() {

              System.out.println("show");

           }

      

       }.show() ;

两个方法的时候: Inter i2 = newInter() ;

       Inter i = new Inter(){     

           @Override

           public void show() {

              System.out.println("show");

           }

           @Override

           public void show2() {

              System.out.println("show2");

           }

    };    

i.show();    //使用对象名调用

i.show2();

 

课堂练习: 看程序 面试题：

       要求请填空分别输出30，20，10。

       外部类和内部类没有继承关系!

class Outer7 {

    public int num = 10;

    class Inner7 {

       public int num = 20;

       public void show() {

           int num = 30;

           System.out.println(num);

           System.out.println(this.num); //调用局部变量

           System.out.println(new Outer7().num);//要访问外部类的成员变量:匿名对象 :new 外部类名().成员变量

           //外部类的this限定

           System.out.println(Outer7.this.num);//调用的值为10

       }

    }

}

public class InnerClassTest {

    public static void main(String[] args) {

       Outer7.Inner7 oi = new Outer7().new Inner7();

       oi.show();

    }

}

输出结果:

30

20

10

10