Java学习【代码2】

day2.edu_01

package com.edu_01;

public class OperatorDemo {
    public static void main(String[] args) {
        /**
         * 快捷键：
         * tab向右缩进
         * shift+tab向左边缩进
         *  
         * 算术运算符：
            +,-,*,/,%,++,--
         */

        int a = 10;
        int b = 5;
        int c = -3;

    System.out.println(a+b);
//      System.out.println(a-b);
//      System.out.println(a*b);
//      System.out.println(a/b);
//      System.out.println(a%c);

        /**
         * 商的结果，如果除数和被除数符号相同，商为正，否则商为负
         */
        System.out.println(10/5);//快速向下复制一行：ctrl+alt+下
        System.out.println(-10/5);
        System.out.println(10/-5);
        System.out.println(-10/-5);

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

        /**
         * 余数的结果符号和被除数相同
         */
        System.out.println(10%3);
        System.out.println(-10%3);
        System.out.println(10%-3);
        System.out.println(-10%-3);

    }
}

day2.edu_02

package com.edu_01;

public class OperatorDemo2 {
    public static void main(String[] args) {
        /**
         * ++,--：自增或者自减1
         * 
         * ++或者--单独使用的时候，结果都是一样的，如果还需要进行参与运算的话，
         * 前++和后++结果是不一样的
         * 
         * 前++：先自增，再操作
         * 后++：先操作，再自增
         */
        int a = 10;
        //a++;
        //++a;

        //int b = a++;//10
        int b = ++a;//11

        System.out.println(b);  
    }
}

day2.edu_03
赋值运算符：
基本：=
扩展：+=,*=,-=,/=,%=
扩展的赋值运算符隐含了强制类型转换：
int a = 10;
a += 20;
a = (a的数据类型)(a + 20)

package com.edu_01;

public class OperatorDemo3 {
    public static void main(String[] args) {
        //多行注释：shift+ctrl+/
        /*int a = 10;
        System.out.println(a);*/

//      int a = 10;
//      a = a+5;//将之前定义的变量值和后面的数字相加，赋值给之前的变量
//      System.out.println(a);


//      int a = 10;
//      a+=5;//左边和右边进行运算之后，将结果赋值给左边，等价于a = a+5;
//      System.out.println(a);


//      int a = 10;
//      a/=5;
//      System.out.println(a);

//      short s = 10;
//      s = (short) (s+10);
//      System.out.println(s);

        System.out.println("-----------------");
        short s = 10;
        s+=10;//+=这种赋值运算会隐含一个强制类型转换
        System.out.println(s);
    }
}

day2.edu_04

package com.edu_01;

public class OperatorTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int c = 10;

        a = b++;//a=10,b=11,c=10
        c = --a;//a=9,b=11,c=9
        b = ++a;//a=10,b=10,c=9
        a = c--;//a=9,b=10,c=8

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);  
    }
}

day2.edu_05
关系运算符：
==,!=,>,>=,<,<=
注意：
A:比较运算符的结果肯定是boolean。
B:你到底是使用”=”还是使用”==”,你自己要清楚。

package com.edu_02;

public class Demo {
    public static void main(String[] args) {        
        int a= 10;
        int b = 20;
        int c = 10;

        System.out.println(a>c);
        System.out.println(a<c);
        System.out.println(a>=c);
        System.out.println(a<=c);
        System.out.println("--------------");
        System.out.println(a!=c);
        System.out.println(a=c);//将c的值赋值给a，并且打印a的值
    }
}

day2.edu_06
逻辑运算符：
&,|,!,^&&,||
注意：
逻辑运算符用于连接关系表达式
结论：
&: 有false则false
|: 有true则true
!：改变结果，取反
^：相同false,不同true

package com.edu_03;

