JavaSE基本知识梳理一

最新推荐文章于 2025-08-20 17:55:57 发布

原创最新推荐文章于 2025-08-20 17:55:57 发布 · 731 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

本文详细介绍了Java编程的基础知识，包括HelloWorld程序的编写、基本数据类型及其取值范围、类型转换及表达式中的类型提升等内容，并提供了丰富的示例代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

变量和数据类型与运算符

一、Hello Word

//1.类的名称不能出现空格或其他特殊字符
//2.类的名称必须和 *.java的名称一样
//3.建议类的名称用英文，每个单词的首字母大写
//4.IDEA的快捷工具 shift+F6 修改名称
//5.反之，凡是看到名字首字母大写的，基本都是类。

public class HelloWorld {

    //必须是 public static void main(String[] args)
    //作为整个程序的入口（第一条语句放在哪）
    
    public static void main(String[] args){
        //意义：系统 的 输出 的 打印
        //语法：调用（执行）println方法
        
        System.out.println("Hello World");
        System.out.println("你好世界");
    }
}

任何一个JAVA程序必然由三部分组成：
1、类（class）
2、方法（method）
3、语句（statement）

类的外部
public class HelloWorld {   				
	   类的内部   
}
类的外部

方法外部
 public static void main(String[] args){
 	  方法内部
 }
   
 语句    
        System.out.println("Hello World");
        System.out.println("你好世界");


注： Java中的方法必须出现在类的内部，但不能出现在方法的内部
			语句只能出现在方法的内部。

二、基本数据类型（三大类，八种）

1、数值

整型：byte (1个字节) / short (2个字节) / int (4个字节) / long (8个字节)

//每个数据类型的取值范围，以byte为例
       
        System.out.println("byte");
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);

byte
127
-128

浮点型: double (8个字节) / float (4个字节)

（2）字符 char (2个字节)

//Ctrl+/注释
public class CharType {
    public static void main(String[] args) {
        //2个字节
        //字符对应的 Unicode(ASCII是Unicode的子集)
        //char a;
        //a='A';
//        int a;
//        a='3';
//        System.out.println(a);

        // \n 000 1010 012   10 0A LF  换行 LineFeed
        // \r 000 1010 015   13 0D CR  回车 Carrier Return
        // \  转义(Escape)
        char a='\n';
        System.out.println((int)a);
    }
}

（3）布尔类型 boolen (无规定)

public class BooleanType {
    public static void main(String[] args) {
        boolean a=true;
        boolean b=false;

        System.out.println(a);
        System.out.println(b);
    }
}

2、字面量（Literal）

(1) 字面量的类型：

0 = > int 0.0= > double

0L = > long 0.0F= > float

(2) 表示特殊数制的字面量:

0 = > 十进制 0b101 = >二进制

010 = > 八进制 0x10 = >十六进制

3、类型转换（type cast）

变量 = 值；变量的类型和值的类型一致，不需要类型转换

例如： int a = 10;

long a = 10 ; 自然转换

int a = 10L ; 精度损失 int a = (int) 10L

4、表达式（expression）中的类型提升（type promotion）

10 + 10L long

10 + 10.0 double

10L + 10.0 double

10L + 10F float

public class VariableDemo {
    public static void main(String[] args) {
        //byte a = 0;  十进制
        //a=0b101; binary  二进制
        //a=010;    Octal 八进制
        //a=0x10;  Hex 十六进制
        
        //int a=(int)10L; 强制转换
        // double a=10;
        // double a=10L;
        //float a=10;
        //float a=10L;     浮点型的类型范围>整型的范围

 注：byte和short两种数据类型在类型转换时比较特殊
        //byte a=10;   byte|short 赋值字面量时，如果在可接受范围，没问题
        // int a=10;
        //byte b= (byte)a; 变量不算

        int a=(int)(10+10L); //类型提升
        System.out.println(a);
    }
}

三、引用数据类型（reference）

