java基础：static的基础

一 static是什么

User.java

package Test;

import com.sun.security.jgss.GSSUtil;

public class User {
    /**
     * 在线人数
     * 注意：static修饰的成员变量：静态成员变量，只在内存中有一份，可以被共享
     */
    public static int onLineNumber=161;
//    实例成员变量：无static修饰，属于每个对象的，必须用对象名.访问
    private String name;
    private int age;

    public static void main(String[] args) {
//        目标：理解static修饰成员变量的作用和访问特点
//        1.类名.静态成员变量
        System.out.println(User.onLineNumber);

//        2.对象.静态成员变量
        User u=new User();
        u.name="张三";
        u.age=21;
        System.out.println(u.name);
        System.out.println(u.age);
        u.onLineNumber++;//来了一个人
        System.out.println(u.onLineNumber);

        User u2=new User();
        u2.name="张三";
        u2.age=21;
        System.out.println(u2.name);
        System.out.println(u2.age);
        u.onLineNumber++;//来了一个人

        System.out.println(u.onLineNumber);
        System.out.println(User.onLineNumber);//推荐方式
//        注意·：同一个类中静态成员变量的访问可以省略类名。
        System.out.println(onLineNumber);

    }
}

二.修饰成员方法，内存机制

package Test;

public class Student {
//    实例成员变量：无static修饰，属于对象
    private String name;
    /**
     * 静态成员方法：有static修饰，归属与类，可以被共享访问，用类名或者对象都可以访问
     */
    public static int getMax(int age1,int age2){
        return age1>age2?age1:age2;
    }

    /**
     * 实例方法：属于对象的，只能用对象触发访问
     */
    public void study(){
        System.out.println(name+"在好好学习，天天向上");
    }
    public static void main(String[] args) {
//        1.类名，静态成员方法
        System.out.println(Student.getMax(10,3));
//        注意：同一个类中，访问静态方法，类名可以省略不写
        System.out.println(getMax(10,32));

//        study();    //报错了
//        2.对象，实例方法
        Student s= new Student();
        s.name="猪八戒";
        s.study();

//        3.对象，静态方法(语法是可行，但是不推荐)
        System.out.println(s.getMax(13,34));

    }

}

三.static的注意事项

package Test;

public class Test3 {
    /**
     * 静态成员
     */

    public static int onlineNumber=10;
    public static void test2(){
        System.out.println("==test2==");
    }

    /*
    实例成员
     */
    private String name;
    public void run(){
        System.out.println(name+"跑的快");
    }

//    3.静态方法不可以出现this关键字
    public static void test3(){
//        System.out.println(this);//this只能代表当前对象
    }

//    2.实例方法可以访问静态成员，也可以访问实例成员
    public void go(){
        System.out.println(Test3.onlineNumber);
        System.out.println(onlineNumber);
        test2();
        System.out.println(name);
        System.out.println(this);
        run();
    }



//    1.静态方法只能访问静态成员，不能直接访问实例成员。
    public static void test(){
        System.out.println(Test3.onlineNumber);
        System.out.println(onlineNumber);
        test2();
//        System.out.println(name);//不能直接访问实例成员
//        run();//不能直接访问实例成员
    }
    public static void main(String[] args) {
//        目标：理解static访问相关的语法：面试笔试题，对以后理解程序很重要
    }
}

四.工具类的使用

ItheimUtil.java

package Test;

import java.util.Random;

//工具类的定义
public class ItheimUtil {

    /*
    注意：由于工具类无需创建对象，所以把其构造器私有化会显得很专业
     */
    private ItheimUtil(){
//        私有方法，禁止new一个对象
    }

    public static String createVerfiyCode(int n) {
        //        开发一个验证码
//        1.定义一个变量记住验证码
        String code="";
//        2.定义一个变量记住全部验证码字符。
        String data="abcdefghijklmoqprstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
//        3.定义一个循环生成几个随机索引，去得到几个字符
        Random r=new Random();
        for (int i=0;i<n;i++){
//            4.获取随机索引对应的字符。链接给code
            int index=r.nextInt(data.length());
            code+=data.charAt(index);
        }
        return code;
    }
}

Login.java

这是用来调用的

package Test;

public class Login {
    public static void main(String[] args) {
//        开发一个验证码
        System.out.println(ItheimUtil.createVerfiyCode(5));
    }
}

总结

第二个案例

ArrayUtil .java

package Test;

import java.util.Random;

//练习：完成数组的工具类的设计
public class ArrayUtil {

    /*
    私有构造器，禁止new对象
     */
    private ArrayUtil(){
    }


//    工具方法：静态方法
    public static String toString(int[] arr) {
//        1.一些校验
        //==比较的是地址
        if (arr==null){
            return null;
        }

//        2.拼接内容并返回    arr={}
        String result="[";
        for (int i=0;i<arr.length;i++){
            result+=(i==arr.length-1?arr[i]:arr[i]+", ");
        }
        result+="]";
        return result;
    }
}

