当前位置:首页 > Java技术 > Java-P3:工具类,继承,随机数random。

Java-P3:工具类,继承,随机数random。

2022年08月05日 15:09:26Java技术4

1,*1. 定义一个工具类
其中提供了对于整形数组和double类型数组的一些工具方法。

方法分别有:

1.求数组值的和.
2.求数组中的最大值
3.对数组进行升序排序.
4.对数组进行倒序排序(也就是反转数组)

工具类要求:
a.私有化构造方法
b.不希望被继承

/**
 * 
 */
package task3;

/**
 * @author 花花
 * 工具类.

全部都是静态的方法。所以可以通过 类名.functionName() 方式来访问。
一般的话,都会对默认构造方法进行私有化处理,来防止别人使用时习惯性的创建对象来调用方法。
 *1. 定义一个工具类
其中提供了对于整形数组和double类型数组的一些工具方法。

方法分别有:

1.求数组值的和.
2.求数组中的最大值
3.对数组进行升序排序.
4.对数组进行倒序排序(也就是反转数组)

工具类要求:
a.私有化构造方法
b.不希望被继承
 */
public class FunctionArray{
    /*
     * 如果不定义为工具类,可以利用泛型,在仅参数类型不同时,实现代码复用。
     * public class FunctionArray<T extends java.lang.Number>
     */
    private FunctionArray() {

    }
        //1.求数组值的和.
        public static int sum(int a[])
        {
            int sum=0;
            for(int i=0;i<a.length;i++)
            {
                 sum=sum+a[i];
            }
            return sum;
        }
        public static double sum(double a[])
        {
            double sum=0;
            for(int i=0;i<a.length;i++)
            {
                 sum=sum+a[i];
            }   
            return sum;
        }
        //2,数组获取最值(获取数组中的最大值最小值)
        public static int max(int a[])
        {
            for(int i=0;i<a.length-1;i++)
            {
                for(int j=i+1;j<a.length;j++)
                {
                    if(a[i]>a[j])//升序:由小到大
                    {
                        int temp=a[i];
                        a[i]=a[j];
                        a[j]=temp;
                    }
                }       
            }
            return a[a.length-1];   
        }
        public static double max(double a[])
        {
            for(int i=0;i<a.length-1;i++)
            {
                for(int j=i+1;j<a.length;j++)
                {
                    if(a[i]>a[j])//升序:由小到大
                    {
                        double temp=a[i];
                        a[i]=a[j];
                        a[j]=temp;
                    }
                }       
            }
            return a[a.length-1];   
        }
        /*3.对数组进行升序排序.
         * 选择排序:最多n-1趟。比较次数最多1/2(n^2-n). T(n)=O(n^2)*/
        public static void sortByAsce(int a[])
        {

            for(int i=0;i<a.length-1;i++)
            {
                for(int j=i+1;j<a.length;j++)
                {
                    if(a[i]>a[j])//升序:由小到大
                    {
                        int temp=a[i];
                        a[i]=a[j];
                        a[j]=temp;
                    }
                }       
            }   
        }
        public static void sortByAsce(double a[])
        {

            for(int i=0;i<a.length-1;i++)
            {
                for(int j=i+1;j<a.length;j++)
                {
                    if(a[i]>a[j])//升序:由小到大
                    {
                        double temp=a[i];
                        a[i]=a[j];
                        a[j]=temp;
                    }
                }       
            }   
        }

        /*4,数组元素逆序 (就是把元素对调)
         * 令n=a.length
         */
        public static void back(int a[])
        {
            if(a.length%2==0)//n为偶数
            {
             for(int i=0,j=a.length-1;(i<a.length/2)&&(j>=a.length/2);i++,j--)
              {
                int temp=a[i];
                a[i]=a[j];
                a[j]=temp;
              }     
            }
            else//n为奇数,a[n/2]不进行交换//如:n=5  0,1,2,3,4
            {
                for(int i=0,j=a.length-1;(i<a.length/2)&&(j>a.length/2);i++,j--)
                  {
                    int temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                  }       
            }
        }//back方法结束
        public static void back(double a[])
        {
            if(a.length%2==0)//n为偶数
            {
             for(int i=0,j=a.length-1;(i<a.length/2)&&(j>=a.length/2);i++,j--)
              {
                double temp=a[i];
                a[i]=a[j];
                a[j]=temp;
              }     
            }
            else//n为奇数,a[n/2]不进行交换//如:n=5  0,1,2,3,4
            {
                for(int i=0,j=a.length-1;(i<a.length/2)&&(j>a.length/2);i++,j--)
                  {
                    double temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                  }       
            }
        }//back方法结束
        //数组遍历(依次输出数组中的每一个元素)
        public static void print(int a[])
        {
            for(int i=0;i<a.length;i++)
            {
                System.out.print(a[i]+" ");
            }   
        }       
        //数组遍历(依次输出数组中的每一个元素)
        public static void print(double a[])
        {
            for(int i=0;i<a.length;i++)
            {
                System.out.print(a[i]+" ");
            }   
        }       
    public static void main(String[] args) {
        int[] a= {1,5,6,2,9};
        double[] b= {1,5,6,2,9};
        System.out.println("a数组初始序列:");
        FunctionArray.print(a);
        System.out.println("\rb数组初始序列:");
        FunctionArray.print(b);
        System.out.println("\ra数组的和为:"+FunctionArray.sum(a));
        System.out.println("b数组的和为:"+FunctionArray.sum(b));
        System.out.println("a数组最大数为:"+FunctionArray.max(a));
        System.out.println("b数组最大数为:"+FunctionArray.max(b));
        FunctionArray.sortByAsce(a);
        System.out.println("a数组升序排列:");
        FunctionArray.print(a);
        FunctionArray.sortByAsce(b);
        System.out.println("\rb数组升序排列:");
        FunctionArray.print(b);
        int[] a2= {1,5,6,2,9};
        double[] b2= {1,5,6,2,9};
        FunctionArray.back(a2);
        System.out.println("\ra数组逆序排列:");
        FunctionArray.print(a2);
        FunctionArray.back(b2);
        System.out.println("\rb数组逆序排列:");
        FunctionArray.print(b2);
    }
}

