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);//预期输出结果为：5System.out.println("优惠券1的编号为："+coupon1);//预期输出为：1001System.out.println("优惠券2的编号为："+coupon2);//预期输出为：1002System.out.println("优惠券3的编号为："+coupon3);//预期输出为：1003System.out.println("优惠券4的编号为："+coupon4);//预期输出为：1004System.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++;}@Overridepublic 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 stubRecord[] 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和endDateSystem.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=2Test4 t2 = new Test4(2);System.out.println(t1.a); // 2System.out.println(t1.b); // 4System.out.println(t2.a); // 3System.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); // 33System.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类的构造方法
)