public class Demo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        //&运算两边连接的布尔值，只要有一个为false整体结果就为fasle
        System.out.println((a>c)&(a>b));//false&false=false
        System.out.println((a<c)&(a<b));//true&true=true
        System.out.println((a>c)&(a<b));//false&true=fasle
        System.out.println((a<c)&(a>b));//true&false=false

        System.out.println("-----------------------");
        //|运算两边连接的布尔值，只要有一个为true就为true
        System.out.println((a>c)|(a>b));//false|false=false
        System.out.println((a<c)|(a<b));//true|true=true
        System.out.println((a>c)|(a<b));//false|true=true
        System.out.println((a<c)|(a>b));//true|false=true

        System.out.println("-----------------------");
        //!运算，false变true，true变false
        System.out.println(!(a>c));


        System.out.println("-----------------------");
        //^运算两边链接的布尔值，相同为false,不同为true
        //记忆：情侣关系(男男,男女,女男,女女)
        System.out.println((a>c)^(a>b));//false^false=false
        System.out.println((a<c)^(a<b));//true^true=fasle
        System.out.println((a>c)^(a<b));//false^true=true
        System.out.println((a<c)^(a>b));//true^false=true
    }
}

day2.edu_07
&&和||与&和|的区别:
从执行结果上来说：两者没有任何其别
区别：&&和||会有一个短路效果

package com.edu_03;

public class Demo2 {
    public static void main(String[] args) {        
        int a = 10;
        int b = 20;
        int c = 30;

        System.out.println((a>c)&&(a>b));//false&&false=false
        System.out.println((a<c)&&(a<b));//true&&true=true
        System.out.println((a>c)&&(a<b));//false&&true=fasle
        System.out.println((a<c)&&(a>b));//true&&false=false

        System.out.println("-----------------------");
        //|运算两边连接的布尔值，只要有一个为true就为true
        System.out.println((a>c)||(a>b));//false||false=false
        System.out.println((a<c)||(a<b));//true||true=true
        System.out.println((a>c)||(a<b));//false||true=true
        System.out.println((a<c)||(a>b));//true||false=true

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

        int x = 3;
        int y = 4;
        //System.out.println(x++>3&&y++>4);
        //false&&   =fasle,&&会存在一个短路效果，前面链接的布尔值为fasle，
        //整体就为fasle，所以后面的判断不执行
        System.out.println(x);//4
        System.out.println(y);//4


        System.out.println(x++>3||y++>4);
        //||运算链接的布尔值，如果前面的布尔值为true，连接的整体结果就为true，后面的不执行
        System.out.println(x);//4
        System.out.println(y);//5
    }
}

day2.edu_08
操作数据的个数。
三元运算符：
格式：?:
(比较表达式)?表达式1:表达式2；
执行流程：
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
需求：获取两个数据中的最大值
嵌套使用(获取三个数的最大值)

package com.edu_04;

public class Demo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        //使用三目运算符求出a,b之间的最大值
        int max = (a>b)?a:b;
        System.out.println(max);

        //嵌套使用(获取三个数的最大值)
        int temp = (a>b)?a:b;
        max = (temp>c)?temp:c;
        System.out.println(max);
    }
}

day2.edu_09
键盘录入三部曲：
1.导包 import java.util.Scanner,导包一定是在class之前
2.创建键盘录入对象 Scanner sc = new Scanner(System.in);
3.使用方法nextInt(),获取键盘录入的数值(整数)

package com.edu_05;
import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        //2.创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //3.获取键盘录入数据,程序在此阻塞，等待接受键盘录入
        int num = sc.nextInt();

        //4.打印键盘录入到的数据
        System.out.println(num);
    }
}

day2.edu_10
需求：键盘录入两个数据，获取这两个数据中的最大值

package com.edu_05;
//1.导包
import java.util.Scanner;
public class ScannerDemo2 {
    public static void main(String[] args) {
        //2.创建键盘录入对象
        Scanner sc  = new Scanner(System.in);

        //3.接受键盘录入数据
        System.out.println("请输入第一个数字");
        int a = sc.nextInt();

        System.out.println("请输入第二个数字");
        int b = sc.nextInt();

        //接受完键盘录入数据之后，后进行比较
        System.out.println((a>b)?a:b);
    }
}

day2.edu_11
需求：键盘录入两个数据，比较这两个数据是否相等

