关键字和保留字

关键字：被 Java 语言赋予了特殊含义，用作专门用途的 字符串 （单词），所有字母都小写

保留字：go、 const

标识符

比如：类名、变量名、方法名、接口名、函数名、包名（自己起名的地方）

命名规则：

• 由26个英文字母大小写、0-9、_或$
• 不可以使用关键字和保留字，可以包含
• 严格区分大小写，长度无限制
• 不能以数字开头
• 不能包含空格

命名规范：

• 包名：多单词组成时所有字母都小写：xxxyyyzzz
• 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
• 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

变量

• 格式：数据类型 变量名 = 变量值；
• 变量必须先声明，后使用
• 变量都定义在其作用域内，只能在作用域内使用
• 同一个作用域，不可声明两个名称相同的变量
• 成员变量和局部变量

数据类型

基本数据类型

• byte ： 整型 1字节（8bit位） -128~127
• short ：整型 2字节
• int： 整型 4字节 默认为Int型，通常也声明为Int型，
• long： 整型 8字节 声明时要以l或L结尾
• float： 浮点型 单精度（7位 有效数字 ） 4字节 声明时要以f或F结尾
• double：浮点型 双精度（14位有效数字） 8字节 默认为double型，通常也声明为double型
• char：字符型 2字节，使用’ ‘；有且只能放一个， 转义字符
• boolean ：布尔型 true、false，常在条件判断、 循环语句 中使用

引用数据类型

• 类class
• 接口interface
• 数组array

自动类型提升：byte\short\char–> Int –>long–>float–>double

byte,short, char 之间不会相互转换，他们三者在计算时首先转换为int类型。

强制类型转换：(int)12.3>>12 ;可能造成精度降低或溢出

 public class Variable2 {
    public  static   void  main(String[] args){
        //自动类型提升
        short a = 1;
        char b = 'a';
        int c = a + b;
        System.out.println(c);//98
        
        char a1 = 'A';
        char a2 = 65;//编译通过 A
        double b1 = a1;
        System.out.println(b1);//65.0
        
        //强制类型转换
        double d = 12.8;//截断,精度损失
        int e = (int)d;
        System.out.println(e);//12
        System.out.println((int)12.3);//12
        
        int d1 = 128;
        byte e1 = (byte)d1;
        System.out.println(e1);//-128
        
        //要注意的编码情况
        long l = 123456;//定义 long 类型时不加l默认为int型,int转换为long
        System.out.println(l);//123456 123456默认为Int，会强制转换为long
        long l1 = 12345678910;//编译失败，12345678910超过Int范围
        long l2 = 12345678910l;//编译成功
        System.out.println(l2);//12345678910
        
        byte by = 12;
        byte by1 = by + 1;//编译失败  byte计算时会自动转换为Int
        
        float f = 12.3;//编译失败，不加f默认为double型不能自动转换为float
        float f1 = 12.3f;//编译成功
    }
}  

String 变量类型

• String属于引用数据类型，翻译为字符串
• 声明 string 类型变量时，使用“”
• String可以和8种基本数据类型变量做运算，且只能是连接运算：+，运算结果是String类型

 public class stringtest {
        public static void main(String[] args){
            //计算时只要有String型，结果就全为String型
            //string练习1
            char c = 'a';
            int num = 10;
            String str = "wangwei";
            System.out.println(c + num + str);//107wangwei
            System.out.println(c + str + num);//awangwei10
            System.out.println(c + (num + str));//a10wangwei
            System.out.println(str + num + c);//wangwei10a
            System.out.println(str + (num + c));//wangwei107
            
            //string练习2
            System.out.println("*   *");//* *
            System.out.println('*' + '\t' + '*');//93
            System.out.println('*' + "\t" + '*');//*  *
            System.out.println('*' + '\t' + "*");//51*
            System.out.println('*' + ('\t' + "*"));//*  * 
            
            char c1 = '';//编译不通过
            String str1 = "";//编译通过
            String str2 = abc;//编译不通过
            String str3 = abc + "";//编译通过
            String str3 = 3.5f + "" + 1;//3.51
        }
    }  

转义字符：

• \b：退格符
• \n：换行符
• \r：回车符
• \t： 制表符
• \”： 双引号
• \’： 单引号
• \\： 反斜线

