Java经典编程(流程控制篇)

1.
package com.java.liuchengkongzhi;
import java.util.Scanner;
/**
 *闰年的判断：
 *普通年（不能被100整除的年份）能被4整除的为闰年。（如2004年就是闰年，1999年不是闰年）；
 *世纪年（能被100整除的年份）能被400整除的是闰年。（如2000年是闰年，1900年不是闰年）； 
 * 
 */
public class RunNian {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查询的年份：");
        long year = sc.nextLong();
        try{
        if(year %4 == 0 && year %100 != 0 || year % 400 == 0){
            System.out.println(year+"是闰年");
        }else{
            System.out.println(year+"不是闰年");
        }
        }catch(Exception e){
            System.out.println(year+"不是有效年份");
        }
    }
}
/**
 * 知识点一:
 * 三元运算符(? :)是if else语句的一个简洁写法，可以根据需求来决定使用哪种，前者常用于赋值判断，后者常用于业务流程
 * 知识点二：
 * &与&& |与||的区别
 * &和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。
 * &&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式
 * &还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。 
 * |和||的区别同理，都可以作为逻辑或运算符；
 * |还可以作为按位或的运算符，运算规则与按位与同理；
 * ||同样有类似短路的功能，即第一个条件若为true，则不计算后面的表达式。
 */

2.
package com.java.liuchengkongzhi;
import java.util.Scanner;
/**
 * 大多数系统的登录模块都会接受用户通过键盘输入的登录信息，这些登录信息将会被登录模块验证
 * 如果使用的是指定的用户名和密码，则允许用户登录，否则将用户拒之门外，本示例通过if...else语句进行多条件判断 
 * 实现登录信息验证
 * 
 */
public class UserValidate {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        //接收用户输入登录名
        System.out.println("请输入用户登录名");
        String username = sc.nextLine();
        System.out.println("请输入登录密码");
        String password = sc.nextLine();
        //判断用户名的合法性
        if(!username.equals("ma")){
            System.out.println("用户名非法");
            //判断密码的合法性
        }else if(!password.equals("ma")){
            System.out.println("登录密码错误");
        }else{
            System.out.println("恭喜您，登录信息验证成功");
        }
    }
}

3.
package com.java.liuchengkongzhi;
import java.util.Scanner;
/**
 * 本示例根据用户输入的信息确定员工应该分配到哪个部门，实例中需要根据用户输入的信息进行多条件判断，所以使用Switch语句 
 * 
 */
public class DepartmentFP {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入员工的姓名：");
        String name = sc.nextLine();
        System.out.println("请输入新员工应聘的编程语言：");
        String language = sc.nextLine();
        //根据编程语言确定员工分配的部门
        switch(language.hashCode()){
            //java的哈希码
            case 3254818:
            //Java的哈希码  
            case 2301506:
            //JAVA的哈希码  
            case 2269730:
                System.out.println("员工"+name+"被分配到Java开发部门");
                break;
            //c#的哈希码
            case 3104:
            //C#的哈希码    
            case 2112:
                System.out.println("员工"+name+"被分配到C#项目维护组");
                break;
            //asp.net的哈希码
            case -709190099:
            //Asp.net的哈希码   
            case 955463181:
            //ASP.NET的哈希码   
            case 9745901:
                System.out.println("员工"+name+"被分配到Asp.net程序测试部");
                break;  
            default:
                System.out.println("本公司不需要"+language+"语言的程序开发人员");
        }
    }
}
/**
 * 技术点：
 * switch多分支语句的使用。该语句只支持对常量的判断，而常亮又只能是Java的基本数据类型。
 * 虽然在JDK1.7之后版本中支持对String类的字符串对象进行判断。但是是把String类的hashCode()方法返回值作为switch语法的表达式。
 * case关键字之后跟随的是各种字符串常亮的哈希码整数值。有兴趣的小伙伴可以去看一下源码 
 * 
 */

