Java概述2

最新推荐文章于 2025-05-13 17:58:09 发布

原创最新推荐文章于 2025-05-13 17:58:09 发布 · 408 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #后端

JavaSE笔记专栏收录该内容

37 篇文章

订阅专栏

一、常见的进制二进制、八进制、十进制、十六进制

二进制：只有0 或 1 逢2进1

十进制：只有0-9 逢10 进 1

八进制：只有0-7 逢8 进 1

十六进制：只有0-9,A-F 逢16 进 1

二、数据类型

1.变量

定义一个变量，变量中存储一个值，变量存储的值是可以改变的。

定义变量的语法：数据类型变量名字 [= 值 ]

定义变量的名字不能重复定义。

2.常量

定义一个常量，常量中存储一个值，常量存储的值是不可以改变的。

定义常量的语法： final 数据类型名字 [= 值 ]

三、Java中的数据类型分为基本类型(简单类型)和引用类型

基本类型分为整数、浮点数、字符、布尔四类，其中

整数分为byte、short、int、long ；

浮点分为float、double；

字符是 char；

布尔是boolean

存储这些数据时，为了节省内存的空间，要选择相应长度的数据类型来定义变量。

（一）整数类型

1.byte类型：1字节(8位) 存储整数值的范围是 -128~127

2.short类型：2字节(16位) 存储整数值的范围是：-2的15次幂~2的15次幂-1 ，一般情况，如果存的数据达到了万位就不用short存了，因为有可能超出范围了。

3.int类型：4字节(32位) 存储整数值的范围是：-2的31次幂~2的31次幂-1 ，一般情况，如果存的数据达到了10个位数了，就不用int存了

注意事项：

（1）如果一个数值要写成八进制，就在数值的前面加个0

以0开头的数字就是八进制的数字；

以0x或0X开头的数字就是十六进制

（2）程序中出现的所有整数的数值默认都是int类型

4.long类型：8字节(64位)存储整数值的范围是：-2的63次幂~2的63次幂-1；

long类型如果有超出范围的情况，看一下数据是否有精确度的要求：

方式一，可以改变数据的单位；

方式二，Java中提供了大数字类型例如 BigInteger类型，但是这个类型属于引用类型

（二）浮点类型

1. float类型：单精度浮点类型，4字节(32位)，数据范围 -3.403E38 ~ 3.403E38

2. double类型：双精度浮点类型，8字节(64位)，数据范围-1.798E308 ~ 1.798E308

注意事项：

1. 程序中出现的所有小数值默认都是double类型

public class Test1{
    public static void main(String[] args){
    //3.14是double类型 ，存储到float中报错
    //3.14f是float类型，就可以赋值给float类型的变量
    float pi = 3.14f;
    double number = 3.14d;
    //10是int类型，存储到byte中 不报错
    byte b = 10;
    }
}

2. 浮点类型的数据可以使用科学计数法表示

public class Test1{
    public static void main(String[] args){
    //3e2 是3*10的2次幂
    double number = 3e2; //也可以是3e-2
    System.out.println(number);
    }
}

（三）字符类型

char类型：16位，值使用单引号引起来的，可以存储一个中文。

char类型的字符是基于Unicode编码来存储的

public class Test1{
    public static void main(String[] args){
    //定义一个人的性别
    char sex = '男' ;
    char c1 = 'a';
    char c2 = '1';
    System.out.println((int)c2);
}
}

1和'1'的区别：1是int类型的数字，'1'是字符类型，在Unicode字符集中对应的数值是49

字符值也可以写成Unicode的形式：

public class Test1{
    public static void main(String[] args){
    char c1 = '\u0061';
    char c2 = '\u0031';
    System.out.println(c2);    
    System.out.println("\u0061\u0031");
    }
}

Java中的\是转义符

\字符对字符进行转义，能转义的字符包括 r、n、t、f、u、\、‘、"、等

\n 是换行符：将光标移动到下一行相同的位置

\r 是回车符：将光标移动到本行的开头位置，键盘的enter键相当于 \r\n

\t 是制表符：相当于键盘的tab键，起到对齐的作用

\\ 是对转义符转义为 \字符

\' 对'号进行转为为 '字符，单引号在java中表示一个字符值的语法符号

\" 对“号进行转为为 ”字符，双引号在java中表示一个字符串值的语法符号

public class Test1{
    public static void main(String[] args){
    char c1 = 'a';
    //n字符 就是n字母在unicode编码代表一个值
    // \n 对齐转义，不是n字符了，是一个换行字符
    char c2 = '\r';
    char c3 = 'b';
    System.out.print(c1);
    System.out.print(c2);
    System.out.print(c3);
    }
}