字符集

0~31及127：控制字符或通信专用字符

48~57：0-9

65~90：A-Z

97~122：a-z

进制 （了解）

• 计算机底层都以 二进制 进的形式存在，以补码的方式来存储数据
• 计算机都以以二进制进行运算，减去一个正数等于加上一个负数所以引入反码补码概念，十进制进行呈现输出
• 二进制（binary）：0b或0B开头，0,1；最高位0表示正数，最高位1表示负数；正数的原码、 反码 、补码相同
• 原码：二进制原始编码（负数的原码是其正数补码的最高位为1，然后求反码和补码）
• 反码：最高位（符号位）确定为1，其他位按位取反
• 补码：反码加1
• 八进制 （ octal ）：0开头，0-7
• 十进制（decimal）：0-9
• 十六进制（hex）：0x或0X开头，0-9及A-F（此处A-F不区分大小写）
• 二进制>>十进制：sum(x*z^(n-1))
• 十进制>>二进制：除2取余的逆
• 二进制>>八进制：每3个一位拼接
• 二进制>>十六进制：每4个一位拼接

 package com.shangguigu. java ;

import java.util.Scanner;

public class test{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.print("请输入一个整数：");
        int value = input.nextInt();
        String bin = Integer.toBinaryString(value);
        System.out.println(value+"的二进制数是"+bin);
        String oct = Integer.toOctalString(value);
        System.out.println(value+"的八进制是"+oct);
        String hex = Integer.toHexString(value);
        System.out.println(value+"的十六进制是"+hex);         
    }
}  

运算符

算术运算符

• +（正数）、-（负数）、+（加）、-（减）、*（乘）、/（取商）、%（取余）
• ++a（前，先自增1然后再运算）、a++（后，先运算然后再自增1） 自增1不会改变数据类型
• –a（前，先自增1然后再运算）、a–（后，先运算然后再自增1）
• +（字符串连接）使用在string之间以及string和其他类型之间

 public class  arithmetic  {
    public static void main(String[] args){
        //取商
        System.out.println(12 / 5);//2
        System.out.println(12 / 5 * 5);//10
        System.out.println((double)(12 / 5));//2.0
        System.out.println((double)12 / 5);//2.4
        //取余
        System.out.println(12 % 5);//2
        System.out.println(-12 % 5);//-2
        System.out.println(12 % -5);//2
        System.out.println(-12 % -5);//-2
        
        //++、--（同理）
        int a = 10;
        int a1 = a++;//先取值
        int a2 = ++a;//先运算
        System.out.println(a1);//10
        System.out.println(a2);//12
        System.out.println(a);//12
        
        int b = 10;
        int b1 = ++b;//先运算
        int b2 = b++;//先取值
        System.out.println(b1);//11
        System.out.println(b2);//11
        System.out.println(b);//12
        
        //注意点
        //aa++和++a本身也属于运算
        int aa = 10;
        aa ++ ;//++ aa; //以上两种写法aa都为11
        System.out.println(aa);//11
        
        //byte范围为-128~127，计算时超过127范围后会从~128重新开始
        byte bb = 127;
        bb ++ ;
        System.out.println(bb);//-128
        
        //+可以把非字符串转换成字符串
        System.out.println("5+5="+5+5);//5+5=55
        
        //练习题：随意一个三位整数，分别输出百位、十位、个位
        int num = 234;
        System.out.println("百位为："+num / 100);//2
        System.out.println("十位为："+num % 100 / 10);//3
        //System.out.println("十位为："+num / 10 % 10);//3
        System.out.println("个位为："+num % 100 % 10);//4
        //System.out.println("个位为："+num % 10);//4
    }
}  

赋值运算符

