03-方法ppt动手动脑问题及课后实验性问题总结

一.如何不使用static来进行调用函数？

1.自己定义的不需要都是static，但是要在主函数中调用就需要static了，因为main是静态的，在类加载时就加载了。如果想用又不加可以吧自己写的方法写在一个类中调用就行。主函数一般也只是调用不做数据处理。

2.static方法是在编译的时候确定的，在类装入内存的时候也同时装入内存了。而非static方法是在类的实例化的时候装入内存的，其必须依赖于类的实例。

实例在装入堆栈的时候是会附加上指向method area的指针，所以可以在非静态方法中调用static方法。

3.static方法中可以通过创建（new）该类的引用或者在调用static方法的时候传递一个对象的引用过去，这种方法来调用非static方法。

典型的例子就是static void main()方法，在这个static方法中可以看到，会创建任意的实例，然后通过这些实例来调用所属类的非静态方法。

特别注意的是：由JVM的执行机制决定了在static方法中是不能直接调用该类的其它非static方法的。

因为类方法（static方法）执行的时候，其所在的堆栈中是没有指向对象的引用的任何信息的，而非static方法在调用的时候又必须要知道调用该方法的对象的引用。所以从这里可以看出，static方法中是没有办法直接调用非static方法的。

从另外一方面来讲，static方法中是不存在this的，而this是一个很重要的指向对象的引用的关键字（每个非static方法中都应该存在的，并且指向了调用该方法的对象的引用；非static方法调用改类其他方法的时候实际上是用到了this.[Method]）。所以没有this的static方法是不可能直接调用该类中的非static方法的。

二.动手动脑：编写一个方法，使用 x[n+1]=(a*x[n]+c) mod m生成指定数目(比如1000个)的随机整数

在java中，我们可以通过两种方式来获取随机数(generating a random number)一种是大家熟悉的java.lang.Math.Random()静态方法,另一种是创建java.util.Random对象。下面是两种方法的使用过程:

1)java.lang.Math.random()

在使用这一静态方法的时候，我们不需要import任何包，因为java.lang.*包是默认载入的,下面举例说面使用方法:

public class RandomTest{
    public static void main(String[] args){
        int i=Math.random();//random()会自动产生一个0.0-1.0的双精度随机数
        System.out.println(i);//输出
        i=Math.random()*1000;//产生0-1000的双精度随机数
        System.out.println(i);
        int b=(int)(Math.random()*1000);//产生0-1000的整数随机数
        System.out.println(b);
    }
}

2)创建java.util.Random对象

import java.util.random
public class RandomTest{
    public static void main(String[] args){
        Random random=new Random();//创建random对象
        int intNumber=random.nextInt();//获取一个整型数
        float floatNumber=random.nextFloat();//获取一个浮点数(0-1)
        double doubleNumber=random.nextDouble();//获取双精度数(0-1)
        boolean booleanNumber=random.nextBoolean();//获取boolean数
        System.out.println("intNumber:"+intNumber);
        System.out.println("floatNumber:"+floatNumber);
        System.out.println("doubleNumber:"+doubleNumber);
        System.out.println("booleanNumber:"+booleanNumber);
    }
}

random在产生随机数的时候使用当前的时间作为基数，我们可以通过System.currentTimeMillis()来获取这个基数。当然我们也可以指定基数:

Random random=new Random(100)，不过，同一基数所产生的随机数序列是一样的。

实现1000个随机数字的方法：

public class RandomTest{
    public static void main(String[] args){
        int z;
        for(int n=0;n<1000;n++)
        {
            int x0=(int)(Math.random()*1000);
            int a=(int)(Math.random()*1000);
            int c=(int)(Math.random()*1000);
            int m=(int)(Math.random()*1000);//产生0-1000的整数随机数  
            int y=n+1;
            z=(a*x0+c)%m;
            System.out.println(y+":"+z);
        }
    }
}

三.查看一下JDK中System.out.println()方法，你发现了什么？

System是jdk自带的一个类，他有很多的方法，这些方法都是静态的，也就是static的。System.out.print()就相当于一个函数，它之所以可以不断的重复使用，是因为它可以有不同类型的参数，不同个数的参数，参数的顺序也可以不同。

四.利用计算机计算组合数：

（1）使用组合数公式利用n！来计算

import java.math.BigInteger;
import java.util.Scanner;

public class YangHui {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("求组合数C（n,k）:(n为下标)");
        //用户输入
        System.out.print("请输入n,k：");
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int k = scan.nextInt();
        if(n<k)
        System.out.println("ERROR!");
        else if(n==0&&k==0)
        System.out.println("1");
        else
        System.out.print("C("+n+","+k+")="+Calculate(n)/Calculate(k)/Calculate(n-k));
    }
    public static long Calculate(int n) {
        if(n==1)
        {
            return 1;
        }
        
        return n*Calculate(n-1);
    }
}

（2）使用递推的方法用杨辉三角形计算

import java.util.Scanner;

public class YangHui1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("求组合数C（n,k）:(n为下标)请输入n,k:");
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int k = scan.nextInt();
        System.out.print("计算结果为："+Calculate(n,k));
    }
    public static long factorial(int a)
    {
         if(a==0||a==1) return 1;
         return a*factorial(a-1);
    }
    public static long Calculate(int n,int k)
    {
            return factorial(n)/(factorial(k)*factorial(n-k));
    }
}

（3）使用递归的方法用组合数递推公式计算

import java.util.Scanner;
public class YangHui2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("求组合数C（n,k）:(n为下标)");
        //用户输入
        System.out.print("请输入n,k：");
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int k = scan.nextInt();
        System.out.print("计算结果为："+Cal(n,k));
    }
    public static long Cal(int N , int k)  
    {     
        if(0 == k || 0 == N)  
        {  
            return 1;  
        }  
          
        if(N < k)  
        {  
            return 0;  
        }  
          
        if(N == k)  
        {  
            return 1;  
        }  
          
        return Cal(N-1,k) + Cal(N-1,k-1);  
    }  
}

四.使用递归方式判断字符串是否是回文数

import java.util.Scanner;

public class HuiWen {
    public static void main(String[] args) {
        String S=" ";
        System.out.println("请输入字符串S:");
        Scanner sc= new Scanner(System.in);
        S=sc.next();
        Judge(S);
    }
    public static void Judge(String S)
    {
        int a= S.length();//字符串的长度
        int b=0;
        if(a==1)
        {
            System.out.println("单个字符是回文字符串！");
        }
        else if(S.charAt(0)!=S.charAt(a-1))//判断确定位置的字符是否一样
        {
            System.out.println("此字符串不是回文的！");
            b=1;
        }
        else
        {
            System.out.println("此字符串是回文的！");
            b=1;
        }
        if(a-2>0&&(b!=1))
            Judge(S.substring(1,a-1));//截取从1到a-1的字符串重新存入字符串S的存储内存
    }
}