javaSE(从0开始)day04

呼哧呼哧.

已于 2025-07-11 19:29:22 修改

阅读量1.1k

点赞数 23

CC 4.0 BY-SA版权

文章标签： java 开发语言 java基础 javaSE 输入输出循环

于 2025-07-10 21:48:51 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_62316729/article/details/149257474

一、Java语言的特性：

1. 面向对象（Object-Oriented）

2. 平台无关性（Write Once, Run Anywhere）

3. 强类型语言（Strongly Typed）

4. 自动内存管理（垃圾回收，Garbage Collection）

（1）创建Scanner 对象，获取键盘输入；

（2） do while循环：先循环后判断循环体至少执行一次

（3）for 循环：

一、Java语言的特性：

Java 是一种广泛使用的高级编程语言，具有以下主要特性：

1. 面向对象（Object-Oriented）

封装：将数据（属性）和操作数据的方法绑定在一起，通过访问控制符保护数据。
继承：子类可以继承父类的属性和方法，实现代码复用和扩展。
多态：同一方法可以根据对象类型的不同表现出不同的行为（通过继承和接口实现）。

2. 平台无关性（Write Once, Run Anywhere）

Java 程序编译后生成字节码（.class 文件），可以在任何安装了 Java 虚拟机（JVM）的平台上运行。

3. 强类型语言（Strongly Typed）

每个变量和表达式都必须有明确的类型，编译时会进行严格的类型检查，减少运行时错误。

4. 自动内存管理（垃圾回收，Garbage Collection）

JVM 自动回收不再使用的对象所占用的内存，开发者无需手动释放内存，降低了内存泄漏的风险。

5. 多线程支持

内置对多线程编程的支持，通过 Thread 类或 Runnable 接口可以轻松创建和管理线程，实现并发执行。

6. 安全性

沙箱机制：限制 Java 程序的访问权限，防止恶意代码破坏系统。
字节码验证：JVM 在加载字节码时会进行验证，确保代码符合安全规范。
安全管理器：可以进一步控制程序对系统资源的访问。

7. 健壮性（Robust）

异常处理：通过 try-catch-finally 机制处理程序运行时的异常，增强程序的稳定性。
严格的错误检查：编译时会检查许多潜在的错误，减少运行时崩溃的可能性。

8. 分布式计算

支持远程方法调用（RMI）和网络编程，方便构建分布式系统。

9. 高性能

即时编译（JIT）技术将热点代码编译为本地机器码，提升执行效率。

10. 丰富的类库

标准库：提供了大量的类和接口，涵盖字符串处理、集合框架、输入输出、网络通信等功能。
第三方库：Java 社区提供了丰富的开源库（如 Spring、Hibernate 等），加速开发。

11. 动态性

支持反射机制（Reflection），可以在运行时检查和修改类、方法、字段等信息。

12. 解释与编译并存

源码先编译为字节码，再由 JVM 解释执行；热点代码会被 JIT 编译为本地机器码。

二、输入与输出：

1.输出：

三种输出方式：（1）换行输出 println() (2)不换行输出print() (3)格式化输出

        System.out.println(); //换行
        System.out.print(' ');// 不换行 必须有内容
        //格式化输出
        System.out.printf("");//必须有内容

格式化输出：

（1）% ? 表示占位符

（2）%S格式化输出字符串任意的数据类型

(3) %d 格式化输出整型如: 整数

(4) %f 格式化输出浮点数

(5) %x 格式化输出16进制的整数整数

        String name ="张三";
        int age =19;
        double money= 13214325.565768;
        System.out.println("姓名为："+name+"年龄："+age+"余额："+money);
        System.out.printf("姓名为：%s 年龄为： %d 银行卡余额为： %.3f\n",name,age,money);
        System.out.printf("姓名为：%s 年龄为： %s 银行卡余额为： %sf\n",name,age,money);
        System.out.printf("年龄的十六进表示：%x\n",age);
        System.out.printf("科学计数法：%e\n",money);

2. 输入 :

（1）创建Scanner 对象，获取键盘输入；

Scanner sc =new Scanner(System.in);

System.out.println("请输入一个字符串");

（2）输入对象常见的方法：

next(); 获取键盘输入的一个字符串，不能识别空字符

             //String next1 = sc.next();
             // System.out.println(next1); //不识别空格，空格之后的不能识别

nextLine()：获取键盘输入的一行字符串能识别空字符

           System.out.println("输入一行字符串：");//识别一行内的空格任意字符
           String s = sc.nextLine();
           System.out.println("输入的一行为："+s);

nextInt() : 获取一个整数。

nextDouble();获取一个浮点数。

 //整数
