Java Day23

static

如果很多对象都有同一个特质，全部都写出来会增加占用资源，此时需要static修饰
eg

成员变量：
	姓名，年龄，国籍

class Person {
private String name;
private int age;
private String country;

// 完成对应的Constructor，Setter and Getter

}

需求:
创建三个Person类对象，国籍都是 中华人民共和国
代码:
Person p1 = new Person(“骚磊”, 16, “中华人民共和国”);
Person p2 = new Person(“骚杰”, 26, “中华人民共和国”);
Person p3 = new Person(“茂林”, 36, “中华人民共和国”);

1. static概述

2. static关键字可以修饰方法！！！
   static关键字可以修饰成员变量！！！

【没有对象】
2 代码中对于static修饰静态成员变量的需求
定义一个Person类

package com.qfedu.a_staticfield;

/*

• 【警告】

•  The static field Person.country should be accessed in a static way
  

•  在Person类内的static修饰成员变量country 应该通过静态方式访问
  

• 【处理警告方式】

•  使用Person类名操作静态成员变量
  

• 【数据共享性】

•  静态成员变量不管通过哪一种方式修改操作数据，都会影响到所有使用的位置
  

• 【没有对象】

•  1. 在对象未创建的情况下，静态成员变量可以通过类名直接调用
  

•  2. 在对象被销毁的情况下，静态成员变量依然可以通过类名直接调用
  

```java
 */
class Person {
	private String name;
	private int age;
	public static String country = "中华人民共和国";

	public Person() {
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}

public class Demo1 {
	public static void main(String[] args) {
		// 静态成员变量在没有创建对象的情况，可以通过类名使用
		System.out.println("Person.country: " + Person.country);
		
		// 匿名对象作为方法的参数
		test(new Person());
		
		// 54行代码执行完毕，是否还存在Person类的对象? 没有对象！！！
		System.out.println("Person.country: " + Person.country);
	}
	
	public static void test(Person person) {
		System.out.println(person);
	}
}

总结：
	1. 静态成员变量推荐使用的方式是通过类名直接调用，**不推荐使用类****对****象来进行操作**，IDE工具中会存在一定的警告提示，与对象无关！！！【没有对象】
	2. 静态成员变量不管通过哪一种方式修改，都会影响到所有的使用者，这是一个**【共享资源】**
	3. 静态成员变量在类对象创建之前可以使用，类对象销毁之后依然可以使用，【生存期完全不同】，所有说静态成员变量和类对象无关，【没有对象】

public static void main(String[] args) {                        
	// 静态成员变量在没有创建对象的情况，可以通过类名使用         
	System.out.println("Person.country: " + Person.country);    
	                                                            
	// 匿名对象作为方法的参数
	test(new Person());                                         
	                                                            
	// 54行代码执行完毕，是否还存在Person类的对象? 没有对象！！！  
	System.out.println("Person.country: " + Person.country);    
}                 

分析:
	1. 在类对象创建之前，静态成员变量已经可以使用，已经准备完毕！！！
	2. 在类对象销毁之后，静态成员变量依旧可以使用，依然存在！！！

生活案例:
	1. 在你去北京之前，共享单车已经存在了
	2. 在你离开北京以后，共享单车依然存在

代码加载原理性过程:
	1. .java文件，会通过Java编译器(javac.exe)编译生成对应的.class字节码文件(二进制文件。文件中包含了所有的.java文件内容)
	2. 在程序的加载过程中，.class字节码文件会加载到内存的【方法区】，同时会按照基本的顺序结构【从上至下，从左至右】完成.class字节码文件的加载过程
	3. 在加载过程中，static修饰的内容会在准备就绪，可以执行，可以使用。
	
	以上操作过程过程中，是否和类对象有关???
		整个类文件加载过程中，是完成不依赖对象的创建，所有从加载过程中可以分析得
		出，类对象和静态成员变量无关。【没有对象】


资源销毁过程:
	1. Java中存在的类对象，是通过该JVM中的垃圾回收机制销毁对象，回收内存。
	2. 静态成员变量是在整个程序退出之后，当前代码中不存在任何一块内存被类对象占用。JVM才会释放.class文件占用的【方法区】空间，与之同时，销毁静态成员变量占用的【数据区】空间
	
