2_语言基础

语言基础

一、变量

1.1 概念

变量是计算机内存中的基本的存储单元，用来存储数据。

1.2 组成

• 变量名：变量在内存中的名字，一般通过名字来操作变量。
• 类型：在存储数据之前，需要定义空间的大小，通过类型来定义大小。
• 值：最终存储到变量中的内容。
• 地址：变量在内存中实际位置。一般在c语言才使用，Java中不使用这些比较复杂的操作，但是有些地方对此操作进行了封装，简化了此操作，在Java中通常需要通过地址来理解一些底层原理。

1.3 变量的定义和使用

1.3.1 先声明后赋值

变量声明：

数据类型 变量名;

int money;

赋值：

变量名 = 值;

money = 5;

操作该变量：

System.out.print(money); // 打印输出变量

1.3.2 声明同时赋值

数据类型 变量名 = 值;

int money1 = 10;

二、数据类型

2.1 数据类型概念和分类

Java中，变量是强类型的，即在变量定义时就必须定义类型，变量在使用过程中类型是不会发生变化的。

分为两大类：

• 基本数据类型（关键字）

  • 整数型
  • 小数型（浮点型）
  • 布尔型（真假）
  • 字符型（字符）

• 引用数据类型

  • 系统提供的类型（字符串等）
  • 数组
  • 程序员自定义的类型（类和对象）

2.2 整数类型

// 整数类型
public class Demo2 {
    public static void main(String[] args) {
        // byte使用(-128~127)
        byte b1 = 100;
        System.out.println(b1);
        // short使用(2字节，-32768~32767)
        short s1 = 32767;
        System.out.println(s1);
        // int使用(-2147483648~2147483647)
        int n1 = 2147483647;
        System.out.println(n1);
        // long使用（-2^63~2^63-1）
        long g = 3245678967788877874L;
        System.out.println(g);
    }
}

注意：

• int是默认值
• long类型的数字后面需要加上L
• 如果超出最大数字范围，需要使用大数字类(BigDecimal)处理
• 程序中建议一般数字使用int

2.3 浮点型

// 小数类型
public class Demo3 {
    public static void main(String[] args) {
        // float 单精度浮点型(4字节)
        // 科学计数法，1234 = 1.234 x 10^3(E3)
        float f = 12346789872342.4555555555F;
        System.out.println(f);
        // double 双精度浮点型(8字节)
        double d = 1234678987435783457834752342.4555555555;
        System.out.println(d);
        // float最大值约为：3.4 x 10 ^ 38
        // long的最大值是：2 ^ 63 - 1 约为 (2 ^ 3) ^ 21 = 8 ^ 21
    }
}

注意：

• 小数默认是double类型
• float类型需要加上F
• float类型虽然是4字节，但是采用科学计数法，所以表示的整数部分比long还要大

2.4 布尔类型

boolean类型，1字节，只有两个值，true/false

// 布尔类型
public class Demo4 {
    public static void main(String[] args) {
        // boolean 1字节
        boolean b = true; // 真
        boolean b1 = false; // 假
        // 也可以将一个表达式的值赋值
        boolean b2 = 5 > 3; // true
        System.out.println(b2);
    }
}

2.5 字符类型

英文：单字节文字，ASCII（美国标准信息交换码）,65表示A，97表示a，32表示空格，48表示数字0，其国标为ISO8859-1

中文：GB2312、GBK、GB18030，双字节表示，范围由小到大

国际统一标准：unicode，双字节文字（Java中）、utf-8(统一传输格式，英文1字节，但是中文或其他文字3-4个字节，可以直接大多数国家的语言)

注意：乱码出现的原因，保存内容时使用一种编码（字符集），但是读取时使用另外一种。

解决方案：将读取的编码采用与保存内容的编码一致即可。

char 字符类型，2字节， 范围：0~65535，英文符号采用ascii值，也可以表示中文，中文采用unicode码。

// 字符类型
public class Demo5 {
    public static void main(String[] args) {
//        char ch = 'a';
//        char ch = 97;
//        char ch = '企';
        char ch = '\u4f01'; // unicode表示中文
        System.out.println(ch);
        char ch1 = '5'; // ASCII对应53
        System.out.println(ch1);
    }
}

转义字符：

表示一些无法直接显示的内容，需要使用转义字符。

// 字符类型
public class Demo5 {
    public static void main(String[] args) {
        // 转义字符
        char ch2 = '\'';
        System.out.println(ch2);
        System.out.println("hello, \nworld");// \n表示换行
        System.out.println("hello\thello");// 表示制表符tab
    }
}

2.6 引用数据类型

主要指数组、系统提供的常用类，以及自定义的相关类。

字符串：

String，由一串（0个到多个）字符组成。用双引号来表示。

// 字符串类型
public class Demo6 {
    public static void main(String[] args) {
        char ch = 'H'; // 字符，必须有一个，有且仅有一个
        String str1 = ""; // 0个
        String str2 = "a"; // 1个
        String str3 = "abc"; //多个
    }
}

三、类型转换

类型转换分为两种：