System.out.println("请输入一个整数"); 
int i = sc.nextInt(); 
System.out.println("输入的整数为： "+i); 
//浮点数 
System.out.println("请输入一个浮点数"); 
double f = sc.nextDouble();
System.out.println("输入的浮点数为： "+f);

三、Java的三种基本结构：

1.顺序结构：

java程序遵循一定的顺序结构：从上到下，从左到右

2.选择结构：if switch

（1）单分支结果：if

/* 单分支：
* if(boolean 表达式){
* 表达式为true 执行语句
* }
*/

（2）双分支结果：if else

/* 双分支：
* if(boolean 表达式){
* 表达式为true 执行语句
* }else{
* 表达式为false 执行语句
* }
*/

（3）多分支结果：if else

/* 多分支
* if(布尔表达式1){
* 表达式1成立时，需要做的事情
* }else if(布尔表达式2){
* 表达式2成立时，需要做的事情}..
* else{
* 不满足上述所有条件做的事情
* }
*/

（4）多分支结果：switch:

注意事项：

1.语句具有穿透性（进行表达式和常量的等值判断后，不会在进行比较，代码从上往下执行完成），break接触穿透性

2. 表达式：int char 字符串枚举

3. case 后面只能是常量，不能是变量，常量值不能重复

4. 如果case 后的常量值不相等，则走default /*

* switch(表达式){
* case: 常量1：
* 语句块1
* break;
* case: 常量1：
* 语句块1
* break;
* case: 常量1：
* 语句块1
* break;
* default:
* break;
* }
*/

if分支结构的应用：

     //单分支
        System.out.println("请输入你本次考试成绩");
        int score =new Scanner(System.in).nextInt();
        if(score >= 60) {
            System.out.println("成绩合格");
        }
            System.out.println("end");

        //双分支
        System.out.println("请输入你本次考试成绩");
        int score2 =new Scanner(System.in).nextInt();
        if(score >= 60) {
            System.out.println("成绩合格");
        }else{
            System.out.println("成绩不合格");
        }
        System.out.println("end");

        //多分支
        int score3 = 59;if(score >= 80){
            System.out.println("优秀");
        }else if(score >=60){
            System.out.println("良好");
        }else if(score <60){
            System.out.println("不及格");
        }
        //使用误差法进行发电书的相等判断
        double x =1-9.0/10;
        System.out.println(x);
        if(Math.abs(x-0.1)<0.000001){
            System.out.println(" x is 0.1");
        }else {
            System.out.println("x is not 0.1");
        }

        String s1 ="ABCd".toUpperCase(); //字符串相等比较
        if("ABCD".equals(s1)){
            System.out.println("相等");
        }else {
            System.out.println("不相等");
        }

switch 分支结构的应用

        String potion =new Scanner(System.in).next();
        final String str="B";
        switch (potion){
            default:
                System.out.println("输入内容不正确");
                break;
            case "A":
                System.out.println("单人模式");
                break;
            case str:
                System.out.println("多人模式");
                break;
            case "C":
                System.out.println("退出模式");
                break;
        }

3.循环结构：

（1）while循环：先判断后循环

while（boolean 类型表达式）{

循环体；

}

//当表达式为true，执行循环体，否则跳出循环

          使用while循环计算数组的和
          int[] arr={1,23,47,73,29,10,2};
          int i=0;
          int sum=0;
          while(i<arr.length){
              sum+=arr[i];
              i++;

          }

（2） do while循环：先循环后判断循环体至少执行一次

do {

循环体；

}while（boolean 类型表达式;

//先执行循环体，当表达式为true，继续循环体，否则跳出循环

 // 输出1~100 之间的奇数 
       int z=1;
        do{
            if(z%2!=0){
                System.out.println(z);
            }
            z++;
        }while (z<=100);

（3）for 循环：

初始化变量：数据类型变量名=值
条件判断; Boolean 类型，为true进入循环体
步进语句：对初始化变量进行修改
循环体：

for(1初始化变量;2条件判断;3步进语句){
4 循环体
}

//执行顺序：第一次1，2，4，3 后面每次： 2，4，3

//求1~100之间的和
        int sum =0;
        for (int i=1;i<=100;i++){
            sum+=i;
        }
        System.out.println(sum);

（3）嵌套for 循环：外层控制行、内层控制列

      //双重 for循环
        for (int i=0;i<4;i++) {
            //内层循环控制列
            for (int j = 0; j < 7; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
        //外层控制行
        //内层控制列
        for(int i=1;i<=9;i++){
            for (int j=1;j<=i;j++ ){
                System.out.print(i+"*"+j+"="+i*j+" ");
            }
            System.out.println();
        }