面向对象3---static,制作帮助文档,代码块

一.static关键字

1. static关键字:可以修饰成员变量和成员方法,静态的,共享的

/*
 * 一个学生类:
 *      成员变量:name,age,country(来自同一个国家)
 *      成员方法:show()
 * **/
class Student{
    //成员变量
    String name;
    int age;
    //String country;
    //将country设为静态
    static String country;

    //两个参数的构造方法
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    //三个参数的构造方法
    public Student(String name,int age,String country){
        this.name = name;
        this.age = age;
        this.country = country;
    }

    //成员方法
    public void show(){
        System.out.println(name+","+age+","+country);
    }
}
public class Demo {
    public static void main(String[] args){
        //每次创建对象的时候都要给country赋值,在堆内存消耗内存较大,因此将country设为static
//      Student s1 = new Student("王一",21,"中国");
//      Student s2 = new Student("王二",22,"中国");
//      Student s3 = new Student("王三",23,"中国");

        //static静态的,共享的
        Student s1 = new Student("王一",21,"中国");
        Student s2 = new Student("王二",22);
        Student s3 = new Student("王三",23);

        s1.show();
        s2.show();
        s3.show();
        System.out.println("---------------");

        //country共享的,为最后一次赋的值
        Student s4 = new Student("王一",21,"中国");
        Student s5 = new Student("王二",22,"英国");
        Student s6 = new Student("王三",23,"美国");

        s4.show();
        s5.show();
        s6.show();      
    }
}

2. static关键字的特点:
static随着类的加载而加载
优先于对象存在
使用对象名可以去访问成员变量,如果这个成员被static修饰,那么可以被类名直接调用

class Number{
    int num1 = 10;
    static int num2 = 20;

    public static void show(){
        System.out.println("show");
    }

}
public class Demo1 {
    public static void main(String[] args){
        //创建一个number类的对象
        Number n = new Number();
        //用对象名调用
        System.out.println(n.num1+","+n.num2);
        n.show();

        //用static修饰的成员可用类名调用
        System.out.println(Number.num2);
        Number.show();
    }
}

3. static的注意事项
在静态方法中是没有this关键字(静态随着类的加载而加载,this代表当前类的对象,随着对象的创建而存在)
静态的成员:静态只能访问静态
　　　　　静态成员变量:在静态成员方法中,只能访问静态的成员变量
　　　　　静态成员方法:只能访问静态(成员方法/成员变量)
　　　　　非静态成员方法:里面可以访问静态的成员

class Number1 {
    //非静态成员变量
    int num1 = 10;

    //非静态成员变量
    static int num2 = 20;

    //非静态成员方法
    public void method1(){
        System.out.println("1");
    }

    //非静态的成员方法
    public static void method2(){
        System.out.println("2");
    }

    //非静态成员方法
    public void show1(){
        System.out.println(num1);//隐藏了是访问该类对象的成员变量
        System.out.println(this.num1);//明确了是访问该类对象的成员变量
        System.out.println(num2);//访问静态成员变量
        //调用静态/非静态的方法
        method1();
        method2();
        System.out.println("------------");
    }
    //静态的成员方法
    public static void show2(){
//      System.out.println(num1);//报错,静态只能访问静态
        System.out.println(num2);

//      method1();//报错,静态只能访问静态
        method2();
        System.out.println("------------");
    }
}
public class Demo2{
    public static void main(String[] args){
        Number1 n = new Number1();
        n.show1();
        n.show2();
        System.out.println(n.num1);
        System.out.println(n.num2);
    }
}

　　
　　　　　　　

---

二.制作帮助文档

制作文档说明书的步骤(用制作数组文档举例):
1. 定义一个数组工具类:ArrayTool(数组工具类中的注释:使用文档注释:解释每一个方法的参数是什么意思)
2. 定义一个测试类ArrayDemo
3. 编辑完这两个代码后新建文件夹,在其中建立两个文本文档,删去包名
4. 打开dos控制台—->切换到当前盘符—–>javadoc -d 目录名 -author -version ArrayTool.java

