java gramática básica - declaraciones de juicio, funciones, matrices

一、程序运行流行控制判断语句
1、 判断结构——if
         if语句的三种格式：
            a)  if(条件表达式)
                 {
                         执行语句；
                 }
            b)  if(条件表达式)
                {
                         执行语句；
                }
                else
                {
                          执行语句；
                }
            c)  if(条件表达式)
                {
                         执行语句；
                }
               else  if (条件表达式)
               {
                        执行语句  
               }
                ……
               else
              {
                        执行语句；
              }
              if语句特点：
    a，每一种格式都是单条语句。
        b，第二种格式与三元运算符的区别：三元运算符运算完要有值出现。好处是：可以简化if else代码。
        c，条件表达式无论写成什么样子，最终的结果不是true就是 false。

/*
 * 练习：如果用户没有填用户名，则提示“请输入姓名”,否则如果姓名长度大于10则
 *      提示“姓名长度不能大于10”  否则提示"某某某"你好
 * 
 * */

import java.util.Scanner;
public class IfTest
{
    public static void main(String[] args) 
    { 
        //键盘录入注意要放到循环外面
        Scanner sc = new Scanner(System.in);
        //循环
        while(true){

         System.out.println("请输入您的姓名:"); 
         //获取键盘录入的字符串
         String name = sc.nextLine();
         //判断条件
         if(name.length()==0) //name=="";
         {
             System.out.println("请重新输入姓名");
         }
         else if(name.length()>=10)
         {
             System.out.println("姓名长度不能大于10");
         }
         else
         {
             System.out.println(name+"欢迎您");
         }

        } 

    }

}  

2、 选择结构——switch
  switch语句格式：
                switch(表达式)
                {
                       case取值1:
                             执行语句；
                              break；
                       case取值2:
                             执行语句；
                              break；
                       …...
                      default:
                             执行语句；
                             break；
                }

/*
 * switch()
 *      多个条件合并的问题：当做个case条件的代码一样的情况下
 *      可以合并，最后加一个break；
 * 
 *      当进行单个离散值判断的时候，witch可以用来替代if
 *      switch能做的if都能做，反之不一定
 * 
 *      break意味着switch的结束标记，default详单与if的else
 *      当所有的case都不匹配的时候，执行default
 * 
 * 还是拿季节的来操练
 * 
 * */
public class SwitchTest
{
    public static void main(String[] args)
    {
        // 键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入月份我帮你分析是几月去哪里好玩");
        int month = sc.nextInt();
        // 通过switch语句对特定的值进行判断
        switch (month)
        {
        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;
        case 12:
        case 1:
        case 2:
            System.out.println("冬天去马尔代夫玩下");
            break;

        default:
            System.out.println("您输入的月份有误");
            break;
        }

    }

}

switch语句特点：
        a，switch语句选择的类型只有四种：byte，short，int， char。
        b，case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
        c，结束switch语句的两种情况：1、遇到break结束；2、执行到switch结尾结束。
        d，如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。 
注：JDK1.5以后可以接收枚举类型，JDK1.7以后可以接收字符串。
        if和switch语句很像。具体什么场景下，应用哪个语句呢？如果判断的具体数值不多，而且符合byte  short  int  char这四种类型。虽然两个语句都可以使用，建议使用switch语句，因为效率稍高。其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。 

  3、 循环结构——while，do while，for
                while语句格式：
                     while(条件表达式)
                     {
                         执行语句；
                     }
                do while语句格式：
                     do
                     {
                         执行语句；
                     }while(条件表达式);
        while和do while的区别：
                while：先判断条件，只有条件满足才执行循环体。
                do while：先执行循环体，再判断条件，条件满足，再继续执行循环体。
        简单一句话：do while：无论条件是否满足，循环体至少执行一次。
                for语句格式：
                    for(初始化表达式；循环条件表达式；循环后的操作表达式)
                    {
                         执行语句；
                    }

 /*
    需求：统计水仙花数有多少个
*/
class WhileDemo{
    public static void main(String[] args) {
            //for循环版本
         // 定义统计变量，初始化值是0
        int count = 0;
        // 3位数告诉了我们范围，用for就可以搞定，三位数初始值100，小于1000 或 <=999
        for (int i = 100; i < 1000; i++)
        {
            // 获取每一个三位数的个，十，百的数据
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 10 / 10 % 10;

            //按照要求进行判断
            if (i==(ge*ge*ge + shi*shi*shi + bai*bai*bai))
            {
                System.out.println(i);
                count++;
            }       
        }
        System.out.println("水仙花数一共有"+count+"个");


        System.out.println("------------");

        //while循环版本
        int count2 = 0;

        int y = 100;
        while(y<1000) {
            int ge = y%10;
            int shi = y/10%10;
            int bai = y/10/10%10;

            if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) {
                count2++;
            }

            y++;
        }       
        System.out.println("count2:"+count2);
    }
}   

