JavaSE-基础语法

标签：个数   功能   ada   变量   break   ||   double   改变   图片   

第一章：变量

1.1-为什么需要变量？

? 在计算机中，程序运行需要对数据进行处理，而程序中的数据在运行时会存储在内存中，编程中需要频繁操作内存中的数据，为了方便操作，程序中需要通过变量名作为标识符来操作内存中相关的数据。

1.2-什么是变量？

? 变量就是在内存中所分配给数据的一块空间。同时内存会为该空间指定一个内存地址。

? 程序中可以通过变量名操作内存中的数据。

1.3-如何定义和使用变量？

定义变量

• 基本格式：数据类型 变量名 = 数据;

• 代码演示：

  public static void main(String[] args) {
          /* 基本格式：数据类型 变量名 = 数据 */;
          int age = 10;
          /* 其他格式: 先定义，后赋值 */
          int num1;
          num1 = 10;
          /* 其他格式：批量定义赋值 */
          int a = 10,b = 20,c = 30;
  }

使用变量

• 使用方式：在程序中，直接调用变量名即可。

• 代码演示：

  public static void main(String[] args) {
          /* 定义变量 */;
          int age = 10;
          /* 调用变量 */
          System.out.println(age); // 输出结果：10
  }

• 注意事项：

  • 在java方法中，若定义变量且没有赋值时，在调用变量时，编译无法通过。

  • 代码演示：

    public static void main(String[] args) {
        /* 在方法中，定义变量，但没有赋值*/
        int age;
        System.out.println(age);  // 结果：编译不通过
    }

1.4-变量名的命名规则和规范是什么？

• 规则：必需按照此方式定义变量名，否则编译不通过
  1. 变量名必须由数字、字母、下划线、$组合，但不能以数字开头。
  2. 变量名不能使用关键字（如：class、int等）
• 规范：在开发中，为了便于后期维护，定义变量名时，要遵循以下规范。若不遵守，编译也可以通过，但会影响代码的阅读性
  1. 变量名要按照小驼峰格式命名。变量名若有多个单词组合时，首个单词字母小写，后续单词首字母大写。如：userName
  2. 变量名命名要顾名思义。
  3. 变量名区分大小写。

第二章：数据类型

2.1-数据为什么要区分类型？

不同种类的数据可以表示不同的事物

? 计算机中存储的所有内容（文本文件、音乐文件、电影文件等等），都可称为数据。

? 数据主要用来模拟现实事物。比如，如何描述商品的价格、人的身高呢？那就可以用数字类型的数据表示。如何描述一段文字呢（如：床前明月光）？此时就无法用数字类型的数据表示了，那就得用字符串表示。

? 所以，根据模拟的现实事物不同，需要用不同类型的数据表示。

? 另外需要注意的是，无论操作什么类型的数据，在计算机中最终都是以二进制存储的。

数据类型的划分

在Java中，数据分为两大类：

• 基本数据类型
  • 数字
  • 布尔
  • 字符
• 引用数据类型
  • 类
  • 接口

本篇先学习基本数据类型，后续再学习引用类型的数据。

2.2-基本数据类型有哪些？

八种基本数据类型：

• 四类八种
  1. 整数：byte/short/int/long
  2. 浮点数：float/double
  3. 字符：char
  4. 布尔：boolean
• 注意
  1. 整数默认类型是int
  2. 浮点数默认类型是double

2.3-不同类型的数据如何转换？

自动转换（隐式）

• 特点：不需要特殊的代码处理，会自动转换。

• 规则：针对数字和字符，范围小的类型会自动转换为范围大的类型。

  • 代码：

    public static void main(String[] args) {
            /* 字节类型 */
            byte a = 10;
            /* 整型 */
            int b = a;
            // 结果：字节类型10会自动转换为int类型
    }

强制转换（显式）

• 特点：需要特殊代码处理

• 格式：(要转换的数据类型)数据