ArrayTool类:

/**
 * 数组的一个工具类
 * @author app
 * @version V1.0
 * */
public class ArrayTool {
    /**
     * 工具类的无参构造方法
     * */
    //为了不让外界创建对象,将无参构造私有化,将其他方法用static修饰,直接使用类名调用
    private ArrayTool(){
    }
    /**
     * 数组的遍历方法
     * @param arr:需要被遍历的数组
     * */
    public static void printArray(int[] arr){
        System.out.print("[");
        for(int i = 0;i < arr.length;i ++){
            if(i == arr.length-1){
                System.out.println(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }
        }
    }
    /**
     * 找出数组最大值的方法
     * @param arr:需要输出最大值的数组
     * @return max:数组的最大值
     * */
    public static int printMax(int[] arr){
        int max = arr[0];
        for(int i = 0;i < arr.length; i++){
            if(max < arr[i]){
                max = arr[i];
            }
        }
        return max;
    }
}

ArrayDemo类:

public class ArrayDemo {
    public static void main(String[] args){
        int[] a = {10,10,30,40,50};
        ArrayTool.printArray(a);
        System.out.println(ArrayTool.printMax(a));
    }
}

重新建立文件夹下的文本文档存储这两个类(注意删去这两个类的包名)

建立文档说明书文件夹,并在其下建立两个文本文档

输入dos命令:

在上述建立的文档说明书文件夹中生成目录文件夹

将目录文件夹下的ArrayTool.html用浏览器打开,即可看到制作好的文档说明书

---

三.代码块

1. **代码块:**java中,用{}括起来的叫代码块
2. 代码块的分类:
   
   • 局部代码块:用来限定变量的生命周期,在main方法中出现
   • 构造代码块:类中的成员位置,用来给对象的数据进行初始化.每次执行构造方法之前,要执行构造代码块
   • 静态代码块:类中的成员位置,用static修饰代码块.
     静态代码块的作用:静态随着类的加载而加载,给类进行初始化
3. 静态代码块,构造代码块,构造方法,执行的顺序?
   静态代码块—>构造代码块—>构造方法
   分析:静态代码块:在类中只加载一次,随着类的加载而加载.构造代码块:每次在执行构造方法之前,先走构造代码块,随着对象的加载而加载.因此顺序是:静态代码块—>构造代码块—>构造方法

package 代码块;
class Code{
    //静态代码块
    static{
        int a = 1000;
        System.out.println(a);
    }

    //构造代码块
    {
        int b = 100;
        System.out.println(b);
    }

    //无参构造
    public Code(){
        System.out.println("code");
    }

    //有参构造
    public Code(int c){
        System.out.println("code..");
    }

    //构造代码块
    {
        int d = 10;
        System.out.println(d);
    }

    //静态代码块
    static{
        int e = 0;
        System.out.println(e);
    }
}
public class Demo1 {
    public static void main(String[] args){
        //局部代码块
        {
            int f = 1;
            System.out.println(f);
        }
//      System.out.println(f);//报错:局部变量限定变量的声明周期
        {
            int g = 0;
            System.out.println(g);
        }
        System.out.println("-----------");
        Code c1 = new Code();
        System.out.println("-----------");
        Code c2 = new Code();
        System.out.println("-----------");
        Code c3 = new Code();
    }
}

分析:
在main方法中按照顺序先执行两个局部代码块,输出1,0.
Code c1 = new Code();静态代码块随着类的加载而加载,先执行Code类中的静态代码块,按照顺序输出1000,0.再执行构造方法之前,先执行构造代码块,输出100,10.最后执行无参构造方法,输出code.
Code c2 = new Code();静态代码块只在类中加载一次.因此,执行构造方法之前,先执行构造代码块,输出100,10.最后执行无参构造方法,输出code.
Code c3 = new Code();静态代码块只在类中加载一次.因此,执行构造方法之前,先执行构造代码块,输出100,10.最后执行无参构造方法,输出code.