java逻辑运算符、java基本语句(一)

---

逻辑运算符

/**
 * 逻辑运算符
 * & | ^ && || ! 
 * */
public class Demo01 {
public static void main(String[] args) {
    /**
     * & （and） 条件1 & 条件2
     * 条件1和条件2同时为true才为true
     * 语法结构：
     * boolean result =表达式A 逻辑运算符  表达式B;
     * 
     * && （短路）和&结果相同，如果左边的操作A是false，result一定为false，且不运行B的运算。
     * 
     * |（or或 ） ：表示或者，A和B都是false结果为false，只要有一个为true，结果就是true。
     * 
     * || （短路 or）：和|结果相同，具有短路效果，只要A或者B是true，结果就是true。
     * 
     *  ^（异或）：判断A和B是否不同，不同则为true，相同则为false。
     *  
     *  ！（非）取反， !true就是false。反之
     *  
     *  ~:二进制中的1换成0, 0换成1        按位取反与非的运算
     * */
    int a=2;
    int b=3;
    boolean b1=a>b & a==2;
    //boolean b1=a<b & b==3;
    System.out.println(b1);//false
    boolean b3=a>b&&a/0==2;
    System.out.println(b3);//false 
    //boolean b3=a<b && a/0==2;算术异常
    System.out.println("-------or---------");
    boolean b6=a>b|a==b;
    System.out.println("b6="+b6);//false
    boolean b7=a<b|a==b;
    System.out.println("b7="+b7);//true
    boolean b8=a>b||a==b;
    System.out.println("b8="+b8);//false
    boolean b9=a<b||a==b;
    System.out.println("b9="+b9);//true
    System.out.println("-------------------");
    System.out.println(a^b);
    位运算(最快)
    int x=10;
    int y=20;
    x=x^y;
    y=x^y;
    x=x^y;
    System.out.println("x="+x+"y="+y);//x=20 y=10

    int x1=10;
    int y1=20;
    int temp=x1;
    x1=y1;
    y1=temp;
    System.out.println("x1="+x1+"y1="+y1);//x1=20  y1=10
    //位异或：(^)都以二进制数据为基础进行的运算。同位值相同（都是0或者都是1）则为0，反之，相反。
    /**二进制
     * a:0b0000000101
     * b:0b0000000011
     * &:0b0000000001//相同为1不同为0
     * |:0b0000000111//两个位只要有一个为1，那么结果就是1，否则就为0
     * ^:0b0000000110//相同为0不同为1
     * */
    int a5=5;
    int b5=3;
    System.out.println(a5&b5);//1
    System.out.println(a5|b5);//7
    System.out.println(a5^b5);//6
    /**
     * 移位操作：
     * 将操作数的二进制码整体左移指定位数，左移之后的空使用“0”补充
     * 或者整体右移指定位数，右移之后空使用“符号位”来补充。
     * 1）如果是整数使用“0”来补充
     * 2）如果是负数使用“1”来补充
     * */
}
}

---

java基本语句

//for的使用
public class ForDemo {
public static void main(String[] args) {
    /**
     * for循环的语法结构
     * for(初始化语句：boolean;循环后的操作){
     * 循环体
     * }
     * */
    //一
    for (int i = 1; i <=100; i++) {
        System.out.println("帅哥"+i);
    }
    //二
    for (int i = 1; i <=100; i++) {
        System.out.println(i);
    }
    //三
    int sum=0;
    for (int i =0; i <=100; i++) {
        sum+=i;
    }
    System.out.println(sum);

    //从1输出到10
    for (int i = 1; i <=10; i++) {
        System.out.println(i);
    }

    int i=1;
    for(;i<=10;){
        System.out.println(i);
        i++;
    }

    int  i2=1;
    while (i2<=10) {
        System.out.println(i2);
    i2++;
    }
}
}

