第二章---Java基础语法（下）

最新推荐文章于 2024-09-23 15:50:28 发布
最新推荐文章于 2024-09-23 15:50:28 发布
阅读量248 收藏
点赞数
分类专栏： Java 文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44760706/article/details/107622552
版权

一、流程控制

|-用来控制程序各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块
|-基本流程结构：
|-顺序结构：程序从上到下逐行执行，中间没有任何判断和跳转
|-分支结构：根据条件，选择性的执行某段代码
|-if-else、switch-case
|-循环结构：根据循环条件，重复性的执行某段代码
|-while、do-while、for
注意：JDK1.5提供了foreach循环，方便的遍历集合，数组元素

二、if-else结构

|-格式：
|-if（条件表达式）{
执行代码块；
}

|-if（条件表达式）{
执行代码块；
}
else{
执行代码块；
}
在这里插入图片描述
|-if（条件表达式）{
执行代码块1；
}
else if（条件表达式2）{
执行代码块2；
}
…
else{
执行代码块n;
}
在这里插入图片描述

二、使用Sacnner从键盘获取值

实现步骤：
|-导包：import java.util.Scanner;
|-Scanner的实例化：Scanner scan = new Scanner(System.in);
|-使用Scanner的相关方法（next（）、nextxxx()），来获取指定类型的变量
|-对于char的获取，Scanner并没有提供相关方法，只能获取一个字符串
注意：需要根据相应的方法，来输入指定类型的值，如果输入的数据类型与要求的数据类型不匹配时，会报inputMisMatchException，导致程序终止。
例：使用Scanner

import java.util.Scanner;
class ScannerTest{
     public static void main(String[] args){
        //从键盘获取不同类型的变量，需要使用Scanner类
        Scanner scan = new Scanner(System.in);

        System.out.println("请输入你的姓名：");
        String name = scan.next();
        System.out.println("你的姓名是： "+name);

        System.out.println("请输入你的芳龄：");
        int age = scan.nextInt();
        System.out.println("你的芳龄是： "+age);

        System.out.println("请输入你的体重：");
        double weigth = scan.nextDouble();
        System.out.println("你的体重是： "+weigth);

        System.out.println("你是否相中我呢？（true/false）");
        boolean islove = scan.nextBoolean();
        System.out.println("你是否相中： "+islove);

        System.out.println("请输入你的性别：（男/女）");
        String gender = scan.next();
        char genderChar = gender.charAt(0);//获取索引为0位置上的字符
        System.out.println("你性别是： "+gender);

    }
}

例：

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

        System.out.println("请输入岳小鹏期末成绩：(0--100)");
        int score = scan.nextInt();

        if(score == 100){
            System.out.println("奖励一辆宝马！");    
        }else if (score > 80 && score <= 99){
            System.out.println("奖励一部iphone xs max！");
        }else if (score >= 60 && score <= 80){
            System.out.println("奖励一部ipad！");
    }else {
            System.out.println("什么也没有！");
    }
}
}

说明：
|-else结构是可选的
|-对于条件表达式：
①：如果多个条件之间是”互斥“关系（或没有交集的关系），哪个判断和执行语句声明在上面还是下面，无所谓。
②：如果多个条件之间有交集的关系，需要根据实际情况，考虑清楚应该哪个结构声明在上面。
③：如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面，否则，范围小的就没机会执行。
例：使用if-else，获取输入的最大数，并排序

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

        System.out.println("请输入第一个整数：");
        int num1 = scanner.nextInt();
        System.out.println("请输入第二个整数：");
        int num2 = scanner.nextInt();
        System.out.println("请输入第三个整数：");
        int num3 = scanner.nextInt();


        if(num1 >= num2){
            if(num3 >= num1)
                System.out.println(num2 + "," + num1 + "," + num3);
            else if(num3 <= num2)
                System.out.println(num3 + "," + num2 + "," + num1);
            else
                System.out.println(num2 + "," + num3 + "," + num1);
            
        
        }else{
            if(num3 >= num2)
                System.out.println(num1 + "," + num2 + "," + num3);
            else if(num3 <= num1)
                System.out.println(num3 + "," + num1 + "," + num2);
            else
                System.out.println(num1 + "," + num3 + "," + num2);
            
        }

    }
}

