类变量
什么是类变量
类变量也叫静态变量/静态属性，是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量。
如何定义类变量
定义语法:
访问修饰符 static 数据类型 变量名;【推荐】
static 访问修饰符 数据类型 变量名;
访问方式
类名.类变量名，例子：
public class VisitStatic {
public static void main(String[] args) {
//类名.类变量名
//说明：类变量是随着类的加载而创建，所以即使没有创建对象实例也可以访问
System.out.println(A.name);
A a = new A();
//通过对象名.类变量名
System.out.println("a.name=" + a.name);
}
}
class A {
//类变量
//类变量的访问，必须遵守 相关的访问权限.
public static String name = "xxxx";
//普通属性/普通成员变量/非静态属性/非静态成员变量/实例变量
private int num = 10;
}
使用细节
1.什么时候需要用类变量
当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量(静态变量)
比如:定义学生类，统计所有学生共交多少钱。Student (name, fee)
2.类变量与实例变量(普通属性)区别
类变量是该类的所有对象共享的,而实例变量是每个对象独享的。
3.加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
4.类变量可以通过类名.类变量名或者对象名.类变量名来访问
但java设计者推荐我们使用类名.类变量名方式访问。【前提是满足访问修饰符的访问权限和范围】
5.实例变量不能通过类名.类变量名方式访问。
6.类变量是在类加载时便初始化。
也就是说，即使你没有创建对象，只要类加载了，就可以使用类变量了。
ps:补充一点个人理解，java中的静态变量和python中的静态修饰其实类似。前者没有创建对象实例也可以访问（因为其在类加载的时候就创建了），后者可以再没有实例化类函数的情况下直接使用类函数
7.类变量的生命周期是随类的加载开始，随着类消亡而销毁。
public class StaticDetail {
public static void main(String[] args) {
B b = new B();
//System.out.println(B.n1);
System.out.println(B.n2);
//静态变量是类加载的时候，就创建了,所以我们没有创建对象实例
//也可以通过类名.类变量名来访问
System.out.println(C.address);
}
}
class B {
public int n1 = 100;
public static int n2 = 200;
}
class C {
public static String address = "北京";
}
类方法
什么是类方法
类方法也叫静态方法。形式如下:
访问修饰符 static 数据返回类型 方法名(){}【推荐】
static 访问修饰符 数据返回类型 方法名(){}
类方法的调用
使用方式:类名.类方法名或者对象名.类方法名【前提是满足访问修饰符的访问权限和范围】
public class StaticMethod {
public static void main(String[] args) {
//创建2个学生对象交学费
Stu jk = new Stu("jk");
//jk.payFee(150);或者如下
Stu.payFee(150);
Stu cc = new Stu("cc");
cc.payFee(300);
Stu.showFee();
}
}
class Stu{
private String name;//普通成员
//定义一个静态变量用于累计学费
private static double fee = 0;
public Stu(String name) {
this.name = name;
}
//当方法使用static修饰之后就可以访问静态变量
//即为静态方法
public static void payFee(double fee){
Stu.fee += fee;//累积
}
public static void showFee(){
System.out.println("总学费为："+Stu.fee);
}
}
类方法的使用场景
当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法,提高开发效率。
//如果我们希望不创建实例,也可以调用某个方法(即当做工具来使用)
//这时,把方法做成静态方法时非常合适
System.out.println("9开平方的结果是="” + Math.sqrt(9));
或者是自己开发工具类时，可将方法设为静态方法，方便调用
//求出两个数的和
class MyTools {
public static double calSum(double n1,double n2) {
return n1 + n2;
}
}
还是类比Python
Java因为是原生支持OOP的语言，因此"类"是Java的核心
类方法就是一种简化使用类步骤的技巧，这样Java的类就更加接近Python中所谓的"函数"的使用方式
也就是：即调即用
使用细节
1.类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区:
类方法中无this的参数；
普通方法中隐含着this的参数；
2.类方法可以通过类名调用,也可以通过对象名调用。
3.普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用。
4.类方法中不允许使用和对象有关的关键字，比如this和super。普通方法(成员方法)可以。
5.类方法(静态方法)中只能访问静态变量或静态方法。【如何理解】
6.普通成员方法，既可以访问普通变量(方法)，也可以访问静态变量(方法)。
小结:
静态方法，只能访问静态的成员；
非静态的方法，可以访问静态成员和非静态成员；(必须遵守访问权限)
public class StaticMethodDetail {
public static void main(String[] args) {
D.hi();//ok
//非静态方法，不能通过类名调用
//D.say();, 错误，需要先创建对象，再调用
new D().say();//可以
}
}
class D {
private int n1 = 100;
private static int n2 = 200;
public void say() {//非静态方法,普通方法
}
public static void hi() {//静态方法,类方法
//类方法中不允许使用和对象有关的关键字，
//比如this和super。普通方法(成员方法)可以。
//System.out.println(this.n1);
}
//类方法(静态方法)中 只能访问 静态变量 或静态方法
//口诀:静态方法只能访问静态成员.
public static void hello() {
System.out.println(n2);
System.out.println(D.n2);
//System.out.println(this.n2);不能使用
hi();//OK
//say();//错误
}
//普通成员方法，既可以访问 非静态成员，也可以访问静态成员
//小结: 非静态方法可以访问 静态成员和非静态成员
public void ok() {
//非静态成员
System.out.println(n1);
say();
//静态成员
System.out.println(n2);
hello();
}
}
练习题for类变量与类方法
public class StaticExercise03 {
}
class Person {
private int id;
private static int total = 0;
public static void setTotalPerson(int total){
// this.total = total;//错误，因为在static方法中，不可以使用this 关键字
Person.total = total;//改成这样即可，意思就是访问静态变量
}
public Person() {//构造器
total++;
id = total;
}
//编写一个方法，输出total的值
public static void m() {
System.out.println("total的值=" + total);
}
}
class TestPerson {
public static void main(String[] args) {
Person.setTotalPerson(3);
new Person(); //最后 total的值就是4
Person.m();//看看输出的是不是4
}
}
main方法的语法
深入理解main方法
解释main方法的形式:public static void main(Stringargs){}
-
main方法是由Java虚拟机调用的
-
Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public【因为JVM与main不在同一个类，不是public怎么调？】
-
Java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static
-
该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数
public class Hello { public static void main(String[] args){ //args是如何传入 //遍历显示 for(int i =e; i < args. length; i++){ System.out.println("第"+(+1)+"个参数="+ args[i]); } } } ================================================================== D: \javacode>javac Hello.java D: \javacode>java Hello （无输出） D:javacode>java Hello tom jack smith 第1个参数=tom 第2个参数=jack 第3个参数=smith上述过程表明多个输入参数会被打包成数组传入方法中
即：String[] args的值是执行程序的时候传入的（面试问题）
-
java 执行的程序 参数1 参数2 参数3
特别提示:
-
在main()方法中，我们可以直接调用main方法所在类的静态方法或静态属性。
-
但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。
public class Main01 {
//静态的变量/属性
private static String name = "韩顺平教育";
//非静态的变量/属性
private int n1 = 10000;
//静态方法
public static void hi() {
System.out.println("Main01的 hi方法");
}
//非静态方法
public void cry() {
System.out.println("Main01的 cry方法");
}
public static void main(String[] args) {
//可以直接使用 name
//1. 静态方法main 可以访问本类的静态成员
System.out.println("name=" + name);
hi();
//2. 静态方法main 不可以访问本类的非静态成员
//System.out.println("n1=" + n1);//错误
//cry();
//3. 静态方法main 要访问本类的非静态成员，需要先创建对象 , 再调用即可
Main01 main01 = new Main01();
System.out.println(main01.n1);//ok
main01.cry();
}
}