• 符号=，不会改变数据类型
• 拓展：+=、-=、*=、/=、%=

 public class setvalue {
    public static void main(String[] args){
        //赋值符号：=
        int a = 10;
        int b = 10;
        //连续赋值
        int a1,b1;
        a1 = b1 =10;
        //共同赋值
        int a3 = 10,b3 = 20;
        
        //拓展+=、-=、*=、/=、%=
        int num = 10;
        System.out.println(num += 2);//12  相当于num = num + 2
        System.out.println(num -= 2);//10  相当于num = num - 2
        System.out.println(num *= 2);//20  相当于num = num * 2
        System.out.println(num /= 2);//10  相当于num = num / 2
        System.out.println(num %= 3);//1   相当于num = num % 2
        
        //练习1
        short s = 3;
        //s = s+2;//编译报错,s+2为Int型，s为short型
        s += 2; //编译通过，+=不改变数据类型
        
        //练习2   
        int i = 1;
        i *= 0.1;//0.1为double型，但是*=不改变数据类型，结果为int型0.1，相当于强转为int型，发生了截断结果为0
        System.out.println(i);//0

        //练习3
        int m = 2;
        int n = 3;
        n *= m++; //n = n * m++
        System.out.println("m=" + m);//3
        System.out.println("n=" + n);//6
        
        //练习4
        int n1 = 10;
        n1 += (n1++) + (++n1);//n1 = n1 + ((n1++) + (++n1))
        System.out.println(n1);//32     
    }
}  

比较运算符

• ==、!=、<、>、<=、>=、 instanceof
• ==可以比较数值，可以进行应用数据类型间的比较不能比较字符串（字符、英文、汉字）
• 比较运算符的运算结果都是boolean，要么是false要么是true

 public class compare{
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        System.out.println(a == b);//false
        System.out.println(a = b);//20 把b赋值给a，然后输出a
    }
}  

逻辑运算符

• &（与，执行完运算）、&&（短路与，一旦遇到假，后面不参与运算） &和&&运算结果相同
• |（或，执行完运算）、||（短路或，一旦遇到真，后面不参与运算） |和||运算结果相同
• ！（非）、^（异或，相同为false，不同为true）
• 逻辑运算符操作的都是boolean类型的变量，结果也是boolean型
• Java中不可以写成3<x<6，需写成x>3&x<6

 public logic {
    public static void main(String[] args){
        boolean a = false;
        int num = 10;
        int num1 = 10;
        System.out.println(a & num++ > 10);//false，a为false，&后面继续执行
        System.out.println(num);//11
        
        System.out.println(a && num1++ > 10);//false,a为false，&&后面不执行
        System.out.println(num1);//10
        
        //练习题
        int x = 1;
        int y = 1;
        if(x++ == 2 & ++y == 2){//false&true
            x = 7;}
        System.out.println("x=" + x + ",y=" + y);//2，2
        
        int x1 = 1;
        int y1 = 1;
        if(x1++ == 2 && ++y1 == 2){//false&& 后面不执行
            x1 = 7;}
        System.out.println("x1=" + x1 + ",y1=" + y1);//2,1
        
        int x2 = 1;
        int y2 = 1;
        if (x2++ == 1 | ++y2 == 1){//ture|true
            x2 = 7;}
        System.out.println("x2=" + x2 + ",y2=" + y2);//7,2
        
        int x3 = 1;
        int y3 = 1;
        if(x3++ == 1 || ++y3 == 1){//ture||后面不执行
            x3 = 7;}
        System.out.println("x3=" + x3 +",y3=" + y3);//7,1
        
        //加强练习
        boolean x4=true;
        boolean y4=false;
        short z=42;
        if(y4=true) z++;//z=43
        if((z++==43)&&(y4=true))z++;//z=45
        if((x4=false)||(++z==46)) z++;//47
        System.out.println("z="+z);     
    }
}  

位运算符 （用的较少）

• 位运算是对整数的二进制进行的运算
• 位运算符操作的都是整型的数据
• << 左移：向左移n位相当于乘上2^n，比如3<<2，结果为3*2^2=12
• >>右移：被移位的二进制最高位是0空缺位补0； 最高位是1空缺位补1
• 向左移n位相当于除以2^n，比如3>>1，结果为3/2^1=1
• >>>无符号右移：被移位二进制最高位无论是0或者是1，空缺位都补0
• &与、|或、^异或、~取反：二进制进行计算，0看作false，1看作ture

三元运算符