public class Test1{
        public static void main(String[] args){
        //输出 路径 d:\abc\a
        char c1 = 'd';
        System.out.println("d:\\abc\\a");
    }
}

public class Test1{
        public static void main(String[] args){
        //输出 '_'
        char c1 = '\'';
        char c2 = '_';
        char c3 = '\'';
        System.out.print(c1);
        System.out.print(c2);
        System.out.print(c3);
    }
}

（四）布尔类型

boolean类型：boolean类型的值只有两个分别是true 和 false ；

true代表真；false代表假；

通常用boolean的值来控制一些判断条件 boolean类型占用 1位空间，在编程时写true或false，但存储在内存中的是0或1 ；0代表false ；1代表true;

四、运算符算数运算符

1. + - * / %

2. ++ 和 -- 运算 ++运算自增1 --运算自减1 在++的前面或后面可以接一个变量，形成自增表达式

public class Test1{
        public static void main(String[] args){
        int a = 3;
        /*
        System.out.println((a++)+(++a)); //3+5
        System.out.println((++a)+(a++)); //4+4
        1. 计算a++表达式的结果是 3
        2. a加1 ，a是4
        3. a 赋值为 a++表达式的结果 最终执行 a=3
        */
        a = a++;
        System.out.println(a); //3
        a = 3;
        a = (a++)+(++a);
        System.out.println(a); //8
    }
}

五、赋值运算符

+= -= *= /= %=

赋值运算符和++ -- 都不需要考虑类型的转换，在编译期通过代码的编译

比较运算符 > < >= <= == != 结果一定是boolean的值

六、逻辑运算符

只有boolean类型的值能进行逻辑运算

1.&& 与运算（短路与）：只要有一个是false，结果就是false；全是true结果才是true

2.|| 或运算（短路或）：只要有一个是true，结果就是true ；全是false结果才是false

3.! 非运算：取反运算，true的非是false，false的非是true

七、位运算符

二进制的每一位都参与运算

& 按位与

| 按位或

~ 按位取反：每一位取反，0变成1；1变成0；

^ 按位异或 : 每一位的数字如果不同，异或的结果是1；如果相同，异或的结果是0 ；

假设a ^ b = c ;那么 c ^ a 一定等于 b ；c ^ b一定等于a 用两种方式，完成两个变量值的交换

如何实现两个变量值的交换？（用三种方法）

方式一：建立一个中间变量

public static void main(String[] args){
        int i = 3;
        int j = 4;
        int temp = i;
        i = j;
        j = temp;
        System.out.println(i);
        System.out.println(j);
}

方式二：用异或实现

public static void main(String[] args){
        int i = 3;
        int j = 4;
       
        //方式二：不用定义第三个变量，用异或实现
        i = i ^ j ;
        j = i ^ j ;
        i = i ^ j ;
        System.out.println(i);
        System.out.println(j);
}

方式三：用加减法实现，如：a+b=c,那么c-b一定等于a , c - a一定等于b

public static void main(String[] args){
        int i = 3;
        int j = 4;
        //方式三：
        i = i - j ;
        j = i +j ;
        i = j - i ;
        System.out.println(i);
        System.out.println(j);
}

移位运算：无符号的左移和右移分别是 << 和 >> ；

符号位（二进制的第一位为符号位）不移动，无符号的左移相当于乘2操作，右移是除2操作；（2的k次幂）

正数的二进制移动用0补齐，负数的二进制移动用1补齐

移位效率高于 * 和 / （乘除）

带符号的右移>>> 符号位跟着向右移动。没有带符号的左移

public static void main(String[] args){
    System.out.println(3>>1); //1
    System.out.println(3<<3); //3*2^3 = 24

    //11111101  右移一位
    //11111110  负数移动用1补齐，取补码
    //10000010  反码加一
    System.out.println(-3>>1); //-2
    //符号位跟着移动的右移,符号位用0补齐
    System.out.println(3>>>1); //1
    
    //-1:11111111 11111111 11111111
    //   11111111 11111111 11111111 右移一位，符号位参与移动，用1补齐
    System.out.println(-1>>>1); //最大的int值
    long num = -1 ;
    System.out.println(num>>>1);//最大的long值
    System.out.println(~(num>>>1)); //最小的long值
}

public static void main(String[] args){
    int i = 1 ;
    //在编译期对32%32=0
    //在编译后的字节码中 i<<0
    System.out.println(i<<32);  //移动32位取余后相当于未移动

  
     int i = 1 ;
     System.out.println(i<<33);  // 2   相当于移动一位
    
}

&&和&的区别：&&叫短路与；&按位与；