二、函数
        定义：定义在类中的具有特定功能的一段独立小程序。也称方法。 
    格式：
        修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，…）
        {
                     执行语句；
                      return返回值；
            }
    其中：
         返回值类型：函数运行后的结果的数据类型。
         参数类型：是形式参数的数据类型。
         形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
         实际参数：传递给形式参数的具体数值。
          return：用于结束函数。
         返回值：该值会返回给调用者。
如何定义一个方法？
明确要定义的功能最后的结果是什么。
明确在定义该功能的过程中，是否需要未知内容参与运算。
函数的一个重要特性——重载(override)
  概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数列表的个数或者参数类型不同即可。
  特点：与返回值类型无关，只看参数列表。
  好处：方便于阅读，优化了程序设计。

/*
 * 重载 和可变参数的练习
 * 
 * 可变参数可以声明为各种类型：test1()(String ... values) //JDK1.5以上新特性
 * 
 * 可变参数前面还可以有其他参数，只要保证可变参数是最后一个就可以
 * 
 * */

public class MethodTest
{

    //获取int类型最大值
    public static int getMax(int[] arr)
    {
        int max = arr[0];
        for(int i=0;i<arr.length;i++)
        {
            if(arr[i]>max)
            {
                max = arr[i];
            }
        }
        return max;
    }
    //获取String类型最大值,如果长度更长就是最大值 , 方法重载，方法名可以相同，参数类型不同，与返回值无关
    public static String getMax(String[] str)
    {
        String max = str[0];
        for(int i=0;i<str.length;i++)
        {
            if(str[i].length()>max.length())
            {
                max = str[i];
            }
        }

        return max;

    } 

    //可变参数重载
    public static void test1(String ...values)
    {

    }
    public static void test2(String a ,String ... strings)
    {
        System.out.println("a="+a);
        for(int i =0;i<strings.length;i++)
        {
            System.out.println(strings[i]);
        }

    }
    public static void test3(int a,String ...nums )
    {

    }
    //计算可变参数数组之和
    public static int sum(int ... nums)
    {
        int  s= 0;
        for (int i=0;i<nums.length;i++)
        {
            s +=nums[i];
        }
        return s ;

    }


    public static void main(String[] args)
    {
        //获取数组中最大值
         int[] arr = {3,6,2,10,15,1};
          int max= getMax(arr);
         System.out.println("max="+max);

         //获取数组中长度最大值
         String[] str = {"454151515","123123","2222","8888888888"};
         System.out.println(getMax(str));

         test1("aa","bbbb");
         test2("qq","dsafqf","fwqfa");

         //可变参数计算数组的和,调用时不需要声明数组，会自动打包成数组
         int sum =  sum(1,5,10,22);
         System.out.println(sum);


    }

}

三、数组
数 组：
用于存储同一类型数据的一个容器。好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。
    如何在java中表现一个数组呢？两种表现形式。
    1）、元素类型[] 变量名 = new 元素类型[元素的个数]；
    2）、元素类型[] 变量名 = {元素1，元素2...}；
    元素类型[] 变量名 = new 元素类型[]{元素1，元素2...}；

/*
 * 1）编写一个方法，计算并返回给定int数组的和。
 * 
 * */
public class Test1
{

     public static void main(String[] args)
    {
         //定义一个数组
        int[] arr = {3,5,2,12,10}; 
        //调用方法把arr数组扔进去求和，用int类型接收输出打印
        int sum = getSum(arr);
        System.out.println(sum);
    }
     //定义一个获取数组之和的方法
     public static int getSum(int[] arr)
     {
         //初始化定义和为0
         int sum=0;
         for(int i=0;i<arr.length;i++)
         {
             sum += arr[i];//通过循环遍历出所有的元素，让元素arr[i]对应的值 累加赋给sum
         }

         return sum; //返回给调用者
     }

}

//3）编写一个方法，bool isEquals(int[] nums1,int[] nums2)，比较两个数组的内容是否完全相等(对应索引位置的元素完全相等)。

import java.util.Scanner;

public class Test3
{
    public static boolean isEquals(int[] num1, int[] num2)
    {
        // 比较两个数组的长度是否相等
        if (num1.length != num2.length)
        {
            System.out.println("该数组长度都不相等根本不用比较内容了");
            return false;
        }
        // 比较两个数组的内容是否完全相等,通过角标索引位置元素是否完全一致
        for (int i = 0; i < num1.length; i++) // 长度一样的情况下 随便使用哪个数组名称 获取长度
        {
            if (num1[i] != num2[i])
            {
                System.out.println("内容不相等");
                return false;
            }

        }

        System.out.println("内容相等");
        return true;

    }

    public static void main(String[] args)
    {

        int[] arr1 =
        { 1, 2, 3 };
        int[] arr2 =
        { 1, 2, 3 };
        boolean b = isEquals(arr1, arr2);
        System.out.println(b);
    }

}