类变量类方法|main语法说明|代码块|单例设计模式|final关键字

一.类变量类方法

不管static变量在哪里

(1) static变量是同一个类所有对象共享(2) static类变量,在类加载的时候就生成了.

定义语法:

访问修饰符 static 数据类型变量名; [推荐] / static 访问修饰符数据类型变量名;

类名类变量名[推荐] / 对象名.类变量名

1.什么时候需要用类变量;

当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量(静态变量)

2.类变量与实例变量(普通属性)区别类变量是该类的所有对象共享的，而实例变量是每个对象独享的。

3.加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量

4.类变量可以通过类名.类变量名或者对象名.类变量名来访问，但Java设计者推荐我们使用类名.类变量名方式访问。[前提是满足访问修饰符的访问权限和范围]

5.实例变量不能通过类名.类变量名方式访问。

6.类变量是在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了，就可以使用类变量了。

7.类变量的生命周期是随类的加载开始，随着类消亡而销毁。

类方法也叫静态方法。形式如下:

**访问修饰符static数据返回类型方法名(){ } **[推荐] / static访问修饰符数据返回类型方法名(){ }

类方法的调用: 使用方式:类名.类方法名 / 对象名.类方法名

package com.Child;

public class Stu {
    public static void main(String[] args) {
        S s1 = new S("uih");
        s1.Fee(234);//依次学费累加
        S s2 = new S("uih");
        s2.Fee(123);
        S s3 = new S("uih");
        s3.Fee(100);
        //展示总学费
        S.showfee();

        //如果我们希望不创建实例，也可以调用某个方法(即当做工具来使用)
        //这时，把方法做成静态方法时非常合适
        System.out.println("9开平方" +Math.sqrt(9));
        System.out.println(MyTools.calSum(10,20));
    }
}
//开发自己的工具类时，可以将方法做成静态的，方便调用
class MyTools {
    //求两数之和
    public static double calSum(double n1, double n2){//将方法做成静态的
        return n1 + n2;
    }
    //可写很多......
}
class S{
    private String name;//普通成员
    //静态变量，累计学生的学费
    private static double fee = 0;

    public S(String name) {
        this.name = name;
    }
    //当方法使用了static修饰后该方法就是静态方法
    //静态方法就就可以访问静态属性/变量
    public static void Fee(double fee){
       S.fee += fee;//学费累加
    }
    public static void showfee(){
        System.out.println("总学费" + S.fee);
    }
}

类方法使用注意事项和细节

1)类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区:

类方法中无this的参数普通方法中隐含着this的参数

2)类方法可以通过类名调用，也可以通过对象名调用。

3)普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用。

4)类方法中不允许使用和对象有关的关键字，比如this和super。普通方法(成员方法)可以。

5)类方法(静态方法)中只能访问静态变量或静态方法

6)普通成员方法，既可以访问非静态成员，也可以访问静态成员。

二.main语法说明

➢特别提示:

1)在main(方法中，我们可以直接调用main方法所在类的静态方法或静态属性。

2)但是，不能直接访问该类中的非静态成员，必须创建该类的一一个实例对象后，才能通过这个对象去访问类中的非静态成员，

在IDEA如何传递参数如图：

三.代码块

代码化块又称为初始化块,属于类中的成员[即是类的一部分], 类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

基本语法: [修饰符]{ 代码 };

注意:

1)修饰符可选，要写的话，也只能写static

2)代码块分为两类，使用static 修饰的叫静态代码块，没有static修饰的，叫普通代码块

3)逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)

4);号可以写上，也可以省略

代码块的好处和案例演示

1)相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作

场景:如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

package com.Child;

public class V {
    public static void main(String[] args) {
        A a = new A("iugh");
        System.out.println("=====================================");
        A uhygvb = new A("uhygvb",234,"iug");
    }
}

class A{
    private String name;
    private double price;
    private String director;
    //(1)下面的三个构造器都有相同的语句
    //(2) 这样代码看起来比较冗余
    //(3) 这时我们可以把相同的语句，放入到个代码块中，即可
    //(4)这样当我们不害调用哪个构造器，创建对象，都会先调用代码块的内容
    //(5) 代码块调用的顺序优先于构造器。.
    {
        System.out.println("起初");
        System.out.println("开始");
        System.out.println("最后");
    }