运行结果:
Java-P3:工具类,继承,随机数random。 _ JavaClub全栈架构师技术笔记
2. a.定义一个英雄类 Hero
属性:(全部私有,提供公共方法让外部访问)
年龄, 血量 ,攻击力,防御力
方法:
释放技能,加血.

必须至少包含一个构造方法,且该构造方法可以初始化所有四个成员变量

b.定义一个类BatMan继承Hero类
方法:
飞行(方法中输出一行打印”飞行”)

c.定义一个SuperBatMan类继承 BatMan类
方法:
重写飞行方法(方法中输出一行打印”超级飞行”)

最终分别创建BatMan对象和SuperBatMan对象,并调用飞行方法.

第一个源文件:Hero.java

/**
 * 
 */
package task3;

/**
 * @author 花花
 *a.定义一个英雄类 Hero 
属性:(全部私有,提供公共方法让外部访问) 
年龄, 血量 ,攻击力,防御力 
方法: 
释放技能,加血.

必须至少包含一个构造方法,且该构造方法可以初始化所有四个成员变量
 */
public class Hero {
    private int age;
    private int blood;
    private int attackPower;
    private int defensePower;
    Hero(){
        age=3;
        blood=4;
        attackPower=5;
        defensePower=6;
    }
    public int getAge()
    {
        return age;
    }
    public int getblood()
    {
        return blood;
    }
    public int getAttackPower()
    {
        return attackPower;
    }
    public int getDefensePower()
    {
        return defensePower;
    }
    //释放技能
    public void skills() {
        System.out.println("火光");
        attackPower--;  
    }
    //加血
    public void addBlood(){
        blood++;
        System.out.println("血量值"+blood);
    }
}

第二个源文件:BatMan.java

/**
 * 
 */
package task3;

/**
 * @author 花花
 *b.定义一个类BatMan继承Hero类 
方法: 
飞行(方法中输出一行打印”飞行”)
 */
public class BatMan extends Hero{
    public void fly() {
        System.out.println("飞行");
    }
}

第三个源文件:SuperBatMan.java

package task3;
/**
 * @author 花花
 *c.定义一个SuperBatMan类继承 BatMan类 
方法: 
重写飞行方法(方法中输出一行打印”超级飞行”) 
 */
public class SuperBatMan extends BatMan{
    public void fly() {
        System.out.println("超级飞行");
    }
}

第四个源文件:KingOfGlory.java

/**
 * 
 */
package task3;

/**
 * @author 花花
 *分别创建BatMan对象和SuperBatMan对象,并调用飞行方法.
 */
public class KingOfGlory {
    public static void main(String[] args) {
        BatMan b=new BatMan();
        SuperBatMan s=new SuperBatMan();
        b.fly();
        s.fly();    
    }
}

Java-P3:工具类,继承,随机数random。 _ JavaClub全栈架构师技术笔记

  1. 实现一个猜数的小游戏.
    随机产生一个数(a)。
    Scanner 的方式来输入一个数字,并提供反馈,告诉用户该输入的值比a大还是比a小,直到最终用户猜中,显示结果.
/**
 * 
 */
package task3;
import java.util.*;
/**
 * @author 花花
 * 实现一个猜数的小游戏.
随机产生一个数(a)。
Scanner 的方式来输入一个数字,并提供反馈,
告诉用户该输入的值比a大还是比a小,直到最终用户猜中,显示结果.  
 */
public class J_GuessNumber {
    private final int RealNumber;
    /*static final int RealNumber只能在定义时初始化,不初始化会编译出错,构造代码块和构造方法中都无法进行初始化
     * final int RealNumber可以在定义时和构造方法中,以及构造代码块中初始化
     */
    private static int times;
    private Boolean guessRight;//猜对标志
    //构造函数
    J_GuessNumber(){
        RealNumber=(int)(Math.random()*10); 
         times=0;
         guessRight=false;
    }
    public int inputNumber() {
        Scanner s=new Scanner(System.in);
        int guessNumber=s.nextInt();
        return guessNumber;
    }
    public void guess(int guessNumber)
    {
        ++times;
        if(guessNumber<RealNumber) {
            System.out.println("这是第"+times+"次猜测,您猜小了!请重新猜。");
        }
        if(guessNumber==RealNumber) {
            System.out.println("这是第"+times+"次猜测,哇,好厉害!您猜对了!");
            System.out.println("随机数为:"+RealNumber);
            guessRight=true;//终止本次猜测

        }   
        if(guessNumber>RealNumber) {
            System.out.println("这是第"+times+"次猜测,您猜大了!请重新猜。");
        }   
    }

