Java快速入门之基本语法

1 、介绍

1. java是平台无关性的 ----- > 通过java虚拟机
2. 源文件.java ----通过编译器—> 字节码文件.class ---->java虚拟机解释执行 —> 具体平台上的机器指令
3. javac 编译器，将源程序转成字节码
4. java --运行编译后的java程序(.class后缀的)

命令行运行：

javac Hello.java    -----> Hello.class
java Hello

2、命名规则

变量命名规则

1. 变量名可以由字母、数字、下划线(_)和美元符($)组成，不能以数字开头。
2. 变量名严格区分大小写
3. 变量名不能是java关键字和保留字
4. 变量名尽可能反映出其作用
5. 变量名符合驼峰命名法(第一个单词首字母小写，之后单词首字母大写)，如userName, userNameLists

命名规范

• 包名：全小写， 且是域名的倒序

• 类名：每一个单词的首字母大写

• 常量：全大写

• 方法名和变量名：驼峰命名法

3、基本数据类型

数据类型	字节	说明
byte	1	字节型
short	2	短整型
int	4	整型
long	8	长整型
float	4	单精度浮点型
double	8	双精度浮点型
char	2	字符型
boolean	1	布尔型

char 占两个字节是因为Java使用了Unicode字符集来表示字符，Unicode字符的编码值范围是0 ~ 65535

double表示方法是：123.43d或123.43

float表示方法是：23.4f

提问,下面三行会出现什么结果
public static void main(String[] args) {
        char c = 65;
        System.out.println("c=" + c);   // A
        System.out.println("c+1 = " + c + 1);   // A1
        System.out.println("c+1 = " + (c + 1));  // 66
    }

类型转换顺序

自动类型转换：指在表达式中将小类型数据自动提升为大类型数据。例如，将 int 类型的数据赋值给 long 类型的变量时，int 数据会自动转换为 long 类型。

强制类型转换

​ 使用强制转换运算符（如 (type) value）将一个大类型数据强制转换为小类型数据。但是需要注意的是，如果被转换的值超出了目标类型的范围，则可能导致精度丢失或发生溢出错误

double weight = 123.4;
float f = (float)weight;

3、易错运算符

3.1 自增(减)运算符

 public static void main(String[] args) {
        int num1 = 3;
        int num2 = num1++;   // num2 = num1; num1 = num1 + 1;
        int num3 = ++ num1;  // num1 = num1 + 1; num2 = num1;
        System.out.println("num2 = " + num2);  // 3
        System.out.println("num3 = " + num3);  // 5
    }

–或++在前表示先-1或加1在赋值，在后表示先赋值后-1或加1

// 浮点数与整数比较，只要值相等就为true
public static void main(String[] args) {
    double d = 5.0;
    int i = 5;
    System.out.println(d == i);  // true
}

3.2 逻辑运算符

package studywithwxd.a1_basic_grammer;

public class A2_TestExpression {
    // 与 : && 或 &
    // 或 : || 或 |
    // 非 : !
    public static void main(String[] args) {
        System.out.println("与操作结果");
        int n = 3;
        boolean flag = (3 > 7) & ((n++) > 2);
        // flag 和 n 的 值是多少
        printToString(flag,n);

        n = 3;
        flag = (3 > 7) && ((n++) > 2);
        // flag 和 n 的 值是多少
        printToString(flag,n);

        // 或操作
        System.out.println("或操作结果");
         n = 3;
         flag = (3 > 7) | ((n++) > 2);
        // flag 和 n 的 值是多少
        printToString(flag,n);

        n = 3;
        flag = (3 > 7) || ((n++) > 2);
        // flag 和 n 的 值是多少
        printToString(flag,n);


    }
    public static void printToString(boolean flag, int n){
        System.out.println(String.format("flag = %b",flag));
        System.out.println(String.format("n = %d",n));
    }
}

运算结果是

结果解析

• (a & b) 不管a是否为真，b都会被执行

  • int n = 3；boolean flag = (3 > 7) & ((n++) > 2);
  • 虽然 3 > 7为假，但第二个条件仍然会被执行，所以n为4

• (a && b) && 为短路与，如果条件a为真才去判断条件b，如果条件a为假，则b不会被判断。

  • int n = 3；boolean flag = (3 > 7) && ((n++) > 2);
  • 由于3 > 7 为假，所以第二个判断不会被执行，所以n 为3

• (a | b) 不论a是否为假，b都会被执行

  • int n = 3；boolean flag = (3 > 7) | ((n++) > 2); // n = 4;