    public A(String name) {
        System.out.println("A(String name)被调用");
        this.name = name;
    }

    public A(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public A(String name, double price, String director) {
        System.out.println("A(String name, double price, String director)被调用");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

小结:

static代码块是类加载时，执行，只会执行一次

2.普通代码块是在创建对象时调用的，创建一次，调用一次

3类什么时候被加载[重要!]

①创建对象实例时(new)

②创建子类对象实例，父类也会被加载

③使用类的静态成员时(静态属性，静态方法)

package com.Child;

public class V {
    public static void main(String[] args) {
        //创建对象实例
//        A a = new A();
        //创建子类对象实例，父类也会被加载且父类先子类后
//        A a1 = new A();
        //使用类的静态成员时(静态属性，静态方法)
//        System.out.println(Cat.n1);
//        D d = new D();
        //普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。
        //如果只是使用类的静态成员时，普通代码块并不会执行
        System.out.println(D.n1);
    }
}
class D{
    public static int n1 = 653;
    //静态代码块
    static {
        System.out.println("D的静态代码块被执行");
    }
    {
        System.out.println("D的普通代码块");
    }
}
class Animal{
    //静态代码块
    static {
        System.out.println("Animal的静态代码块被执行");
    }
}
class Cat extends Animal{
    public static int n1 = 978;
    //静态代码块
    static {
        System.out.println("Cat的静态代码块被执行");
    }
}
class B{
    //静态代码块
    static {
        System.out.println("B的静态代码块被执行");
    }
}
class A extends B{
    //静态代码块
    static {
        System.out.println("A的静态代码块被执行");
    }
}

我们看一下创建一一个子类对象时(继承关系)，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下:

①父类的静态代码块和静态属性(优先级一样，按定义顺序执行)

②子类的静态代码块和静态属性(优先级一样，按定义顺序执行)

③父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)

④父类的构造方法

⑤子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)

⑥子类的构造方法

单例设计模式

单例(单个的实例) 1.所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

步骤如下: （饿汉式）

1)构造器私有化

2)类的内部创建对象

3)向外暴露- 个静态的公共方法。getInstance

4)代码实现

package com;

public class singleTon01 {
    public static void main(String[] args) {
        //通过方法可以获取对象
//        GirFriend instance = GirFriend.getInstance();
//        System.out.println(instance);
//        GirFriend instance1 = GirFriend.getInstance();
//        System.out.println(instance);
//        System.out.println(instance == instance1);
        System.out.println(GirFriend.n1);
    }
}

//有一个类
//只有一个女朋友
class GirFriend {

    private String name;
    private static int n1 = 100;
    //如何保障只能创建一个GirFriend
    //为了能够在静态方法中，返回gf对象，需要将其修饰为static
    //对象，通常是重量级的对象，饿汉式可能创建了对象但是没有使用
    private static GirFriend gf = new GirFriend("jhkj");//2.在类的内部直接创建对象（该对象是静态的）
    private GirFriend(String name) {//1.将构造器私有化
        this.name = name;
    }

    //3.提供一个公共的static方法，返回gf对象
    public static GirFriend getInstance() {
        return gf;
    }

    @Override
    public String toString() {
        return "GirFriend{" +
                "name='" + name + ''' +
                '}';
    }
}

步骤如下: （懒汉式）

1)构造器私有化=》防止直接new

2)类的内部创建对象

3)向外暴露一个静态的公共方法。getInstance

4)代码实现

package com;

public class single03 {
    public static void main(String[] args) {
        Cat instance = Cat.getInstance();
        System.out.println(instance);
//        System.out.println(Cat.n1);
        //再次调用getInstance()
        Cat instance2 = Cat.getInstance();
        System.out.println(instance);
        
        //懒汉式，只有当用户使用getInstance()时，才返回Cat对象，后面再次使用时，会返回上次创建的cat对象
        System.out.println(instance == instance2);
    }
}

class Cat{
    private String name;
    public static int n1 = 987;
    private static Cat cat;//2.定义一个静态属性对象，默认是null

    private Cat(String name) {//1.将构造器私有化
        System.out.println("构造器被调用");
        this.name = name;
    }
    public static Cat getInstance(){//3.提供一个public的static方法，可以返回一个cat对象
        if(cat == null){//如果还没有创建静态对象
            cat = new Cat("小可爱");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + ''' +
                '}';
    }
}