static 关键字的用法
1.static关键字修饰的(静态方法)
使用static关键字修饰的方法的调用方式
调用方式1:如果是在当前类的static方法中，则直接调用
调用方式2:如果是在其他类的static方法中，则需要通过类名.方法()调用
备注1:普通方法(没有使用staitc关键字修饰的方法)允许调用static修饰的方法
备注2: static修饰的方法(静态方法)不允许调用普通方法
package com.ztt.Demo01;
//static关键字修饰的(静态方法)
public class test2 {
public static void main(String[] args) {
doSth();
test2.doSth();
}
//使用static关键字修饰的方法的调用方式
//调用方式1:如果是在当前类的static方法中，则直接调用
//调用方式2:如果是在其他类的static方法中，则需要通过类名.方法()调用
//备注1:普通方法(没有使用staitc关键字修饰的方法)允许调用static修饰的方法
//备注2: static修饰的方法(静态方法)不允许调用普通方法
public static void doSth() {
//不允许调用普通方法
//normal();
}
public void normal() {
}
}
2.静态方法和普通方法之间的调用关系总结:
静态方法和普通方法之间的调用关系总结:
//静态方法“允许”调用静态方法
//普通方法“允许”调用静态方法\其它普通方法
package com.ztt.Demo01;
//静态方法和普通方法之间的调用关系总结:
//静态方法“允许”调用静态方法
//普通方法“允许”调用静态方法\其它普通方法
public class test3 {
public static void main(String[] args) {
//调用静态方法
Father.doSth();//通过类名调用
//调用普通方法（实例方法）
Father f=new Father();//创建对象（实例）
f.work();//调用普通方法
//f.doSth();//调用静态方法（不推荐）
}
}
class Father{
//定义的方法形式
//静态方法：使用static关键字修饰的方法
public static void doSth() {
//在静态方法中，不允许调用普通方法
//this.work();
}
//普通方法：实例方法，没有static 关键字修饰
public void work() {
//普通方法中，允许调用static静态方法
doSth();
}
}3.static关键字修饰的静态代码块
静态代码块:类被“加载”时，静态代码块自动执行
构造代码块:每次调用构造方法前，构造代码块自动执行
static关键字修饰的静态代码块
//执行顺序
静态代码块(先父类、再子类)=>父类构造代码块=>父类构造方法=>子类构造代码块=>子类构造方法
package com.ztt.Demo01;
//static关键字修饰的静态代码块
//执行顺序
//静态代码块(先父类、再子类)=>父类构造代码块=>父类构造方法=>子类构造代码块=>子类构造方法
public class test4 {
//main主函数所在的类必须被加载
static {
System.out.println("test4的静态代码块！");
}
public static void main(String[] args) {
// Person p1=new Person();
// Person p2=new Person();
//
// Object obj=new Object();
User u1=new User();
User u2=new User();
}
}
//父类
class Person{
//静态代码块:类被“加载”时，静态代码块自动执行
static {
System.out.println("Person父类静态代码块1执行ing......");
}
static {
System.out.println("Person父类静态代码块2执行ing......");
}
//构造代码块:每次调用构造方法前，构造代码块自动执行
{
System.out.println("Person父类构造代码块执行ing......");
}
public Person() {
System.out.println("Person类的无参构造方法执行ing...");
}
}
//子类
class User extends Person{
static {
System.out.println("User子类的静态代码块执行ing......");
}
{
System.out.println("User子类的构造代码块执行ing......");
}
public User() {
System.out.println("User子类的无参构造方法执行ing...");
}
}运行结果：
test4的静态代码块！
Person父类静态代码块1执行ing......
Person父类静态代码块2执行ing......
User子类的静态代码块执行ing......
Person父类构造代码块执行ing......
Person类的无参构造方法执行ing...
User子类的构造代码块执行ing......
User子类的无参构造方法执行ing...
Person父类构造代码块执行ing......
Person类的无参构造方法执行ing...
User子类的构造代码块执行ing......
User子类的无参构造方法执行ing...
4.static 关键字修饰的静态变量
普通成员变量：通过实例对象
静态成员变量:可以通过实例对象或类名
package com.ztt.Demo01;
//static 关键字修饰的静态变量
public class test5 {
public static void main(String[] args) {
//普通成员变量：通过实例对象
// Counter c1=new Counter();
// c1.value++;
//
// Counter c2=new Counter();
// c2.value++;
// c2.value++;
// c2.value++;
//
// System.out.println("c1的value="+c1.value);
// System.out.println("c2的value="+c2.value);
//静态成员变量:可以通过实例对象或类名
// c1.count++;
Counter c1 = new Counter();
c1.count++;
Counter c2 = new Counter();
c2.count++;
c2.count++;
c2.count++;
System.out.println("c1的count="+c1.count);
System.out.println( "c2的count="+c2.count) ;
}
}
class Counter{
//成员变量
int value;//普通成员变量（通过实例）
static int count;//静态成员变量（通过实例或类名）
}运行结果：
c1的count=4
c2的count=4package com.ztt.Demo01;
public class test6 {
public static void main(String[] args) {
// 创建3个优惠券对象
Coupon coupon1=new Coupon();
Coupon coupon2=new Coupon();
Coupon coupon3=new Coupon();
Coupon coupon4=new Coupon();
Coupon coupon5=new Coupon();
System.out.println("创建Coupon优惠券对象的个数为："+Coupon.count);//预期输出结果为：5
System.out.println("优惠券1的编号为："+coupon1);//预期输出为：1001
System.out.println("优惠券2的编号为："+coupon2);//预期输出为：1002
System.out.println("优惠券3的编号为："+coupon3);//预期输出为：1003
System.out.println("优惠券4的编号为："+coupon4);//预期输出为：1004
System.out.println("优惠券5的编号为："+coupon5);//预期输出为：1005
}
}
//优惠券
class Coupon{
private int id;//优惠券编号
private static int idVal=1000;//编号记录器
public static int count=0;//对象计数器
public Coupon(){
this.id=++idVal;
count++;
}
@Override
public String toString() {
return String.valueOf(id);
}
}运行结果：
创建Coupon优惠券对象的个数为：5
优惠券1的编号为：1001
优惠券2的编号为：1002
优惠券3的编号为：1003
优惠券4的编号为：1004
优惠券5的编号为：1005package com.ztt.Demo01;
import java.time.LocalDate;
public class test7 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Record[] recordArray = {
new Record( LocalDate.of( 2020,1,15)),
new Record( LocalDate.of( 2020,3,17)),
new Record(LocalDate.of( 2021,6,19)),
new Record( LocalDate.of(2020,2,21)),
new Record(LocalDate.of( 2021,1,25))};
for(Record record : recordArray) {
//判断每个record记录对象是否超时，都会重复创建beginDate和endDate
System.out.println(record.isTimeout());
}
}
}
class Record{
private LocalDate writeDate;//记录写入日期
private static LocalDate beginDate;//开始
private static LocalDate endDate;//结束
static {
beginDate = LocalDate.ofYearDay(2020, 1);//开始日期2020年1月1日
endDate = LocalDate.ofYearDay(2021, 1);//结束日期2021年1月1日
}
//构造方法:创建记录时，传入该记录的写入日期
public Record(LocalDate date) {
this.writeDate = date;
}
//判断记录写入日期是否超时
public boolean isTimeout() {
//检查"记录写入日期"是否 >= 开始时间 并且 < 结束日期
return writeDate.compareTo(beginDate) >= 0 && writeDate.compareTo(endDate) < 0;
}
}运行结果：
true
true
false
true
false
看代码！！！！！
package com.ztt.Demo02;
public class Test1 {
static int value = 33;
public static void main(String[] args) throws Exception{
new Test1().printValue();
}
private void printValue(){
int value = 3;
System.out.println(this.value);
}
}运行结果：
33package com.ztt.Demo02;
public class Test2 {
public static void main(String[] args) {
new Test();
}
}
class Test extends Base{
static{
System.out.println("test static");
}
public Test(){
System.out.println("test constructor");
}
}
class Base{
static{
System.out.println("base static");
}
public Base(){
System.out.println("base constructor");
}
}
运行结果：
base static
test static
base constructor
test constructorpackage com.ztt.Demo02;
public class Test3 {
static{
System.out.println("test static 1");
}
public static void main(String[] args) {
}
static{
System.out.println("test static 2");
}
}运行结果：
test static 1
test static 2package com.ztt.Demo02;
public class Test4 {
int a = 1;
static int b = 1;
// 无参
Test4() {
a++;
b++;
}
// 有参
Test4(int c) {
this.a = this.a + c;
this.b = this.b + c;
}
public static void main(String[] args) {
Test4 t1 = new Test4(); // a=2 b=2
Test4 t2 = new Test4(2);
System.out.println(t1.a); // 2
System.out.println(t1.b); // 4
System.out.println(t2.a); // 3
System.out.println(t2.b); // 4
}
}
2
4
3
4package com.ztt.Demo02;
public class Test5 {
static {
int x = 5;
}
static int x, y;
public static void main(String args[]) {
x--;
myMethod();
//x+y;
//1+ ++x;
System.out.println(x + y + ++x);
}
public static void myMethod() {
//++x;
//y=x+x;
//x++;
y = x++ + ++x;
}
}
3
package com.ztt.Demo02;
public class Test6 {
static int a = 1;
static int b = 2;
public static void main(String[] args) {
// static String c = "3"; // 编译出错//static 不能修饰局部变量
final String c = "3";
System.out.println(a + b + c); // 33
System.out.println(c + a + b); // 312
}
}
运行结果：
33
312package com.ztt.Demo02;
public class Test7 {
// 先创建static修饰的静态成员变量(对象)
public static Test7 t1 = new Test7();
public static Test7 t2 = new Test7();
{
System.out.println("构造块");
}
static
{
System.out.println("静态块");
}
public static void main(String[] args){
Test7 t3 = new Test7();
}
}
运行结果：
构造块
构造块
静态块
构造块// 1.父类的静态代码块
// 2.子类的静态代码块
// 3.父类的构造代码块(父类中的对象person1创建)
// 3.1 父类的构造方法
// 4.子类的构造代码块(子类中的对象person2创建)
// 4.1子类的构造方法
// 1. 加载Test8类
// 1.1 执行Test8类的静态代码块(父类)
// 2.加载MyClass类
// 2.1 执行MyClass类的静态代码块(子类)
// 3.创建Test8类中的Person对象(执行父类的构造行为)
// 3.1 加载Person类，执行Person类的静态代码块
// 3.2 执行Person类的构造方法
// 4.执行Test8类的构造方法
// 5.创建MyClass类中的Person对象
// 5.1 执行Person类的构造方法
// 6. 执行MyClass的构造方法
package com.ztt.Demo02;
public class Test8 {
// 先加载Person类，再执行Person类的构造方法
Person person1 = new Person("Test");//相当于构造代码块
static {
System.out.println("test static");
}
public Test8() {
System.out.println("test constructor");
}
public static void main(String[] args) {
// 1.父类的静态代码块
// 2.子类的静态代码块
// 3.父类的构造代码块(父类中的对象person1创建)
// 3.1 父类的构造方法
// 4.子类的构造代码块(子类中的对象person2创建)
// 4.1子类的构造方法
// 1. 加载Test8类
// 1.1 执行Test8类的静态代码块(父类)
// 2.加载MyClass类
// 2.1 执行MyClass类的静态代码块(子类)
// 3.创建Test8类中的Person对象(执行父类的构造行为)
// 3.1 加载Person类，执行Person类的静态代码块
// 3.2 执行Person类的构造方法
// 4.执行Test8类的构造方法
// 5.创建MyClass类中的Person对象
// 5.1 执行Person类的构造方法
// 6. 执行MyClass的构造方法
new MyClass();
}
}
class Person {
static {
System.out.println("person static");
}
public Person(String str) {
System.out.println("person " + str);
}
}
class MyClass extends Test8 {
// 执行Person类的构造方法
Person person2 = new Person("MyClass");//相当于构造代码块
static {
System.out.println("myclass static");
}
public MyClass() {
System.out.println("myclass constructor");
}
}
运行结果：
test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor
package com.ztt.Demo02;
public class Test9 {
public static void main( String[] args) {
Example e = new Example();
}
}
class Example{
Demo demo1 =new Demo() ;
Demo demo2 =new Demo();
static {
System.out.println( "Example类的static" ) ;
}
{
System.out.println( "Example类的构造代码块");
}
public Example() {
System.out.println( "Example类的构造方法");
}
}
class Demo{
static {
System. out.println( "Demo类的static" );
}
{
System.out.println( "Demo类的构造代码块");
}
public Demo(){
System.out.println( "Demo类的构造方法");
}
}
运行结果：
Example类的static
Demo类的static
Demo类的构造代码块
Demo类的构造方法
Demo类的构造代码块
Demo类的构造方法
Example类的构造代码块
Example类的构造方法