重学Java 13.面向对象.1.static关键字和可变参数

在熟悉的事物中循环

        新年快乐！学习继续~

                2024年加油！

                                ——24.2.12

一、static关键字

1.static关键字的介绍以及基本使用

1.概述：static是一个静态关键字

2.使用：

        a.修饰一个成员变量：

                static 数据类型 变量名

        b.修饰一个方法：

                修饰符 static 返回值类型 方法名（形参）{

                        方法体

                        return 结果

                }

3.调用静态成员

        类名直接调用（不用new对象）

4.静态成员特点：

        a.静态成员属于类成员，不属于对象成员（非静态的成员属于对象成员）

        b.静态成员会随着类的加载而加载

        c.静态成员优先于非静态成员存在在内存中

        d.凡是根据静态成员所在的类创建出来的对象，都可以共享这个静态成员

2.static关键字的使用

public class Demo84S09ObjectOriented01Static {
    public static void main(String[] args) {
        //先给静态成员赋值
        Demo85S09ObjectStudent.classRoom = "111";
        Demo85S09ObjectStudent s1 = new Demo85S09ObjectStudent();
        s1.name = "郭靖";
        s1.age = 21;
        //教师更改classRoom就需要重新赋值，不可以用对象.可以用类名.
        //s1.classRoom = "308";
        System.out.println(s1.name+","+s1.age+","+s1.classRoom);

        Demo85S09ObjectStudent s2 = new Demo85S09ObjectStudent();
        s2.name = "黄蓉";
        s2.age = 26;
        //s2.classRoom = "111";
        System.out.println(s2.name+","+s2.age+","+s2.classRoom);
    }
}

public class Demo85S09ObjectStudent {
    String name;
    int age;
    static String classRoom;
}

3.static成员的内存说明

jdk版本的更新主要针对于内存优化

4.static成员的访问特点

1.在静态方法中能直接访问非静态成员吗？

 （静态方法是先产生的，非静态成员是后产生的）

        无法访问 需要先new对象来调用

2.在非静态方法中能直接访问静态成员吗？

        能直接访问，但是要观察是否在同一个类中

        a.同类：

                直接调用

                类名调用

        b.不同类：

                类名调用

3.在静态方法中能直接访问静态成员吗？

        a.同类：

                直接调用

                类名调用

        b.不同类：

                类名调用

4.在非静态方法中能直接访问非静态成员吗？  

        a.同类：

                直接调用

                new对象调用

        b.不同类：

                new对象调用

总结：

        ①不管在不在同一个类中，非静态成员都可以new对象调用

        ②不管在不在同一个类中，静态成员都可以类名调用

package S10ObjectOriented02;

public class Demo86ObejectPerson {
    public void eat(){
        System.out.println("人要吃饭");
    }

    public static void drink(){
        System.out.println("人要喝水");
    }
}

package S10ObjectOriented02;

public class Demo87ObjectOriented02Test {
    public static void main(String[] args) {
        //静态成员中访问非静态成员 静态成员先出生，要想访问后出生成员，必须要先new一个对象
        Demo87ObjectOriented02Test Test = new Demo87ObjectOriented02Test();
        Test.method03();

        Demo86ObejectPerson person = new Demo86ObejectPerson();
        person.eat();
    }

    public static void method01(){

    }

    public static void method02(){

    }

    public void method03(){
        //同类中非静态成员访问静态成员
        method01();
        Demo87ObjectOriented02Test.method01();

        //不同类中非静态成员访问静态成员
        Demo86ObejectPerson.drink();
        //静态成员推荐类名.
        Demo86ObejectPerson person = new Demo86ObejectPerson();
        person.drink();
    }

    public void method04(){
        method03();
        new Demo87ObjectOriented02Test().method03();

        new Demo86ObejectPerson().eat();
    }
}

5.static_静态成员在开发中的使用场景

问题1:

既然static成员那么好使(类名直接调用),那么我们在实际开发中,能不能将所有的成员都定义成静态的呢?

        不能 原因:由于静态成员会随着类的加载而加载,如果将所有的成员都变成静态的,那么类一加载,静态成员都会进内存,会大量占用内存空间

问题2:

那么静态成员都啥时候定义呢?
        一般情况下,我们在抽取工具类的时候可以将工具类中的所有成员都定义成静态的

问题3:

啥时候定义工具类?
        比如我们在写代码的过程中,发现有的功能在反复实现,代码一样,功能一样,此时就可以抽取出来,形成工具类，构造方法用private修饰，工具类中的成员都是静态的，静态成员都是类名调用，不需要new对象，所以工具类中的构造方法都是用private修饰的

二、可变参数

1.需求：

        定义一个方法，实现n个整数相加

2.分析：

        方法参数位置，只确定了参数的类型，但是不明确参数的个数，此时就可以定义为可变参数

1.介绍和基本使用

1.定义格式：

        数据类型……变量名

2.注意：

        a、可变参数的本质是一个数组

        b、参数位置不能连续写多个可变参数，而且当可变参数和其他普通参数一起使用时，可变参数需要一起放到参数列表最后

2.可变参数的练习

练习1

返回n个字符串拼接结果，如果没有传入字符串，那么返回空字符串""

package S11ChangeParameter;

public class Demo89Var02Practice {
    public static void main(String[] args) {
        String result = concat("一切都会好的",",","我一直相信");
        System.out.println("result="+result);
    }

    public static String concat(String...s){
        String str = "";
        for (int i = 0; i < s.length; i++) {
            str+=s[i];
        }

        return str;
    }
}

练习2

n个字符串进行拼接，每一个字符串之间使用某字符进行分割，如果没有传入字符串，那么返回空字符串

package S11ChangeParameter;

public class Demo90Var03Practice02 {
    public static void main(String[] args) {
        String result = concat(",","万事胜意","一切都会好的","我一直相信");
        System.out.println(result);
    }

    public static String concat(String regex,String...s){
        String str = "";
        for (int i = 0; i < s.length; i++) {
            if(i==s.length-1){
                str+=s[i];
            }else{
                str+=s[i]+regex;
            }
        }

        return str;
    }

}