一、static：
1、static基础知识点：
类的五个成员：属性、方法、构造函数、初始化块、内部类。
static,静态的，可以用来属性、方法、*代码块(或初始化块)、*内部类。
class SportsMan{
// 实例变量
String name;
int age;
// 类变量(大家都共用)
static String nation;
}
SportsMan s=new SportsMan();后
SportsMan.nation;、s.nation、s.name;、s.age;可以。但SportsMan.name;和SportsMan.age;不行。
A、static修饰属性(类方法)：
1、由类创建的所有对象,都共用这一个属性。
2、当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。VS 实例变量(非static修饰的属性，各个对象各自拥有一套副本)；静态的变量是共用的。
3、类变量：只要加载了这个类，这个变量就会加载。(类变量在没有实例对象时是不在内存中的；而实例变量是所有对象都共有的，即使没创建对象实例时，实例变量也在内存中)。
4、实例变量必须通过对象调用并赋值；而类变量可直接用”类名.实例变量名”。
5、类变量的加载早于对象。(所以当有对象以后,可以用“对象.类变量”；但是”类.实例变量” 是不可以的)实例变量是随着对象的加载而加载的；而类对象是只要类加载了,类对象就加载。
6、类变量存在于静态域中。
B、static修饰方法(类方法)：
1、随着类的加载而加载，在内存中也是独一份。
2、可以直接通过”类.静态类方法名”的方式调用。而普通的方法不可以用“类.普通方法名”来调用。
3、在静态方法内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法；反之，非静态的方法是可以调用静态的属性或静态的方法的。
4、构造器没有静态与非静态之说，构造器类似于方法，内部可以引用静态与非静态两种结构的属性、方法等。
à静态的方法里面不可以由this或super关键字。
注：静态的结构(static类型的属性、方法、代码块、内部类)的生命周期都要早于非静态的结构，同时被回收也要晚于非静态结构。
实例代码讲解：
package com.atguigu.cn03;
public class TestSportsMan {
public static void main(String[] args) {
SportsMan s1=new SportsMan("金龙",23);
SportsMan s2=new SportsMan("银龙",21);
s1.age=34;
s1.nation="China";
System.out.println(s1);
System.out.println(s2);
System.out.println(SportsMan.nation);
// --------------------------------------------
// SportsMan.show(); 此形式不正确。有错误。普通方法调用不可以用"类.普通方法名"
s1.show();
SportsMan.show1(); //静态方法可以用"类.静态方法名"调用。
}
}
class SportsMan{
// 实例变量
String name;
int age;
// 类变量(大家都共用)
static String nation;
public SportsMan(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "SportsMan [name=" + name + ", age=" + age + ", nation=" + nation + "]";
}
public void show() {
// 非静态的方法是可以调用静态的属性或静态的方法的。
System.out.println("age:"+this.age+",nation:"+nation);
info();
System.out.println("我是一个来自于中国的运动员。");
}
public static void show1() {
// 在静态方法内部可以调用静态的属性或静态的方法。
info();
System.out.println("我是一个来自于中国的运动员2号。");
}
public static void info(){
System.out.println("我是被调的静态的方法。");
}
}注：依赖于具体的对象的话就不可以声明为静态的,
2、static编程练习题：
误解：
package com.atguigu.cn03;
提示：//使用静态的变量可以实现累加的效果，因为静态的变量在内存中独一份。
public class TestAccount {
public static void main(String[] args) {
Account a1=new Account("abc123",1000);
Account a2=new Account("abc456",2000);
System.out.println(a1);
System.out.println(a2);
}
}
class Account{
private int id;//账号--账号递增(自增)
private String password;//密码
private double balance;//余额
private static double rate;//利率
private static double minBalance;//最小余额
private int init=1000; // private static int init=1000;
public Account(String password,double balance) {
this.id=init++;
this.password=password;
this.balance=balance;
}
//gettters and setters方法
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public static double getRate() {
return rate;
}
public static void setRate(double rate) {
Account.rate = rate;
}
public static double getMinBalance() {
return minBalance;
}
public static void setMinBalance(double minBalance) {
Account.minBalance = minBalance;
}
//toString方法
@Override
public String toString() {
return "Account [id=" + id + ", password=" + password + ", balance=" + balance + "]";
}
}结果：(未能实现id自增即累加)
Account [id=1000, password=abc123, balance=1000.0]
Account [id=1000, password=abc456, balance=2000.0]
改正：应将init（初始账号）设置为static类型的变量,这样才能实现自增累加。
提示：//使用静态的变量可以实现累加的效果，因为静态的变量在内存中独一份。