static
static 修饰成员变量
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 ( ) ) ;
System. out. println ( "Person.country: " + Person. country) ;
}
public static void test ( Person person) {
System. out. println ( person) ;
}
}
总结:
1.静态成员变量推荐使用的方式是通过类名直接调用,不推荐直接使用类对象来进行操作,IDEA会存在一定的警告提示,与对象无关。
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. .java文件,会通过Java编译器(javac.exe)编译生成对应的.class字节码文件(二进制文件。文件中包含了所有的.java文件内容)
2. 在程序的加载过程中,.class字节码文件会加载到内存的【方法区】,同时会按照基本的顺序结构【从上至下,从左至右】完成.class字节码文件的加载过程。
3.在加载过程,static修饰的内容会在准备就绪,可以执行,可以使用。
以上操作过程中,是否和类对象有关?
整个类文件加载过程中,是完成不依赖对象的创建,所有从加载过程可以分析的出,类对象和静态成员变量无关。【没有对象】
资源销毁过程:
1.Java中存在的类对象,是通过该JVM中的垃圾回收机制销毁对象,回收内存。
2.静态成员变量是在整个程序退出之后,当前代码中不存在任何一块内存被类对象占用。JVM才会释放.claa文件占用的【方法区】空间,与之同时,销毁静态成员变量占用的【数据区】空间。
静态成员变量生存周期是远远大于类对象的。早于类对象出现,晚于类对象销毁。类对象和静态成员变量没有关系。【没有对象】
关于static修饰静态成员变量总结
1. static修饰静态成员变量是一个【共享资源】,但是需要明确当前代码中的确需要对应的共享资源之后,才可以使用static修饰,而且static修饰的方式只是共享资源解决案例的一种
2. static修饰的静态成员变量,推荐使用类名调用,因为【没有对象】
3. static修饰的静态成员变量,一次修改,处处受影响,因为【共享资源】
4. static修饰的静态成员变量,在类对象创建之前出现,在类对象销毁之后销毁,生存周期不同,所以【没有对象】
static修饰成员方法【重点】
static修饰静态成员方法案例
package com.qfedu.b_staticmethod;
/*
* 【警告】
* 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关键字
*
* 【可以使用】
* 静态成员方法中可以使用类内的其他静态成员变量,和其他静态成员方法。
* 【难兄难弟】
*/
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();
}
}
static修饰静态成员方法总结和问题
总结
1. 静态成员方法不推荐使用类对象调用,而是推荐使用类名直接调用,因为【没有对象】
2. 静态成员方法中不能够使用类内非静态成员变量 【没有对象】
3. 静态成员方法中不能够使用类内非静态成员方法 【没有对象】
4. 静态成员方法中不能够使用this关键字 【没有对象】
5. 静态成员方法可以使用类内的其他静态成员变量和静态成员方法 【难兄难弟】
问题:
1.为什么没有对象?
2.为什么静态成员方法可以使用其他静态资源
问题解答
从静态方法的调用方式来解释
静态成员方法,我们推荐是采用类名直接调用的!!!当然可以使用类对象调用,只不过会存在警告!!!而且这个警告是非常重要的!!!
IDE工具都在提示你 (静态成员方法,静态成员变量)与对象无关
静态成员方法和对象无关,那也就是说所有和对象有关的内容就不要使用了!!!
静态成员方法推荐使用类名调用,那么也就是说调用过程中是没有对象的,所有需要使用对象来操作的非静态成员变量,非静态成员方法都是无法直接在静态方法中使用的。
从加载时间和销毁时间来解释
发现:
1. 在代码中创建对象之前,静态成员方法已经可以通过类名直接调用,而且是明确可以执行的状态。
2. 对象销毁之后,依然可以通过类名直接调用静态成员方法
代码加载过程的分析:
1. .java文件通过编译之后,生成对应的.class字节码文件。字节码文件中包含了Java文件的所有内容
2. Java程序需要运行的时候,首先会加载对应的资源(.class字节码文件)到内存的【方法区】
3. 加载.class文件的过程中,static修饰的静态成员方法会准备就绪!!!所有运行需要的内容,条件全部OK,可以直接通过类名调用。
整个过程和类对象无关!!!完全是摆脱类对象存在的!!!
销毁过程:
1. 程序运行结束退出之前,会销毁所有的类对象
2. 所有的类对象销毁之后,对于资源没有任何的需求,资源销毁,内存释放,这时静态成员方法使用空间,才会被销毁。
静态成员方法的作用
最重要的作用
工具类!!!
静态成员方法是完全不依赖成员变量,也不能使用非静态成员方法和非静态成员变量。所有使用的数据,都是外来数据。
静态成员方法可以摆脱类对象约束,通过类名直接调用。
好处:
1. 节约内存。简化逻辑
不需要创建对象,不需要申请对象空间,也不需要销毁对象空间。
2. 复用度更高!!!
摆脱对象的限制,更加自由。
今天需要学习的工具类
Arrays数组工具类
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,没有找到返回负数
【要求】
当前查询使用的数组必须是升序排序完成的数组
package com. qfedu. b_staticmethod;
import java. util. Arrays;
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, 5 ) ;
System. out. println ( index) ;
}
}
代码块
代码块就是
{}包含的内容
主要有:
方法体代码块,分支结构,循环结构
构造代码块
功能:
初始化当前类所有的类对象,只要【使用new+构造方法创建当前类对象】,就一定会执行构造代码块中的内容
格式:
在class大括号以内,成员变量之后,构造方法之前
// 构造代码块
{
}
静态代码块
功能:
类文件加载,静态代码块中的内容一定会执行,有且只执行一次!!
类文件的加载是当前代码中的确需要当前类,才会进行加载。
格式:
在class大括号以内,成员变量之后,构造方法之前
// 静态代码
{
}
用途:
一般会使用类文件加载操作过程,完成一定的自动化操作。
程序的配置,数据的加载,驱动的使用,资源的处理....
JDBC
补充:
非静态成员变量,非静态成员方法,this关键字都无法在静态代码块中使用。
面试题【重点】
class Demo {
static Demo demo1 = new Demo ( ) ;
static Demo demo2 = new Demo ( ) ;
{
System. out. println ( "构造代码块" ) ;
}
static {
System. out. println ( "静态代码块" ) ;
}
public Demo ( ) {
System. out. println ( "构造方法" ) ;
}
public static void main ( String[ ] args) {
Demo demo1 = new Demo ( ) ;
}
}
1.构造代码块和构造方法,首先执行构造代码块内容,再来执行构造方法内容
2.main方法是目前代码的【执行的入口】,代码执行之前存在一个【加载】过程,加载过程中,所有的static修饰的内容都要执行完毕,要求【从上至下,从左至右】