• 代码：

  public static void main(String[] args) {
          /* 大范围数据无法自动转换为小范围数据 */
          // int a = 20;
          // byte b = a;  
          // 结果：编译错误
  
          /* 强制转换 */
          int a = 20;
          byte b = (byte)a;
          // 结果：转换成功
   }

• 注意事项：

  • 事项：

    1. 强制转换可能会造成数据溢出。
    2. 强制转换可能会丢失精度。

  • 代码：

    public static void main(String[] args) {
            /* 数据溢出 */
            int a = 130;
            byte b = (byte)a;
            System.out.println(b);
            // 运行结果：-126
            // 原因：130超出了byte表示范围
    
            /* 丢失精度 */
            double pai = 3.14;
            int c = (int)pai;
            System.out.println(c);
            // 运行结果：3
            // 丢失了0.14
    }

第三章：运算符

3.1-为什么需要运算符？

? 在程序中，需要频繁的运算数据，比如我们在网上购物时，需要计算总价格。

? 如何命令计算机计算数据呢？这时就需要运算符号表示运算。

3.2-如何使用不同的运算符？

算术运算符

• 运算符号：

  1. 表示加法运算：+
  2. 表示减法运算：-
  3. 表示乘法运算：*
  4. 表示除法运算：/
  5. 表示取模运算：%

• 代码：

  public static void main(String[] args) {
          int a = 10;
          int b = 3;
          /* 加法运算 */
          System.out.println(a + b);
          // 结果：13
          /* 减法运算 */
          System.out.println(a - b);
          // 结果：7
          /* 乘法运算 */
          System.out.println(a * b);
          // 结果：30
          /* 除法运算 */
          System.out.println(a / b);
          // 结果：3
          /* 取模运算-求余数 */
          System.out.println(a % b);
          // 结果：1
          /* 注意：在java中，任何整数不能除以0， 在运行时会发生错误！ */
          System.out.println(200/0);
          // 结果：Exception in thread "main" java.lang.ArithmeticException: / by zero
  }

比较运算符

• 运算符：

  • 大于：>
  • 小于：<
  • 等于：==
  • 大于等于：>=
  • 小于等于：>
  • 不等于：>

• 代码：

  public static void main(String[] args) {
          int a = 10;
          int b = 12;
          /* 大于 */
          System.out.println(a > b);
          // 结果：false
          /* 小于 */
          System.out.println(a < b);
          // 结果：true
          /* 等于 */
          System.out.println(a == b);
          // 结果：false
          /* 大于等于 */
          System.out.println(a >= b);
          // 结果：false
          /* 小于等于 */
          System.out.println(a <= b);
          // 结果：true
          /* 不等于 */
          System.out.println(a != b);
          // 结果：true
  }

• 注意：比较运算符的运算结果是布尔值（true或false）

逻辑运算符

• 运算符及运算规则：运算结果始终是布尔值

  • 与运算：&&
    • 使用格式：左侧条件表达式 && 右侧条件表达式
    • 规则：当左右两边的表达式结果都是true时，与运算结果才是true，其他结果都是false
  • 或运算：||
    • 使用格式：左侧条件表达式 || 右侧条件表达式
    • 规则：当左右两边的表达式有任意一边结果是true时，或运算结果才是true，其他情况结果都是false
  • 非运算：!
    • 使用格式：!条件表达式
    • 规则：取反，若条件表达式结果是true时，取反结果就是false，反之就是true。

• 代码：

  public static void main(String[] args) {
          int age = 18;
          char gender = '女';
          /* 逻辑运算与- && */
          System.out.println(age>=18 && gender=='男');
          // 运行结果：false。原因：右侧表达式不满足
  
          /* 逻辑运算或- || */
          System.out.println(age>=18 || gender=='男');
          // 运行结果：true。原因：左侧表达式满足
  
          /* 逻辑运算非- ! */
          System.out.println(!(age>=18));
          // 运行结果：false
  }

其他运算符

• 赋值运算符

  • 运算符：=

  • 意义：可以把右侧的数据赋值给指定的变量。

  • 代码：

    int age = 10; 

