一、Static修饰符
String name;//成员变量，实例(对象)变量。
Static String name;//静态的成员变量，类变量。
用于修饰成员（变量，函数）
当每个对象都有共性的数据（不是属性）时，可以用Static修饰，此时被修饰的变量数据不在堆内存，被放在共享区（方法区，数据区）对象建立后直接引用该数据。既静态所修饰内容被对象所共享。
当成员被静态修饰后,就多了一个调用方式，除了可以被对象调用，还可以直接被类名调用。类名.静态成员；
1. Static特点：
随着类的加载而加载，消失而消失，说明它的生命周期最长
优先于对象的存在
被所有对象共享
静态成员可以直接被类名调用，因此静态成员变量又称为类变量。非静态成员变量又被称为实例变量。
2. 实例变量和类变量的区别：
存放位置：类变量随着类的加载而存在方法区（共享区）中。实例变量随着对象的建立而存在于堆内存中。
生命周期：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。
3. 静态使用注意事项：
静态方法只能访问静态成员，非静态方法既可以访问静态也可以访问非静态。
静态方法中不可以定义this,super关键字，因为静态优先于对象存在。
主函数是静态的；
4.静态利弊：
利处：对对象的共享数据开辟单独空间的存储，节省空间，没必要每一个对象中都存储一份；
可以直接被类名调用；
弊端：生命周期过长，访问出现局限性（静态虽好，只能访问静态）
二、什么时候使用静态？
两方面下手：静态修饰的内容有成员变量和函数。
1. 什么时候定义静态变量（类变量）呢？
当对象中出现共享数据（数据指：具体的值，学校名称属于学生的共享数据）时，该数据被静态所修饰。例如：学生都有自己特有的姓名。
对象中特有的数据要定义成非静态存在于堆内存中。
2.什么时候定义静态函数呢？
当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。
三、静态的应用-工具类
当一个类中创建了另一个类的对象，编译的时候会同时编译两个类文件；
/*
每一个应用程序中都有共性的功能，
可以将这些功能进行抽取，独立封装，以便复用。
虽然 可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。
发现问题：
对象是用于封装数据的，可是ArrayTool对象并未封装特有（非公性）数据。
操作数组的每一个方法度没有用到ArrayTool对象中的特有数据。
考虑让程序更严谨，不需要对象。
直接将这些方法定义成静态的，直接通过类名调用即可。
方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的，
为了更为严谨，强制让该类不能建立对象，
可以通过将默认的构造函数私有化完成。
空参数的构造函数不一定是默认构造函数，默认的是看不见的，写了就不是默认的了。
class Demo
{
Demo(){}:当你定义了空参数的构造函数，就不是默认的了，而是自定义构造函数了。
}
*/
1. class ArrayTool//工具类,通常是静态的方法
{
private ArrayTool(){};//将默认的构造函数私有化，对方不能建立对象。
//获得最大值
public static int getMax(int[] arr)
{
int max=0;
for(int x=1; x<arr[max];x++)
{
if(arr[x]>arr[max])
max=x;
}
return arr[max];
}
//获得最小值
public static int getMin(int[] arr)
{
int min=0;
for(int x=1; x<arr[min],x++)
{
if(arr[x]<arr[min])
min=x;
}
return arr[min];
}
//选择排序
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];
}
}
}
}
//冒泡排序
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 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.print(arr[x]+"]");
}
}
}
2. class ArrayToolDemo //调用工具类的方法
{
public static void main(String[] args)
{
int[] arr={3,6,89,43,56};
int max=ArrayTool.getMax(arr);
System.out.println("Max="+max);
//能够创建对象，因为工具类有个默认的空构造函数。只要有属性或行为，就可以创建对象。
/*ArrayTool tool=new ArrayTool();//此对象没必要生成，将工具类的方法改为静态
int max=tool.getMax(arr);
System.out.println("Max="+max);
tool.printArray(arr);
tool.selectSort(arr);
tool.printArray(arr);
*/
}
}
四、主函数
是一个特殊的函数，作为程序的入口，可以被JVM调用。
1. 主函数的定义：
Public:代表着该函数的访问权限的最大的。
Static :代表着主函数随着类的加载就已经存在了。
Void :主函数没有具体的返回值。
Main :不是关键字，但是是一个特殊的单词，可以被JVM识别。
(String[] args):函数的参数，是一个字符串类型的数组。(arguments)
主函数是固定格式，包括参数（参数名自定义），才能被JVM识别。
数组有两种值：数组和NULL
JVM在调用主函数时，传入的是new string[0]; hiahia
五、帮助文档的制作javadoc
当有工具类.CLASS文件时，只要将该文件设置到class路径下，就可以使用该工具类了。
但无法知道定义了多少方法。可以制作程序说明书，通过文档注释，javadoc程序；
识别符：@param等。
在命令行输入
javadoc -d myhelp -author -version ArrayTool.java
D盘自动创建html文件的存放文件夹
需要制作说明文档的类要public修饰,否则不能生成相应的注释；
一个类中默认会有一个空参数的构造函数，权限与所属类一致；
空参数的构造函数不一定是默认构造函数，默认的是看不见的，写了就不是默认的了。
class Demo
{
Demo(){}:当你定义了空参数的构造函数，就不是默认的了，而是自定义构造函数了。
}
*/
/**
这是一个可以对数组操作的工具类，提供了获取最值，排序等功能。
@author 杨xx
@version v1.1
*/
class ArrayTool//工具类,通常是静态的方法
{
/**
空参数构造函数。
*/
private ArrayTool(){};//将默认的构造函数私有化，对方不能建立对象。
/**
获取一个数组中的最大值
@param arr 接收一个INT类型数组
@return 返回一个该数组中的最大值
*/
public static int getMax(int[] arr)
{
int max=0;
for(int x=1; x<arr[max];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[min];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;
}
/**
打印int数组元素，打印形式是：[elemet 1,elemet2, ...]
@param arr 接收一个INT类型数组
*/
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.print(arr[x]+"]");
}
}
}
六、静态代码块
静态代码块。
格式：
static
{
静态代码块中的执行语句。
}
特点：随着类的加载而执行，只执行一次,并优先于主函数。
用于给类进行初始化的。
class StaticCode
{
int num = 9;//非静态成员
StaticCode()
{
System.out.println("b");
}
//静态代码块，给类初始化
static
{
System.out.println("a");//这里加上NULL,无法编译，因为静态代码块不能访问实例变量；
}
//构造代码块，给对象初始化
{
System.out.println("c"+this.num);
}
StaticCode(int x)
{
System.out.println("d");
}
public static void show()
{
System.out.println("show run");
}
}
class StaticCodeDemo
{
static
{
//System.out.println("b");
}
public static void main(String[] args)
{
new StaticCode(4);//a c d
//new StaticCode();//执行一次
//new StaticCode();//不执行
//System.out.println("over");
//StaticCode.show();
//StaticCode s = null;//没有指向，未加载StaticCode
//s = new StaticCode();
//StaticCode.show();
}
static
{
///System.out.println("c");
}
}
//d:\>java0217\day06>java StaticCodeDemo
//b c a over
七、对象的初始化过程
class Person
{
private Person(){}
private String name = "hah";//，先默认初始化null，然后输出hah,既显示初始化
private int age;
private static String country = "cn";
Person(String name,int age)
{
this.name = name;
this.age = age;
}
{
System.out.println(name+".."+age);
}
public void setName(String name)
{
this.name = name;
}
public void speak()
{
System.out.println(this.name+"..."+this.age);
}
public static void showCountry()
{
System.out.println("country="+Person.country);
Person.method();
}
public static void method()
{
System.out.println("method run");
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person("zhangsan",20);
p.setName("lisi");
new Person();
}
}
<span style="font-family:Calibri;font-size:14px;">Person p = new Person("zhangsan",20);</span>
该句话都做了什么事情？
1， 因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2， 执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3，在堆内存中开辟空间，分配内存地址。
4，在堆内存中建立对象的特有属性。并进行默认初始化(NULL,0)。
5，对属性进行显示初始化。（给属性赋值的时候）
6，对对象进行构造代码块初始化。
7，对对象进行对应的构造函数初始化。
8，将内存地址赋给栈内存中的p变量。
八、对象调用成员过程
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
对象调用非静态成员时访问堆内存，调用静态成员是没有访问堆内存；
静态成员调用静态成员，前面省略了类名.
九、单例设计模式(饿汉士)
设计模式：解决某一类问题最行之有效的方法。
java中23种设计模式：
单例设计模式：解决一个类在内存只存在一个对象。
想要保证对象唯一。
1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
这三部怎么用代码体现呢？
1，将构造函数私有化。
2，在类中创建一个本类对象。
3，提供一个方法可以获取到该对象。
对于事物该怎么描述，还怎么描述。
当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。
class Single
{
private Single(){}
private static Single s = new Single();
public static Single getInstance()
{
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
s1.setNum(23);
System.out.println(s2.getNum());
// Single s1 = new Single();//没有将构造代码块私有化时可以NEW 新对象，对象间互不影响
// Single s2= new Single();
// s1.setNum(30);
// System.out.println(s2.getNum());
// Student s1 = new Student();
// s1.setAge(30);
//
// Student s2 = new Student();
// s2.setAge(12);
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
}
}
class Student
{
private int age;
private static Student s = new Student();
private Student(){}
public static Student getStudent()
{
return s;
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
}
十、单例设计模式(懒汉士)
这个是先初始化对象。
称为：饿汉式。（开发中较多使用，安全简单）
Single类一进内存，就已经创建好了对象。
class Single
{
private static Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}
*/
//对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。
//Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()//同步加在此处，效率低，每次都要加载锁，判断是否空
{
if(s==null)
//假设两个对象A,B；-->A,-->B(CPU处理是急速的轮流切换的，即A执行这条语句后B接着执行)
{
synchronized(Single.class)//A加锁，B进不来，保证只生成一个对象，也降低了加载锁的次数
{
if(s==null)
s = new Single();
}
}
return s;
}
}
//记住原则：定义单例，建议使用饿汉式。
class
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}