javaSE(从0开始)day04

目录

一、Java语言的特性：

1. 面向对象（Object-Oriented）

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

3. 强类型语言（Strongly Typed）

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

5. 多线程支持

6. 安全性

7. 健壮性（Robust）

8. 分布式计算

9. 高性能

10. 丰富的类库

11. 动态性

12. 解释与编译并存

二、输入与输出：

  1.输出：

  2.  输入 :      

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

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

三、Java的三种基本结构：

  1.顺序结构：

   2.选择结构：if   switch

           （1）单分支结果：if 

           （2）双分支结果：if  else

           （3）多分支结果：if  else

           （4）多分支结果：switch:

if分支结构的应用：

switch 分支结构的应用

3.循环结构：

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

       （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

       （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);