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

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);
    }
}

运行结果：

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();    
    }
}

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=否循环结束                
    }
}