构造函数，静态，主函数，静态代码块初始化执行顺序

/*

构造函数里参数不同给不同的对象初始化，不同的参数分别传递到不同的构造函数中。
构造代码块
作用：给对象进行初始化和构造函数还是有差距的，优先于构造函数
构造代码块给所有对象进行统一初始化，而构造函数给相应对象进行初始化，
如传递的参数类型不同，运行的构造函数不同，而代码块是创建了对象后就直接运行，与参数无关且优先于有参数传递构造函数。
外如果构建的类没有自定义构造函数其系统会默认构造函数。
所以
构造代码块可以执行不同用对象的共性方式，这样，不用在此类的所有构造函数中都写此代码


注意：如果对构造函数私有化，那么在别的函数中创建对象时，就不能执行构造函数，如


private Person(String name){
this.name=name;
（this表示本类，本类的名字等于参数）
}
   |  |
   在另一个类中
Person p=new Person(string name);
就不能执行
在类中定义一个功能（此功能又恰好需要用到该类的其他对象）
 class Person{


int age;
Person(int age){
this.age=age;
}
public boolean compare(Person p){
return p.age==this.age;
}
} 
class hellow
{
public static void main(String[] args){
Person p1=new Person(30);
Person p2=new Person(25);
boolean b=p1.compare(p2);
System.out.println(b);
}
}






构造函数之间的调用：不能直接用构造函数调用，用this关键字
例如：这里面的this表示对象person构造函数调用构造函数。
注意：this语句的特殊性，需要定义在构造函数的第一行！！！
因为构造函数初始化属性也有优先性啊（优先+优先）
（构造函数之间调用时注意不能出现死循环）  
Person(String name)
{
this.name=name;
}
Person( String name,int age)
{
//this.name=name;//上面的构造函数已经有此功能了，如果功能多的时候这个写会重复，所以可以在构造函数中使用构造函数）
//Person(name);这么写不符合规范
this(name)//不需要加点
this.age=age;
}
静态修饰内容被对象共享，另外静态的内容可以直接被类名调用（直接使用）
 


 静态特点：
1.被所有对象共享（同方法）
2.可以直接被类名调用（同方法）
3.新建类时，类中占内存时已经把类中静态的方法加载进内存了，类与类中的静态事物同生命周期
比如例子中创建完Person类时，内存中已经有静态country但是非静态name并不在内存中，而创建具体的对象是name才被放入到内存中
name为实例变量，与对象同生命周期
4.优先于对象存在静态先存在，对象后自定义时存在
不能全部变为静态，会一直占内存，共享的数据定义为静态节省内存
5.静态变量存在与方法区中，实例变量存在于堆内存中（对象内存）
静态的使用方法：
静态先于非静态，所以静态方法只可以访问静态成员而非静态方法可以访问静态+非静态。
静态方法不可以出现super，this（非静态）
访问有局限性，不能访问非静态
class Person
{
String name;
static String country="CN";
public void show()
{
System.out.println(name+"::"+country);
}
}
class hellow
{
public static void main(String[] args)
{
Person p=new Person();
p.name="zhangsan";
p.show();
System.out.println(Person.country)//直接使用了类中的属性
}
}
 




主函数
static 静态，随着加载完主类，就已经存在主函数了。
public 权限最大
void 没有返回值（虚拟机调用主函数）
main 可以被jvm虚拟机识别
string[] args 字符串类型的数组


class hellow
{


public static void main(String[] args)
{
String arr[]={"1","2","3","4"};
helloww.main(arr);
// System.out.println(args);//直接使用了类中的属性
}
}
class helloww
{


public static void main(String[] args)
{
for(int i=0;i<args.length;i++)
System.out.println(args[i]);//直接使用了类中的属性
}
}


建立对象->封装数据
静态函数：当此函数功能内部并没有访问到非静态数据时，就可以把此函数定义成静态的
静态||非静态（成员变量，成员方法）
静态的应用：同c语言中的自定义函数相似，自定义函数可以在主函数中执行多次。
所以可以把共性的功能进行独立封装
2.对象是用来封装数据的，但是在此类中并没有封装任何数据（没有定义成员变量，全部都是）
1.当类里面的全部功能（方法）都没有用到类里面的属性时（类特有数据，成员变量）：
就可以吧类里面的功能全部封装成静态的，
调用时也不需要建立对象，可以直接通过类名调用（建立对象已经没有意义）
为了防止建立无用的对象，可以将构造函数私有化（private）此时使用该类中的函数直接通过类名调用不能构造对象
另外，在类中的函数中，在外界不能直接调用的，而是让类中其他函数调用的（辅助方法）可以将此方法也私有化，防止外部调用






静态代码块:给类进行初始化，只在创建类时执行一次，
当此类创建完毕以后就不再执行了
优先于主函数执行
*/
class StaticDemo
{
static{
System.out.println("a");
} 
}
class StaticDemoo
{
static{
System.out.println("b");
}
public static void main(String[] args)
{
new StaticDemo();
new StaticDemo();
System.out.println("over");
}
static{
System.out.println("c");
}


   } 
   /*
   运行结果是b c v over; 程序入口是hellow
类，在内存重创建此类时优先主函数执行静态代码块（尽管位置在主函数之下，两个代码块所以
输出b和c）
然后执行主函数，主函数中创建了两遍类，第一遍执行代码块输出a，第二遍时已经有内存了，不
再执行代码块，然后执行主函数中下一条语句输出over


静态代码块在加载类内存时执行,在用到类的内容是才加载类（单纯new
一个对象也算，用到了构造函数）但是直接定义对象为空则不加载类，并没有用到构造函数，
new s=new StaticDemoo();加载类
StaticDemoo  s=null;不加载类
执行顺序：加载类内存，->静态代码块，创建对象时->加载属性内存(属性默认初始化)->构造代码块（属性初始化），构造函数（传递参数进行初始化）




Person p=new person("zxr",20);
1.用到了person.class，先找到Person.class加载到内存中
2.执行该类中的静态代码块对类进行初始化


3.在堆内存中开辟空间，分配内存地址
4.在对内存中建立属性，并对属性进行默认初始化
5.对属性进行显示初始化。（定义属性时赋予的值）
6.执行构造代码块，对对象进行初始化
7.执行构造函数，给对象初始化
8.把地址付给p的变量


Class Demo{
static{
System.out.println("静态代码块"); 
} 
{
System.out.println("构造代码块"); 
}
Demo(){
System.out.println("构造函数");
}
}


*/
 单例设计模式一：
想要保证一个类中对象为一：
1.为了避免其它程序过多建立对象，先禁止其他程序建立该对象
2.为了让其他程序可以访问该类对象，在本类中自定义一个对象。
3.为了方便其他程序对在自定义对象的访问需要对外提供一个访问方式。




1.构造函数私有化（不能在外部创建对象）但是可以调用静态类中的方法
2.在类中创建一个本类对象
3.提供一个方式获取该对象


这样外部怎样调用静态的方法获得对象，他的类中的内存只有一个对象，不然建立一个对象，类中内存会增加一个对象的内存
主函数的内存正常
class Single
{
private Single(){};//将构造函数私有化
private static Single s=new Single();//在内部创建一个对象
public static Single GetSingle(){
return s;//提供外部访问方式，设置成静态，供外部访问（静态方法访问静态成员，g定义s时也是静态的）
}
}
class SingleDemo
{
public static void main(String[] args){
Single ss=Single.getsingle();//在主函数中调用类的方法获得一个对象
}
}
 单例设计模式二：