面向对象三

1、static关键字
static变量特点：
A、随着类的加载而加载（在类定义定义对象前就存在），随着类的消失而消失（生命周期最长）。
B、在类定义定义对象前就存在。
C、被所有对象共享。
D、可以直接被类名调用。
实例对象和类变量的区别：
A、存放位置
类变量随着类的加载而存放在方法区中；实例变量随着对象的建立存放在堆内存中。
B、生命周期
类变量生命周期最长，随着类的消失而消失；实例变量随着对象的消失而消失。
静态使用注意事项：
A、静态方法只能访问静态成员。
B、静态方法不可以定义this\super关键字。
C、主函数是static。
静态利弊：
利处：对对象的共享数据进行单独空间的存储，节省空间。
弊处：生命周期过长。访问只能访问静态变量。

class Person1{
 String name;
 static String country="CN";
 public static void show(){
  System.out.println(country);
 }
 public static void ha(){
  
 }
}
public class StaticDemo {
 public static void main(String[] args){
  Person1.show();
 }
}

2、main函数
public:表示访问权限最大，jvm可以访问。
static：表示类加载的时候就存在了。
void:没有返回值，jvm不需要返回值。
main：方法名称，jvm就调用此方法。
3、静态什么时候使用
静态变量：当对象中有共享数据值。
静态函数：当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

public class Person{
 String name;
 public static void show(){
  System.out.println(name);//没有访问对象的特有数据
 }
}

4、静态的应用(工具类)
每一个应用程序中都有共性的功能，可以将这些功能打包在一个类中，进行复用。
A、将类中的方法定义为静态的，用类名.函数名进行调用。
B、将方法都静态后可以方便使用，但是该类还可以被调用建立对象，可以将构造函数private。

class ArrayTool{
 //将构造函数私有化
 private ArrayTool(){}
 public static int getMax(int[] arr){
  int max = 0;
  for(int i=1;i<arr.length;i++){
   if(arr[i]>arr[max]){
    max = i;
   }
  }
  return arr[max];
 }
 public static int getMin(int[] arr){
  int min = 0;
  for(int i=1;i<arr.length;i++){
   if(arr[i]>arr[min]){
    min = i;
   }
  }
  return arr[min];
 }
 public void selectSort(int[] arr){
  for(int x=0;x<arr.length-1;x++){
   for(int y=x+1;y<arr.length;y++){
    swap(arr,x,y);
   }
  }
 }
 public void bubbleSort(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]){
     swap(arr,y,y+1);
    }
   }
  }
 }
 private void swap(int[] arr,int a,int b){
  int temp = arr[a];
  arr[a] = arr[b];
  arr[b] = temp;
 }
}

 5、帮助文档的制作javadoc

A、类为public

B、文档只提供public;不提供protected、private类型的范围

C、javadoc -d help(doc放置的目录) -author -version ArrayTool.java

D、API:application program interface

/**
 * @description 这是一个可以对数组进行操作的工具类，包含查找数组中的最大值、最小值、排序。
 * @date 2013-5-15 上午8:38:29
 * @author luxiangzhou
 * @version V1.0
 */
public class ArrayTool{
 //将构造函数私有化
 private ArrayTool(){}
 /**
  * @param arr 接收一个int类型的数组
  * @return 返回一个数组中最大值
  */
 static int getMax(int[] arr){
  int max = 0;
  for(int i=1;i<arr.length;i++){
   if(arr[i]>arr[max]){
    max = i;
   }
  }
  return arr[max];
 }
 /**
  * @param arr 接收一个int类型的数组
  * return 返回一个数组中最小值
  * */
 public static int getMin(int[] arr){
  int min = 0;
  for(int i=1;i<arr.length;i++){
   if(arr[i]>arr[min]){
    min = i;
   }
  }
  return arr[min];
 }
 /**
  * @param arr 拍戏
  * */
 public static void selectSort(int[] arr){
  for(int x=0;x<arr.length-1;x++){
   for(int y=x+1;y<arr.length;y++){
    swap(arr,x,y);
   }
  }
 }
 /**
  * @param arr 排序
  * */
 public static void bubbleSort(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]){
     swap(arr,y,y+1);
    }
   }
  }
 }
 private void swap(int[] arr,int a,int b){
  int temp = arr[a];
  arr[a] = arr[b];
  arr[b] = temp;
 }
}

一个类中的默认会有一个构造函数，这个构造函数的权限与所属类一致，如果类被public修饰，那么默认的构造函数权限也为public；如果类没有被public修饰，则默认的构造函数也没有被public修饰。

6、静态代码块
静态代码块随着类的加载而加载，且只执行一次，并优先于主函数执行。

class StaticTest01{
 //静态变量，内加载
 private static int num = 1;
 //静态代码块，类加载
 static{
  System.out.println("1");
 }
 //构造代码块，对象加载
 {
  System.out.println("2");
 }
 //构造函数，对象加载
 public StaticTest01(){
  System.out.println("3");
 }
}
public class StaticDemo01 {
 public static void main(String[] args){
  new StaticTest01();
 }
}

 总结：

1、代码执行顺序：静态代码块---构造块---构造函数；

2、工具类中一般定义静态权限函数，且构造函数权限为private

3、制作java帮助文档javadoc：javadoc -d 目录名 -author -version 源文件.java