从零开始学JAVA -基础完结

已于 2024-06-13 19:20:21 修改
阅读量769 收藏 24
点赞数 10
文章标签： java 开发语言
于 2024-06-06 15:14:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_70851535/article/details/139500197
版权

目录

一、编写Hello world程序

二、关键字

三、常量

四、变量

五、字符和字符串中的‘+’操作

六、关系运算符

七、数据类型的特性或数据类型的属性

八、逻辑运算符

九、三元运算符

十、Scanner打印机用法

十一、流程控制语句

1、if语句

2、Switch语句

3、for语句

4、while循环语句

5、do-while循环语句

十二、Random随机数

十三、跳转控制语句

一、编写Hello world程序

public class JavaMain1 {
    //主程序执行入口，main方法
    public static void main(String[] args){
        System.out.println("Hello world!");
    }
}

运行结果 

Hello world!
java编写主程序常见错误：
1、System ---首字母没有大写
2、主程序没有void

二、关键字

关键字：就是Java语言赋予的特定含义单词

特点：关键字字母全部都是小写，IDEA针对关键字有特殊的颜色标记。如：public class static void 如在IEDA中的关键字，有明显的颜色区分。

三、常量

常量类型说明
字符串常量
 
双引号括起来的内容
整数常量
 
不带小数点的数字
小数常量
 
带小数的数字
字符常量
 
用单引号括起来的内容
布尔常量 
布尔值，表示真假
空常量  
一个特殊的值，空值

示例代码： 

public class JavaMain1 {
    //主程序执行入口，main方法
    public static void main(String[] args){
        //输出字符串常量
        System.out.println("Hello world");
        //输出整数常量
        System.out.println(77777);
        //输出小数常量
        System.out.println(77.777);
        //输出字符常量
        System.out.println('男');
        //输出布尔常量
        System.out.println(ture);
    }
}

运行结果 

Hello world
77777
77.777
男
true

四、变量

变量：在程序运行过程中，其值可以发生改变的值（变量是内存中一小块区域）
定义变量：变量的数据类型 变量名称=赋值

五、字符和字符串中的‘+’操作

字符的‘+’操作：拿字符在计算机底层对应的数值来进行计算（底层计算使用ASCII码）
ASCII码表中的26个大小写字母对应的十进制如下表：
| 大写字母 | ASCII码 | 小写字母 | ASCII码 |
|----------|----------|----------|----------|
| A         | 65        | a         | 97        |
| B         | 66        | b         | 98        |
| C         | 67        | c         | 99        |
| D         | 68        | d         | 100       |
| E         | 69        | e         | 101       |
| F         | 70        | f         | 102       |
| G         | 71        | g         | 103       |
| H         | 72        | h         | 104       |
| I         | 73        | i         | 105       |
| J         | 74        | j         | 106       |
| K         | 75        | k         | 107       |
| L         | 76        | l         | 108       |
| M         | 77        | m         | 109       |
| N         | 78        | n         | 110       |
| O         | 79        | o         | 111       |
| P         | 80        | p         | 112       |
| Q         | 81        | q         | 113       |
| R         | 82        | r         | 114       |
| S         | 83        | s         | 115       |
| T         | 84        | t         | 116       |
| U         | 85        | u         | 117       |
| V         | 86        | v         | 118       |
| W         | 87        | w         | 119       |
| X         | 88        | x         | 120       |
| Y         | 89        | y         | 121       |
| Z         | 90        | z         | 122       |

字符串的‘+’操作：当字符串中出现‘+’，此时的‘+’是连接运算符

六、关系运算符

关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。

符号说明
==a==b，判断a和b的值是否相等，成立为true，不成立为false
!=𝑎 =𝑏a =b，判断a和b的值是否不相等，成立为true，不成立为false
>>a>>b,判断a是否大于b，成立为true，不成立为false
> => =𝑎>=𝑏 a>=b，判断a是否大于等于b，成立为true，不成立为false
<<𝑎<𝑏 a<b，判断a是否小于b，成立为true，不成立为false
< =< =𝑎<=𝑏 a<=b，判断a是否小于等于b，成立为true，不成立为false

注意事项：关系运算符的结果都是𝑏𝑜𝑜𝑙𝑒𝑎𝑛类型，要么是𝑡𝑟𝑢𝑒，要么是𝑓𝑎𝑙𝑠𝑒。千万不要把“”误写成“=”，“”是判断是否相等的关系，“=”是赋值。注意事项：关系运算符的结果都是boolean类型，要么是true，要么是false。千万不要把“”误写成“=”，“”是判断是否相等的关系，“=”是赋值。