4.
package com.java.liuchengkongzhi;
/**
 * 如会员折扣制度，即对会员的消费金额进行累加，当超过一定数额时，可以享受相应的折扣。
 * 累计消费金额越多，享受的折扣越多。
 * 本示例将使用switch语句计算累计消费金额达到一定数额，享受不同的折扣价格。
 * 
 */
public class XiaoFeiLeiJia {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        float money = 1171;
        String rebate = "";
        if(money>200){
            int grade = (int)money/200;
            switch(grade){
            case 1:
                rebate = "九五折";
                break;
            case 2:
                rebate = "九折";
                break;
            case 3:
                rebate = "八五折";
                break;
            case 4:
                rebate = "八三折";
                break;
            case 5:
                rebate = "八折";
                break;
            case 6:
                rebate = "七八折";
                break;
            case 7:
                rebate = "七五折";
                break;
            case 8:
                rebate = "七三折";
                break;
            case 9:
                rebate = "七折";
                break;
            case 10:
                rebate = "六五折";
                break;
            default:
                rebate = "六折";
            }
        }
        System.out.println("您累计消费金额为："+money);
        System.out.println("您将享受"+rebate+"优惠！");
    }
}

5.
package com.java.liuchengkongzhi;
import java.util.Scanner;
/**
 * 一年有四季，每季三个月。其中，12月、1月、和2月为冬季。
 * 3月、4月和5月为春季。
 * 6月、7月和8月为夏季
 * 9月、10月、11月为秋季
 * 本示例将根据用户输入的月份进行判断季节，这是一个最典型的演示switch语法的例子。
 * 
 */
public class SeasonCompare {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查询的季节");
        int mouth = sc.nextInt();
        switch(mouth){
            case 12:
            case 1:
            case 2:
                System.out.println("您输入的月份属于冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("您输入的月份属于春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("您输入的月份属于夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("您输入的月份属于秋季");
                break;
            default:
                System.out.println("您那有"+mouth+"月份么？");
        }
    }
}
/**
 * switch语句的每一个case关键字都用于判断一个常量并作出相应的业务处理，熟练掌握switch
 * 语句之后可以组合多个case来完成多条件的处理。就是多个常量结果执行相同的业务处理
 * 
 */

6.
package com.java.liuchengkongzhi;
/**
 * 在多数情况下，
 * 
 */
public class BianLiShuZu {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] aves = new String[]{"白鹭","黄鹂","鹦鹉","乌鸦","喜鹊","布谷鸟","斑鸠"};
        //创建索引变量
        int index = 0;
        System.out.println("我的花园里有很多鸟，大约包括：");
        //遍历数组
        while(index<aves.length){
            //自增索引值
            System.out.println(aves[index++]);
        }
    }
}
/**
 * 自增自减运算符分前置和后置两种，其中，前置运算如"++index"会先将index的值递增。然后再使用递增后的值
 * 而后置运算如"index++"会首先使用该变量的值，然后再把变量值传递
 * 
 */

7.
package com.java.liuchengkongzhi;
/**
 * 杨辉三角
 * 1.杨辉三角由数字排列，可以把它看作一个数字表，其基本特性是两侧数值均为1，
 * 其他的位置的数值是其正上方的数值与左上角数值之和。本示例将使用for循环输出包括10行内容的杨辉三角
 * 
 */
