黑马程序员：基础----静态、单例设计模式

static 关键字
它是一个修饰符，用于修饰成员（成员变量和成员函数）
被静态修饰后的成员变量，可以被对象共享
静态优先于对象存在（只要类一加载进去，就存在于方法区里面的数据共享区）
对于静态成员，除了对象可以访问之外，还可以被类名直接访问
类名.静态名;
静态随着类的加载而加载，随着类的消失而消失

对象特有的数据存储到对象的堆内存中
对象的共享数据存储在方法区的静态区中

例如： 饮水机。
class Person
{
string name;
static String country="cn"; //把国家定义成静态的
static  void show()  //静态除了可以修饰成员变量 或成员函数
{
System.out.println();

}
当这个类变成静态后，它的访问权限就有限了
静态方法里面不能存在，非静态的成员变量

class StaticDemo
{
public static void main(String[] args)
{
System.out.println(Person.country);
P

}

}

}
静态使用的注意事项
1、 静态方法只能访问静态成员（所以静态虽然多了一种用类名调用的方式，但是也出现了访问的局限性）
非静态方法 既可以访问静态的又可以访问非静态
因为非静态们，都所属于对象
2、 静态方法中不可以出现this、super关键字
因为this代表对象，static方法存在时还没有对象呢！！！
3、 主函数是静态的。

类中定义的变量是成员变量，也称为实列（对象）变量
如果该变量被static 修饰，称静态变量，也称为类变量

成员变量和静态变量的区别
1、在内存空间中
成员变量： 是存在于对象所在堆内存中
静态变量存储方法区的静态区中

2、生命周期
成员变量：随着对象的建立而出现，随着所属对象变成垃圾被回收
静态变量随着类的加载而出现，随着类的消失而消失
3、调用方法
成员变量：只能被对象调用
静态变量既可以被对象调用，也能被类调用

4、数据体现
成员变量的值称为对象中的特有数据
静态变量的值称为对象中的共享数据

什么时候定义静态呢？
1、静态变量
当对象中的数据都相同时，就将该数据定义成静态的
被所有对象共享即可，没有必要每一个对象都存储一份

2、静态函数
如果函数中没有访问到对象中的特有数据
那么该函数需要被静态修饰，不需要创建对象，就可以通过类名访问该函数了

main主函数：
public :主函数是一个功能，被JVM调用所以权限要足够大
static :jvm调用主函数，是不需要对象的
void:  主函数没有返回值。
main:	主函数固定的名称，jvm认识 （不关键字，但是是一个特殊的单词）
(String[] args): 主函数的参数列表，就一个参数，字符串数组类型

主函数只有一个地方可以改变，那就是: args
例： public static void main(String[] x);

jvm调用main函数时，传递 的实际参数是 new String();
args.length长度为0。
主函数的格式是固定的，可以重载
主函数传值：java 类名  要传的值（java Demo haha hei hee）

静态代码块：
static
{

}

特点：
随着类的加载而执行，只执行一次
作用
给类进行初始化

java文档的注释使用

javadoc生成的文档html就是程序的“说明文档”，简称“api帮助文档” @api aplication 应用程序
**对一个类制作帮助文档，必须保证这个类的修饰类型是public
***类中空参数构造函数的的修饰类型应为private，因为防止人为的建立对象，浪费空间。可以直接用类名调用。

(1)名词解释：
/** */ 文档注释
@auther 作者
@version v1.1 版本号
@param arr 接收一个int类型的数组
@param代表参数 后跟参数名 参数名后跟参数的解释
@return 对return的返回值进行解释
(2)在DOS命令行运行格式
首先进入指定目录 例：d:\java0709\day06>
输入命令：javadoc -d myhelp -auther -version ArrayTool.java
@-d 代表生成文档的存放目录  -d myhelp 代表存在当前文件夹的myhelp目录中，如果当前目录中没有myhelp文件夹，系统会自动创建。
@-auther 文档中显示作者
@-version 文档中显示版本号
(3)进入存放目录myhelp中，会看到很多html文件，“index.html”就是说明文档的索引文件
(4)文档中显示的方法区中，只有被public、protected修饰的方法，不会显示被private修饰的私有方法

/**
这是一个可以对数组进行操作的工具类，该类中提供了，获取最值，排序等功能。
@author 李四
@version V1.1

*/

/*
定义一个工具类，用于对数组的进行遍历、排序、
*/
public 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 接收一个int类型的数组。
*/
public static void selectSort(int[] arr)
{
for (int x=0; x<arr.length-1 ; x++ )
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
}

/**
给int数组进行冒泡排序。
@param arr 接收一个int类型的数组。
*/
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);
}
}
}
}

/**
给数组中元素进行位置的置换。
@param arr  接收一个int类型的数组。
@param a 要置换的位置
@param b 要置换的位置
*/
private  static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}

/**
用于打印数组中的元素。
*/
public static void printArray(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.println(arr[x]+"]");
}
}
}

设计模式:解决某类问题行之有效的思考方式
原来的思想出现在建筑行业

单例设计模式：
不管 是想了解什么样的设计模式
都 可以通过如下方式去想：
1、它到底解决什么问题
保证一个类在内存中的对象唯一性

应用场景：比如多程序使用同一个配置文件，那就需要该配置文件保证对象唯 一

如何保证对象的唯一性呢？？

由其他程序创建该类对象，无法进行控制，所以必须不让其他程序创建该类对象
为了让其他程序还可以有对象使用，在该类中自定义一个本类对象
对外提供一个可以访问到这个对象的方法即可
步骤
1、可以将该类的构造函数私有化
2、在本类中创建一个本类对象
3、对外提供一个公共方法返回该对象

成员变量一般都要私有化

饿汉式：就是先将对象初始化，在single 类一进内存，就已经建立对象
class Single()
{
private Single(){}   //私有化构造函数
private static  Single s=new Single();
public static   single getInstance()
{
return s;  //定义 方法返回S 是让这个S在可控

}

}
饿汉式会先初始化对象，在Single类一进内存时，就已经建立了对象
例：
class Person
{
private Person(){}
private static Person p=new Person();
public static Person getInstance()
{
return p;

}
}

如果在设计程序过程中，发现要让这个程序保证数据的唯一性，就可以通过单例设计模式来进行

懒汉式
class Single
{
private static Single s=null;
private Single(){}  //让对象不可以初始化
public static Single getInstance()
{
if(s==null)
{
s=new Single();

]
return s;
}
}
懒汉式:是方法被调用时才对对象初始化，也叫做对象的延时加载
Single类进内存时，对象还没有存在，只有调用了getInstance()方法时，才建立对象
懒汉式在多线程中会出不安全