package com.edu_05;
import java.util.Scanner;
public class ScannerDemo3 {
    public static void main(String[] args) {
        /**
         * 键盘录入三部曲：
         * 1.导包
         * 2.创建键盘录入对象
         * 3.获取键盘录入数据
         */
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入第一个数据");
        int a = sc.nextInt();
        System.out.println("请输入第二个数据");
        int b = sc.nextInt();

        System.out.println(a==b);
    }
}

day2.edu_12
顺序结构：代码从上至下依次执行

package com.edu_06;

public class Demo {
    public static void main(String[] args) {
        //顺序结构：代码从上至下依次执行
        System.out.println("加油");
        System.out.println("好好学习");
        System.out.println("天天向上");
    }
}

day2.edu_13
if语句格式1：
if(比较表达式) {
语句体
}
执行流程：
首先判断比较表达式看其结果是true还是false
如果是true就执行语句体
如果是false就不执行语句体
需求：1.如果我得了100分爸爸就给我买飞机
2.如果数字是10，就输出10这个数字
if语句的注意事项：
A:比较表达式无论简单还是复杂，结果必须是boolean类型
B:一般来说：
有左大括号就没有分号，有分号就没有左大括号

package com.edu_07;

public class IfDemo {
    public static void main(String[] args) {
        //1.如果我得了100分爸爸就给我买飞机
        int score = 90;
        if(score==100){
            System.out.println("老爸答应我买一架飞机");
        }

        //2.如果数字是10，就输出10这个数字
        int num = 9;
        if(num==10){
            System.out.println(num);
        }
    }
}

day2.edu_14
if语句格式2：
if(比较表达式) {
语句体1;
}else {
语句体2;
}
执行流程：
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体1
如果是false就执行语句体2
需求：1.判断两个数的最大值（用if和三元实现）
2.判断两个数是否相等（用if和三元实现）

package com.edu_07;

public class IfDemo2 {
    public static void main(String[] args) {
        //需求：1.判断两个数的最大值（用if和三元实现）
        int a = 10;
        int b = 20;
        //alt+/,自动补全代码
        if (a>b) {
            System.out.println(a);
        }else {
            System.out.println(b);
        }

        //2.判断两个数是否相等（用if和三元实现）
        if(a==b){
            System.out.println("两数相等");
        }else{
            System.out.println("两数不等");
        }

        System.out.println("--------------");
        boolean flag = (a==b)?true:false;
        System.out.println(flag);
    }
}

day2.edu_15
if语句格式3：
if(比较表达式1) {
语句体1;
}else if (比较表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
执行流程：
首先判断关系表达式1看其结果是true还是false
如果是true就执行语句体1
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句体2
如果是false就继续判断关系表达式…看其结果是true还是false
…
如果没有任何关系表达式为true，就执行语句体n+1。
需求：
键盘录入学生成绩，根据学生成绩判断，输出学生等级
90-100 A
80-89 B
70-79 C
60-69 D
60以下 E

package com.edu_07;

import java.util.Scanner;

public class IfDemo3 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //获取键盘录入数据
        System.out.println("请输入你的学生成绩");
        int score = sc.nextInt();

        //拿到成绩使用if做判断
        if(score>=90&&score<=100){
            System.out.println("成绩等级是A");
        }else if(score>=80&&score<=89){
            System.out.println("成绩等级是B");
        }else if (score>=70&&score<=79) {
            System.out.println("成绩等级是C");
        }else if(score>=60&&score<=69){
            System.out.println("成绩等级是D");
        }else if (score>=0&&score<60) {
            System.out.println("不及格");
        }else {
            System.out.println("输入成绩不再考核范围内");
        }
    }
}

day2.edu_16
需求：键盘录入x的值，计算出y的并输出。
x>=3 y = 2x + 1;
-1<=x<3 y = 2x;
x<=-1 y = 2x – 1;

package com.edu_07;
import java.util.Scanner;

public class IfDemo4 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //获取键盘录入数据
        System.out.println("请输入数字");
        int num = sc.nextInt();//先写右边，自动补全左边，快捷键ctrl+1+回车

        if (num>=3) {
            System.out.println(2*num+1);
        }else if (num>=-1&&num<3) {
            System.out.println(2*num);
        }else {
            System.out.println(2*num-1);
        }
    }
}

