1，static关键字:
static是一个修饰符，用于修饰成员（成员变量和成员函数），当成员被static修饰后，除了能被对象调用外，还可以直接被静态类调用（格式：类名.静态成员）
静态的特点：
A．随着类的加载而加载，随着类的消失而消失，说明它的生活周期最长；
B．被所有对象所共享；
C．优先于对象的存在；
D．可以直接被类名调用。
string name;//成员变量，也叫实例变量。
static String name;//静态的成员变量，类变量。
实例变量于类变量的区别：
存放位置：类变量随着类的加载而加载，存放在方法去中(也可叫共享区/数据区)
实例变量随着对象的创建而存放在堆内存中。
生命周期：类变量随着类的消失而消失。
实例变量随着对象的消失而消失。（生命周期期：类是最长的，没有类就不能创建对象；类>静态>对象>实例）
静态使用注意：
静态方法只能访问静态成员；非静态方法既能访问静态成员也能访问非静态成员。
静态方法中不能出现this、super关键字，因为静态优先于对象存在。
静态有利有弊：
利：
静态对对象共享数据进行单独空间的储存，节省空间；
可以直接被类名调用。
弊：
生命周期过长；
访问出现局限性。(只能访问静态)
2，main函数：
格式是固定的：public static void main(String[] arg)是程序的入口，直接被jvm调用
public：代表该函数的访问权限最大
static：随着类的加载而加载
void：没有返回值类型
main：不是关键字，但是可以被jvm识别
(String[] args)：函数的参数，参数类型是一个数组，数组的元素是字符串。
JVM调用主函数时调用的是new String[0];
Eg:class Demo
{
public static void main(String[] args)
{
for(int x=0;x<3;x++)
System.out.println(args[x]+"---------------"+args.length);
}
}
class Demo2//这个类作为主函数
{
public static void main(String[] args)
{
String[] arr1 = {"1","2","3"};
Demo.main(arr1);
}
}
3，什么时候使用静态：
要从两方面下手：因为静态修饰的内容有成员变量和成员函数；
什么时候使用静态变量：
当对象中出现共享数据时，该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数：
当功能内部没有访问到静态数据(对象的特有数据)，那么该功能可以定义为静态的。
4，静态的应用——工具类：
每一个应用程序中都有一个共性的功能，可以将这些功能进行抽取，独立封装，以便复用。
虽然可以通过建立ArrayTools的对象使用这些工具方法，对数组进行操作。
发现了问题：
1，对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。
2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。
这时就考虑，让程序更严谨，是不需要对象的。
可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。
将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。
为了更为严谨，强制让该类不能建立对象。
可以通过将构造函数私有化完成。
class Demo3
{
public static void main(String[] args)
{
int[] arr = {3,5,6,7,8,44,2};
//ArrayTools tool = new ArrayTools();
//int max = tool.getMax(arr);
int max = ArrayTools.getMax(arr);
ArrayTools.sortselect(arr);
ArrayTools.printarr(arr);
System.out.println("max============"+max);
}
}
class ArrayTools
{
private ArrayTools(){}
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];
}
public static int getMinx(int[] arr)
{
int min = 0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]<arr[min])
min = x;
}
return arr[min];
}
public static void sortselect(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);}
}
}
}
private static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
public static void printarr(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]+"]");
}
}
}
5，帮助文档制作：
javadoc –d myhelp –author –version ArrayTAools.java
只有public修饰的才能被提取。
6，静态代码块：
static
{
静态代码块中的执行语句;
}
特点：随着累的加载而加载，只执行一次，并优先于主函数。
作用：用于给类初值化。
7，对象初始化过程：
class Person
{
private Person(){}
private String name = "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();
}
}
/*
Person p = new Person("zhangsan",20);
*/
该句话都做了什么事情？
1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3，在堆内存中开辟空间，分配内存地址。
4，在堆内存中建立对象的特有属性。并进行默认初始化。
5，对属性进行显示初始化。
6，对对象进行构造代码块初始化。
7，对对象进行对应的构造函数初始化。
8， 将内存地址付给栈内存中的p变量。
8，对象调用成员过程：
9，当例设计模式：
设计模式：解决某一类问题最行之有效的方法。Java中有23中设计模式：单例设计模式：解决一个类在内存中只存在一个对象。