Java随机数

今日收获：

一、所有引用类型变量的初始化一定要使用new 关键字定义声明，空指针异常的错误原因可能是变量没有初始化导致的。

        每一个类体的数据成员一定要在实例化的同时赋值，用一个实例化的类实现问题中最小的一部分，比如四则运算题目，一个类就是一个算式，问题要极度分解简化。

　　函数之间的返回值和参数

二、定义int 或者 char 类型的数组   ：        int [ ]a=new int [10];    int char [ ]c=new char [10];

三、Random的使用  Random r1=new Random(seed);       这里的seed可以用 System.nanotime获取时间随机种子   

        Random 函数    r1.nextInt( ) ; 指定随机数的范围；      r1.nextInt( max) %(max-min+1)+min;      这表示从 min 到 max 的随机数

         r1.nextInt( num) ; 表示  从 0   ---  num-1  的范围随机数。 

　　随机数的产生有三种方式

　　　    第一种：new Random()

　　　第二种：Math.random()

　　　第三种：currentTimeMillis()

 　　  第二种方法返回的数值是[0.0,1.0）的double型数值

 

 

 

 

public class RandomTest {
    public static void main(String[] args) {
        int max=20;
        int min=10;
        Random random = new Random();

/*
    random.nextInt(max)表示生成[0,max]之间的随机数，然后对(max-min+1)取模。
   以生成[10,20]随机数为例，首先生成0-20的随机数，然后对(20-10+1)取模得到[0-10]之间的随机数，然后加上min=10，最后生成的是10-20的随机数  
*/
        int s = random.nextInt(max)%(max-min+1) + min;
        System.out.println(s);
    }
}

四、ArrayList 数组存储数据要一个一个存，那么取数据也一定是一个一个取出来，不然容易出错！

**************************************************************************************************************

理解空指针异常错误产生的原因（图片来自 https://blog.csdn.net/qq_44543508/article/details/94589868?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.channel_param）

 

 

 

 

 

 

总之，NullPointerException由RuntimeException派生出来，是一个运行时异常。其意指可能会在运行的时候才会被抛出，一个变量是null,及只有其名,没有实值内容,也没分配内存,当你要去取他的长度,对他进行操作就会出现NullPointException,所以声明变量时最好给它分配好内存空间，给予赋值，例如拿该变量与一个值比较时，要么先做好该异常的处理要么给它进行判断先： if (str ！=null && str “”){ …}
判断一个String的实例s是否等于“a”时，不要写成s.equals(“a”)，这样容易抛NullPointerException，而写成"a".equals(s)就可以避免这个问题，不过对变量先进行判空后再进行操作更好，尽量避免返回null，方法的返回值不要定义成为一般的类型，用数组。这样如果想要返回null的时候，就返回一个没有元素的数组。就能避免许多不必要的NullPointerException

拿到一个题之后，先考虑一个类可以做的最基本的事情是什么，哪些数据是在类里面的，哪些数据是要在主方法的，定义方法的时候，一定每次都要考虑方法的参数和返回值，调用关系是否可以满足。尽量不要采用“散装”的数据变量来存储数据，要用高级的数据类型，数组等等，方便数据之后的存取。定义变量必须初始化赋值，实例化对象要给每一个成员变量赋初值！！！

类的实例化对象调用自己的类是不需要再传递一个本类参数的，直接在方法中使用this. 调用就可以使用成员变量！！！

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

测试二阶段一：

FourOperations.java

package fouroperations;
import java.util.*;
public class FourOperations {
    /*
     * 总体思路，一个实例化的类就是一个算式，里面有单独的几个函数
     * 判断重复函数，需要一个参数引用所有的实例化类。
     * 在主类定义一个ArrayList类存储每一个实例化的 FourOperations类
     * 
     * 
     * 
     * 
     * 1,定义一个数组存储生成的指定数量的操作数（2---5）个，那么就只需要一个随机数生成的变量，
     * 
     * 2，定义一个char类型的数组    来存储4个符号    + - * /；
     * 
     * 
     */
     private int operationnum;              //随机数个数
     private int max;                          //最大值
     private int min;                        //最小值
     private String formulas;                //最终产生的完整的算式
     String symbol;                          //运算符号
     private int []allnumber=new int[5];    //操作数数组
     private int tempnum_1;                    
     private Random r1=new Random(10);      //随机数变量
    
    public int getOperationnum() {
        return operationnum;
    }
    public void setOperationnum(int operationnum) {
        this.operationnum = operationnum;
    }
    public int getMax() {
        return max;
    }
    public void setMax(int max) {
        this.max = max;
    }
    public int getMin() {
        return min;
    }
    public void setMin(int min) {
        this.min = min;
    }
    public String getFormulas() {
        return formulas;
    }
    public void setFormulas(String formulas) {
        this.formulas = formulas;
    }
    public String getSymbol() {
        return symbol;
    }
    public void setSymbol(String symbol) {
        this.symbol = symbol;
    }
    FourOperations(){};              //无参构造
    /*
     * 定义初始化变量函数
     * 参数
     * int operationnum,int max,int min
     */
    public void init(int operationnum,int max,int min) {
         this.setOperationnum(operationnum);
         this.setMax(max);
         this.setMin(min);
    }
    
    /*
     * 定义产生随机数的函数，生成算式String对象  
     * 参数：
     * 无
     */
    
     public void creatNum( ) 
     {
               int tempnum_1=0;
               for(int j=0;j<this.operationnum;j++) {
                   this.r1=new Random(System.nanoTime());
                 tempnum_1=this.r1.nextInt(this.max)%(this.max-this.min+1) +this.min;
                 this.allnumber[j]=tempnum_1;
             }
                 switch(this.operationnum) {
                     case 2:
                         this.formulas=""+this.allnumber[0]+this.creatSymbol()+this.allnumber[1];
                         break;
                     case 3:
                         this.formulas=""+this.allnumber[0]+this.creatSymbol()+this.allnumber[1]+
                         this.creatSymbol()+this.allnumber[2];
                         break;
                     case 4:
                         this.formulas=""+this.allnumber[0]+this.creatSymbol()+this.allnumber[1]+
                         this.creatSymbol()+this.allnumber[2]+this.creatSymbol()+this.allnumber[3];
                         break;
                     case 5:
                         this.formulas=""+this.allnumber[0]+this.creatSymbol()+this.allnumber[1]+
                         this.creatSymbol()+this.allnumber[2]+this.creatSymbol()+this.allnumber[3]+
                         this.creatSymbol()+this.allnumber[4];
                         break;
                    default : break;
                 }
         }
     /*
      * 定义查重函数；
      * 参数   ArrayList<FourOperations> arrays
      */
     public boolean Repeatition(ArrayList<FourOperations> arrays) {
        boolean flag=false;
         for(int i=0;i<arrays.size();i++) {
             if(this.formulas.equals(arrays.get(i).formulas)) {
                 flag=true;
             }
         }
         while(flag) {
             for(int i=0;i<arrays.size();i++) {
                 if(!(this.formulas.equals(arrays.get(i).formulas)) ){
                     flag=false;
                 }
             this.creatNum();
             }    
         }
         return true;
     }
    /*
      * 定义产生随机符号的函数
      * 参数 无
      * 返回值 String 类型的一个变量
      */
     
     public String creatSymbol() {
         Random r2=new Random();
         int flag= r2.nextInt(4);
         switch(flag) {
         case 0:
             this.symbol="+";
             break;
         case 1:
             this.symbol="-";
             break;
         case 2:
             this.symbol="*";
             break;
         case 3:
             this.symbol="/";
             break;
         }
        return symbol;
     }
     
     /*
      * 定义输出函数  display
      * 
      */
    
    public static void display(int num,ArrayList<FourOperations> arrays) {
        for(int j=0;j<num;j++) {
            //实例化类 tempclass 接收arrays的返回值
            FourOperations tempclass=new FourOperations();
            tempclass=arrays.get(j);
            System.out.println(""+(j+1)+"、"+tempclass.formulas);
        }
     }
    public int getTempnum_1() {
        return tempnum_1;
    }
    public void setTempnum_1(int tempnum_1) {
        this.tempnum_1 = tempnum_1;
    }
    
     
}

FourOperationsDome.java

package fouroperations;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Scanner;
public class FourOperationsDemo {
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        
        int num;
        //定义arrays数组 存储每次产生的类
        ArrayList<FourOperations> arrays = new ArrayList<FourOperations>();
        
        Scanner sc= new Scanner(System.in);
        System.out.println("请输入算式的个数：");
        num=sc.nextInt();
         int operationnum;              //随机数个数
         int max;                       //最大值
         int min;                         //最小值
         System.out.println("请输入操作数的个数（2---5）");
         operationnum=sc.nextInt();
         //输入max min 
         while(true)
         {
             System.out.println("请输入操作数的最大值");
             max=sc.nextInt();
             System.out.println("请输入操作数的最小值");
             min=sc.nextInt();
             if(max>min)
             break;
             else {
                 System.out.println("输入的最大值要大于最小值，请检查后重新输入！");
                 }
         }
         
         
         boolean f=true;                   //查重循环条件
         for(int i=0;i<num;i++) {
                FourOperations test1=new FourOperations();
                test1.init(operationnum,max,min);       //调用初始化函数
                test1.creatSymbol();                     //调用生成随机运算符函数
                test1.creatNum();                        //调用生成随机式子函数
                test1.Repeatition(arrays);                //调用查重函数
                arrays.add(test1);                        //把新生成的类存到ArrayList数组中 
        }
        //调用输出函数
         FourOperations.display(num, arrays);
        sc.close();
    }
}

@Override

重写的一定是Object类有的方法，而且一定有一个参数是Object类的一个引用。

 

 

Object类的对象obj 要进行向下转型      （MyTestClass）obj