day2.edu_17
需求：键盘录入月份的值，输出对应的季节。
春 3,4,5
夏 6,7,8
秋 9,10,11
冬 12,1,2

package com.edu_07;

import java.util.Scanner;
public class IfDemo5 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //接受键盘录入数据
        System.out.println("请输入月份值");
        int month = sc.nextInt();

        //拿着月份值做判断
        if (month==3||month==4||month==5) {
            System.out.println("春天");
        }else if (month==6||month==7||month==8) {
            System.out.println("夏天");
        }else if (month==9||month==10||month==11) {
            System.out.println("秋天");
        }else if (month==12||month==1||month==2) {
            System.out.println("冬天");
        }
    }
}

day2.edu_18
获取三个数据中的最大值
if语句的嵌套。
if() {
if语句
}

package com.edu_07;

public class IfDemo6 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        if (a>b) {
            //a大
            if (a>c) {
                System.out.println(a);
            }else {
                System.out.println(c);
            }

        }else {
            //b大
            if (b>c) {
                System.out.println(b);
            }else {
                System.out.println(c);
            }
        }
    }
}

day2.edu_19
switch语句的格式：
switch(表达式) {
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default：
语句体n+1;
break;
}
格式解释：
A:switch表示这是switch语句
B:表达式
表达式的取值：byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是String
C:case后面跟的是要和表达式进行比较的值
D:语句体部分可以是一条或多条语句
E:break表示中断，结束的意思，可以结束switch语句
F:default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
执行流程：
首先计算出表达式的值
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
需求：
键盘录入一个数字(1-7),输出对应的星期几。

package com.edu_08;
import java.util.Scanner;

public class SwitchDemo {
    public static void main(String[] args) {
        int a = 4;

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //获取键盘录入数据
        System.out.println("请输入数字");
        int day = sc.nextInt();

        switch(day){
        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;
            /**
             * break不建议省略，因为会出现 case穿透：
             * case穿透：省略了break，程序在执行过程中没有遇见break之前是不会停止的
             * 程序会继续向下执行，直到遇见下一个break，程序才会停止
             */
        case 6:
            System.out.println("星期六");
            break;
        case 7:
            System.out.println("星期日");
            break;
        default:
            System.out.println("您输入的数据不存在");
            break;
        }   
    }
}

day2.edu_20
用switch语句实现键盘录入月份，输出对应的季节

package com.edu_08;

import java.util.Scanner;
public class SwitchDemo2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        //接受键盘录入数据
        int month = sc.nextInt();

        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;
        }   
    }
}

day2.edu_21
模拟做单项选择题，根据你的选择，给出对应的答案。(表达式是字符的情况)

package com.edu_08;

public class SwitchDemo3 {
    public static void main(String[] args) {
        char choice = 'R';

        switch(choice){
        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:
            System.out.println("您的选项有点过分了");
            break;
        }   
    }
}

day2.edu_22
for循环：
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
执行流程：
A:执行初始化语句
B:执行判断条件语句
如果是true：就继续执行。
如果是false：就结束循环。
C:执行循环体语句
D:执行控制条件语句
E:回到B
执行次数：
A:初始化语句
只执行一次
B:判断条件语句
一次以上
C:循环体语句和控制条件语句
0次以上
需求：使用for循环打印10次helloworld

package com.edu_09;

public class ForDemo2 {
    public static void main(String[] args) {
        for(int i = 0;i<10;i++){
            System.out.println("helloworld");
        }
    }
}

day2.edu_23
需求：
A:请在控制台输出数据1-10
B:请在控制台输出数据10-1

package com.edu_09;

public class ForDemo3 {
    public static void main(String[] args) {
        //A:请在控制台输出数据1-10
//      for(int i =1;i<=10;i++){
//          System.out.println(i);
//      }

        //B:请在控制台输出数据10-1
        for(int i =10;i>=1;i--){
            System.out.println(i);
        }
    }
}