说明：
|-if-else结构是可以互相嵌套的
|-如果if-else结构中的执行语句只有一行时，对应的一对{}是可以省略的，但是不建议
随机数的说明：
|-公式：[a,b],(int)(Math.random()(b-a+1)+a)
例：高富帅

package Exercise;
import java.util.Scanner;
class IfExer1 {
     public static void main(String[] args) {
           Scanner scan = new Scanner(System.in);
           
           System.out.println("请输入你的身高：（cm）");
           int height = scan.nextInt();
           System.out.println("请输入你的财富：（千万）");
           double wealth = scan.nextDouble();
           //System.out.println("请输入你是否帅：（true/false）");
           //boolean isHandsome = scan.nextBoolean();
        
           //方式1：
//         if(height >= 180 && wealth >= 1 && isHandsome){
//              System.out.println("我一定要嫁给他！");
//         }else if(height >= 180||wealth >= 1 ||isHandsome){
//              System.out.println("嫁吧，比上不足，比下有余！");
//         }else{
//              System.out.println("不嫁!");
//         }
//         
           //方式2：
           System.out.println("请输入你是否帅：（是/否）");
           String isHandsome = scan.next();
           
           if(height >= 180 && wealth >= 1 &&  isHandsome.equals("是")){
                System.out.println("我一定要嫁给他！");
           }else if(height >= 180||wealth >= 1  ||isHandsome.equals("是")){
                System.out.println("嫁吧，比上不足，比下有余！");
           }else{
                System.out.println("不嫁!");
           }
     
     }
     }

三、switch-case结构

|-格式：
switch（表达式）{
case 常量1：
语句1；
//break;
case 常量2：
语句2；
//break;
…
case 常量n：
语句n；
//break;
default:
语句；
//break;
}
在这里插入图片描述
例：

package Exercise;
public class SwitchCaseTeat {
     public static void main(String[] args) {
           int number = 2;
           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("three");
                break;
           default :
                System.out.println("other");
           }
     }
}

说明：
|-根据switch表达式中的值，依次匹配各个case中的常量，一旦匹配成功，进入相应case结构中调用其执行语句，当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
|-break，可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
|-switch-case结构中的表达式，只能是如下的6种数据类型之一：byte、short、char、int、枚举类型、String类型
|-case之后只能声明常量，不能声明范围
|-break关键字是可选的
|-default：相当于if-else结构中的else，结构是可选的，而且位置是灵活的
例：

package Exercise;
public class SwitchTest1 {
     public static void main(String[] args) {
           int score = 78;
           
           switch(score / 10){
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                      System.out.println("不合格！");
                    break;
                case 6:
                case 7:
                case 8:
                case 9:
                case 10:
                      System.out.println("合格");
                    break;
                
                //更优的结构
//                  switch(score /60) {
//                  case 0:
//                    System.out.println("合格！");
//                  case 1:
//                    System.out.println("不合格！");
//                  }
//              
           
           }
           
     }
}

说明：
|-如果switch-case结构中的多个case执行语句相同，则可以考虑进行合并
例：

