Java程序的初始化

静态对象

java静态对象到底有什么好处？

1.静态对象的数据在全局是唯一的，一改都改。如果你想要处理的东西是整个程序中唯一的，弄成静态是个好方法。 非静态的东西你修改以后只是修改了他自己的数据，但是不会影响其他同类对象的数据。
2.引用方便。直接用 类名.静态方法名  或者  类名.静态变量名就可引用并且直接可以修改其属性值，不用get和set方法。
3.保持数据的唯一性。此数据全局都是唯一的，修改他的任何一处地方，在程序所有使用到的地方都将会体现到这些数据的修改。有效减少多余的浪费。 （让我想到了os里的信号量）

4.static final用来修饰成员变量和成员方法，可简单理解为“全局常量”。对于变量，表示一旦给值就不可修改；对于方法，表示不可覆盖。

 

关于static关键字的用法

1.修饰成员变量

public class Person {
    private int count = 0;
    
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.count = 10;
        Person p2 = new Person();
        p2.count = 12;
        System.out.println(p1.count);
        System.out.println(p2.count);
    }
}

运行结果：
10
12

在这段代码中，未使用static关键字，所以初始化的两个独立的Person对象中的count变量是相互独立的，打印后可分别得到他们被赋值的count值。即count属性是在对象中被初始化的。 

public class Person {
    private static int count = 0;
    
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.count = 10;
        Person p2 = new Person();
        p2.count = 12;
        System.out.println(p1.count);
        System.out.println(p2.count);
    }
}

运行结果：
12
12

在这段代码中，使用了static关键字，得到两个相同的count值。可以看出，count是在类中被初始化的，即被static修饰的成员变量是同类一起被放在静态存储区中，一旦类被初始化，则存在了，所以一旦有一个对象修改了count值，则静态存储区中的count值改变，所以所有对象的count值也随之改变。这让我想起了OS中的信号量机制，就像是一个临界区中的信号量一样，访问的东西是一个。

2.修饰成员方法

修饰成员方法与原本的差别不大，因为成员方法本就是保存在类的静态存储区中的，每次调用时实例化一个对象然后用对象名加方法名调用即可。用static修饰方法的区别就是可以直接使用类名.方法名对方法进行调用而无需实例化对象这样的操作。

public class Person {
    public static void print(){
    	System.out.println("123");
    }
    
    public static void main(String[] args) {
        Person.print();
    }
}

运行结果：
123

3.静态块

当我们初始化static修饰的成员时，可以将他们统一放在一个以static开始，用花括号包裹起来的块状语句中，这样，就可以在构造函数之前就对其进行初始化。

4.静态导入包

/*Person.java代码*/
package test;


public class Person {
    public static void print(){
    	System.out.println("123");
    }
}

/*main.java代码*/
package test1;

import static test.Person.print;


public class main {
	public static void main(String[] args){
		print();
	}
}

运行结果：

123 

父类和子类

在Java中，一个父类可以有多个子类，但是一个子类只能继承一个父类（另一种情况是接口，可以有多个）。父类和子类，涉及到Java作用域的问题以及继承与重写的问题。

1.作用域与可见性

作用域与可见性	当前类	同一package	子类	其他package
public	✔	✔	✔	✔
protect	✔	✔	✔	×
default	✔	✔	×	×
private	✔	×	×	×

 

2.继承与重写

在Java中如果子类继承父类，则全面继承父类的属性和方法，同时可以对父类中的方法进行重写。

public class Son extends Father{
	public String toString(){
		return "Son"+id+name;
	}
	public static void main(String[] args) {
		Son s = new Son();
		System.out.println(s);
		Father f = new Father();
		System.out.println(f);
	}
}

class Father{
	int id=1;
	String name="zhangsan";
	public String toString(){
		return "father"+id+name;
	}
}

构造函数

 在Java中，构造函数是一个特殊的方法，主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。它有以下几个特点：

1.构造函数名字必须与类名相同，构造函数没有返回值同时也不能有void，如果有void则是普通的方法而不是构造函数。

2.一个类可以有多个构造函数，即重载，用参数个数或者参数类型来区分。

3.类的构造函数可以是任意个，例如：0、1以及1以上。

4.构造函数总是伴随new操作一起调用，且不能被程序员直接调用，必须由系统调用。

5.构造函数不能被继承，因此也不能被覆盖，但是可以被重载。

6.子类可以通过super来显示的调用父类的构造函数（当父类没有无参构造函数时）。

public class Person {
	String name;
	int age;
	public Person(String name){
		this.name = name;
	}
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String toString(){
		return name+age;
	}
	public static void main(String[] args) {
		Person p1 = new Person("zhangsan");
		Person p2 = new Person("lisi",18);
		System.out.println(p1);
		System.out.println(p2);
	}
}

运行结果：
zhangsan0
lisi18

 总结：

1.Java程序初始化的三个原则

A.静态对象优先于非静态对象。

B.父类优先于子类。

C.其他按照成员变量的定义顺序进行初始化。

2.Java程序初始化的顺序

父类静态变量>父类静态块>子类静态变量>子类静态块>父类非静态变量>父类非静态代码块>父类构造函数>子类非静态变量>子类非静态块>子类构造函数。

public class Son extends Father{
	static{
		System.out.println("son static block");
	}
	{
		System.out.println("son block");
	}
	public Son(){
		System.out.println("son construct");
	}
	public static void main(String[] args) {
		new Son();
	}
}

class Father{
	static{
		System.out.println("father static block");
	}
	{
		System.out.println("father block");
	}
	public Father(){
		System.out.println("father construct");
	}
}


运行结果：
father static block
son static block
father block
father construct
son block
son construct