• 结构：(条件表达式)？表达式1:表达式2
• 条件表达式的结果为boolean类型，为true时执行表达式1，为false时执行表达式2
• 表达式1和表达式2要求为同一类型，或者可以转换为同一类型，结果接收者类型与之同步
• 可嵌套使
• 三元运算符 可以改写为if-else，反之不成立；优先使用三元运算符(效率高)

 public class sanyuan {
    public static void main(String[] args){
    //获取两个数中的最大值
    int a = 10;
    int b = 20;
    int num = (a > b) ? a : b;
    String str = (a > b) ? "a大" : ((a == b) ? "a和b相等" : "b大");
    System.out.println(num);//20
    System.out.println(str);//b大
    
    //获取三个数中的最大值
    int x = 10;
    int y = 20;
    int z = 30;
    int max1 = (x > y) ? x : y;
    int max2 = (max1 > z) ? max1 : z;
    //int max = (((x > y) ? x : y) > z) ? ((x > y) ? x : y) : z;//不建议
    System.out.println(max2);//30
    //System.out.println(max);
    }
}  

键盘输入Scanner

• 第一步：导包 import java.util.Scanner;
• 第二步：Scanner实例化 Scanner input = new Scanner(System in);
• 第三步：调用Scanner类 input.nextXxx()
• 应输入指定接收的数据类型，如果输入的数据类型和要求的类型不一致，会报错InputMisMatchException

 package com.shangguigu.java;

import java.util.Scanner;

public class test{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        
        System.out.print("请输入您的姓名：");
        String name = input.next();
        
        System.out.print("请输入您的性别（男/女）：");
        String sex = input.next();
        
        System.out.print("请输入您的年龄：");
        int age = input.nextInt();
        
        System.out.print("请输入您的身高：");
        double hight = input.nextDouble();
        
        System.out.print("您是否单身（false/true）：");
        boolean single = input.nextBoolean();
        if(single){
            System.out.println("您叫"+name+"，您是一个"+sex+"生，您今年"+age+"岁了，您的身高是"+hight+"，您是一个单身狗！");
        }
        else{
            System.out.println("您叫"+name+"，您是一个"+sex+"生，您今年"+age+"岁了，您的身高是"+hight+"，您不是单身！");   
        }   
    }
}  

程序流程控制

顺序结构

分支结构

if else

• if…else（条件表达式后面可以不加{}）
• 程序中else可选，可写可不写

 package com.shangguigu.java;

import java.util.Scanner;