package Exercise;
import java.util.Scanner;
public class SwitchCaseTest2 {
     public static void main(String[] args) {
           
           Scanner scan = new Scanner(System.in);
           System.out.println("请输入2019年的month：");
           int month = scan.nextInt();
           System.out.println("请输入2019年的day：");
           int day = scan.nextInt();
           
           //方式1：代码冗余
           //定义一个变量来保存天数
           int sumDays = 0;
           /*
           if(month==1) {
                sumDays = day;
           }else if(month == 2) {
                sumDays = 31+day;
           }else if(month == 3) {
                sumDays = 31+28+day;
           }else if(month == 4) {
                sumDays = 31+28+31+day;
                */
                
           
           //方式2：冗余
           /*
           switch(month) {
           case 1:
               sumDays = day;
               break;
           case 2:
                sumDays = 31+day;
                break;
           case 3:
                sumDays = 31+28+day;
                break;
           }
           */
           
           //方式3：
           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:
                sumDays += 28;
           case 2:
                sumDays += 31;
           case 1:
                sumDays += day;
           }
           System.out.println("2019年"+month+"月"+day+"日是当年的第"+sumDays+"天");
           
           }
           
     }

说明：
|-break在switch-case结构中是可选的
例：判断某一年是否是闰年

package Exercise;
import java.util.Scanner;
public class SwitchCaseExer {
     public static void main(String[] args) {
           Scanner scan = new Scanner(System.in);
           System.out.println("请输入year：");
           int year = scan.nextInt();
           System.out.println("请输入month：");
           int month = scan.nextInt();
           System.out.println("请输入day：");
           int day = scan.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;
                //判断year是否是闰年
           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+"天");
           
           }
     }

四、switch-case与if-else的转换说明

|-凡是可以使用switch-case的结构都可以转换为if-else,反之不成立
|-写分支结构时，当发现既可以使用switch-case（同时switch中表达式的取值情况不太多），又可以使用if-else时，优先使用switch-case,原因：switch-case执行效率稍高

五、循环结构

|-在某些条件满足的情况下，反复执行特定代码的功能
分类：
|-for循环
|-while循环
|-do-while循环
|组成：
|-初始化部分
|-循环条件部分—>boolean类型
|-循环体部分
|-迭代部分
在这里插入图片描述
|-for循环结构：
for( 初始化;循环条件;迭代){
循环体;
}
例：

package Exercise;
public class ForTest {
     public static void main(String[] args) {
           
           /*for (int i = 1; i <= 5; i++) {
                System.out.println("Heello World");
           }*/
           
           //练习：
           /*int num = 1;
           for(System.out.print("a");  num<=3;System.out.print("c"),num++) {
                System.out.print("b");
           //输出结果：abcbcbc
           }*/
           
           //例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
           int sum = 0;//记录所有偶数的和
           int count = 0;//记录偶数的个数
           for(int i = 1;i <= 100; i++) {
                if(i % 2 == 0) {
                      System.out.println(i);
                      sum += i;
                      count++;
                }          
           }
           System.out.println("所有偶数总和为："+sum);
           System.out.println("偶数个数为："+count);
     }
}

例：

package Exercise;
public class ForTest1 {
     public static void main(String[] args) {
           for(int i = 1;i <= 150; i++) {
                System.out.print(i + " ");
                
                if(i % 3 == 0) {
                      System.out.print("foo ");
                }
                if(i % 5 == 0) {
                      System.out.print("biz ");
                }
                if(i % 7 == 0) {
                      System.out.print("baz ");
                }
                //换行
                System.out.println();
           }
     }
}

例：

package Exercise;
import java.util.Scanner;
public class ForTest2 {
     public static void main(String[] args) {
           
           Scanner scan = new Scanner(System.in);
           
           System.out.println("请输入第一个正整数：");
           int m = scan.nextInt();
           
           System.out.println("请输入第二个正整数：");
           int n = scan.nextInt();
           //获取最大公约数
           //1.获取两个数中的较小值
           int min = (m <= n)?m : n;
           //遍历
           for(int i = min;min>=1; i--) {
                if(m % i == 0 && n % i ==0) {
                      System.out.println("最大公约数为："+i);
                      break;//一旦执行到break，就跳出循环
                }          
           }
           
           //获取最小公倍数
           //获取两个数中的较大值
           int max =(m >= n)?m:n;
           for(int i = max; i <= m*n;i++) {
                if(i % m == 0 && i % n == 0) {
                      System.out.println("最小公倍数为："+i);
                      break;
                }
                
           }
           
     }
}