七、数据类型的特性或数据类型的属性

Java中基本数据类型名称、关键字、内存占用和取值范围的表格：

数据类型关键字内存占用取值范围
bytebyte1 字节-128 到 127 (-2^7 到 2^7-1)
shortshort2 字节-32,768 到 32,767 (-2^15 到 2^15-1)
intint4 字节-2,147,483,648 到 2,147,483,647 (-2^31到 2^31-1)
longlong8 字节-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 (-2^63 到 2^63-1)
floatfloat4 字节大约 ±3.4E-45 到 ±3.4E38，有效位数为6-7位
doubledouble8 字节大约 ±4.9E-324 到 ±1.8E308，有效位数为15位
charchar2 字节'\u0000'（0）到 '\uffff'（65,535）
booleanboolean不确定，通常实现为1位或1字节true 或 false

请注意以下几点：

  • char 类型表示一个Unicode字符。它以16位（2个字节）的形式存储，范围从'\u0000'（也就是0）到'\uffff'（也就是65,535）。
  • boolean 类型的内存占用在Java中没有明确指定，并且可能因JVM实现而异。虽然它可以只用1位来表示，但出于对齐原因通常会使用更多空间。
  • float 和 double 类型遵循IEEE 754标准，分别用32位和64位来存储浮点数。

以上表格提供了每种基本数据类型的关键字、内存占用和取值范围的基本概述。

八、逻辑运算符

名称运算符描述
逻辑与&a&b，a和b都是true，结果为true。否则为false。
逻辑或|a|b，a和b都是false，结果为false。否则为true。
逻辑非！!a，结果和a的结果正好相反
逻辑异或^a^b，a和b结果不同为true，相同为false
短路与&&作用和&相同，但是有短路
短路或||作用和|相同，但是有短路

逻辑运算符的代码示例如下 

public class Logicaloperation {
    public static void main(String[] args){
        // 逻辑与,左边&右边，都必须是true,则返回结果是为true
        System.out.println("&并且");
        System.out.println(true & true);
        System.out.println(true & false);
        System.out.println(false & false);
        int a = 10;
        int b = 20;
        int c = 30;
        //a>b false b>c false
        System.out.println(a>b&b>c);// 输出：false
        //a<b true b<c true
        System.out.println(a<b&b<c);// 输出：true
        //a<b true b>c false
        System.out.println(a<b&b>c);// 输出：false

        // 逻辑或,左边 | 右边，只要有一个为true,则返回为true
        System.out.println("| 演示");
        System.out.println(true | false); // 输出：true
        System.out.println(false | false); // 输出：false
        System.out.println(true | true); // 输出：true
        // 逻辑异或
        System.out.println("异或 演示");
        System.out.println(true ^ false); // 输出：true
        System.out.println(true ^ true); // 输出：false

        //逻辑非 ！
        System.out.println("! 取反");
        System.out.println(!true); // 输出：
        System.out.println(!false); // 输出：


        // 短路与
        //左边返回false,右边不会执行,若左边返回true，两边执行
        System.out.println("短路与&& 演示");
        System.out.println((a++>100)&&(b++>100));
        System.out.println(a);
        System.out.println(b);

        // 短路或
        //左边和右边只要有一个返回true，最终结果是true
        int d = 10;
        System.out.println("短路或 ||");
        System.out.println((d++>1)||(b++>100));
        System.out.println(d);
        System.out.println(b);
    }
}

运行结果 

&并且
true
false
false
false
true
false
| 演示
true
false
true
异或 演示
true
false
! 取反
false
true
短路与&& 演示
false
11
20
短路或 ||
true
11
20

九、三元运算符