public class YangHuiSanJiao {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int triangle[][] = new int[10][];
        //遍历二维数组的第一层
        for(int i = 0 ; i < triangle.length ; i++){
            //初始化第二层数组的大小
            triangle[i] = new int[i+1];
            //遍历第二层数组
            for(int j = 0 ; j <= i ; j++){
                //将两侧的数组元素赋值为1
                if(i == 0 || j == 0 || j == i){
                    triangle[i][j] = 1;
                }else{
                    triangle[i][j] = triangle[i-1][j]+triangle[i-1][j-1];
                }
                System.out.print(triangle[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

8.
package com.java.liuchengkongzhi;
/**
 *九九乘法表
 *要在控制台上输出九九乘法表，可以通过嵌套for循环来实现，即创建双层的for循环，
 *第一层for循环，也成为外循环，用来控制表格的行数
 *第二层for循环，也成为内循环，用于控制表格的列
 *其中，第一层for循环的控制变量最大值为9，第二层for循环的控制变量的最大值要等于行数的最大值
 *然后输出内层与外层循环控制变量的乘积，即可实现九九乘法表
 * 
 */
public class JiuJiuChengFaBiao {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for(int i = 1 ; i <= 9 ; i++){
            for(int j = 1 ; j <= i ; j++){
                System.out.print(j+" * "+i+" = "+j*i+"\t");
            }
            System.out.println();
        }
    }
}

9.
package com.java.liuchengkongzhi;
import java.math.BigDecimal;
/**
 *使用While循环计算1+1/2!+1/3!...1/20!
 *本示例在计算阶乘的算法之上应用while循环语句计算 1+1/2!+1/3!...1/20!的和。
 *如果使用基本数据类型double是无法精确地显示运算结果的，所以本示例使用了BigDecimal了的实例来完成这个运算
 *由于本示例的运算精度非常高，小数位数过长，默认情况下。运行结果只能显示单行的数字，所以需要对控制台进行拆行设置。
 *具体方法是，在控制台中单击鼠标右键，在弹出的快捷菜单中选择“首选项”命令。在弹出的“首选项”对话框中选中“固定宽度控制台”
 *复选框，并设置每行的最大字符数。可以采用默认的80个。(Word Wrap)然后单击“确定”按钮即可。这时，在运行本示例。
 * 
 */
public class JieChengHe {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BigDecimal sum = new BigDecimal(0.0);
        BigDecimal factorial = new BigDecimal(1.0);
        int i = 1;
        while(i<=20){
            sum = sum.add(factorial);
            ++i;
            factorial = factorial.multiply(new BigDecimal(1.0/i));
        }
        System.out.println("1+1/2!+1/3!...1/20!的计算结果等于：\n"+sum);
    }
}
/**
 *在BigDecimal中。
 *加法运算：
 *sum = sum.add(); 
 *减法运算：
 *sub = sub.subtract();
 *乘法运算：
 *mul = mul.multiply();
 *除法运算：
 *div = div.divide();
 * 
 */

10.
package com.java.liuchengkongzhi;
/**
 *本示例的目在于要求熟练掌握for循环的嵌套使用。 
 *本示例应用的主要技术是for循环语句的嵌套和if...else语句。
 *其中，if...else语句用于控制菱形中心位置不输出*号。即输出空心菱形
 * 
 */
public class KongXinLingXing {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        pointHellowRhombus(7);
    }

    public static void pointHellowRhombus(int size){
        //计算菱形大小(size只能是奇数。size是偶数，无法画出空心菱形)
        if(size % 2 == 0){
            size ++;
        }
        for(int i = 0 ; i < size/2+1 ;i++){
            //输出左上角位置的空白
            for(int j = size/2+1 ; j>i+1 ; j--){
                System.out.print(" ");
            }
            //输出菱形的上半部
            for(int j = 0 ; j < 2*i+1 ; j++){
                if(j == 0 || j == 2*i){
                    //输出菱形的上半部边缘
                    System.out.print("*");
                }else{
                    //输出菱形上半部空心
                    System.out.print(" ");
                }
            }
            //换行
            System.out.println();
        }
        for(int i = size/2+1 ; i < size ; i++){
            //输出菱形左下角空白
            for(int j = 0 ; j < i-size/2 ; j++){
                System.out.print(" ");
            }
            //输出菱形的下半部
            for(int j = 0 ; j < 2*size-1-2*i ; j++){
                if(j == 0 || j == 2*(size - i - 1)){
                    //输出菱形的下半部边缘
                    System.out.print("*");
                }else{
                    //输出菱形下半部空心
                    System.out.print(" ");
                }
            }
            //换行
            System.out.println();
        }
    }
}