说明：
|-一旦执行到break就跳出循环
|-while循环：
|-结构：
初始化；
while（循环条件）{
循环体；
}
迭代；
例：

package Exercise;
public class WhileTest {
     public static void main(String[] args) {
           // 遍历100以内的偶数
           int i = 1;
           while(i<=100) {
                if(i % 2 == 0) {
                      System.out.println(i);
                }
                i++;
                
           }
     }
}

说明：
|-不要丢失迭代条件，否则程序将会进入死循环
|-写程序避免出现死循环
|-for循环和while循环是可以相互转换
|-区别：for循环和while循环的初始化条件部分的作用范围不同
算法特征之一：有限性
|-do-while循环：
|-结构：
初始化;
do{
循环体；
迭代；
}while(循环条件;)
例：

package Exercise;
public class DoWhileTest {
     public static void main(String[] args) {
           //遍历100以内的偶数,并计算所有偶数的和，以及偶数的个数
           int num = 1;
           int sum = 0;//记录总和
           int count = 0;//记录个数
           do {
                if(num % 2 == 0) {
                      System.out.println(num);
                      sum += num;
                      ++count;
                }
                num++;
           } while (num <= 100);
           
                System.out.println("总和为："+ sum);
                System.out.println("个数为："+ count);
     }
}

说明：
|-do-while至少会执行一次循环体
例:

package Exercise;
import java.util.Scanner;
public class ForWhileTest {
     public static void main(String[] args) {
           // TODO Auto-generated method stub
           Scanner scan = new Scanner(System.in);
           
           int positiveNumber = 0;//记录正数的个数
           int negativeNumber = 0;//记录负数的个数
            
            while(true) {
                 int number = scan.nextInt();
                 
                 //判断number的正负情况
                 if(number > 0) {
                       positiveNumber++;
                 }else if(number < 0) {
                       negativeNumber++;
                 }else {
                       //一旦执行break，就跳出去
                       break;
                 }
            }
            System.out.println("输入的正数个数为："+  positiveNumber);
            System.out.println("输入的负数个数为："+  negativeNumber);
     }
}

说明：
|-不在循环条件部分限制次数的结构：for(;;)或while（true）
|-结束循环的方式：
|-循环条件部分返回false
|-在循环体中，执行break

五、嵌套循环

|-将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环
|-外层循环：循环结构B
|-内层循环：循环结构A
例：

package Exercise;
public class ForForTest {
     public static void main(String[] args) {
           /*
           for(int i = 1;i <= 500; i++) {
                System.out.println("*");
           }
           */
           
           for(int j = 1; j<=4;j++) {
                for(int i = 1;i <= 6; i++) {
                      System.out.print("*");
                }
                System.out.println();
           }
     }
}

说明：
|-内层循环结构遍历一遍，只相当于外层循环循环体执行一次
|-外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体一共执行了m*n次
技巧：外层循环控制行数，内层循环控制列数
例：

package Exercise;
public class ForForTest {
     public static void main(String[] args) {
     for(int i = 1; i <= 5; i++) {//控制行数
                for(int j = 1;j<=i; j++) {
                      System.out.print("*");
                }
                System.out.println();
           }
           
           for(int i = 1; i<=4; i++) {
                for (int j = 0; j <= 5-i; j++) {
                      System.out.print("*");
                }
                System.out.println();
           }
     }
}

例：九九乘法表

package Exercise;
public class NineNineTable {
     public static void main(String[] args) {
           for(int i = 1; i <= 9; i++) {
                for (int j = 1; j <= i; j++) {
                      System.out.print(j + "*" + i +"=" +(i*j) +  " ");
                }
                System.out.println();
           }
     }
}