public class ifelse {
    public static void main(String[] args){
        //if笔试题1
        boolean x = true;
        boolean y = false;
        int z = 40;
        if((z++ == 40)&&(y = true)){
            z++;    
        }
        if((++z == 43)||(x = false)){
            z++;
        }
        System.out.println("z="+z);//44
        
        //if笔试题2
        int x1 = 4;
        int y1 = 1;
        if(x1 > 2){
            if(y1 > 2){
                System.out.println(x1 + y1);
                }
            else{
                System.out.println("atguigu");
                }
        } 
        else
            System.out.println("x1 is " + x1);//atguigu
            
        //if笔试题3
        boolean boo = true;
        if(boo == false) //if(b = false) 则输出c
            System.out.println("a");
        else if(boo)
            System.out.println("b");
        else if(!boo)
            System.out.println("c");
        else
            System.out.println("d");        
        
                        
        //if练习题1：岳小鹏的成绩
        Scanner input = new Scanner(System.in);
        System.out.print("请输入岳小鹏的成绩：");
        int source = input.nextInt();       
        if(source == 100){
            System.out.println("成绩为"+source+"分，奖励一辆BMW");
        }
        else if(source > 80 && source <= 99){
            System.out.println("成绩为"+source+"分，奖励一台iphone14 pro max");
        }
        else if(source >= 60 && source <= 80){
            System.out.println("成绩为"+source+"分，奖励一个ipad");
        }
        else{  //程序中else可选，可写可不写
            System.out.println("成绩为"+source+"分，什么奖励也没有");
        }
                
        //if练习题2：从小到大输出三个数
        //Scanner input = new Scaneer(System.in);
        System.out.print("请输入三个整数：");
        int a = input.nextInt();
        int b = input.nextInt();
        int c = input.nextInt();
        System.out.println("输入的三个整数分别为："+a+"、"+b+"、"+c);
        if (a > b && b > c){
            System.out.println("输入的三个整数从小到大一次是"+c+"、"+b+"、"+a);
        }
        else if (a > c && c > b){
            System.out.println("输入的三个整数从小到大一次是"+b+"、"+c+"、"+a);
        }
        else if (b > a && a > c){
            System.out.println("输入的三个整数从小到大一次是"+c+"、"+a+"、"+b);
        }
        else if (c > a && a > b){
            System.out.println("输入的三个整数从小到大一次是"+b+"、"+a+"、"+c);
        }
        else if (b > c && c > a){
            System.out.println("输入的三个整数从小到大一次是"+a+"、"+c+"、"+b);
        }
        else {
            System.out.println("输入的三个整数从小到大一次是"+a+"、"+b+"、"+c);
        }
        
        //if练习题3：判断两数之和
        int num1 = 25;
        int num2 = 30;
        if(num1 + num2 >= 50){
            System.out.println("两数之和大于等于50！");
        }
        else{
            System.out.println("两数之和小于50");
        }
        
        //id练习题4：判断两数大小
        double num3 = 5;
        double num4 = 20;
        if(num3 > 10.0 && num4 < 20.0){
            System.out.println(num3 + num4);
        }
        else{
            System.out.println(num3 * num4);
        }
        
        //if练习题5：狗的年龄
        //Scanner input = new Scanner(System.in);
        System.out.print("请输入狗的年龄：");
        double dogage = input.nextDouble();
        if(dogage <= 2){
            System.out.println("狗的年龄是"+dogage+",相当与人的年龄"+(10.5*dogage)+"岁！");
        }
        else{
            System.out.println("狗的年龄是"+dogage+",相当于人的年龄"+(21+4*(dogage-2)));
        }
        
        //if练习题6：彩票
        //Scanner input = new Scanner(System.in);
        System.out.print("请输入一个两位数：");
        int caipiao = input.nextInt();
        System.out.println("您输入的数字是："+caipiao);
        //Math.random() [0.0,1.0)
        //公式：[a,b] (int)(Math.random()*(b-a+1)+a)
        int value = (int)(Math.random() * 90 + 10);//随机获取一个两位数 [10,99]
        System.out.println("产生的随机数是："+value);
        
        if(caipiao / 10 == value / 10 && caipiao % 10 == value % 10){
            System.out.println("奖金10000美元！");
        }
        else if (caipiao / 10 == value % 10 && caipiao % 10 == value / 10){
            System.out.println("奖金3000美元");
        }
        else if (caipiao / 10 == value / 10 && caipiao % 10 != value % 10){
            System.out.println("奖金1000美元");
        }
        else if (caipiao / 10 == value % 10 || caipiao % 10 == value / 10){
            System.out.println("奖金500美元");
        }
        else{
            System.out.println("彩票作废");
        }
        
        //if练习题7：高富帅
        //==：比较的是两个字符串内存地址（堆内存）的数值是否相等，属于数值比较；
        //equals()：比较的是两个字符串的内容，属于内容比较;
        //Scanner input = new Scanner(System.in);
        System.out.print("请分别输入男方的身高(cm)、财富(千万)、帅否(是否)：");
        int hight = input.nextInt();
        double money = input.nextDouble();
        String face = input.next();
        if(hight > 180 && money > 1 && face.equals("是")){
            System.out.println("我一定嫁给他！");
        }
        else if(hight < 180 && money < 1 && face.equals("否")){
            System.out.println("不嫁！");
        }
        else{System.out.println("嫁吧，比上不足，比下有余！");
        }
    }
}  

switch case

• switch-case结构
• break关键字是可选的，要注意加与不加的区别
• defaule关键字也是可选的，位置也是可选的（一般放在最后面）
• 表达式：byte、short、int、char、string、枚举类型
• case后面只能声明常量，不能声明范围，不能使用变量或不确定的表达式
• switch-case都可以转换为if else，反之不成立；优先用switch，因为效率更高

 /*
switch-case结构

switch(表达式):{
case 常量1：
    语句1；
    //break;
case 常量2:
    语句2；
    //break;
......
case 常量n:
    语句n;
    break；
default:
    语句;
    //break;
}
*/
package com.shangguigu.java;

import java.util.Scanner;