• 复合赋值运算符

  • 运算符：+=、-=、/=、*=、%=

  • 意义：针对变量，是算术运算符和赋值运算符的组合使用。

  • 代码：

    int age = 10;
    age+=3; 
    System.out.print(age); 
    // 运行结果：13。 age+=3 拆解 age = aeg + 3

• 小括号

  • 运算符：(表达式)

  • 意义：可以提高运算的优先级。

  • 代码：

    int result = (10 + 8) * 2

• 自增和自减

  • 运算符：++ 、 --

  • 意义：针对变量自增1或自减1

    • 前置自增或自减：++变量或--变量，先让变量自身加1或减1，再参与表达式运算。
    • 后置自增或自减变量++或变量--，先让变量自身参与表达式运算，再自身加1或减1

  • 代码：

    /* 前置自增 */
    int a = 10;
    System.out.print(++a);  // 结果：11
    System.out.print(a);  // 结果：11
    /* 后置自增 */
    int b = 10;
    System.out.print(b++);  // 结果：10
    System.out.print(b);  // 结果：11

• 三元运算符

  • 格式：条件表达式？表达式1:表达式2

  • 意义：若条件表达式成立，则执行并返回表达式1的结果，反之返回表达式2的结果。

  • 代码：

    int a = 10>8?10:8;
    System.out.print(a);  // 结果：10

第四章：流程控制

4.1-为什么需要流程控制？

? 流程，指的是程序的执行顺序。程序默认的执行顺序是自上而下执行的。

? 但是，在程序中有些程序是选择执行的或是重复执行的，不同的选择会有不同的功能。比如我们玩游戏时王者荣耀时，我们在手机上选择不同英雄时，就是程序在执行不同的代码。

? 所以，若要控制程序执行的流程，就必须学习流程控制语句。

? 流程控制语句分为两大类：分支语句 和 循环语句

4.2-如何使用流程控制？

分支语句

1. if语句

   • 格式：

     if(条件表达式){
       // 代码块
     }
     /*
      若条件表达式成立（结果是true），则执行代码块中的程序。
     */

   • 图解执行流程：
     

   • 代码：

     /* if语句 */
     int age = 19;
     if(age >=18 ){
         System.out.println("欢迎进入");
     }
     // 执行结果：欢迎进入

2. if-else语句

   • 格式：

     if(条件表达式){
       // 代码块
     }else {
       // 代码块
     }
     /*
      若条件表达式成立（结果是true），则执行if代码块中的程序，反之执行else代码块中的程序。
     */

   • 图解执行流程：

     

   • 代码：

     /* if语句 */
     int age = 10;
     if(age >=18 ){
         System.out.println("欢迎进入");
     }else {
         System.out.println("对不起，年龄不合法");
     }
     // 执行结果：对不起，年龄不合法

3. if-else if...else语句

   • 格式：

     if(条件表达式){
       // 代码块
     }else if(条件表达式){
       // 代码块
     }
     else if(条件表达式){
       // 代码块
     }
     ...
     else {
       // 代码块
     }
     /*
       代码从上而下依次判断。
       若其中有满足条件的，则进入对于的代码块执行，后续分支不再执行。
       若都不满足，则执行else中的语句。
     */

   • 图解执行流程：
     

   • 代码：

     /* if-else if -...-else 语句 */
     int score = 80;
     if(score>=90){
         System.out.println("A");
     }else if(score>=80){
         System.out.println("B");
     }else if(score>=70){
         System.out.println("C");
     }else if(score>=60){
         System.out.println("D");
     }else {
         System.out.println("E");
     }
     // 执行结果：B