例：100以内所有质数（只能被1和它本身整除的自然数）
|-从2开始，到这个数-1结束为止，都不能被这个数本身整除
实现方法一：（以下均为实现方法一）

package Exercise;
public class PrimeNumberTest {
     public static void main(String[] args) {
           
           boolean isFlag = true;//标识i是否被j除尽
           
           for (int i = 2; i <= 100; i++) {//遍历100以内的自然数
                for (int j = 2; j <i; j++) {//被i去除
                      if(i % j == 0) {//i被j除尽
                           isFlag=false;
                      }
                }
                if(isFlag == true) {
                      System.out.println(i);
                }
                //重置isFlage
                isFlag = true;
                
           }
     }
}

对上述质数输出算法优化：
|-优化1：加break---->优化前：23984 优化后：2290,只对本身非质数的自然数是有效的

package Exercise;
public class PrimeNumberTest2 {
     public static void main(String[] args) {
    
           boolean isFlag = true;//标识i是否被j除尽
           
           //获取当前时间距离1970-01-01 00:00:00的毫秒数
           long start = System.currentTimeMillis();
           
           for (int i = 2; i <= 100000; i++) {//遍历100以内的自然数
                for (int j = 2; j <i; j++) {//被i去除
                      if(i % j == 0) {//i被j除尽
                           isFlag=false;
                           break;//优化1：只对本身非质数的自然数是有效的
                      }
                }
                if(isFlag == true) {
                      System.out.println(i);
                }
                //重置isFlage
                isFlag = true;
                
           }
           long end = System.currentTimeMillis();
           
           System.out.println("所花费的时间为："+(end - start));
     }
}

|-优化2：去掉输出语句，只记录质数个数---->优化前：21768，优化后：2068

package Exercise;
public class PrimeNumberTest2 {
     public static void main(String[] args) {
    
           boolean isFlag = true;//标识i是否被j除尽
           int count = 0;//记录质数的个数
           
           //获取当前时间距离1970-01-01 00:00:00的毫秒数
           long start = System.currentTimeMillis();
           
           for (int i = 2; i <= 100000; i++) {//遍历100以内的自然数
                
                //优化2：Math.sqrt(i)，对本身是自然数的质数是有效的
                for (int j = 2; j <i; j++) {//被i去除
                      if(i % j == 0) {//i被j除尽
                           isFlag=false;
                           break;//优化1：只对本身非质数的自然数是有效的
                      }
                }
                if(isFlag == true) {
//                    System.out.println(i);
                      count++;
                }
                //重置isFlage
                isFlag = true;
                
           }
           long end = System.currentTimeMillis();
           System.out.println("质数的个数为："+count);
           System.out.println("所花费的时间为："+(end - start));
     }
}

优化3：Math.sqrt(i)，—>优化后18，对本身是自然数的质数是有效的

package Exercise;
public class PrimeNumberTest2 {
     public static void main(String[] args) {
    
           boolean isFlag = true;//标识i是否被j除尽
           int count = 0;//记录质数的个数
           
           //获取当前时间距离1970-01-01 00:00:00的毫秒数
           long start = System.currentTimeMillis();
           
           for (int i = 2; i <= 100000; i++) {//遍历100以内的自然数
                
                //优化2：Math.sqrt(i)，对本身是自然数的质数是有效的
                for (int j = 2; j <=Math.sqrt(i); j++) {//被i去除
                      if(i % j == 0) {//i被j除尽
                           isFlag=false;
                           break;//优化1：只对本身非质数的自然数是有效的
                      }
                }
                if(isFlag == true) {
//                    System.out.println(i);
                      count++;
                }
                //重置isFlage
                isFlag = true;
                
           }
           long end = System.currentTimeMillis();
           System.out.println("质数的个数为："+count);
           System.out.println("所花费的时间为："+(end - start));
     }
}

