static关键字
(1)是一个状态修饰符。静态的意思
(2)它可以修饰成员变量和成员方法
(3)特点：
A:随着类的加载而加载
B:优先于对象存在
C:被所有对象共享
这也是判断我们是不是该使用静态的条件
举例：饮水机和水杯例子。
D:可以通过类名调用
静态修饰的内容，可以通过类名调用，也可以通过对象名调用
(4)方法访问特点
A:普通成员方法
可以访问静态成员变量，非静态成员变量，静态成员方法，非静态成员方法
B:静态成员方法
只能访问静态成员变量，静态成员方法
简记：静态只能访问静态
注意：
静态中是不能有this的。
先进内存的不能访问后进内存的。反之可以。
5:静态成员变量和普通成员变量的区别(理解)
(1)所属不同
静态属于类的，称为类变量
非静态属于对象的，称为对象变量，实例变量
(2)内存空间不同
静态在方法区的静态区
非静态在堆内存
(3)生命周期不同
静态随着类的加载而加载，随着类的消失而消失
非静态随着对象的创建而存在，随着对象的消失而消失
(4)调用不同
静态可以通过类名调用，也可以通过对象名调用。建议通过类名调用
非静态只能通过对象名调用
package Practice.OOPPractice.Static;
//static关键字
class Student{
String name;
int age;
static String classNumber;//因为编辑编号应该是被班级的每个人都共享的，定义一个OK
public Student(String name, int age){
this.name = name;
this.age = age;
}
public Student(String name, int age, String classNumber){
this.age = age;
this.name = name;
this.classNumber = classNumber;
}
public void show(){
System.out.println(name+"---"+age+"---"+classNumber);
}
}
public class StudentDemo01 {
public static void main(String[] args) {
Student s1 = new Student("王霸总",18, "2021071");
s1.show();
Student s2 = new Student("林小二", 20, "2021071");
s2.show();
Student s3 = new Student("孙小姐", 19);
s3.show();
Student s4 = new Student("张大哥", 21);
s4.show();
}
}
//王霸总---18---2021071
//林小二---20---2021071
//孙小姐---19---2021071
//张大哥---21---2021071
package Practice.OOPPractice.Static;
/*
static关键字
作用： 修饰成员变量和成员方法
特定： 1。 随着类的加载而加载
2。 优先于对象存在
3。 被类的所有对象共享
这一条也是我们判断是否使用static关键字的条件
4。 可以通过类名调用
我们的调用既可以是对象，也可以是类名
*/
class Student2{
public void show(){
System.out.println("show");
}
public static void show2(){//此方法被static关键字修饰
System.out.println("show2");
}
}
public class StudentDemo02 {
public static void main(String[] args) {
Student2 s = new Student2();
s.show(); //show
s.show2(); //show2
Student2.show2(); //show2
//Student2.show();没有被static修饰，不可使用
}
}
//show
//show2
//show2
package Practice.OOPPractice;
/*
static注意事项：
1。 静态方法中没有this关键字
因为static是随着类的加载而加载，优先于对象存在，而rhis是最这对象的创建而存在。
先进内存的，不能访问后进内存的；但后进内存的，可以访问先进内存的
2。 静态static只能访问静态static
非静态的成员方法：
可以访问静态成员变量， 非静态成员变量， 静态成员方法，非静态成员方法
静态的成员方法：
只能访问静态的成员变量，静态的成员方法
*/
/*
class Student3 {
private String name;
public static void setName(String name){
//this.name = name; 没有this关键字，无法使用
}
public void show(){
System.out.println(name);
}
}
*/
class Demo {
int x = 10;
static int y = 20;
public void show(){
System.out.println(x);
System.out.println(y);
}
public static void show2(){
//System.out.println(x); //static方法只能访问static变量，但是int x没有被static修饰，不是静态变量
System.out.println(y);
}
public void show3(){
show();
show2();
}
public static void show4(){
show2();
//show(); 无法访问非静态方法
}
}
public class StudentDemo03 {
public static void main(String[] args) {
}
}
package Practice.OOPPractice;
//静态static内容是被所有对象共享的，非静态是每个对象特有的
class Student4 {
String name;
int age;
static String classNumber;
public Student4(String name, int age) {
this.age = age;
this.name = name;
}
public Student4(String name, int age, String classNumber) {
this.name = name;
this.age = age;
this.classNumber = classNumber;
}
public void show() {
System.out.println(name + "---" + age + "---" + classNumber);
}
}
public class StudentDemo04 {
public static void main(String[] args) {
Student4 s1 = new Student4("仗义", 20, "nteq8293");
Student4 s2 = new Student4("侠义", 20);
Student4 s3 = new Student4("浩气", 17);
s1.show();
s2.show();
s3.show();
System.out.println("======================");
s3.name = "老挝";
s3.classNumber = "yqck008"; //动手改，一改全改
s1.show();
s2.show();
s3.show();
}
}
//仗义---20---nteq8293
//侠义---20---nteq8293
//浩气---17---nteq8293
//======================
//仗义---20---yqck008
//侠义--- 20---yqck008
//老挝---17---yqck008
public static void main(String[] args){}的含义：
package Practice.OOPPractice;
/*
public static void main(String[] args){}
public: 访问权限修饰符， 表示最大的访问权限，被jvm调用， 所以权限要够大
static：被jvm调用， 不用创建对象，直接类名访问
void：被jvm调用， 不需要给jvm返回值
main：一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args: 早期出现是为了接受键盘录入数据的
*/
public class main_HelloWorld {
public static void main(String[] args){
}
}
}
原文：https://www.cnblogs.com/Natsumeno/p/14492116.html