短路与的效率高于按位与运算，因为两个表达式做短路与运算时，如果第一个表达式的结果是false，短路与运算的结果直接就是false，第二个表达式不在计算了。

||和|的区别：||短路或；如果第一个表达式的结果是true ，短路或运算的结果直接就是true，第二个表达式不在计算了。

public static void main(String[] args){
    int i = 1;
    int j = 3;
    //System.out.println(i>j&&++i<5);
    //System.out.println(i); // 1
    System.out.println(i>j&++i<5);
    System.out.println(i); // 2
}

八、类型转换

基本类型中除了boolean类型，其他的七种可以互相的转换

类型转换分为强制转换和自动转换

强制转换：

语法：（类型）数据或变量

自动转型：

程序会自动为数据转型，遵循自动向上转型，如果要实现向下转型，就得通过强制转型了

byte -- short -- int -- long -- float -- double

char -- int -- long -- float -- double

public static void main(String[] args){
    System.out.println((double)3+1.5);
    System.out.println(3+(int)1.5);
    //自动向上转型
    System.out.println(3+1.5); //4.5
    System.out.println('a'+1); //98
    System.out.println('a'/2); //48
    System.out.println(5.0/2); //2.5
    System.out.println('a'+'b'); //195
    //17.0是double类型 ； 0 是int类型
    //自动将0 转为double类型 0.0
    //而浮点型的0是一个无限接近0的小数
    System.out.println(17.0/0); //Infinity 无穷大
    int i = 3;
    double d = 1.5;
    System.out.println((double)i+1.5);
}

附加：空格和null的区别

public static void main(String[] args){
    String s1 = " ";
    String s2 = null;
    //" " 和 null 的区别
    //null 是一个关键字，想在一个引用类型的空间中不存储任何的地址
    //那么就让这个变量 = null ；
    //null 叫空值 ，没有存储任何的地址
}

九、整数的进制

第一位是符号位， 0 代表正数； 1代表负数；

后面的位数都叫原码；正数的值就是原码的值

原码取反叫反码

补码是对反码+1

字符串类型

字符串类型是String类型（String的S要大写的），是引用类型

字符串的值使用双引号标注的，其实字符串就是由字符组成的。

字符串的连接使用+号连接，也就是说 + 的两边如果有一个是字符串，就是连接符，连接后得到一个新的字符串，如果两边都是数字，+ 是运算符

public static void main(String[] args){
    String s1 = "Hello";
    String s2 = "World";
    //String s3 = s1 + s2;
    String s3 = s1 + 1 ;
    System.out.println(s3);
    System.out.println(1+1+"1") ; //21
    System.out.println("1"+1+1) ; //111
    int age = 20;
    System.out.println("年龄："+age);
    double r = 4;
    System.out.println("圆的面积是："+r*r*3.14);
    System.out.println("半径是"+r+"的圆面积是："+r*r*3.14);
    char c1 = "a"; //错误 "a"是字符串类型无法赋给char类型的变量
    String s = 'a' ; //错误
}

Scanner工具

在控制台输入一些内容，在程序运行的过程中可以获得从控制台输入的内容。

import java.util.Scanner;

public class Test1 {

        public static void main(String[] args) {

               String s = "HelloWorld";

                //创建一个工具

                //这个工具是Scanner类型的，scanner是一个变量

                //new 新建，其实在内存空间中创建了一个对象

                //System.in 是标准的输入流，包含了输入的内容

                Scanner scanner = new   Scanner(System.in);

                //获得控制台输入的数据，并获得其整数(int)形式

                //调用了nextInt()功能，程序就阻塞了(等待)，等待着输入内容，以回车作为输入结束

                int i = scanner.nextInt();

                int j = scanner.nextInt();

                System.out.println(i+j);

                System.out.println("Hello World!");

        }

}

import java.util.Scanner;
public class Test1{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        //next功能不能获得回车符
        String s = scanner.next();
        //String s = scanner.nextLine();
        System.out.println("输入的内容是："+s);
    }
}

字符集

字符集是一种字符和数字的对应关系 ,在存储、读取字符时，计算机通过字符集进行了编码(Encoding)和解码 (decoding)

1. ASCII 字符集，定义了字母和一些常用的符号，用1字节存储需要记忆：a 是 97 ； A 是 65

2. Unicode字符集，包含了所有国家的文字，前255位是ASCII字符集

3. UTF-8字符集，万国码，包含了所有国家常用的文字，前255位是ASCII字符集，开发是已经成为了程序员通用的字符集了。

4. GBK字符集，中国的字符集，包含了中文，前255位是ASCII字符集

乱码

在对字符进行编码和解码时使用了不同的字符集，就会出现乱码。