test.java

package Test;

public class test {
    public static void main(String[] args) {
        int[] arr=null;
        int[] arr1={};
        int[] arr2={12,23,44,99};

        System.out.println(ArrayUtil.toString(arr));
        System.out.println(ArrayUtil.toString(arr1));
        System.out.println(ArrayUtil.toString(arr2));
    }
}

六.代码块

静态代码块

package Test;

public class test {
    public static String schoolName;

    /**
     * 静态代码块：有static修饰，属于类，与类一起优先加载一次，自动触发执行
     * 作用：可用于初始化静态资源
     */
    static{
        System.out.println("=============静态代码块被触发执行了=============");
        schoolName="黑马";
    }
    public static void main(String[] args) {
//        目标：先理解静态代码块
        System.out.println("=============main方法执行==============");
        System.out.println(schoolName);
    }
}

构造器法

package Test;

public class test {
    public test(){
        System.out.println("===无参构造器被触发===");
    }

    /**
     * 实例代码块：无static修饰，属于对象，每次构建对象时，都会触发一次执行
     */
    {
//        与类一起被执行
        System.out.println("===实例代码块被触发执行===");
    }

    public static void main(String[] args) {
//        目标：理解实例代码块(构造代码块)
        test s1=new test();
        test s2=new test();

    }
}

代码块案例：斗地主

package Test;

import java.util.ArrayList;

public class test {
    /**
     * 1.定义一个静态的集合，这样这个集合只加载一个，因为当前房间内只需一副牌
     */
    public static ArrayList<String> cards=new ArrayList<String>();

//    2.在程序真正运行main方法前，把54张牌放进去吧，把后续游戏可以直接使用了
    static{
//       3.正式做牌，放到集合中去
//       a.定义一个数组存储全部点数：类型确定了。个数确定了
        String[] sizes={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
//        b.定义一个数组存储全部的花色：类型确定了，个数确定了
        String[] colors={"♥","♠","♦","♣"};
//        c.遍历点数
        for (int i=0;i< sizes.length;i++){
//            sizes[i]
//            d.遍历花色
            for (int j=0;j<colors.length;j++){
//                colors[j]
//                一张牌
                String card=sizes[i]+colors[j];
                cards.add(card);
            }
        }
//        e.单独加入大小王
        cards.add("大🃏");
        cards.add("小🃏");
    }
    public static void main(String[] args) {
//      目标：模拟游戏启动前，初始化54张牌数据
        System.out.println("新牌:"+cards);
    }
}

结果

新牌:[3♥, 3♠, 3♦, 3♣, 4♥, 4♠, 4♦, 4♣, 5♥, 5♠, 5♦, 5♣, 6♥, 6♠, 6♦, 6♣, 7♥, 7♠, 7♦, 7♣, 8♥, 8♠, 8♦, 8♣, 9♥, 9♠, 9♦, 9♣, 10♥, 10♠, 10♦, 10♣, J♥, J♠, J♦, J♣, Q♥, Q♠, Q♦, Q♣, K♥, K♠, K♦, K♣, A♥, A♠, A♦, A♣, 2♥, 2♠, 2♦, 2♣, 大🃏, 小🃏]
进程已结束,退出代码0

七，设计模式

1.饿汉单例

SingleInstance.java

package Test;

//使用饿汉单例实现单例类
public class SingleInstance {
    /**
     *2.饿汉单例是在获取对象前，对象已经提前准备好了一个
     * 这个对象只能是一个，所以定义静态成员变量记住
     */
    public static SingleInstance instance=new SingleInstance();
//    把new SingleInstance赋给instance

    private SingleInstance(){
    }

}

test.java

package Test;

import java.util.ArrayList;

public class test {
    public static void main(String[] args) {
//        目标：理解饿汉单例的设计步骤
        SingleInstance s1=SingleInstance.instance;
        SingleInstance s2=SingleInstance.instance;
        System.out.println(s1==s2);

    }
}

2.懒汉单例

test.java

package Test;

import java.util.ArrayList;

public class test {
    public static void main(String[] args) {
//        目标：掌握懒汉单例的设计，理解其思想
        SingleInstance s1=SingleInstance.getInstance();
        SingleInstance s2=SingleInstance.getInstance();
        System.out.println(s1==s2);
    }
}

SingleInstance.java

package Test;

//懒汉单例
public class SingleInstance {
    /**
     * 2.定义一个静态的成员变量负责存储一个对象
     * 只加载一次，只有一份
     */
    private static SingleInstance instance;

    /**
     * 3.提供一个方法，对外返回单例对象
     */
    public static SingleInstance getInstance(){
        if (instance == null){
//            第一次来拿对象：此时需要创建对象
            instance = new SingleInstance();
        }
        return instance;
    }

//    1.私有化构造器
    private SingleInstance(){

    }
}