1、以String为例（实质是一种引用类型 / 类）

//		  String a="你好中国";
//        String a="你好"+"Java32班";   +代表字符串的连接（拼接） concatenate
//        String s="你好";
//        String t=s.concat("Java32班");

//        System.out.println(t);
//        System.out.println(a);  //两者结果一样

//        String a="你好"+10;///首先10=>'10'，然后做concatenate
//        System.out.println(a);

2、String类型和其他类型的转换

 // int-> String	
 		int a=10;
        String  as=String.valueOf(a);
        System.out.println(as); 
 
 // String->int
        String b = "10";
        int bi = Integer.parseInt(b);// Interger.valueOf
        System.out.println(bi+10);

// String->byte
        String c="10";
        byte cb=Byte.parseByte(c);

//String->int 十六进制
        String d="10";
        int di=Integer.parseInt(d,16);
        System.out.println(di);

四、变量

1、变量的三种形态

class Test {
    static int a; // 静态属性/类成员变量/类变量
    int b; // 属性/成员变量/实例变量
    
    public static void main(String[] args // 局部变量) {
        int c; // 局部变量
   }
}

2、变量的作用域：指该变量能生效的范围, 一般是变量定义所在的代码块 (大括号)

class Test {
    public static void main(String[] args) {
       {
            int x = 10;
            System.out.println(x);   // 编译通过;
       }
        System.out.println(x); // 编译失败, 找不到变量 x. 
   }
}


class Test {
    public static void main(String[] args) {
       {
            int x = 10; // 这里定义了一个变量 x，类型是 int，值是 10
            System.out.println(x); // 会打印 10
       }
        
       {
            double x = 20.0; // 这里又定义了一个变量 x，类型是 double，值是20.0
                                        // 和上面的变量完全无关，只是用到的符号（变量名）相同
                                        // 也就是两个人，都叫张三而已
            System.out.println(x);  // 会打印 20.0
       }
   }
}

3、变量的命名规则

硬性指标:

一个变量名只能包含数字, 字母, 下划线
数字不能开头.
变量名是大小写敏感的. 即 num 和 Num 是两个不同的变量.
注意: 虽然语法上也允许使用中文/美元符($)命名变量, 但是强烈不推荐这样做.

软性指标:

变量命名要具有描述性, 见名知意.
变量名不宜使用拼音(但是不绝对).
变量名的词性推荐使用名词.
变量命名推荐小驼峰命名法, 当一个变量名由多个单词构成的时候, 除了第一个单词之外, 其他单词首字母都大写.
小驼峰命名示例:

int maxValue = 100;
String studentName = "张三";

注：在Java中一个变量的定义必须要有初始值

4、变量的定义和使用

（1）变量的定义(define)。定义出一个符号，这个符号在某个范围内，就代表一个变化的值.

int a;
// 这个变量有以下几部分内容
// 1. 变量允许存储的数据类型
// 2. 表示变量的符号
// 3. 变量中存储的值（这里由于没有初始化，所以没有值）

（2）变量的赋值(assign)。为一个符号，赋予一个明确的值

int w;      // 定义变量 w
w = 5;      // w 这个符号，目前的值是 5
// 这里使用 w，值就是 5
w = 7;      // w 这个符号，目前的值变成了 7
// 这里使用 w，值就是 7

（3）变量的定义 + 初始化(initialize)。定义一个符号，同时为其赋值。

int w = 7; // 定义变量 w，目前的值是 7
// 这里使用 w，值就是 7

（4）变量的使用(use)。使用一个符号，其实是想使用这个符号代表的值

int w = 7;
int h = 2;
System.out.println(w * h); // 使用 w、h 这两个变量。打印 14
w = 5; h = 3;
System.out.println(w * h); // 使用 w、h 这两个变量。打印 15

注：变量（局部变量）必须被在定义+初始化或者定义+赋值之后才能被使用，否则程序会报错。