public class ThreeYuan {
    public static void main(String[] args){
        //三元运算符：关系表达式 ? 表达式1 ：表达式2
        //关系表达式--boolean(布尔类型)，返回true，则执行表达式1，否则执行表达式2
        int a = 10;
        int b = 20;
        int c = a>b?a:b;
        System.out.println(c);//输出：20
        /*三元运算符（表达式案列）
        需求：动物园里有两只老虎，已知两只老虎的体重分别为180kg，200kg。
        请用程序判断两只老虎的体重是否相同。
        */
        int weight1 = 180;
        int weight2 =200;
        boolean d = weight1 == weight2 ? true:false;
        System.out.println("d:"+d);
        //优化，通过中文更直观表达
        //关系表达式--boolean(布尔类型)，返回true，则执行表达式1，否则执行表达式2
        System.out.println(d? "两只老虎相等的":"两只老虎不相等");

        /*三元运算符（表达式案列）二
        班级中有三名同学，已知他们的身高分别为150cm，210cm，165cm,
        请用程序实现获取这三名同学的最高身高。
        */
        int height1 = 150;
        int height2 = 210;
        int height3 = 165;
        int testHeight = height1 > height2?height1:height2;
        int maxHeight = testHeight > height3 ? testHeight:height3;
        System.out.println("最高身高是："+maxHeight);

    }
}

 运行结果

20
d:false
两只老虎不相等
最高身高是：210

十、Scanner打印机用法

Scanner使用基本步骤

1、导包 import java.util.Scanner;导包的动作必须出现在定义的类上面

2、创建对象 Scanner sc = new Scanner(System.in);src是为变量名称 可以发生变化 其他不容许发生变化

3、接受数据 int i = sc.nextInt();接受一个int的数据 i是为变量名称 可以发生变化 其他的都不允许发生变化
import java.util.Scanner;
public class Scannerdemo {
    public static void main(String[] args) {
        //创建了一个打印机
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数值类型的数据");
        //接受用户在控制台中输入的数值类型
        int i = sc.nextInt();
        System.out.println("输入的数值类型值为：" +i);
    }
}

 运行结果 

请输入一个数值类型的数据
1
输入的数值类型值为：1

 Scanner类实现求两个数之和

//Scanner类实现求两个数之和
import java.util.Scanner;
public class Scannerdemo {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个类型的数值：");
        int a = sc.nextInt();
        System.out.println("请输入第二个类型的数值：");
        int b = sc.nextInt();
        int c = a + b;
        System.out.println("输入的值的总和为："+c);
    }
}

 运行结果

请输入第一个类型的数值：
1
请输入第二个类型的数值：
2
输入的值的总和为：3

十一、流程控制语句

流程控制语句：
1、顺序结构
2、分支结构（if、Switch）
3、循环结构（for、while、do……while）

1、if语句

格式：
if(关系表达式){
    语句体；
}
关系表达式只有两个结果true或false
首先判断关系表达式看其结果是true还是false
如果是true执行语句体
如果是false不执行语句体
案例判断a和b的值是否相等，如果相等，控制台输出a==b,否则反之
public class IfDemo {
    public static void main(String[] args){
        int a = 10;
        int b = 10;
        if (a==b){
            System.out.println("a==b");
        }
        if(a!=b){
            System.out.println("a不等于b");
        }
        System.out.println();
    }
}

运行结果

a==b

 if写法二：

格式：
if(关系表达式){
    语句体1；
}else{
    语句体2;
}
关系表达式只有两个结果true或false
首先判断关系表达式看其结果是true还是false
如果是true执行语句体1
如果是false执行语句体2
public class IfDemo {
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        if (a>b){
            System.out.println("a>b");
        }
        else {
            System.out.println("a<b");
        }
        System.out.println();
    }
}

运行结果

a<b

案例：

需求：任意给出一个整数，请用程序实现判断改整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶然数
import java.util.Scanner;
public class IfDemo {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int a = sc.nextInt();//存储到变量a中
        if(a % 2 == 0){
            System.out.println("该整数是偶数");
        }else {
            System.out.println("该整数是奇数");
        }
    }
}

运行结果

请输入一个整数：
1
该整数是奇数
多重if判断语句
格式：
if(判断条件1){
    执行语句1；
}else if(判断条件2){
    执行语句2;
}else if(判断条件n){
    执行语句n;
}else{
    执行语句n+1
}
首先判断条件1看其结果是true还是false
如果是true执行语句体1,否则执行判断条件2
如果是false，就判断条件2，看其结果是true还是false
如果是true执行语句2，否则执行判断条件n，以此类推。
案例1：键盘输入一个星期数{1，2，3，4，5，6，7}输出对应的星期。
import java.util.Scanner;
public class IfDemo {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();//存储到变量中
        if(week == 1){
            System.out.println("星期一");
        }else if(week == 2) {
            System.out.println("星期二");
        }else if(week == 3) {
            System.out.println("星期三");
        }else if(week == 4) {
            System.out.println("星期四");
        }else if(week == 5) {
            System.out.println("星期五");
        }else if(week == 6) {
            System.out.println("星期六");
        }else if(week == 7) {
            System.out.println("星期日");
        }else {
            System.out.println("你输入的不是星期数……");
        }
    }
}

