从零开始学java (运算符,流程控制,数组)

拜拜、爱过 提交于 2020-02-19 05:39:51

运算符

  运算符是一种特殊符号,用来表示数据的运算、赋值和比较等。

  java中的运算符可分为一下几种:

  1.赋值运算符

  2.算术运算符

  3.比较运算符

  4.逻辑运算符

  5.位运算符

  6.三目运算符(不是三目童子!)

  赋值运算符:

    java的赋值运算符用作与为变量指定变量值,赋值预算符 符号是 "=" ;

    

    这段程序要从右向左看,计算机是先计算出右边数据,再给左边赋值!

 

  算术运算符:

    java的算术运算符比较好理解, 加(+/++)、减(-/--)、乘(*)、除(/)、求余(%)

/**
 * 运算
 * @author GMZ
 * 
 */
public class Computations {
    
    public static void main(String[] args) {
        //这一步先不管
        Computations c = new Computations();
        
        //声明并给变量赋值
        double num_a = 5.2;
        double num_b = 3.1;
        
        
        System.out.println(c.plus(num_a,num_b));//相加     8.3
        System.out.println(c.reduce(num_a,num_b));//相减 2.1
        System.out.println(c.except(num_a,num_b));//除 大约 1.7
        System.out.println(c.ride(num_a,num_b));//乘  16.12
        System.out.println(c.remain(num_a,num_b));//取余  2.1
        
    }
    /**
     * 求和      "+" 号运算符
     * @param num_a 
     * @param num_b 
     * @return 
     */
    public double plus(double num_a,double num_b){
        double sum = 0;
        //相加 并获得结果,赋值与sum
        sum = num_a + num_b;
        return sum;
    }
    
    /**
     * 减      "-" 号运算符
     * @param num_a 
     * @param num_b 
     * @return 
     */
    public double reduce(double num_a,double num_b){
        double resultNum = 0;
        //相减 并获得结果,赋值与resultNum
        resultNum = num_a - num_b;
        return resultNum;
    }

    /**
     * 除     "/" 号运算符
     * @param num_a 
     * @param num_b 
     * @return 
     */
    public double except(double num_a,double num_b){
        double resultNum = 0;
        //相除 并获得结果,赋值与resultNum
        resultNum = num_a / num_b;
        return resultNum;
    }
    
    /**
     * 乘     "*" 号运算符
     * @param num_a 
     * @param num_b 
     * @return 
     */
    public double ride(double num_a,double num_b){
        double resultNum = 0;
        //相乘 并获得结果,赋值与resultNum
        resultNum = num_a * num_b;
        return resultNum;
    }
    
    /**
     * 取余     "%" 号运算符
     * @param num_a 
     * @param num_b 
     * @return 
     */
    public double remain(double num_a,double num_b){
        double resultNum = 0;
        //取余 并获得结果,赋值与resultNum
        resultNum = num_a % num_b;
        return resultNum;
    }

  其实还有两个比较常用的,也就是自加与自减:

/**
 * 运算Demo
 * @author GMZ
 *
 */
public class Computation {

    public static void main(String[] args) {
            int num_a = 5;
            int num_b = 2;
            System.out.println(num_a++);// a 自加 结果6 ++在后
            System.out.println(++num_a);// a 自加 结果6 ++在前
            
            System.out.println(num_b--);// b 自减 结果1 ++在后
            System.out.println(--num_b);// b 自减 结果1 ++在前
            
            
            // ++ 与 -- 同理
            int resultNum = 0;
            //这个是     a先执行自加(++)    然后与b 相加
            resultNum = ++num_a + num_b;
            System.out.println(resultNum); // 结果为  8
            //这个是     a先与b执行相加      然后进行自加 
            resultNum = num_a++ + num_b;  // 结果为  8
    }
}

   比较运算符:

    java中的比较运算符与常见的比较符大多一样(除了相等)。>(大于)、<(小于)、  ==(等于)、 >=(大于等于)、 <=(小于等于)、 !=(不等)

  逻辑预算符:

    逻辑预算符 包括有 或("||" / "|")、与("&&" / "&")、非("!")以及异或("^");

    一般逻辑运算符是和比较运算符一起用的,||与|的区别 和 &&与&的区别一样,后者不短路,简单来说 例:一个表达式(1 > 2 && 1 < 5 )和(1 > 2 & 1 < 5)其最后的作用是一样的,但是前者第一个条件也就是1>2不  成立,为false时 前者则不在去运算后面的1<5 而后者则是不管前面条件成立与否,一样计算后面的表达式 及1<5,但是结果一样。具体运用场景在以后会慢慢掌握。

  

  位运算符:

    位运算符在这里不多讲,因为运用的不多,有兴趣的可以留言,人多的话,我单独拿出来一期做位运算符,这里就知道它是可以算术运算符和赋值运算符结合,从而可以扩展为强大的运算符。

  

  三目运算符:

    三目运算符的语法为 (expression) ? if-true-statement : if-false-statement   这样看比较乱 直接 上代码

    三目运算符在工作中使用的还是比较多的(当然也可以被替代),三目还有更复杂的比如三目中的三目,多重三目。有兴趣可以自己敲一下

  

在运算符这里,有几个小知识点,

  不要把一个表达式写的太复杂,第一是不便于自己去维护,更不便于别人去读你的代码,如果是一个很负责的表达式,你可以拆开来写,尽量简化

  不要以来运算符的优先级去去控制表达式执行顺序,尽量使用()去控制它的执行顺序。下面附上运算符的执行顺序表以上到下等级也是如此

            

 

流程控制