//while的使用
public class WhileDemo {
public static void main(String[] args) {
    /**闯关游戏
     * 第一关：喊四百声帅哥，不用复读机
     * 第二关：从一数到一百，不用复读机
     * 第三关：求100以内正整数的和
     * 第四关：求1000以内正整数的和
     * */
    /**
     * while语法结构：
     * while（Boolean表达式）{
     *  若为true，则执行
     * }
     * 注意：先判断Boolean表达式 
     * */
//  一：
    int count=1; //计数器
    while (count<=400) {
        System.out.println("帅哥"+count);
        count++;
    }
    //1----100
    int num=1;
    while (num<=100) {
        System.out.println(num);
        num++;//每次递增1
    }

    //求100以内正整数的和
    int numb=1;
    int sum=0;
    while (numb<=100) {
        sum+=numb;
        numb++;
    }
    System.out.println(sum);

//  求1000以内正整数的和
    int numb1=1;
    int sum1=0;
    while (numb1<=1000) {
        sum1+=numb1;
        numb1++;
    }
    System.out.println(sum1);
}
}
//for-for循环
public class ForForDemo {
public static void main(String[] args) {
//  需求：四个人同时从1数到100
    for (int i = 1; i <=100; i++) {
        for (int j = 0; j <=100; j++) {
            System.out.println(j);
        }
    }

    //输出矩形图案
    for (int i = 0; i <=3; i++) {
        for(int j=0;j<=5;j++){
            System.out.print("*");
        }
        System.out.println("*");
    }

    //输出三角形图案
    for (int i = 0; i <=3; i++) {
        for(int j=0;j<=i;j++){
            System.out.print("*");
        }
        System.out.println("*");
    }

    //一：使用forfor循环
    for (int i = 0; i <=3; i++) {
        for(int j=0;j<=i;j++){
            System.out.print("*");
        }
        System.out.println("*");
    }

    //二：九九乘法表
    System.out.println("------九九乘法表-----");
    for (int i = 1; i <=9; i++) {
        for(int j=1;j<=i;j++){
            System.out.print(i+"x"+j+"="+i*j+"\t");
        }
        System.out.println();
    }

public class IfDemo {
public static void main(String[] args) {
    /**
     * 顺序结构：
     * 如果代码里没有流程控制，程序是按照书写的格式从上而下一行一行执行的，
     * 一条语句执行完后继续执行下一条语句，中间没有判断和跳转，直到程序的结束。
     * */
    System.out.println("A");
    System.out.println("B");
    System.out.println("C");
    System.out.println("D");
    System.out.println("E");
    /**
     * 需求：
     * 如果使用程序描述“如果今天是周一，就上班，
     * 如果今天是周二就逛街，如果今天是周三就去公园。。。。”
     * 程序有多个条件，需要通过条件来判断的时候，就用到了if语法结构，选择语句，分支语句
     * 语法结构：
     * 第一种
     * if(boolean条件){
     * 代码/当boolean条件结果为true的时候就这行这里的代码。
     * }
     * 第二种：
     * if(boolean条件){
     *     true的代码
     * }else{
     *    false的代码
     * }
     * */
    //如果你是男的，就去男厕所
    boolean isMan=false;
    if(isMan){
        System.out.println("男厕所");
    }
    if (!isMan) {
        System.out.println("去男厕所");
    }
    System.out.println("ending");
    //求两个数的最大的数
    int a=120;
    int b=45;
    if(a>b){
        System.out.println("a最大");
    }else {
        System.out.println("b最大");
    }       
}
}
        /* 三大循环：
     仅仅是语法结构上不一样而已。
     三大循环可以相互转换，一般情况下，要是制定了循环的次数，选用for循环要方便点。
     一般习惯上选择，i,j,k,count作为循环变量
         */
//if-else
public class IfElseDemo {
public static void main(String[] args) {
    /*需求
     * 考试成绩大于90分，打印优
     * 大于80分，良
     * 大于70分，中
     * 其他情况多多努力。
     * if(){
     * 
     * }else if{
     * 
     * }
     * else{
     * 
     * }
     * */
    int score=70;
    if(score>90){
        System.out.println("优");
    }else if (score>80&&score<=90) {
        System.out.println("良");
    }else if(score>70&&score<=80){
        System.out.println("中");
    }else{
        System.out.println("请多多努力!");
    }
//如果今天是周一，就上班，
//如果今天是周二逛街
//周三 去公园
    int day=1;
    if(day==1){
        System.out.println("上班");
    }else if (day==2) {
            System.out.println("逛街");
        }else if (day==3) {
            System.out.println("去公园");
        }else{
            System.out.println("没有这天");
        }
        }
}
    /**注意点：
     * if-else结构和三元运算符的区别：
     * 1）一个是结构，一个是运算表达式
     * 2）运算表达式必须得有一个结果
     * 3）从功能上，从语义上是相同的
     * 
     * 注意
     * 1）不能写成：if（boolean）;{}
     * 2）若if的语句只有一句话，其实可以省略{}，
     * 3）对于boolean类型的表达式，不要使用boolean表达式==true的写法。
     * */

break语句： continue语句： return语句：

//break的使用
public class BreakDemo {
public static void main(String[] args) {
    //break：结束当前所在的循环
    //注意点：break之后的语句，执行不到
    //如果编写了，则语法错误
    //从1数到10，到5的时候停止
    for (int i = 1; i<= 5; i++) {
        System.out.println("i="+i);
        if (i==2) {
            break;
//      System.out.println("i="+i);
        }
    }
//打印100以内，前五个3的倍数
    int count=0;
    for (int i = 1; i <=100; i++) {
        if (i%3==0) {
        System.out.println(i);
        count++;
        }
        if (count==5) {
        break;
        }       
        }
    System.out.println(count);
}
}

//continue的使用
public class ContinueDemo {
    public static void main(String[] args) {
        /**continue
         * 表示跳过当前循环
         * 继续执行下一次循环
         * */
        //从1数到10，当数到4的时候跳过
        for (int i = 0; i <=10; i++) {
            if (i==4) {
            continue;
            }
        System.out.println(i);
        }
        //输出100到200之间能被3整除
    for (int i = 100; i <200; i++) {
        if (i%3!=0) {
        continue;
    }
     System.out.println(i);
    }
    }
}

//Return的使用
public class ReturnDemo {
  public static void main(String[] args) {
    /**return
     * 结束循环所在的方法
     * 方法结束了，循环结构自然也结束了
     * */
      for (int i = 0; i <=10; i++) {
        if (i==4) {
            break;
        }
        System.out.println(i);
    }
     System.out.println("ending"); 

   for (int i = 0; i <=10; i++) {
        if (i==4) {
        return;//直接结束main方法
        }
        System.out.println(i);
    }
     System.out.println("ending"); 
  }
}
   /**
     * break语句： continue语句： return语句： 三者的使用，区别
     * break：
     * （1）结束当前整个循环，执行当前循环下边的语句。忽略循环体中任何其他语句和循环条件测试。
     * （2）如果循环是嵌套循环，逐步使用break跳出
     * （3）break在循环体内，强行结束循环的执行，也就是结束整个循环过程，不在判断执行循环的条件
     * 是否成立，直接转向循环语句下面的语句。
     * （4）当break出现在循环体中的switch语句体内时，其作用只是跳出该switch语句体。就近原则
     * continue： 
     * （1）终止本次循环的执行，即跳过当前这次循环中continue语句后尚未执行的语句，接着进行下一次循环条件的判断。
     * （2）结束当前循环，进行下一次的循环判断。
     * （3）终止当前的循环终止当前的循环过程，但他并不跳出循环，而是继续往下判断循环条件执行语句。
     * 他只能结束循环中的一次过程，但不能终止循环继续进行。过程，但他并不跳出循环，而是继续往下
     * return：
     * （1）从当前的方法中退出，返回到该调用的方法的语句处，继续执行。
     * （2）return返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一致。
     * （3）return后面也可以不带参数，不带参数就是返回空，其实主要目的就是用于想中断函数执行，返回调用函数处。
     *  表示中止当前函数的运行，并将操作权返回给调用者。    
     *  如果是在main函数中，表示将操作权返回给操作系统。
     * */

switch语句

//switch的使用
public class SwitchDemo {
public static void main(String[] args) {
    /**
     * 根据是周一的例子来更改为switch的语法结构
     * switch的语法结构和if-elseif-else的语义相同。
     * 语法结构:
     * switch(整型表达式){
     * case A值：
     *    语句1；
     *    break；//结束
     *      语句2；
     *    break；//结束
     *    default；
     * 
     *1）程序的可读性不好，不简洁
     *2）switch更简单，功能相同
     * 语法分析以及注意：
     * 1）switch语句，一旦找到入口，就会进入
     * 并执行功能语句，后面的case不z再判断，除非语句break，或return，或执行完成穿透功能。
     * 2）switch语句中的表达式的结构类型，必须是整数类型。
     * 整数类型：int short byte long char
     * 从Java7开始，支持string类型
     * 3)default,当case中值都不成立的时候才执行，一般放到最后。
     * 
     * if-else和switch的优缺点：
     * 1）都是选择、条件语句
     * 2）对于所有的条件语句，if都可以完成
     * 3）switch语句，只能对结果是为数值的情况做判断
     * 4）当if中条件的结果是数值的时候，使用switch简单。
     * */
    int today=7;
    switch (today) {
    case 1:System.out.println("周一");break;
    case 2:System.out.println("周二");break;
    case 3:System.out.println("周三");break;
    case 4:System.out.println("周四");break;
    case 5:System.out.println("周五");break;
    case 6:System.out.println("周六");break;
    default:
        System.out.println("没有这一天");
        break;
    }

    //使用switch->char类型
    //char ='B'
    char Word='B';  //string
    switch (Word) {
    case 'A':System.out.println("A");break;
    case 'B':System.out.println("B");break;
    case 'C':System.out.println("C");break;
    case 'D':System.out.println("D");break;
    default:
        break;
    }
    //判断是工作日还是休息日
    //1-5上班 6-7休息
    int r=7;
    switch (r) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        System.out.println("工作日");
        break;
    case 6:
    case 7:
        System.out.println("休息日");
        break;
    default:
        System.out.println("没有这一天");
        break;
    }
/*  int day=6;
    if (day>=1&&day<6) {
        System.out.println("工作日");
    }else if (day>=6) {
        System.out.println("休息日");
    }*/
}
}

//控制标签

//控制外层循环
public class OuterDemo {
public static void main(String[] args) {
    /**控制外层循环：
     * 使用标签：标签用来给某个循环起的别名：
     * 标准：标签的命名得满足标识符的规范：
     * */
    outer: for (int i = 0; i <5; i++) {
        for (int j = 1; j <=4; j++) {
            if (i==3) {
                break outer;
            }
            System.out.println("i="+i+",j="+j);

        }
    }
}
}