类变量和类方法main方法代码块单例设计模式final关键字

类变量

package Static_;public class ChildGame {public static void main(String[] args) {//定义一个变量 count 统计有多少小孩加入了游戏Child child1 = new Child("白骨精");child1.join();child1.count++;Child child2 = new Child("白骨精");child2.join();child2.count++;Child child3 = new Child("白骨精");child3.join();child3.count++;System.out.println("共有 " + child1.count + " 小孩加入了游戏...");System.out.println("共有 " + child2.count + " 小孩加入了游戏...");System.out.println("共有 " + child3.count + " 小孩加入了游戏...");}
}class Child{public static int count = 0;private String name;public Child(String name){this.name = name;}public void join(){System.out.println(name + " 加入了游戏... ");}
}

不管static变量在哪里

1.静态变量是对象共享的，因此不影响使用

2.static类变量，在类加载的时候就生成了

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是同一个变量，同样任何一个该类的对象去修改它时，修改的也都是同一个变量。

如何定义类变量

定义语法：

访问修饰符 static 数据类型 变量名；

static 访问修饰符 数据类型 变量名；

如何访问类变量

类名.类变量名【推荐】

或者 对象名.类变量名【静态变量的访问修饰符的访问权限和范围 和 普通属性是一样的】

package Static_;public class VisitStatic_ {public static void main(String[] args) {//类变量是随着类的加载而创建，所以即使没有创建对象实例也能访问System.out.println(A.name);//类名.类变量名A a = new A();System.out.println(a.name);//对象名。类变量名}
}class A {public static String name = "天下第一大帅";
}

package Static_;public class StaticMethod {public static void main(String[] args) {Stu jack = new Stu("jack");jack.payFee(100);Stu mary = new Stu("mary");mary.payFee(100);Stu.showFee();}
}
class Stu{private String name;private static double fee = 0;public Stu(String name) {this.name = name;}//1.当方法使用static修饰后，该方法就是静态方法//2.静态方法就可以访问静态属性/变量public static void payFee(double fee){Stu.fee += fee;}public static void showFee(){System.out.println("总学费：" + Stu.fee);}
}

main方法

可在此处传参

代码块

3个构造器重载

（1）假如三个构造器都有相同的语句

（2）代码看起来会很冗余

（3）这时我们可以把相同的语句放进代码块中

（4）这样当我们不管调用哪个构造器，都会创建对象，都会先调用代码块的内容

（5）代码块的调用顺序优先于构造器

单例设计模式

package SingleTon_;public class SingleTon01 {public static void main(String[] args) {//    GirlFriend xh = new GirlFriend("小红");//    GirlFriend xh1 = new GirlFriend("小红2");  私有的对象只能在本类使用//通过方法可以获取对象GirlFriend instance = GirlFriend.getInstance();System.out.println(instance);GirlFriend instance1 = GirlFriend.getInstance();System.out.println(instance1);System.out.println(instance == instance1);System.out.println(GirlFriend.n1);}
}
class GirlFriend{private String name;public static int n1 = 100;//为了能在静态方法中，返回gf对象，需要将其修饰为static//对象，通常是重量级对象，饿汉模式可能会造成创建了对象，但是没有使用private static GirlFriend gf = new GirlFriend(("小红红"));//如何保障我们只能创建一个 Girlfriend 对象//步骤：[单利模式-饿汉式]//1.将构造器私有化（防止在类的外部创建）//2.在类的内部直接创建（该对象是static）//3.提供一个公有的static方法，返回gf对象private GirlFriend(String name){this.name = name;}public static GirlFriend getInstance(){return gf;}@Overridepublic String toString() {return "GirlFriend{" +"name='" + name + '\'' +'}';}
}

懒汉式

package SingleTon_;
/*
* 演示懒汉式的单例模式
* */public class SingleTon02 {public static void main(String[] args) {System.out.println(Cat.n1);Cat instance = Cat.getInstance();System.out.println(instance);Cat instance1 = Cat.getInstance();System.out.println(instance1);}
}
//希望在程序运行过程中，只创建一个Cat对象
class Cat{private String name;public static int n1 = 999;private static Cat cat;//步骤// 1.仍然构造器私有化// 2.定义一个static静态属性对象// 3.提供一个public的static方法，可以返回一个Cat对象// 4.懒汉式，只有当用户使用getInstance时，才返回cat对象，后面再次调用时，会返回上次创建的cat对象// 从而保证了单例private Cat(String name) {System.out.println("构造器被调用");this.name = name;}public static Cat getInstance(){if (cat == null){cat = new Cat("大可爱");}return cat;}@Overridepublic String toString() {return "Cat{" +"name='" + name + '\'' +'}';}
}

final关键字