Java暑假复习4

Java面向对象进阶：

static静态关键字：

1、static是静态的意思，可以修饰成员变量和成员方法。

2、static修饰的成员变量表示该成员变量只在内存中之储存一份，可以被共享访问、修改。

注意事项： 同一个类中访问静态修饰的方法或者成员变量，类名可以不写。

成员方法的分类：

1、静态成员方法（有static修饰，归属于类），建议用类名访问，也可以用对象访问。

        访问：类名.静态成员方法

使用场景：表示对象自己的行为的，且方法中需要直接访问实例成员，则该方法必须申明成实例方法。

2、实例成员方法（无static修饰，归属于对象），只能用对象触发访问。

        访问：对象.实例成员方法。

使用场景：如果该方法是以执行一个通用功能为目的，或者需要方便访问，则可以申明成静态方法。

访问注意事项：

1、静态方法只能访问静态的成员，不可以直接访问实例成员。

package example1;

public class Test2 {
//    静态成员方法
    public static int Number = 5;

    /**
        实例方法
     */
    public void run(){
        System.out.println("跑起来");
    }
    
    public static void main(String[] args) {
        System.out.println(Number);
        System.out.println(Test2.Number);
        
//        run();无法直接访问非静态的实例方法
        
//        利用对象可以实现访问
        Test2 test2 = new Test2();
        test2.run();
    }

}

2、实例方法可以访问静态的成员，也可以访问实例成员。

package example1;

public class Test2 {
//    静态成员变量
    public static int Number = 5;

//    实例成员变量
    public String str = "***";
    
    /**
        实例方法
     */
    public void run(){
        System.out.println("跑起来");
    }

    public void test(){
        System.out.println(Number);
        run();
        System.out.println(str);
    }
    

}

3、静态方法中是不可以出现this关键字的。

        因为this是指当前对象，而静态方法中的访问是不一定需要对象来进行的，this又只能代表对象，不可能代表类吧。

static Util工具类：

就是将一些重复量大的方法写到一个类中，方便随时调用，这样只写一次就好了。而这些方法都是静态的。 

在工具类的创建中将构造器私有化可以使代码更安全，更专业。

进行工具类的简单练习：

public class ArraysUtils {

    /**
     * 打印整数类型的数组
     * 以[ , , , ]的形式
     * @param ints 对应整数数组
     */
    public static void toString(int[] ints){
        System.out.print("[");
        for (int i = 0; i < ints.length; i++) {
            System.out.print(ints[i]);
            if (i != ints.length-1){
                System.out.print(",");
            }
        }
        System.out.print("]");
    }

    /**
     * 去除最大值最小值，求剩下的平均值
     * @param floats 传入一个浮点型数组
     * @return 返回一个字符串
     */
    public static float getAverage(float[] floats){
        float avg = 0;
        float max = floats[0];
        for (int i = 0; i < floats.length; i++) {
            if (floats[i] > max){
                max = floats[i];
            }
        }
        float min = floats[0];
        for (int i = 0; i < floats.length; i++) {
            if (floats[i] < min){
                min = floats[i];
            }
        }
        for (int i = 0; i < floats.length; i++) {
            if (floats[i] != max && floats[i] != min){
                avg += floats[i];
            }
        }
        return avg/(floats.length - 2);
    }

代码块：

类的五大成分之一（成员变量、构造器、方法、代码块、内部类），定义在类中方法外。

在Java类下，使用{}括起来的代码被称为代码块。

代码块分为：

静态代码块:

static{}

需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次

使用场景：在类的加载的时候做一些静态数据初始化的操作，以便后续使用。

构造器代码块（少见）：

{}

每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行。

使用场景：初始化实例资源。

利用静态代码块实现的扑克牌展示：

package example1;

import java.util.ArrayList;

public class Test3 {
    /*
    扑克牌
    */
    //创建一个集合储存最终扑克牌
    public static ArrayList<String> cards = new ArrayList<>();

    /**
     * 创建一个静态代码块，用于加载类时就将扑克牌创建好
     */
    static {
        //牌号
        String[] number = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        //花色
        String[] suit = {"♠","♣","♥","♦"};

        //进行搭配
        for (int i = 0; i < number.length; i++) {

            for (int j = 0; j < suit.length; j++) {
                String card = suit[j] + number[i] ;
                //添加到集合
                cards.add(card);
            }
        }
        cards.add("小王");
        cards.add("大王");
    }

    public static void main(String[] args) {
        for (int i = 0; i < cards.size(); i++) {
            System.out.print(cards.get(i));
            if ((i+1) % 8 == 0){
                System.out.print("\n");
            }
        }
    }
}

感谢“黑马程序员”提供的网络学习资源！