运行结果

请输入一个星期数：
7
星期日
案例2：根据学生的成绩评定出等级，90以上是优，80-89是良，70-79是中，60-69是及格，60以下是不及格

import java.util.Scanner;
public class IfDemo {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个成绩：");
        int re = sc.nextInt();//存储到变量中
        if(re >90 && re<+100){
            System.out.println("成绩为优");
        }else if(re >= 80 && re <=89) {
            System.out.println("成绩为良");
        }else if(re >= 70 && re <=79) {
            System.out.println("成绩为中");
        }else if(re >= 60 && re <=69) {
            System.out.println("成绩及格");
        }else if(re <60) {
            System.out.println("成绩不合格");
        }else {
            System.out.println("你输入的不是成绩……");
        }
    }
}

运行结果

请输入一个成绩：
89
成绩为良

2、Switch语句

switch(10){
    case 1:
      语句体1;
      break;
    case 2:
      语句体2;
      break;
      ...................................
    default:
      语句体n+1;
      break;
        }
格式说明：
1.表达式取值为byte,short,int,char,JDK5以后可以是枚举，JDK7以后可以是字符串（String）
2.case：后面跟的是要和表达式进行比较的值
3.语句体：这个部分可以是一条或者多条语句
4.break：表示中断，结束的意思，可以控制switch语句的结束
5.default：当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实他就相当于if语句的else

执行流程：
1.首先计算出表达式的值
2.其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
3.最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

案例：键盘录入一个星期数{1,2,3,4,5,6,7} 输出对应的星期一.....星期日（使用switch实现）

import java.util.Scanner;
public class Switchdemo{

    public static void main(String[] args){
        //2.创建键盘录入
        Scanner sc=  new Scanner(System.in);
        System.out.println("请您输入一个星期数:");
        //3.接受用户输入的整数类型值
        int  number= sc.nextInt();
        switch(number){
            case 1:
                System.out.println("星期一");
                // 如果匹配上 case 则会 break退出switch语句
                break;
            case 2:
                System.out.println("星期二");
                // 如果匹配上 case 则会 break退出switch语句
                break;
            case 3:
                System.out.println("星期三");
                // 如果匹配上 case 则会 break退出switch语句
                break;
            case 4:
                System.out.println("星期四");
                // 如果匹配上 case 则会 break退出switch语句
                break;
            case 5:
                System.out.println("星期五");
                // 如果匹配上 case 则会 break退出switch语句
                break;
            case 6:
                System.out.println("星期六");
                // 如果匹配上 case 则会 break退出switch语句
                break;
            case 7:
                System.out.println("星期日");
                // 如果匹配上 case 则会 break退出switch语句
                break;
            default:
                System.out.println("您输入的星期数不正确!");
                break;
        }
    }

}

运行结果


请您输入一个星期数:
8
您输入的星期数不正确!

案例：

需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。

春：3、4、5

夏：6、7、8

秋：9、10、11

冬：1、2、12

多个case后面的值不可以重复，重复则编译报错

import java.util.Scanner;
public class Switchdemo{

    public static void main(String[] args){
        //2.创建键盘录入
        Scanner sc=  new Scanner(System.in);
        System.out.println("请您输入一个月份");
        //3.接受用户输入的整数类型值
        int  number= sc.nextInt();
        // 冗余 穿透
        switch(number){
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            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;			 
            default:
                System.out.println("用户输入的月份不正确!");
        }

    }

}

运行结果

请您输入一个月份
2
冬季

3、for语句

for循环语句格式：
for （初始化语句;条件判断语句;条件控制语句）
{
 循环体语句;
}
执行流程：
1.执行初始化语句
2.执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
3.执行循环体语句
4.执行条件控制语句
5.回到2过程继续

public class Fordemo{

