Java练习题总结

注意：我的程序编写环境为  wind7； 64位； jdk：10.0.2,； VSCodeUserSetup-x64-1.26.1 编辑器

1.使用for循环打印乘法口诀表

// Tables.java

public class Tables
{
    public static void main(String[] args){
        int i,j;
        for(i=1; i<=9; i++){
            for(j=1; j<=i; j++){
                System.out.print(j+"*"+i+"="+(i*j)+"\t");
            }
            System.out.println();
        }
    }
}

2. 递归实现20！

// Factorial.java

public class Factorial
{
    public static long Factor(int n){
        if(n == 1){
            return 1L;
        }
        else{
        return n*Factor(n-1);
        }
    }
    public static void main(String[] args){
        System.out.print(Factor(20));
    }
}

3. 使用递归实现快速排序(Java实现) 

// QuickSort_1.java

public class QuickSort_1{
    public static int Partition(int[] arr, int start,int end){
        int key = arr[start];
        while(start < end){
            while (arr[end]>=key && end>start){
                end--;
            }
            arr[start] = arr[end];
            while(arr[start]<=key && end>start){
                start++;
            }
        }
        arr[end] = arr[start];
        return start;
    }

    public static void quickSort(int[] arr, int start, int end){
        if(start < end){
            int index = Partition(arr, start, end);
            quickSort(arr, start, index-1);
            quickSort(arr, index+1, end);
        }
    }

    public static void main(String[] args){
        int[] data = new int[]{1,3,2,9,7,4,6,8,20,17,25,21};
        quickSort(data, 0, data.length-1);
        for(int temp : data){
            System.out.print(temp+", ");
        }
    }
}

4. 使用数组静态初始化方式初始化一个大小为10的整型数组并输出。

// ArrayInit.java

public class ArrayInit
{
    public static void main(String[] args){
        int[] Array = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        int i = 0;
        for(i=0; i<10 ;i++){
            System.out.print(Array[i]+"  ");
        }
    }
}

5.创建一个Test类，包含有一个public权限的int型成员变量与一个char类型的成员变量，观察在main方法中的初始值。

// Test.java

class Persion{
    public int num;
    public String fruit;
    public void number(){
        System.out.println(fruit+"的数量是："+num);
    }
} 

public class Test
{
    public static void main(String[] args){
        Persion x = new Persion();
        x.num = 100;
        x.fruit = "apple";
        x.number();
        
        Persion y = new Persion();
        y.num = 200;
        y.fruit = "peach";
        y.number();
    }
}

6. 一个斐波那契数列是由数字 1、1、2、3、5、8、13、21、34 等等组成的，其中每一一个数字(从第三个数字起)都是前两个数字的和创建一个方法，接受一个整数参数，并显示从第-一个元素开始总共由该参数指定的个数所构成的所有斐波那契数字。例如，如果运行java Fibonacci 5(Fibonacci为类名)，那么输出应该是1、1、2、3、5。

// Fibonacci.java

import java.util.Scanner;
public class Fibonacci
{
    public static void main(String[] args){
        @SuppressWarnings("resource")
        Scanner in = new Scanner( System.in );
		int i = in.nextInt();
       // int i = Inter.parseInt(args[0]);
        for(int j=1; j<=i; j++){
            System.out.print(Fib(j)+"  ");
        }
    }

    public static int Fib(int i)
    {
        if(i<=0){
            return 0;
        }
        else if(i<3){
            return 1;
        }
        else{
            return Fib(i-2)+Fib(i-1);
        }
    }
}

3. 创建-一个带默认构造方法  (即无参构造)的类，在构造方法中打印一条消息"Hello Constructor"；再为这个类添加一一个重载构造方法，令其接收一个字符串参数，并在这个有参构造方法中把"Hello Constructor"和接收的参数一起打印出来。

// Parameter.java

class para
{
    //无参构造
    public para(){
        System.out.println("Hello Constructor");
    }
    //有参构造
    public para(String str){
        this();
        System.out.println(str);
    }
}

public class Parameter
{
    public static void main(String[] args){
        new para();
    }
}