静态的使用

主函数Main方法

/*

 * public static void main(String[]args)

 * 主函数是一个特殊函数，作为程序的入口，可以被jvm(虚拟机)调用

 *

 * 主函数的定义：

 * public：代表着该函数的访问权是最大的。

 * static：代表主函数随着类的加载已经存在了。

 * void：主函数没有具体的返回值。

 * main：不是关键字，只是一个特殊的单词，只有这个单词可以jvm识别。

 * （String[]args)：函数的参数，参数的类型是一个数组。该数组是一个字符串数组。

 *

 * 主函数是固定格式的：被jvm识别

 * jvm调用主函数时，传入的是new String[0]

 */

public class _02Main函数 {

   

    public static void mani(String[]args)

    {

       String[]arr={"haha","hehe","heihei","huhu"};

       //调用方法

       MainDemo.main(arr);//传参

    }

 

}

//定义一个Main方法

class MainDemo

{

    public static void main(String[]arr)

    {

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

       {

           System.out.println(arr.length);

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

       }

    }

}

 

静态Static 什么时候使用？

/*

 * 什么时候使用静态？

 *

 * 要从两方面下手：

 * 因为静态修饰的内容有成员变量和函数。

 * 什么时候定义静态变量呢？

 * 当对象中出现共享数据时，（例如：同属一个国家：中国）该数据被静态所修饰。

 * 对象中特有的数据要定义成非静态存在于堆内存中。

 *

 * 什么时候定义静态函数呢？

 * 当功能内部没有访问到非静态数据时，（对象的特有数据）

 * 那么该功能可以定义成静态的。

 */

class Person

{

    String name;

   

    //直接调用方法功能

    public static void Show()

    {

       System.out.println("haha");

    }

}

public class _03静态Static什么时候用 {

   

    public static void main(String[]args)

    {

       //创建对象的方式   调用方法

       Person P = new Person();

       P.Show();

      

       //不创建对象的方式调用

       Person.Show();//无需new一个对象，直接调用静态方法功能（这样可以节省内存）

    }

 

}

 

 

静态的应用+文档说明书

/*

 * 静态工具类（ArrayTool)

 * 静态的应用：

 * 每一个程序都有共性的功能。

 * 可以将这些功能抽取，独立封装。以便复用

 *

 * 虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作

 * 发现了问题：

 * 1，对象是用于封装数据的，可是ArrayTool对象并未封装特有数据

 * 2。操作数组中的每一个方法都没用到ArrayTool对象中特有数据

 *

 * 这时就考虑让程序更严谨，是不需要对象的。

 * 可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可

 *

 * 将方法都使用Static静态后，可以方便于使用，但是该类还是可以被其它程序建立对象的。

 * 为了更为严谨，强制让该类不能建立对象

 * 可以通过将构造函数私有化完成（Private)  直接私有化 private ArrayTool(){};

 *

 * 一个类中默认会有一个空参数的构造函数

 * 这个默认构造函数的权限与所必类一致。（想改权限需：private 类名(){}）私有化

 * 如果被public修饰，默认的构造函数也被public修饰

 *

 * 默认构造函数的权限是随着类的变化而变化的。

 */

 

/**

 * 这是一个可以对数组操作的工具类，该类中提供了，数组获取最大小值，排序等功能

 * @author张三

 * @version V1.0

 * */

class ArrayTool

{

    /**

     * 空参数构造函数

     * */

    //初始化设置成私有的，

    private ArrayTool(){};

    /**

     * 获取一个整型数组中的最大值

     * @param arr接收一个int类型的数组

     * @return会返回一个该数组中的最大值

     * */

    public static int getMax(int[] arr)

    {

       int max=0;

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

       {

           if(arr[x]>arr[max])

           {

              max = x;

           }

       }

       return arr[max];

    }

    /**

     * 获取一个整型数组中的最小值

     * @param arr会接收一个int类型的数组

     * @return会返回一个该数组中的最小值

     * */

    public static int getMin(int[] arr)

    {

       int min=0;

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

       {

           if(arr[x]<arr[min])

           {

              min=x;

           }

       }

       return arr[min];

    }

    /**

     * 给int数组进行有序排列

     * @param arr会接收一个整型数组

     *

     */

    public static void selectSort(int[] arr)

    {

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

       {

           for(int y=0;y<arr.length-x-1;y++)

           {

              if(arr[y]>arr[y+1])

              {

                  print(arr,y,y+1);

              }

           }

       }

 

    }

   

    //帮--助--文--档

    //将ArrayTool.class文件发给他人，其它人只要将该文件设置到classpath路径下就可以使用。

    //但是里面包含多少方法，对方不清楚，所以需要制作一个说明书。

    //在java文件中用注释完成。

    /**

     * 给数组中元素进行位置对换。

     * @param arr接收一个数组。

     * @param a要置换的位置

     * @param a要置换的位置

     * */

    private static void print(int[]arr,int a,int b)

    {

       int temp = arr[a];

       arr[a]=arr[b];

       arr[b]=temp;

    }

    /**

     * 用于打印数组中的元素，打印形式是：[elemet1,elemet2,];

     * */

    public static void ArrayPrint(int[]arr)

    {

       System.out.print("[");//放在循环前

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

       {

           if(x!=arr.length-1)

           {

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

           }

           else

           {

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

           }

       }

    }

}

public class _04静态Static工具类 {

   

    public static void main(String[]args)

    {

       int[]arr={2,3,6,33,22,55,11};

       int max = ArrayTool.getMax(arr);

       System.out.println(max);

       int min = ArrayTool.getMin(arr);

       System.out.println(min);

      

       ArrayTool.selectSort(arr);

      

       ArrayTool.ArrayPrint(arr);

    }

 

}

 

 

静态代码块

/*

 * 静态代码块：格式

 * static

 * {

 *      静态代码块的执行语句

 * }

 *

 * 静态代码块特点：随着类的加载而加载。只执行一次。（并优先于主函数执行）

 * 白话是：程序一执行起来，先对静态代码块执行，所有的静态代码块执行完成后，再执行主函数

 * 对类进行初始化。

 */

class StaticCode

{

    /*小知识点：

    int num=9;

    static

    {

       System.out.println("后面不能加gum，因为静态成员只能访问静态变量！"+num);

    }

    */

    static

    {

       System.out.println("a.静态代码块特点：随着类的加载而加载。只执行一次。并优先于主函数执行");

    }

    {

       System.out.println("e..构造代码块，给对象初始化的。");

    }

    StaticCode(int x)

    {

       System.out.println("f..构造函数，给对应对象初始化的");

    }                 //这个后面可以加上面的num;因为它是对象的初始化，所以可以访问成员变量

}

public class _05静态代码块 {

   

    static

    {

       System.out.println("b..对类进行初始化。");

    }

 

    public static void main(String[]args)

    {

       ///new StaticCode();

       //new StaticCode();   //new两个对象，但在程序中只执行了一次。

      

       new StaticCode(4);//进行传递参数

       System.out.println("over");

    }

    static

    {

       System.out.println("c");

    }

}

/*

 * 上面代码的执行顺序是：

 *  b..对类进行初始化。

    c

    a.静态代码块特点：随着类的加载而加载。只执行一次。并优先于主函数执行

    e..构造代码块，给对象初始化的。

    f..构造函数，给对应对象初始化的

    over

 */