• (a || b) || 为短路或，如果条件a为假才去判断条件b，如果条件a为真，则b不会被判断。

  • int n = 3；boolean flag = (3 > 7) || ((n++) > 2);
  • 由于3 > 7 为假，所以第二个判断会被执行，n = 4

3.3 三目运算符

语法：布尔表达式？表达式1 ： 表达式2

解析：布尔表达式为真执行表达式1，为假执行表达式2

public static void main(String[] args) {
    boolean flag = true;
    int res = flag ?  4 : 3;
    System.out.println(res);  // 4
}

3.4 优先级顺序

为了防止记不住优先级顺序导致出现程序逻辑错误，一般情况下，在使用运算符的时候，加上()来确保程序逻辑的正确性

4 流程控制

流程控制语句:顺序，选择，循环

4.1 顺序

一行一行按顺序的执行代码

4.2 选择

// if结构 和 switch结构
package studywithwxd.a1_basic_grammer;

public class A3_TestChoose {
    public static void main(String[] args) {

        int age = 16;
        // if

        if (age < 18) {
            System.out.println("年龄未满18,属于未成年");
        }

        // if else 形式
        age = 19;
        if (age < 18) {
            System.out.println("年龄未满18,属于未成年");
        } else {
            System.out.println("成年人");
        }

        // if else if else 形式
        age = 60;
        if (age < 18) {
            System.out.println("年龄未满18,属于未成年");
        } else if (age < 60) {
            System.out.println("年轻人或中年人");
        } else {
            System.out.println("老年人");
        }

        // case用法
        int grade = 70;
        switch (grade / 10) {
            case 10:
            case 9:
                System.out.println("成绩优秀\n");
                break;
            case 8:
                System.out.println("成绩良好\n");
                break;
            case 7:
                System.out.println("成绩中等\n");
                break;
            case 6:
                System.out.println("成绩及格\n");
                break;
            default:
                System.out.println("成绩不及格\n");
                break;
        }
    }
}

4.3 循环

// while(){};  do while(){};   for(;;), 增强for循环:foreach
 public static void main(String[] args) {
        // for
        for(int i = 0; i < 10; i++){
            System.out.println("wxd is my girlfriend");
        }
        int[] nums = {1,2,3,4,5};
        // 增强版for循环(foreach)
        for(int num : nums)
            System.out.print(num + " ");
        System.out.println();
    }
   

5 数组

5.1 创建数组

 public static void main(String[] args) {
        // 声明整型数组变量 'arr'
        // 创建一个大小为 10 的整型数组并将其赋值给 'arr' 变量
        int[] arr;
        arr = new int[10];

        // 声明并创建一个大小为 10 的整型数组 'arr1'
        int[] arr1 = new int[10];

        // 声明并创建一个包含 {0, 1, 2} 的整型数组 'arr2'
        int[] arr2 = new int[]{0, 1, 2};

        // 声明并创建一个包含 {1, 2, 3, 4, 5} 的整型数组 'arr3'
        int[] arr3 = {1, 2, 3, 4, 5};
    }

数组的理解

int [][][] array = new int [5][25][55];
// array[0]就是指向二维数组的数组变量
// array[0][0]就是指向一维数组的变量
// array[0][0][0]就是指向一个数组元素
//本例中array有五个二维数组变量组成，每一个二维数组变量又由25个一维数组变量组成，每一个一维数组变量由55个数组元素组成

6 方法

语法格式：访问修饰符 返回类型 方法名(参数列表) {方法体}

方法重载： 方法名相同，参数列表不同

public int add(int a, int b) {
    int sum = a + b;
    return sum;
}
public double add(double a, double b) {
    double sum = a + b;
    return sum;
}

可变参数列表

• 格式：类型 … 参数名
• 参数列表只可以有一个可变参数，且只能在方法参数最末尾的位置。
• 当有多个重载方法的时候，先匹配参数个数确定的方法，如果匹配不到，才会选择可变参数列表方法(最不受待见的方法，哈哈哈)

package studywithwxd.a1_basic_grammer;

public class A6_TestFunction {
    public static void main(String[] args) {
        int[] nums = {1,2,3};
        int sum = addSum(nums);
        System.out.println("sum = " + sum);

        sum = addSum(1,2,3);
        System.out.println("sum = " + sum);

    }
    public static int addSum(int... nums){
        int sum = 0 ;
        for(int num : nums)
            sum += num;
        return sum;
    }
}