上述优化为了清晰分辨只是分开做的笔记，代码是一样的，只是修改而已

六、break、continue的使用

使用范围：
|-break:switch-case循环结构中，结束当前循环
|-continue:循环结构中，结束当次循环
|-相同点：关键字后面不能声明执行语句
例：

package Exercise;
public class BreakContinueTest {
     public static void main(String[] args) {
           for(int i = 1;i <= 10;i++) {
                if(i % 4 == 0) {
                      //break;
                      continue;
                }
                System.out.print(i);
           }
     }
}

|-带标签的break、continue使用
例：

package Exercise;
public class BreakContinueTest {
     public static void main(String[] args) {
lable:for(int i = 1; i <= 4; i++) {
                for(int j = 1;j <= 10;j++) {
                      if(j % 4 == 0) {
                           //break;//默认跳出包裹此关键字最近的一层循环  
                           //continue;
                           
                           //break lable;//结束指定标识的一层循环结构
                           continue lable;//结束指定标识的一层循环结构当次循环
                      }
                      System.out.print(j);
                }
                System.out.println();
           }
           
     }
}

附加：
return：并非专门用于结束循环，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法就将结束，与break，continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。
例：100以内所有质数（只能被1和它本身整除的自然数）
**|-从2开始，到这个数-1结束为止，都不能被这个数本身整除
实现方法二：