public class switchcase {
    public static void main(String[] srgs){
        Scanner input = new Scanner(System.in);
        
        //练习1
        System.out.print("请输入一个整数：");
        int number = input.nextInt();
        switch(number){
        case 0:
            System.out.println("zero");
            break;
        case 1:
            System.out.println("one");
            break;
        case 2:
            System.out.println("two");
            break;
        case 3:
            System.out.println("there");
            break;
        default:
            System.out.println("other");
            break;//default之后的break加不加一样加不加一样
        }       
        
        //练习2
        System.out.print("请输入现在的季节:");
        String season = input.next();
        switch(season){
        case "spring":
            System.out.println("春暖花开!");
            break;
        case "summer":
            System.out.println("夏日炎炎!");
            break;
        case "autumn":
            System.out.println("秋高气爽");
            break;
        case "winter":
            System.out.println("白雪皑皑!");
            break;
        default:
            System.out.println("您输入的季节有误!");
            break;
        }
        
        
        //练习3：case执行结果相同的可以省略结果表达式
        System.out.print("请输入月份：");
        int m = input.nextInt();
        switch(m){
        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;
        }
            
        //练习4：年月日
        //Scanner input = new Scanner(System.in);
        System.out.print("请输入年月日：");
        int year = input.nextInt();
        int month = input.nextInt();
        int day = input.nextInt();
        int sumdays = 0;
        switch(month){
        case 12:
            sumdays += 30;
        case 11:
            sumdays += 31;
        case 10:
            sumdays += 30;
        case 9:
            sumdays += 31;
        case 8:
            sumdays += 31;
        case 7:
            sumdays += 30;
        case 6:
            sumdays += 31;
        case 5:
            sumdays += 30;
        case 4:
            sumdays += 31;
        case 3:
            if((year % 4 == 0 && year % 100 != 0)||(year % 400 == 0)){
                sumdays += 29;
            }
            else{
                sumdays += 28;
                }
        case 2:
            sumdays += 31;
        case 1:
            sumdays += day; 
        }
        System.out.println(year+"年"+month+"月"+day+"日是当年的第"+sumdays+"天");
        
    }
}  

循环结构

• 初始化部分
• 循环条件部分
• 循环体部分
• 迭代部分
• for循环和while循环可以相互装换
• do-while较少使用
• whlie(true)和for(;;)是无限循环

for

 package com.shangguigu.java;

import java.util.Scanner;

public class forxunhuan {
    public static void main(String[] args){
        
        //练习1
        for(int i = 1;i <= 5;i++){
            System.out.println("Hello World!");
        }
        
        //练习2：遍历输出100以内所有的偶数，变输出个数和总和
        int sum = 0;
        int count = 0;  
        for(int i = 1;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(i);
                count ++;
                sum += i;
            }
        }
        System.out.println("个数为:"+count);
        System.out.println("总数为:"+sum);
        
        //练习3：
        for(int i = 1;i <= 150;i++){
            //for(j = 3;j <= 7;j += 2){}
            System.out.print(i);
            if(i % 3 == 0){
                System.out.print(" foo");
            }
            if(i % 5 == 0){
                System.out.print(" bin");
            }
            if(i % 7 == 0){
                System.out.print(" baz");
            }
            System.out.println();
            }
        
        //练习4：最大公约数、最小公倍数
        Scanner input = new Scanner(System.in);
        System.out.print("请输入两个整数：");
        int m = input.nextInt();
        int n = input.nextInt();
        //求最大公约数
        for(int i = m;i >= 1;i--){
            if(m % i == 0 && n % i == 0){
                System.out.println(m+"和"+n+"的最大公约数是："+i);   
                break;
            }
        }
        //求最小公倍数
        for(int j = m;j <= m*n;j++){
            if(j % m == 0 && j % n == 0){
                System.out.println(m+"和"+n+"的最小公倍数是："+j);
                break;              
            }
        }
        
        //练习5：1~100之间奇数的和
        
        //练习6:1~100之间7的倍数的个数及总和
        
        //练习7输出水仙花数
        for(int i = 100;i <= 999;i++){
            if((Math.pow((i / 100),3) + Math.pow((i % 100 / 10),3) + Math.pow((i % 10),3)) == i){
                System.out.println(i);
            }       
        }   
            
    }           
}  

