Java--静态static关键字、静态代码块、数组类Arrays和数学工具类Math

最新推荐文章于 2021-10-10 15:52:45 发布

原创最新推荐文章于 2021-10-10 15:52:45 发布 · 218 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

Java基础学习专栏收录该内容

14 篇文章

订阅专栏

本文介绍了Java中的静态关键字，包括静态变量、静态方法和静态代码块的使用，以及它们在类和对象之间的关系。同时，通过示例展示了如何使用Arrays工具类进行数组操作，如转换为字符串和排序。此外，还讲解了Math类中的一些数学方法，如求绝对值、向上取整和向下取整，并提供了一个实际应用的例子。

1.静态static关键字概述

如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享同一份数据。

public class Student {

    private int  id;

    private String name;
    private int age;
    static String room;//所在教室
    private static int idCount = 0;//学号计数器

    public Student(){
        this.id = ++idCount;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCount;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Demo01Static {
    public static void main(String[] args) {

        Student one = new Student("杨过",10);
        one.room = "101教室";
        Student two = new Student("小龙女",12);

        System.out.println("姓名："+one.getName()+",年龄："+one.getAge()+"，教室："+one.room
        +",学号"+one.getId());
        System.out.println("姓名："+two.getName()+",年龄："+two.getAge()+"，教室："+two.room
                +",学号"+two.getId());
    }
}

2.静态static关键字修饰成员方法

一旦使用static修饰成员方法，那么这就成为了静态方法。

静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。

如果有static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

public class MyClass {
    int num;//成员变量
    static int numStatic;//静态变量
    //成员方法
    public void method(){
        System.out.println("这是一个普通的成员方法。");

        //成员方法可以访问成员变量
        System.out.println(num);
        // 成员方法可以访问静态变量
        System.out.println(numStatic);
    }
    //静态方法
    public static void methodStatic(){
        System.out.println("这是一个静态方法。");
        //静态方法可以访问静态变量
        System.out.println(numStatic);
        // 静态不能直接访问非静态
//        System.out.println(num);//错误写法

        //静态方法不能用this
//        System.out.println(this);//错误写法
    }
}

public class Demo02StaticMethod {

    public static void main(String[] args) {

        MyClass obj = new MyClass();//首先创建对象
        obj.method();

        //对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。
        obj.methodStatic();//正确，不推荐
        MyClass.methodStatic();//正确，推荐

        //对于本类当中的静态方法，可以省略类名称。
        myMethod();
        Demo02StaticMethod.myMethod();//完全等效
    }
    public static void myMethod(){
        System.out.println("这是自己的方法！");
    }
}

3.静态代码块

静态

静态代码块的格式是：

public class 类名称{

static{

//静态代码块的内容

} }

特点：当第一次用到本类时，静态代码块执行唯一的一次。

public class Person {

    static{
        System.out.println("静态代码块执行！");
    }

    public Person(){
        System.out.println("构造方法执行！");
    }
}

public class Demo04Static {

    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();

    }
}

输出结果

静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途：用来一次性地对静态成员变量进行赋值。

4.数组工具类Arrays

java.util.Array 是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

（1）public static String toString(数组):将参数数组变成字符串

（2）public static void sort(数组):按照默认升序（从小到大）对数组的元素进行排序。

public class Demo01Array {
    public static void main(String[] args) {
        int[] intArray ={10,20,30};
        //int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);//[10, 20, 30]

        int[] array1 = {2,1,3,10,5};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));//[1, 2, 3, 5, 10]

        String[] array2 = {"nnnn","mmmmm","bbbb"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));//[bbbb, mmmmm, nnnn]

    }
}

输出结果

备注：

（1）如果是数值，sort默认按照升序从小到大

（2）如果是字符串，sort默认按照字母升序

Arrays练习：

请使用Array相关API，将一个随机字符串中的所有字符升序排列，并倒序打印。

import java.util.Arrays;
public class Demo02ArraysPractise {

    public static void main(String[] args) {
        String str = "assssdgydiuu54c2";
        char[] chars = str.toCharArray();
        Arrays.sort(chars);// 对字符数组进行升序排列

        //需要倒序遍历
        for (int i = chars.length-1; i >=0 ; i--) {
            System.out.println(chars[i]);
        }
    }
}

5.数学工具类Math

java.util.Math 类是数学相关的工具类，里面提供了大量的静态方法，完成数学相关的操作。

public static double abs():获取绝对值；

public static double ceil():向上取整；

public static double floor():向下取整；

public static long round():四舍五入；

Math.PI 代表近似的圆周率常量。

public class Demo03Math {
    public static void main(String[] args) {
        //获取绝对值
        System.out.println(Math.abs(3.14));//3.14
        System.out.println(Math.abs(0));//0
        System.out.println(Math.abs(-2.5));//2.5
        System.out.println("===============");

        //向上取整
        System.out.println(Math.ceil(3.9));//4.0
        System.out.println(Math.ceil(3.1));//4.0
        System.out.println(Math.ceil(3.0));//3.0
        System.out.println(Math.ceil(3));//3.0
        System.out.println("===============");

        //向下取整
        System.out.println(Math.floor(30.1));//30.0
        System.out.println(Math.floor(30.9));//30.0
        System.out.println(Math.floor(31.0));//31.0
        System.out.println("===============");

        //四舍五入
        System.out.println(Math.round(20.4));//20
        System.out.println(Math.round(10.5));//11
    }
}

关于Math练习：

计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个。

public class Demo04MathPractise {
    public static void main(String[] args) {
        int count  = 0;
        double min = -10.8;
        double max = 5.9;

        for (int i=(int)min;i<max;i++){
            int abs = Math.abs(i);//绝对值
            if(abs>6 || abs<2.1){
                System.out.println(i);
                count++;
            }
        }
        System.out.println("总共个数："+count);//9
    }
}