4. switch语句

   • 格式：

     switch(表达式) { 
       case 常量值1: 
         语句体1;
        break;
       case 常量值2:
        语句体2;
        break; 
        ...
        default: 
         语句体n+1; 
        break;
     }
     // 首先计算出表达式的值 
     // 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
     // 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

   • 图解执行流程：
     

   • 代码：

     /* switch 语句*/
     int num = 2;
     switch (num){
         case 1:
             System.out.println("星期一");
             break;
         case 2:
             System.out.println("星期二");
             break;
         case 3:
             System.out.println("星期三");
             break;
         case 4:
             System.out.println("星期四");
             break;
         case 5:
             System.out.println("星期五");
             break;
         case 6:
             System.out.println("星期六");
             break;
         case 7:
             System.out.println("星期日");
             break;
         default:
                 System.out.println("不合法");
                 break;
     }

循环语句

1. for循环

   • 格式：

     for(初始化表达式1; 布尔表达式2; 步进表达式4){ 
       // 循环体3
     }
     /*
     执行顺序:1234>234>234...2不满足为止。 
       1负责完成循环变量初始化 
       2负责判断是否满足循环条件，不满足则跳出循环 
       3具体执行的语句 
       4循环后，循环条件所涉及变量的变化情况
     */

   • 图解：
     

   • 代码：

     /* for循环 */
     for (int i = 0; i <5 ; i++) {
         System.out.println("hello" + i);
     }
     /*
     执行结果：
       hello0
       hello1
       hello2
       hello3
       hello4
     */

2. while循环

   • 格式：

     初始化表达式1 
     while(布尔表达式2){
        循环体3
        步进表达式4 
     }
     /*
       执行顺序:1234>234>234...2不满足为止。
       1负责完成循环变量初始化。
       2负责判断是否满足循环条件，不满足则跳出循环。 
       3具体执行的语句。 
       4循环后，循环变量的变化情况
     */

   • 图解：

     

   • 代码：

     /* while循环 */
     int count = 0;
     while(count<5){
         System.out.println(count);
         count++;
     }
     /*
     执行结果：
       hello0
       hello1
       hello2
       hello3
       hello4
     */

3. do-while循环

   • 格式：

     初始化表达式1 do{
        循环体3
        步进表达式4 
     }while(布尔表达式2);
     /*
     
        执行顺序:134>234>234...2不满足为止。 
        1负责完成循环变量初始化。 
        2负责判断是否满足循环条件，不满足则跳出循环。 
        3具体执行的语句
        4循环后，循环变量的变化情况
     */

   • 图解：

     

   • 代码：

     /* do-while循环 */
     int j = 0;
     do {
         System.out.println(j);
         j++;
     }while (j<5);
     /*
     执行结果：
       hello0
       hello1
       hello2
       hello3
       hello4
     */

4. break和continue关键字

   • break：终止整个循环。

   • continue：结束循环中本次执行，并继续循环下次执行。

   • 代码：

     /* break 关键字 */
     // 如：连续吃5个包子，吃到第3个，吃饱了，后面第包子就不吃了
     for(int i = 1; i <=5; i++){
         if(i==3){
             System.out.println("吃饱了");
             break;
         }
         System.out.println("吃第" + i + "个包子");
     }
     
     /* continue关键字 */
     // 如：连续吃5个包子，吃到第3个时掉地上了，则第3个包子就不吃了，继续吃后面的包子
     for (int i = 1; i <=5 ; i++) {
         if(i==3){
             System.out.println("第" + i+ "包子掉地上了");
             continue;
         }
         System.out.println("吃第" + i + "个包子");
     
     }

第五章：数组

5.1-为什么要学习数组？

? 在程序中，有时需要一个变量来管理一组数据，此时用数组结构比较合适。

5.2-什么是数组？

? 数组，就是在内存中开辟一组连续的长度固定的且有序的存储一组同类型的数据。

? 数组，是一种引用数据类型。

• 数组是有序的，索引或是下标是有序的，从0开始
• 同类型，数组中的数据也称为数组的元素，必须是同类型的。

5.3-如何定义数组？

• 方式：

  1. 数据类型[]变量名 = new 数据类型[数组长度]
  2. 数据类型[]变量名 = new 数据类型[]{数据1,数据2...数据n}
  3. 数据类型[]变量名 = {数据1,数据2...数据n}