    public static void main(String[] args){
		/*
		for循环语句格式：
		for （初始化语句;条件判断语句;条件控制语句）
		{
			循环体语句;
		}

		*/
        // 控制台输出5个我是余胜军 非常冗余（重复）
        System.out.println("控制台输出");
        System.out.println("控制台输出");
        System.out.println("控制台输出");
        System.out.println("控制台输出");
        System.out.println("控制台输出");
        System.out.println("使用for循环输出:");
        // 1.初始化语句 int i=0;
        // 2.条件判断语句 i(0)<5 true
        // 3.控制台输出
        // 4.条件控制语句  控制循环是否可以继续执行 i+1
        // 5.条件判断语句 i(1)<5
        // 6.控制台输出
        // 7.条件控制语句 i(1)+1
        // 5.条件判断语句 i(2)<5
        for(int i=0;i>5;i++){
            System.out.println("控制台输出我");
        }


    }

}

运行结果

控制台输出
控制台输出
控制台输出
控制台输出
控制台输出
使用for循环输出:
控制台输出我
控制台输出我
控制台输出我
控制台输出我
控制台输出我

案例：在控制台输出1-5和5-1数据

public class Fordemo{
    public static void main(String[] args){
        System.out.println("输出1-5的数据");
        //第一次i=0
        //第二次i=1
        //第三次i=2
        //第四次i=3	
        //第五次i=4
        //第六次i=5
        for(int i=0;i<=5;i++){
            System.out.println("第:"+(i+1)+"次");
        }
        System.out.println("----输出5-1的数据-----");
        for(int i=5;i>=1;i--){
            System.out.println(i);
        }
    }

}

运行结果

public class Fordemo{
    public static void main(String[] args){
        System.out.println("输出1-5的数据");
        //第一次i=0
        //第二次i=1
        //第三次i=2
        //第四次i=3	
        //第五次i=4
        //第六次i=5
        for(int i=0;i<=5;i++){
            System.out.println("第:"+(i+1)+"次");
        }
        System.out.println("----输出5-1的数据-----");
        for(int i=5;i>=1;i--){
            System.out.println(i);
        }
    }

}

案例：求1-5之间的数据和，并且将求和的结果在控制台输出

public class Fordemo{
    public static void main(String[] args){
        System.out.println("求1-5的总和");
        int sum=0;
        for(int i =1;i<=5;i++){
            // sum=sum+i;
            sum+=i;
            // 	sum+=i;==等价于sum=sum+i;
            //第一次 sum= sum(0)+1;=1
            //第二次 sum= sum(1)+2;=3
            //第三次 sum= sum(3)+3;=6
            //第四次 sum= sum(6)+4;=10
            //第五次 sum= sum(10)+5;=15
        }
        System.out.println("sum:"+sum);
    }

}

运行结果

public class Fordemo{
    public static void main(String[] args){
        System.out.println("求1-5的总和");
        int sum=0;
        for(int i =1;i<=5;i++){
            // sum=sum+i;
            sum+=i;
            // 	sum+=i;==等价于sum=sum+i;
            //第一次 sum= sum(0)+1;=1
            //第二次 sum= sum(1)+2;=3
            //第三次 sum= sum(3)+3;=6
            //第四次 sum= sum(6)+4;=10
            //第五次 sum= sum(10)+5;=15
        }
        System.out.println("sum:"+sum);
    }

}

运行结果

求1-5的总和
sum:15

案例：

求1-5之间的数据和，并且将求和的结果在控制台输出

1,2,3,4,5 1+2+3+4+5=

public class Fordemo {
    public static void main(String[] args){
        System.out.println("求1-5的总和");
        int sum=0;
        for(int i =1;i<=5;i++){
        // sum=sum+i;
            sum+=i;
        // 	sum+=i;==等价于sum=sum+i;
        }
        System.out.println("sum:"+sum);

    }
}

运行结果

求1-5的总和
sum:15

4、while循环语句

基本格式：
while(判断条件语句) {
     循环体语句;
}
完整格式：
初始化语句；;
while(判断条件语句) {
     循环体语句;
     控制条件语句;
}
①执行初始化语句；
②执行条件判断语句，看其结果是true还是false；
如果是false，循环结束；
如果是true，继续执行；
③执行循环体语句；
④执行条件控制语句；
⑤返回②继续执行。

public class Whiledemo{
    public static void main(String[] args){
		/*
		初始化语句；;
		while(判断条件语句) {
		循环体语句;
		控制条件语句;
		}
		*/
        int j=1;//初始化语句
        while(j<=5){
            System.out.println("我是诸葛成");
            j++;//	控制条件语句;
        }
    }

}

运行结果

我是诸葛成
我是诸葛成
我是诸葛成
我是诸葛成
我是诸葛成

5、do-while循环语句