自动类型转换：当目标类型兼容需要转入的类型时，会自动类型转换。

强制类型转换：当目标类型不兼容需要转入的类型时，需要强制类型转换。

注意： 类型转换是考虑类型是否兼容，不用考虑值。

// 类型转换
public class Demo7 {
    public static void main(String[] args) {
        // 类型转换是考虑类型是否兼容，不用考虑值
        // 自动类型转换
        short s = 120;
        int n = s; // 将变量s中的值赋值到n中，此时n的值为120

        // 强制类型转换
        // 如果能放下，则值不会有影响，但是超出范围，则值会发生变化，
        // 最大值会走向最小值，最小值会走向最大值
        int n1 = -32769;
        short s1 = (short) n1;
        System.out.println(s1);

        // 数字之间可以相互转换
        // 小类型向大的类型中放入，都是自动转换
        // 大的类型向小的类型中放入，都需要强制转换
        // 小数向整数中放入，都需要强制转换
        // 整数向小数中放入，都是自动转换，需要注意long与float
        // 布尔值不能与其他类型相互转换
        // char在转换时当作一个范围为0~65535的整数来处理

    }
}

四、运算符

4.1 算术运算符

加减乘除余

注意：整数相除结果为整数

// 算术运算符
public class Demo8 {
    // 二元运算符(需要在符号两边都有值参与运算)
    public static void main(String[] args) {
        // 加
        int n1 = 5 + 3;
        System.out.println(n1);
        // 减
        int n2 = 5 - 3;
        System.out.println(n2);
        // 乘
        int n3 = 5 * 3;
        System.out.println(n3);
        // 除
        int n4 = 5 / 2;
        System.out.println(n4);
        // 余数（求模）
        int n5 = 5 % 2;
        System.out.println(n5);
        // 混合运算，先算乘除余，后加减，有括号优先
        int n6 = (5 + 3) * 6;
        System.out.println(n6);
        // 也可以使用变量
        int n7 = n6 + n5 * n3;
        System.out.println(n7);
    }
}

单目运算符

// 算术运算符
public class Demo9 {
    // 一元运算符（只有一个操作数）
    public static void main(String[] args) {
        int n1 = 5;
//        n1++; // 自增1
        ++n1; // 也可以写作
        System.out.println(n1);
        int n2 = 6;
        n2--; // --n2; 自减1
        System.out.println(n2);

        int n3 = 1;
//        int n4 = n3++ + 1; // ++在后，先参与运算，再自增1，
        int n4 = ++n3 + 1; // ++在前，先自增1，再参与运算，--同理
        System.out.println(n4);
        System.out.println(n3);

//        int n5 = 3;
//        int n6 = n5++ + n5++ + n5++; // int n6 = 3 + 4 + 5;
//        System.out.println(n6);
//        System.out.println(n5); // 6

        int n5 = 3;
        // 单目运算符，括号不影响运算结果
        int n6 = (n5++) + (n5++) + (n5++); // int n6 = 3 + 4 + 5;
        System.out.println(n6);
        System.out.println(n5); // 6
    }
}

4.2 赋值运算符

// 赋值运算符
public class Demo10 {
    public static void main(String[] args) {
        int n1 = 5 * 3;
        int n2 = n1 * 2;

//        n2 = n2 - 1; // 简写为n2--;
        n2 = n2 - 2; // 简写为n2 -= 2;
        n2 += 5; // 自增5，相当于n2 = n2 + 5;
        n2 *= 2; // 相当于n2 = n2 * 2;
        n2 /= 5; // 相当于n2 = n2 / 5;
        n2 %= 3; // 相当于n2 = n2 % 3;

        int n3 = 2;
        double d = 5 / (double)n3;
        System.out.println(d);

        double d1 = -5.5 % -2;
        System.out.println(d1);
    }
}

4.3 关系运算符

用来比较两个值的运算符，结果为布尔值。

// 关系运算符
public class Demo11 {
    public static void main(String[] args) {
        boolean b = 5 >= 3;
        System.out.println(b);
        int n1 = 5;
        boolean b1 = n1 == 5;
        System.out.println(b1);
        boolean b2 = n1 != 5;
        System.out.println(b2);
        int n2 = 8;

        // 注意：==用来比较等于，!=用来比较不等于
        // 不能使用连续比较，3 <= n2 <= 8
    }
}

4.4 逻辑运算符

使用&&表示并且，使用||表示或者，!表示取反

// 逻辑运算符
public class Demo12 {
    public static void main(String[] args) {
        int n1 = 5;
        // 并且
        boolean b = n1 >= 3 && n1 <= 8; // 等同于数学中的 3 <= n1 <= 8
        System.out.println(b);
        // 或者
        boolean b1 = n1 >= 3 || n1 <= 8;
        System.out.println(b1);
        // 非（取反）
        boolean b2 = !(n1 >= 3 || n1 <= 8);
        System.out.println(b2);

        // 注意：&&和||都是短路操作，意味着，如果前面一个表达式能够决定整个表达式的值，后面的表达式将不会进行运算
    }
}