• 代码：

  /* 方式1-定义一个长度为5的数组，默认每个位置的元素值是0 */
  int[]nums = new int[5];
  /* 方式2-定义一个长度为3，且指定位置的值 */
  int[]nums2 = new int[]{100,200,300};
  /* 方式3-方式2的简写 */
  int[]nums3 = {100,200,300};

5.4-如何操作数组？

操作数组内部元素

• 读取数组内部元素：数组名[索引]

• 设置数组内部元素：数组名[索引]= 值

• 代码：

  int[]nums3 = {100,200,300};
  System.out.println(nums3[1]);   // 执行结果：200
  nums3[1] = 20;
  System.out.println(nums3[1]);   // 执行结果：20

遍历数组

• 数组的长度：数组名.length

• 遍历方式：循环

• 代码：

  /* 遍历数组 */
  for (int i = 0; i < numbers.length; i++) {
      System.out.println(numbers[i]);   
  }

5.5-基本数据类型和引用数据类型的区别？

数据创建时，内存分配的区别

• 基本数据类型：

  • 会在栈内存开辟一块空间存放数据。

• 引用数据类型：

  • 会在堆内存开辟一块空间存放数据具体信息。
  • 同时也会在栈内存开辟一块空间存放堆数据的引用（堆区的地址）

• 图解：

  

数据传递时的区别

• 基本数据类型是值传递（数据在栈中会克隆一份新的，两个数据互不影响）。

• 引用数据类型是引用传递（数据的引用在栈中会克隆一份新的，但两个引用指向堆区中的同一个具体数据）

• 代码：

  public static void main(String[] args) {
          int a = 10;
          int b = a;
          b = 20;
          System.out.println(a);
          // 结果：10。改变b时，a不会受到影响。
  
          int[]numbers1 = {100,200,300};
          int[]numbers2 = numbers1;
          numbers2[0] = 10;
          System.out.println(numbers1[0]);
          // 结果：10。改变numbers2时，numbers1受到影响。
  }

• 图解：

  • 图解1：基本数据类型传值

    

  • 图解2: 引用数据类型传递引用

    

第六章：方法

6.1-什么是方法

方法，在编程中也叫函数。

方法，可以将一段代码封装在一个代码块中，代表一个功能。

6.2 方法的定义和使用

定义方法的两个关键

1. 返回值
2. 参数列表

定义方式

权限修饰符 返回值类型 方法名(参数列表){
    // 封装的程序
    // return 返回对应类型的数据;
}

注意事项：

1. 若没有返回值，则返回值类型定义为void
2. 参数列表可有可无，根据需求定义。
3. 方法名和变量名命名规则一样。

// 定义无参无返回值方法
public void fn1(){
    System.out.print("你好”)；
}
// 定义有参无返回值方法
public void fn2(int num1,int num2){
     System.out.print(num1 + num2)；                        
}
// 定义有参有返回值方法
public int fn3(int num1,int num2){
  return num1 + num2；                        
}
                     

调用方法

调用方式：方法名(实参列表)

注意事项：

1. 若定义时没有形参标识，不用传入实参
2. 若方法有返回值，则需要定义与返回值同类型的变量接收。

如调用上述定义的方法：

fn1();
fn2(100,200);
int sum = fn3(100,300);

6.3 方法的重载

在Java程序中，可以定义的多个·重名的参数列表不同(参列表的个数或类型不同)的方法。这种现象叫做方法的重载。

代码如下：

public void fn(int num1,int num2){
     System.out.print(num1 + num2)；                        
}
// 定义有参有返回值方法
public int fn(int num1,int num2,int num3){
  return num1 + num2；                        
}

注意事项：

1. 重载与方法的权限修饰符和返回值类型无关

JavaSE-基础语法

标签：个数   功能   ada   变量   break   ||   double   改变   图片   

原文地址：https://www.cnblogs.com/lpl666/p/11979997.html