day2.edu_24
求出1-100之间数据之和
1.遍历1-100之间的每一个数字
2.将每一个数字加起来

package com.edu_09;

public class ForDemo4 {
    public static void main(String[] args) {
        int sum = 0;
        for(int i =1;i<=100;i++){
            //System.out.println(i);
            //sum = sum + i;
            sum+=i;
        }

        System.out.println(sum);
    }
}

day2.edu_25
需求：求出1-100之间偶数和
1.遍历出1-100之间的没一个数字
2.判断偶数
3.将偶数进行累加

package com.edu_09;

public class ForDemo5 {
    public static void main(String[] args) {
        int sum = 0;
        for(int i = 1;i<=100;i++){
            //取余操作，判断偶数
            if (i%2==0) {
                sum+=i;
            }
        }

        System.out.println(sum);
    }
}

day.edu_26
需求：求5的阶乘
规则：
n! = n*(n-1)(n-2)…*3*2*1

package com.edu_09;

public class ForDemo6 {
    public static void main(String[] args) {
        int sum = 1;
        for(int i = 1;i<=5;i++){
            //累乘
            sum*=i;
        }
        System.out.println(sum);
    }
}

day2.edu_27
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
执行流程：
A:执行初始化语句
B:执行判断条件语句
如果是true：就继续执行。
如果是false：就结束循环。
C:执行循环体语句
D:执行控制条件语句
E:回到B
需求：请在控制台输出10次”HelloWorld”

package com.edu_10;

public class WhileDemo {
    public static void main(String[] args) {
        //初始化语句
        int i = 0;
        //条件判断语句
        while(i<10){
            //循环语句
            System.out.println("helloworkd");
            //控制条件语句
            i++;
        }       
    }
}

day2.edu_28
需求：利用while语句求出1-100之间偶数和

package com.edu_10;

public class WhileDemo2 {
    public static void main(String[] args) {
        int i = 1;
        int sum = 0;
        while (i<=100) {
            if (i%2==0) {
                sum+=i;
            }
            i++;
        }
        System.out.println(sum);
    }
}

day2.edu_29
我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。
请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?

package com.edu_10;

public class WhileDemo3 {
    public static void main(String[] args) {
        int end = 884800;
        int start = 1;
        int count = 0;

        while (start<end) {
            start*=2;
            count++;
        }

        System.out.println(count);
    }
}

day2.edu_30
控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，
而while循环结束还可以继续使用，如果你想继续使用，就用while，
否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。

package com.edu_10;

public class WhileFor {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }

        //想要用到for循环中的i变量,是引用不到的
        //System.out.println(i);
        System.out.println("-----------");

        /*int i  = 0;
        while (i<10) {
            System.out.println(i);
            i++;
        }

        System.out.println(i);*/
    }
}

day2.edu_31
do…while的格式：
do {
循环体语句;
}while((判断条件语句);
变形格式：
初始化语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
执行流程：
A:执行初始化语句
B:执行循环体语句
C:执行控制条件语句
D:执行判断条件语句
如果是true：就继续执行。
如果是false：就结束循环。
E:回到B
需求：使用do…while循环打印10次helloworlkd

package com.edu_11;

public class DoWhile {
    public static void main(String[] args) {
        int i  = 0;
        do{
            System.out.println("helloworld");
            i++;
        }while(i<10);

    }
}

day2.edu_32
break的使用场景：
A:在选择结构switch语句中
B:在循环语句中
注意：
离开使用场景的存在是没有意义的
break:
遇到break,就中断整个循环。
默认情况下，break只能中断它所属的那个循环。

package com.edu_12;

public class BreakDemo {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i==5) {
                break;//可以中断整个循环体
            }
            System.out.println(i);
        }

    }

}

day2.edu_33
continue的使用场景：
在循环语句中
注意：
离开使用场景的存在是没有意义的

            continue  退出本次循环

package com.edu_12;

public class ContinueDemo {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i==5) {
                continue;//中断本次循环，并不是中断整个循环
            }
            System.out.println(i);
        }   
    }
}