Static & Arrays Practice

public class StaticClass {
    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);//静态方法不能访问非静态变量
        //System.out.println(this);//错误
    }
}

《 静态static关键字修饰成员变量 》

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

一旦使用static修饰成员方法，那么就成为了静态方法
静态方法不属于对象，而是属于类的

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有static关键字，那么不需要创建对象，直接可以通过类名称来使用它。

无论是成员变量还是成员方法，若有了static，都推荐使用类名称进行调用。
静态变量： 类名称.静态变量;
静态方法： 类名称.静态方法();

注意事项：
1、静态只能直接访问静态，不能直接访问非静态。（原因：内存中先有静态内容，后有非静态内容；后人知道先人；）
2、静态方法中不能用this；（原因：this代表当前对象，通过谁调用方法，谁就是当前对象。不能通过对象调用静态方法。）

静态代码块的格式：
public class 类名称{
static{
//静态代码块的内容
}
}

 public class Student {
    private int id;//学号
    private String name ;
    private int age;
    static String room;//所在教室
    private static int idCounter = 0;//每new一个新对象，计数器++
    public Student() {
        idCounter++;
    }

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

    public int getId() {
        return id;
    }

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

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

    public String getName(){
        return name;
    }

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

    public int getAge(){
        return age;
    }
}
public class StaticField {
    public static void main(String[] args){
        Student one = new Student("ivory",19);
        Student two = new Student("milfa",23);
        one.room = "7304";

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


public static void main(String[] args){

        StaticClass object = new StaticClass();//首先创建对象
        object.method();//然后才能使用没有static关键字的内容

        //对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用
        object.methodStatic();//正确，但不推荐（编译后也会被javac翻译成‘’类名称.静态方法名‘’）
        StaticClass.methodStatic();//推荐

        //对于本类当中的静态方法，可以省略类名称
        myMethod();
        StaticMethod.myMethod();
    }

        public static void myMethod(){
            System.out.println("我的方法");
        }

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

public class Person {
    static {
        System.out.println("静态代码块执行了");
    }

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

Arrays相关API及练习

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

 */
import java.util.Arrays;
public class ArraysPractice01 {
    public static void main(String[] args){
        String str = "qwertyuiopasdfghjklzxcvbnm";
        //进行升序排列需要sort
        //必须为一个数组才能用Arrays.sort
        char[] chars = str.toCharArray();
        Arrays.sort(chars);//对字符数组进行升序排列

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

        }

    }
}

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

public static String toString(数组)：将参数数组变成字符串（按默认格式[,]）
public static void sort(数组)：按照默认（升序）对数组元素进行排序

备注：
1、如果是数值，则sort默认按照升序从小到大
2、如果是字符串，sort默认按字母升序
3、如果是自定义类型，那么这个自定义的类需要有comparable函数h或者comparator接口的支持。
 */
import java.util.Arrays;
public class ArraysTools {
    public static void main(String[] args) {
        int[] Array1 = {1, 2, 3};
        //将int[]数组按照默认格式变成字符串
        String str1 = Arrays.toString(Array1);
        System.out.println(str1);

        int[] Array2 = {3,52,35,746};
        Arrays.sort(Array2);
        System.out.println(Arrays.toString(Array2));

        String[] Array3 = {"ddd","ada","eee"};
        Arrays.sort(Array3);
        System.out.println(Arrays.toString(Array3));
    }
}

/*
    题目   ：  计算-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？

分析：1、已确定范围，用for循环
     2、起点位置-10.8转换为-10，两种方法：(1)Math.ceil向上取整；
                                      (2)强转成为int类型，自动舍弃所有小数位；
     3、每个数字都为整数，所以步进表达式应该为num++，每次加一
     4、拿到绝对值
     5、计数器++
 */
public class MathPractice {
    public static void main(String[] args){
        int count = 0;
        double min = -10.8;
        double max = 5.9;
        /*for(double i = Math.ceil(min); i < Math.ceil(max) ; i ++){
            double c = Math.abs(i);  //  Math.ceil得到的是一个double值
            if(c > 6 || c <= 2){
                System.out.println(i);
            }
        }*/  //输出数字类型为double，即小数
        for(int i = (int)min ; i < max ; i++){   //把min强转为int类型，舍弃所有小数位
            int abs = Math.abs(i);
            if( abs > 6 || abs <= 2.1){
                System.out.println(i);
                count++;
            }
        }
        System.out.println("符合要求的数字共有"+ count + "个");
    }
}

/*
java.lang.math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

常用方法：1、public static double abs(double num);获取绝对值
        2、public static double ceil(double num);向上取整
        3、public static double floor(double num);向下取整
        4、public static long round(double num);四舍五入

      Math.PI代表近似的圆周率（double类型值）
 */
public class MathTools {
    public static void main(String[] args){
        System.out.println(Math.abs(3.14));
        System.out.println(Math.abs(-1));//多种重载
        System.out.println("------------------------");

        System.out.println(Math.ceil(3.3));
        System.out.println(Math.ceil(4.0));
        System.out.println("------------------------");

        System.out.println(Math.floor(2.1));
        System.out.println(Math.floor(3.0));
        System.out.println("------------------------");

        System.out.println(Math.round(2.67));
        System.out.println(Math.round(2.3));
    }
}