    public static void main(String[] args) {
        System.out.println("随机给您分配了一个0~9的整数,请猜!");
        String str="是";
        while(str.equals("是"))
        {
            J_GuessNumber guess1=new J_GuessNumber(); 
            while(!guess1.guessRight) 
            {
                int guessNumber=guess1.inputNumber();
                guess1.guess(guessNumber);
            }//猜对后循环结束
            System.out.println("还想再玩儿吗?是?否?");
            Scanner s2=new Scanner(System.in);
            str=s2.next();
            if(str.equals("是"))
            {
                System.out.println("随机给您分配了一个0~9的整数,请猜!");
            }   
        }//str=否循环结束                
    }
}

Java-P3:工具类,继承,随机数random。 _ JavaClub全栈架构师技术笔记

作者:快乐的内啡肽呀
来源链接:https://www.cnblogs.com/flower-bky/p/15134771.html

版权声明:
1、JavaClub(https://www.javaclub.cn)以学习交流为目的,由作者投稿、网友推荐和小编整理收藏优秀的IT技术及相关内容,包括但不限于文字、图片、音频、视频、软件、程序等,其均来自互联网,本站不享有版权,版权归原作者所有。

2、本站提供的内容仅用于个人学习、研究或欣赏,以及其他非商业性或非盈利性用途,但同时应遵守著作权法及其他相关法律的规定,不得侵犯相关权利人及本网站的合法权利。
3、本网站内容原作者如不愿意在本网站刊登内容,请及时通知本站(javaclubcn@163.com),我们将第一时间核实后及时予以删除。


本文链接:https://www.javaclub.cn/java/17811.html

标签: Java随机数
分享给朋友:

“Java-P3:工具类,继承,随机数random。” 的相关文章

java生成随机数

/** * 生成20位的随机数,用系统当前时间的毫秒数(13)+七位随机数 * @return */ public String generateStr() { StringBuffer v...

Java随机数Random

记录一个比较操蛋的问题 1、随机数是由随机种子根据一定的计算方法计算出来的结果。只要计算方法一定,随机种子一定,那么计算出来的结果就相同。 2、如果你每次调用srand()时都提供相同的种子值,那么,你将会得到相同的随机数序列 3、Rand...

java产生随机数的方法

一.在j2se里我们可以使用Math.random()方法来产生一个随机数,这个产生的随机数是0-1之间的一个double,我们可以把他乘以一定的数,比如说乘以100,他就是个100以内的随机,这个在j2me中没有。 二.在java.util这个包里面提供了一个...

利用java随机数模拟求π的值

利用java随机数模拟求π的值

我们从小学的时候就已经熟知了π的值是介于3.1415926到3.1415927之间的一个无限不循环小数,今天我们就来利用java中的Math.random()这个随机数产生器来计算π的值,产生的数值范围为0~1。 用随机数来计算π的值可能...

java byte 随机数

Java中想要生成一个指定范围之内的随机数字通常两种方法:调用 Math 类的 random() 方法 使用 Random 类。 Random 类提供了丰富的随机数生成方法,可以产生 boolean、int、long、float、byte 数组以及 do...

java中自定义随机数据

要生成自定义随机数1或-1,您需要使用nextBoolean()。首先,循环并在每次迭代中创建一个Random对象-for (int i = 0; i  Random rand =&...

Java 随机数

Java 随机数

Java 随机数   本章先讲解Java随机数的几种产生方式,然后通过示例对其进行演示。 广义上讲,Java中的随机数的有三种产生方式: (01). 通过System.currentTimeMillis(...

java生成永远不重复的随机数

java生成不重复随机数的方法 发布时间:2020-07-01 11:00:00 来源:亿速云 阅读:225 作者:Leah java怎么实现生成不重复随机数 ?针对这个问题,这篇文章详细介绍了相对应的分析和解答,希望可以帮助更多...

java byte 随机数

java byte 随机数

人机交互过程中,当我们需要机器给我们反馈不确定的数字结果时,就会需要用到随机数了,那么,在Java中,我们应当如何来生成并使用随机数呢? 一、通过Random类来实现 Random类是JDK的java.util包中的一个工具类,该类可用于在指定范围内产生...

java随机数类Random类

1 方法简介 2 public int nextInt(int maxValue) 产生[0,maxValue)范围的随机整数,包含0,不包含maxValue; 3 public double nextDouble() 产生[0,1)范围的随机小数,包含0.0,不包含1.0。...

发表评论

访客

◎欢迎参与讨论,请在这里发表您的看法和观点。