package Exercise;
public class PrimeNumberTest3 {
     public static void main(String[] args) {
           
           int count = 0;//记录质数的个数
           
           //获取当前时间距离1970-01-01 00:00:00的毫秒数
           long start = System.currentTimeMillis();
           
           lable:for (int i = 2; i <= 100000; i++) {//遍历100以内的自然数
                for (int j = 2; j <=Math.sqrt(i); j++) {//被i去除
                      if(i % j == 0) {//i被j除尽
                           continue lable;
                      }                     
                }
                //能执行到此步骤的都是质数
                      count++;
           }
           long end = System.currentTimeMillis();
           System.out.println("质数的个数为："+count);
           System.out.println("所花费的时间为："+(end - start));
     }
}
不用氪金的小马哥
关注
专栏目录
javaSE基础知识第二章基础语法组成(下)
weixin_45645828的博客
03-26 155
7.程序流程控制语句 流程控制概述: 在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。 所以，我们必须清楚每条语句的执行流程。 而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。 流程控制语句共分为三类 - 1.顺序结构 按照代码的先后顺序，从上往下依次执行， - 2.分支(判断)结构 根据条件判断,选择执行一段代码 - ...
java流程控制
shuai_举的博客
03-10 198
java流程控制 1. 分支结构 1.1 if-else条件判断结构 书写方法： 结构一： if(条件表达式){ 执行表达式 } 结构二：二选一 if(条件表达式){ 执行表达式1 }else{ 执行表达式2 } 结构三：n选一 if(条件表达式){ 执行表达式1 }else if(条件表达式){ 执行表达式2 }else if(条件表达式){ 执行表达式3 } ... else{ 执行表达式n } 说明： else结构是可选的 针对于条件表达式 ① 如果多个条件表达式之间是“互斥”
第三章 流程控制
weixin_42023744的博客
08-30 161
第三章 流程控制 今日内容 if else判断语句 switch选择语句 学习目标 掌握键盘输入各种数据类型的值 理解if语句的格式和执行流程 理解if…else语句的格式和执行流程 理解if…else if语句的格式和执行流程 了解if语句和三元运算符互换 理解switch选择语句的格式和执行流程 掌握switch选择语句接收的数据类型 理解case的穿透性 掌握brea...
Java自学之路：经典求质数问题
dong19991007的博客
02-18 131
100以内的所有质数的输出 质数：素数，只能被1和它本身整除的自然数。 如何判断是否是质数 —> 从2开始，到这个数-1结束为止，都不能被这个数本身整除 public class PrimeNumberTest { public static void main(String[] args) { // TODO Auto-generated method stub boolean isFlag = true;//表示i是否被j除尽,一旦除尽,修改其值 for.
Java基础题10：(单选题)以下代码的输出结果是（） public class Test { public static void main(String[] args) { Stri
热门推荐
qq_45453185的博客
08-15 2万+
Java基础语法——Java语言介绍
qq_52519008的博客
04-11 9226
1. Java语言简介 1.1 Java故事 Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。 Java
java基础语法练习题（第二章）
DecorateCC的博客
04-05 8007
文章目录一、java基础语法变量的类型转换变量作用域算数运算符赋值运算符 一、java基础语法 变量的类型转换 1、下列数据类型进行运算时，哪一个会发生自动类型提升（ ） A、int+int B、long+long C、byte+byte D、double+double 参考答案：C byte型的变量在运算期间类型会自动提升为int型 2、下列数据类型中，哪种数据类型转为int类型需要进行强制转换（） A、byte B、short C、char D、float 参考答案：D 3、请阅读下列的程序 pub
Java全栈学习---后端---Java基础
weixin_51267250的博客
03-25 262
Java全栈学习—后端—Java基础
第二章：JAVA编程基础
link的博客
08-29 1751
Java基础知识总结
Java程序设计-第02章-Java基础语法PPT课件.ppt
07-04
第二章主要讲解Java的基础语法，这是学习任何编程语言的基础。在这个章节中，学生将深入理解Java中的标识符、关键字、基本数据类型、变量和常量、运算符、语句以及输入参数的处理方式。 标识符在Java中用于给变量、...
第5章-JAVA面向对象编程基础.ppt
11-21
JAVA面向对象编程基础 ...本章内容涵盖了 JAVA 面向对象编程的基础知识，包括定义类、创建类的实例对象、构造函数、访问控制修饰符、静态属性和静态方法等，旨在帮助读者掌握 JAVA 面向对象编程的基础知识和技能。
JAVA语言程序设计--第二章JAVA基础
03-21
在“JAVA语言程序设计--第二章JAVA基础”这个主题中，我们主要探讨的是Java编程语言的基本概念和核心特性。Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现为Oracle公司）于1995年发布。它以其“一...
第2章-Java语言基础语法.pptx
03-27
Java语言基础语法 Java语言基础语法是Java程序设计的基础，涵盖了数据类型、变量、运算符、控制流语句、数组等知识点。在本章节中，我们将详细介绍Java语言的基础语法。 数据类型是Java语言的基础，Java语言定义了...
计算机后端-Java-Java核心基础-第06章 Java基本语法4 16. 质数输出的实现方式二.avi
05-22
计算机后端-Java-Java核心基础-第06章 Java基本语法4 16. 质数输出的实现方式二.avi
微服务--Gateway网关
最新发布
weixin_51933701的博客
09-23 833
Zuul是Spring Cloud早期版本中广泛使用的网关组件，它基于Netflix Zuul构建。Zuul提供了路由、负载均衡、容错、安全性等多种功能，是微服务架构中API网关的常用选择之一。然而，需要注意的是，随着Spring Cloud的发展，Zuul逐渐进入维护模式，Spring Cloud官方推荐使用Spring Cloud Gateway作为替代方案。
Android系统：系统架构
liufeismart2024的博客
09-23 293
Android的系统结构的设计混合了分层设计和分块设计。
JDK17新增语法特性
2201_76124988的博客
09-20 752
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 260
faiss版本 faiss-v1.7.4。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 1109
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
Java基础：第二章 - 变量与运算符详解
"Java基础第二章_withMarginNotes.pdf主要涵盖了Java语言的基本语法，特别是变量与运算符、关键字和保留字的使用，以及相关的编程规范。" 在Java编程中，了解和掌握关键字和保留字至关重要，因为它们是构成程序的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值