do while语句
基本格式：
do {
     循环体语句;
}while((判断条件语句);

完整格式：	  
初始化语句; 
do {   
	循环体语句;   
	条件控制语句; 
}while(条件判断语句);
	  
执行流程：
①执行初始化语句
②执行循环体语句
③执行条件控制语句
④执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
⑤回到②继续

public class Whiledemo{
    public static void main(String[] args){
        // do while
		/*
		初始化语句;
		do {
			循环体语句;

		  }while(条件判断语句);

		*/
        int j=1;//初始化语句;
        do{
            System.out.println("我是诸葛成");	//循环体语句;
            j++;//条件控制语句;
        }while(j<=5);

    }

}

运行结果

我是诸葛成
我是诸葛成
我是诸葛成
我是诸葛成
我是诸葛成

十二、Random随机数

作用：用于产生一个随机数
①导包
import java.util.Random;
导包的动作必须出现在类定义上边
②创建对象
Random r = new Random();
上边这个格式里面，r是变量名，可以变，其他的都不允许变
③获取随机数
int number = r.nextInt(10);//获取数据的范围：[0,10)包括0，不包括10
上边这个格式里面，number是变量名，可以变，数字10可以变，其他都不可以变

十三、跳转控制语句


跳转控制语句(break),跳出循环，结束循环
跳转控制语句(continue),跳过本次循环，继续下次循环
注意： continue只能在循环中进行使用！
break 结束整个循环  continue 只是结束本次循环 但是还会继续下次循环

continue用法：使用for 循环1-10 不输出偶数结果
1,2,3,4,5,6,7,8,9,10  

public class Whiledemo {
    public static void main(String[] args){
        for(int i=1;i<=10;i++){
            if(i%2==0){
                continue;// i是偶数结束了本次循环，不打印
            }
            System.out.println("i:"+i);
        }
    }
}

运行结果

i:1
i:3
i:5
i:7
i:9

诸葛成
关注
  • 10
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
从零开始学Java资源包
02-16
图书《从零开始学Java》配套的资源包。本书针对初学和自学读者的特点,以通俗易懂的语言讲解Java语言编程。全书内容分为六篇共23章,讲解了Java的各个方面,主要内容包括Java语言的环境配置、基本语法、流程控制语句、...
Java编程之从零开始学Java——初始java
fzt12138的博客
12-22 3221
注意：该文章仅针对零基础想入门、在校大学生、即将毕业的相关专业学生以及社会人群想转行但未入门的人群。 一、写在前面 从步入大学到现在的职场，各种各样的见闻让我有了这样一个想法，我想借助CSDN这样一个平台，给一些看到我文章的人提供一个机会，一个明白自己是否适合这个行业的机会。 不知道正在看我文章的你是否也有这样的体会，学校课程繁杂加上自己的不认真，以至于连最基本的作业都无法完成。或者是学习期间忙于各种考证，忽视了专业课，以至于毕业将至，自己却对相关知识似懂非懂。亦或是有心进入这个行业，却发现网上教程五花八门
从零开始学习JAVA java 基础
11-17
从零开始学习JAVA java 基础 很适合初学者 下载下来看看吧
如何从零开始学习Java开发.docx
03-02
Java开发是一项广泛应用于软件开发领域的技能，从零开始学习Java，需要掌握一系列基础知识和技术。以下是一些关键知识点的详细介绍： 1. **JVM相关**： - **JVM内存模型和结构**：JVM分为堆内存、栈内存、方法区、...
Java编程规范-从零开始学习
10-13
本文将深入探讨Java编程规范，从基础开始，逐步解析各个关键点。 首先，我们来讨论为什么需要编码规范。一个软件项目的生命期中，维护阶段通常占据了大部分的时间，而这期间，原始开发人员可能已经离开，新接手的...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 622
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 702
JSON，Ajax
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 953
GeoServerBasePage 登录
探讨 MyBatis 特殊 SQL 执行技巧与注意事项
良月柒
06-18 620
/MyBatis 作为一个灵活的持久层框架，通过提供丰富的动态 SQL 标签、SQL 片段复用、存储过程调用、复杂结果集处理、分页查询和批量操作等功能，使开发者能够高效地实现各种复杂的 SQL 操作。
SpringCloud Alibaba Sentinel基础入门与安装
小小默：进无止境
06-19 268
随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式、多语言异构化服务架构的流量治理组件，主要以流量为切入点，从流量路由、流量控制、流量整形、熔断降级、系统自适应过载保护、热点流量防护等多个维度来帮助开发者保障微服务的稳定性。
Javase.认识异常
最新发布
Joseit的博客
06-21 1135
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
Java SE入门及基础（55）& Stream流及常用API
m0_63181360的博客
06-19 487
通过外部迭代，你的应用程序既可以确定要迭代的集合，又可以确定迭代的方式。它可以更轻松地利用并行计算的优势，这涉及将问题分为子问题，同时解决这些问题，然后将解决方案的结果组合到子问题中。）会产生非流结果，例如原始值（如双精度值），集合，或者在forEach的情况下根本没有任何值。它们处理流中的元素：聚合操作从流中而不是直接从集合中处理元素。流将一个基本数据类型的数组转换为包装类型的数组，再将包装类型的数组转换基本数据类型数组。筛选器操作返回一个新流，该流包含与筛选条件（此操作的参数）匹配的元素。
高通Android 12/13 Launcher3修改RecentView与屏幕方向保持一致
qq_15950325的博客
06-18 356
最近同事遇到一个需求说，recentview应用预览与屏幕方向不一致，问题，于是加了一些日志，实现此需求。3、最后展示RecentView与屏幕方向保持一致。2、源码修改diff如下所示。源码修改路径汇总如下。
c# 学习笔记 PropertyChangedEventHandler、 =＞、DependencyObject、DataContext
汤圆
06-19 714
在C#中，和常常与接口一起使用，这是实现数据绑定和通知机制的关键部分，尤其在WPF (Windows Presentation Foundation) 或其他支持数据绑定的UI框架中。
java-System 概述 2
weixin_41247813的博客
06-18 812
模块化和高内聚性是设计优良系统的重要原则。`System`类通过`setSecurityManager`和`getSecurityManager`方法允许设置和获取当前的安全管理器（Security Manager）。`System`类中的许多方法（例如`currentTimeMillis`和`arraycopy`）都是通过类似的机制实现的。- **使用`arraycopy`进行数组拷贝**：与手动循环相比，`System.arraycopy`方法在性能上更优，因为它是本地实现的，直接操作内存。
什么是try-catch?
qq_60504665的博客
06-18 405
try-catch是编程中用于处理异常（errors 或 exceptions）的一种结构，特别是在许多编程语言中，如 JavaScript、Java、C#、Python（尽管 Python 的语法略有不同）等。它的主要目的是在代码执行过程中捕获并处理运行时错误，从而防止程序因未处理的异常而意外终止。以下是try-catch。
场景设计题
大袤宏图
06-15 394
为什么要这样分表？跨库join如何解决？数据量突增怎么解决？ 如何解决线上问题？cpu狂飙怎么办？频繁minor gc怎么办？可能造成的原因是什么？如何避免？ 数据库 隔离级别，怎么实现的？当前读，快照读？MVCC？ 分库分表的设计？ 分布式事务出现过不一致吗？为什么？怎么解决？有什么方法避免？怎么监控？监控到怎么处理？什么时候需要人工接入 如何优雅的写代码？什么代码算做优雅？什么代码是规范？你们代码规范是什么样的？ 如何进行code review？ mysql innodb下，能不能不设置主键？主键
【并发编程实战】内存模型--解决可见性和有序性的利器
上善若水
06-18 776
在前面讲了三个问题，缓存导致的可见性问题，编译优化带来的有序性问题，线程切换带来的原子性问题。既然存在问题，那么总要有解决方案的，这一章里主要就是解决这三个问题的关键点--内存模型。
Java 面向对象之重写
王员外的博客
06-20 290
重写、也被称作覆盖、英文名为Override，它是面向对象程序设计中非常重要的思想，什么时候该用重写？怎么重写？这都需要一点点经验哦！今天我们一起学习重写！
如何从零开始学习Java
03-09
从零开始学习Java，可以按照以下步骤进行： 1. 先学习Java的基础语法，包括数据类型、变量、运算符、流程控制语句等。 2. 学习面向对象编程的概念和Java中的类、对象、继承、多态等。 3. 掌握Java中的常用类库，如集合框架、IO流、网络编程等。 4. 学习Java的高级特性，如多线程、反射、注解等。 5. 练习编写Java程序，可以通过做一些小项目来提高编程能力。 6. 参加Java相关的培训课程或者在线学习平台，如慕课网、网易云课堂等，加深对Java的理解和应用。 希望以上建议对您有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值