	以上操作可以得出，静态成员变量生存周期是远远大于类对象的。早于类对象出现，晚于类对象销毁。类对象和静态成员变量没有关系。【没有对象】                  
小总结
1. static修饰静态成员变量是一个【共享资源】，但是需要明确当前代码中的确需要对应的共享资源之后，才可以使用static修饰，而且static修饰的方式只是共享资源解决案例的一种。
	例如:
		姓名，年龄，家庭住址...[以上数据不能使用静态]

2. static修饰静态成员变量，推荐使用类名调用，因为【没有对象】
3. static修饰的静态成员变量，一处修改，处处受影响，因为【共享资源】
4. static修饰的静态成员变量，在类对象创建之前出现，在类对象销毁之后销毁，生存周期不同，所有【没有对象】
                            
                            **static修饰成员方法**
```java

```java
/*
 * 【警告】
 * 		The static method testStatic() from the type Car should be accessed in a static way
 * 		在Car类static修饰的静态成员方法testStatic() 应该通过静态方法访问
 * 【建议】
 * 		static修饰的方法全部采用类名访问！！！
 * 
 * 【错误】
 * 		Cannot make a static reference to the non-static field name
 * 		在静态成员方法中，不能使用一个静态的引用指向一个非静态成员变量。
 * 		在静态成员方法中，不能使用非静态成员变量
 * 	
 * 【错误】
 * 		Cannot make a static reference to the non-static method test() from the type Car
 * 		在一个静态成员方法中，不能使用一个静态引用去操作Car类内的非静态成员方法test();
 * 		在静态成员方法中，不能使用非静态成员方法
 * 
 * 【错误】
 * 		Cannot use this in a static context
 * 		不能在static修饰的静态内容中，使用this关键字
 * 
 * 【可以使用】
 * 		静态成员方法中可以使用类内的其他静态成员变量，和其他静态成员方法。
 * 		【难兄难弟】
 */

```java
class Car {
	// 非静态成员变量
	public String name;
	
	// 静态成员变量
	public static String color = "白色";
	
	public Car() {}
	
	// 非静态成员方法
	public void test() {
		System.out.println("Car类【非静态成员方法】");
	}
	
	// 静态成员方法
	public static void testStatic() {
		// name = "A4L";
		// test();
		// this.name = "ATSL";
		color = "黑色";
		test2();
		System.out.println("Car类【静态成员方法】");
	}
	
	public static void test2() {
		System.out.println("12321321");
	}
}

public class Demo1 {
	public static void main(String[] args) {
		Car car = new Car();
		
		// 通过类对象操作非静态成员变量
		car.name = "领克05";
		
		Car.color = "黑色";
		
		car.test();
		
		// 推荐使用类名调用静态成员方法
		Car.testStatic();
	}
}     

Arrays工具类

需要了解的方法:
	String toString(任意类型数组);
		返回整个数组的字符串描述方式
		int[] arr = {1, 3, 5, 7, 9};
		==> [1, 3, 5, 7, 9] 
		数组内容使用[]包含，然后元素直接使用 ,+空格 隔开 字符串展示 
		
	sort(int[] arr);
		排序算法，int类型
		快速排序！！！Quick Sort 性能特别好，占用空间特别大
		
	int binarySearch(int[] arr, int find);
		二分法查找，找到对应的元素，返回值大于等于0，没有找到返回负数
		【要求】
			当前查询使用的数组必须是升序排序完成的数组

/**
 * Arrays工具类使用演示
 * 
 * 通过Arrays类名直接调用方法，Arrays工具类内的所有方法都是static修饰的
 * 静态成员方法。
 * @author Anonymous
 *
 */
public class Demo2 {
	public static void main(String[] args) {
		int[] array = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
		
		// 将数组转换成字符串形式展示
		String str = Arrays.toString(array);
		System.out.println(str);
		
		// 数组内容排序，默认升序
		Arrays.sort(array);
		System.out.println(Arrays.toString(array));
		
		// 找出指定元素在数组中下标位置，不保证找的元素是第几个！
		int index = Arrays.binarySearch(array, 0);
		System.out.println(index);
		
		System.out.println(array[5]);
	}
}
     

构造代码块

功能:
初始化当前类所有的类对象，只要【使用new + 构造方法创建当前类对象】，就一定会执行构造代码块中的内容

格式:
在class大括号以内，成员变量之后，构造方法之前
// 构造代码块
{

}

静态代码块

功能:
类文件加载，静态代码块中的内容一定会执行，有且只执行一次！！！
类文件的加载是当前代码中的确需要当前类，才会进行加载。

格式：
在class大括号以内，成员变量之后，构造方法之前
// 静态代码块
static {

}

用途:
一般会使用类文件加载操作过程，完成一定的自动化操作。
程序的配置，数据的加载，驱动的使用，资源的处理…
JDBC

补充：
非静态成员变量，非静态成员方法，this关键字都无法在静态代码块中使用。