whlie

 package com.shangguigu.java;

import java.util.Scanner;

public class whilewhile {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
                    
        //练习题键盘读入不确定的整数，判断读入的整数和负数的个数，输入为0是程序结束
        int zhengshu = 0;
        int fushu = 0;
        while(true){
        //for(;;){
            System.out.print("请输入一个整数：");
            int value = input.nextInt();
            if(value > 0)
                zhengshu++;
            else if(value < 0)
                fushu++;
            else
                break;
        }
        System.out.println("输入的正数个数为："+zhengshu);
        System.out.println("输入的负数个数为："+fushu);
        
            
        //九九乘法表
        //for
        for(int x = 1;x <= 9;x++){
            for(int y =1;y <= x;y++ ){
                    System.out.print(y+"*"+x+"="+y*x+" ");
            }
            System.out.println();
        }
        
        //while
        int i = 1;
        while(i <= 9){
            int j = 1;
            while(j <= i){
                System.out.print(j+"*"+i+"="+j*i+" ");
                j++;
            }
            i++;
            System.out.println();
        
        
        //100以内的质数
        //方法一
        long start = System.currentTimeMillis();
        for(int m = 2;m <= 10000;m++){
            int num1 = 0;
            for(int n = 1;n <= m;n++){
                if(m % n == 0)
                    num1++; 
            }
            if (num1 <= 2)
                System.out.println(m);
        }
        long end = System.currentTimeMillis();
        System.out.println("所花费的时间为："+(end - start));
        //方法二
        long start = System.currentTimeMillis();
        for(int m = 2;m <= 100000;m++){
            boolean isflag = true;
            for(int n = 2;n <= Math.sqrt(m);n++){//优化2 Math.sqrt(m) 优化较少遍历次数
                if(m % n == 0)
                    isflag = false;
                    break;//优化1
            }
            if (isflag == true)
                System.out.println(m);
        }
        long end = System.currentTimeMillis();
        System.out.println("所花费的时间为："+(end - start));
        //方法三  
        long start = System.currentTimeMillis();
        lable1:for(int m = 2;m <= 100;m++){
                   for(int n = 2;n <= Math.sqrt(m);n++){//优化2 Math.sqrt(m) 优化较少遍历次数
                        if(m % n == 0)
                            continue lable1;
                    }
                    System.out.println(m);
            }
        
        long end = System.currentTimeMillis();
        System.out.println("所花费的时间为："+(end - start));
    }
}
  

do while

 package com.shangguigu.java;

import java.util.Scanner;

public class whilewhile {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        
        //练习 for、while、do-while的区别
        System.out.print("请输入一个整数：");
        int num = input.nextInt();
        int i = 1;
        int sum = 0;
        
        //for 循环条件是局部变量
        for(int j = 1;j<= num;j++){
            sum += j;
        }
        System.out.println(sum);//55
        
        //while 先判断，再执行。循环条件是全局变量
        while(i <= num){
            sum += i;
            i++;
        }
        System.out.println(sum);//110
        
        //do while 先执行 再判断。循环条件是全局变量
        do{
            sum += i;
            i ++;
        }while(i <= num);
            System.out.println(sum);//121
    }
}
  

break、continue、return

• break用于循环语句和switch case语句中，表示终止本层循环，后面的不执行
• continue用于循环语句中，表示终止本次循环，继续下一次
• return结束当前方法，后续再讲

 package com.shangguigu.java;

import java.util.Scanner;

public class test{
    public static void main(String[] args){
        //for和while
        for(int i = 1;i < 10;i++){
            if(i % 4 == 0)
                //break;//123
                continue;//1235679
                System.out.print(i);
        }
        System.out.println();
        
        //带标签的for和while
        lable1:for(int i = 1;i < 4;i++){
            for(int j =1;j < 10;j++){
                if (j % 4 == 0)
                    //break lable1;//123     终止内层循环的同时也直接终止了外层的循环
                    continue lable1;//123123123 终止了内层循环，跳出内层循环继续执行外层循环
                    System.out.print(j);                    
            }
            System.out.println();//此时的换行不生效
        }
        
    }
}