   先来说说流程控制吧,不管哪种语言都是有流程控制的,而且都会提供两种基本控制结构:分支结构和循环结构。

  简单来说:分支结构就是,我今天吃了早饭 就去上学,没吃就不去。吃或者没吃就是条件,去或者不去就是结果,根据条件去选择结果。

  分支结构:

/**
 * 流程控制
 * @author GMZ
 *
 */
public class Control {

    public static void main(String[] args) {
        int a = 20;
        int b = 10;
        
        
        
        //第一种
        /*
         *if(logic expression)
         *{
         * statement..
         *} 
         */
        if(a > 30){
            //打印一句话
            System.out.println("假如a大于30我就执行了!");
            //可是表达式 a>30 返回的结果是false 所以这句话并没有执行
        }
        
        
        //第二种
        /*
         *if(logic expression)
         *{
         * statement..
         *} else {
         * statement...
         *}
         */
        if(a > 30){
            //打印一句话
            System.out.println("假如a大于30我就执行了!");
            //可是表达式 a>30 返回的结果是false 所以这句话并没有执行
        } else {
            //打印一句话
            System.out.println("假如a大于30不成立(即返回值是false时)我就执行了!");
            //这个时候就执行了这句话
        }
        //第三种
        /*
         *if(logic expression)
         *{
         * statement..
         *} else if(logic expression) {
         * statement...
         *}....后面可以添加无数个else if()
         */
        a = 45;
        if(a > 20){
            System.out.println("当a大于20小于等于40时,我执行!");
        }else if(a > 40){
            System.out.println("当a大于40小于等于60时,我执行!");
        }else if(a > 60){
            System.out.println("当a大于60时,我执行!");
            
        }
        
    }
}

 下面是switch分支语句,

  switch语句由一个控制表达式和多个case标签组成,与if语句不同的是,switch语句后面的控制表达式的数据类型只能是byte、short、char、int四种整数类型,枚举类型和java.lang.String类型(从java7版本后才允许String),不能用boolean类型。

  语法:

  switch(expression)

                            {

                            case  condition1:

                                     {

                                               statement(s)

                                               break;

          }

        case  condition2:

                                     {

                                               statement(s)

                                               break;

          }

        case  conditionN:

                                     {

                                               statement(s)

                                               break;

          }

                     Default:{

                 Statement(s)

          }

}

看着很烦、冗长,直接来代码把。 

    //switch结构
        
        String index="1";
        switch(index){ //这里的index 可以是 String、 byte、short、char、int类型的变量
        case "1":  //第一个条件
            System.out.println("这里写匹配到\"1\"后,所做的操作!");
            break;
        case "2":  //第二年个条件
            System.out.println("这里写匹配到\"2\"后,所做的操作!");
            break;
        case "3":  //第三个条件
            System.out.println("这里写匹配到\"3\"后,所做的操作!");
            break;
        default:
            System.out.println("当index的值不存在任何一个条件可以匹配时,走这里!");
            break;
        }

  循环结构:

//while循环
        
        while(1==1)//这里写while循环表达式,如果返回值是true则进入循环体,反之则程序向下执行
        {
            System.out.println("如果表达式成立,我就打印啦!(现在1==1肯定是true 所以当前是无限循环!)");
        }
        
        // do while循环
        
        do 
        {
            System.out.println("无论如何我肯定执行一次!后判断表达式的结果是否是true,如果是则继续执行");
            System.out.println("与while不同的是,do while 是一定执行一次。后面与while 无异");        
        } while (1==1);
        
        
        //for循环
        //for循环的表达式与其他两个不同
        //下面三个用分号分开的分别是:初始条件、循环条件、循环迭代语句
        for (int i = 0; i < 5; i++)
        {
            System.out.println("我们的初始条件是0,每次我打印一次,i就会自加1,直到i>=5的时候,这个循环体 就会停止循环");
        }
        //那个while与do while也可以迭代,但是迭代是在循环体内
        
        int index_num=1;
        while(1==1)
        {
            index_num++;
            //这段代码意思是循环每执行一次,num就自加1 直到 num>=5的时候跳出这个循环体,
            //这里我们用了一个break关键字,去跳出循环体   do while与这个相同。
            //break的意思可以理解为,代码执行到它那里,它会跳出当前的循环体,关键词当前的循环体!!!!!!
            if(index_num>=5){
                break;
            }
            //还有个关键字也是与循环体有关的
            //continue关键字的意思是,当代码执行到它,循环回到开头,即回到表达式处,继续计算表达式,继续执行代码块
            //也就是它是跳过,它下面的代码继续执行循环体。
            //break则是直接跳出循环体,不在执行当前循环体。
            if(index_num == 3){
                continue;
            }
            System.out.println("================>我执行啦!!");
        }

 

数组

  数组是编程语言中最常见的一种数据结构,来用于储存多个数据。每个数组元素存放一个数据。通常可通过数组元素的索引(也可以理解为下标)来访问数组元素,包括为数组的元素赋值和取出数组元素的值。

  其实可以理解数组是一种数据类型,因为java中的数组要求数组的元素具有相同的数据类型,所以呢在一个数组中元素的数据类型是唯一的。也就说一个数组中只能储存一种数据类型的数据,不能储存多种数据类型。

  本来这期是打算把数组做完的,但是看到了数组可能用到了面对对象的思想,更是用到的了java的继承与多态,所以放到下一期专做一期。

  (最近可不是犯懒啊,是有些事耽搁了,而且带不了电脑。过两天可能就比较忙了,要新做一个公众号开发 - -! 加油!)

 

  

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!