Java基础 1

Java

数据类型
变量
常量

一.数据类型

强制性语言
要求变量的使用要严格符合规定，所有变量要先定义才能使用
弱类语言
Java的数据类型分为两大类
- 基本类型（primitive type）
- 引用数据类型（reference type）

1. 进制

package com.snow.base;

public class Demo01 {
    static void main(String[] args) {
        int i = 10;
        int i2 =010;//八进制
        int i3 =0x10;//十六进制0x

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("==================");

    }
}

2.浮点数

float 类型的存储规则：
IEEE 754单精度浮点数标准
大数无法“感知”微小增量
则存储有限，有舍入误差，接近但是不等于

        float f =0.1f;//0.1
        double d = 1.0/10;//0.1
        System.out.println(f == d);//false
        System.out.println(f);
        System.out.println(d);
        float d1 = 2313131313131213123123123123f
        float d2 = d1 + 1;
        System.out.println(d1==d2);//true

由于d1则这个数太大了，float根本无法存下全部细节，只能存个大概值则加1 后大概值并未变化因此结果为true
double 相较于float精度更高但仍然存在类似问题
由此对于金融，科学计算等场景，使用BigDecimal数学工具类来避免精度丢失

3.字符

字符的本质还是数字
Unicode

public class Demo02 {
    static void main(String[] args) {
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);// a
        System.out.println((int)c1);//强制转换  97
        System.out.println(c2);//中
        System.out.println((int)c2);//强制转换  20013
    }

强制类型转换

注意点
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.再把高容量转换到低容量的时候，强制转换
4.转换的时候可能存在内存溢出，或者精度问题！

数字之间可以用下划线分割

public class Demo03 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;
        long total2 =  money*years;//-1474836480，计算的时候溢出了
        System.out.println(total2);
        long total3 = ((long)(money*years));//默认是int，转换之前已经存在问题？ 
        System.out.println(total3);//YES 依旧是-1474836480
        long total4 = money*((long)years);//把其中一个强转为long，运算就会自动升级为long类型
        System.out.println(total4); 
    }
    }

二.变量

变量：可变化的量
Java是一种强类型语音，每个变量都必须声明其类型
Java变量是程序中最基本的存储单位，其要素包括变量名，变量类型和作用域。

type varName [=value] [{,varName[=value]}];
//数据类型 变量名 = 值；可以用逗号隔开来声明多个同类型变量
eg:
int a = 1;
int a = 1,b = 2,c = 3;

注意事项

每个变量都有类型
变量名必须是合法的标识符
变量声明是一条完整的语句，以分号结束

1.变量作用域

类变量

类变量 static
实例变量

实例变量（方法外面，类里面）从属于对象,可以不初始化，有默认值

局部变量

必须声明和初始化值

public class Variable{
   
    static int allClicks = 0;  // 类变量
    String str = "hello world";// 实例变量
    
    public void method(){
      int i = 0;               //局部变量
  }
}

public class Demo08{
    //类变量 static
    static double salary = 2500;

    //属性：变量
    //实例变量（方法外面，类里面）从属于对象；如果不自行初始化，默认为0 0.0
    //布尔值：默认：false
    //除了基本类型，其余：null

    String name;
    int age;
    
    //mian方法
    public static void main(String[] args){
      
      //局部变量：必须声明和初始化值
      //int i;🚫
      int i = 10;
      System.out.println(i);
      
      //变量类型 变量名 = new Demo08();
      Demo08 demo08 = new Demo08();
      System.out.println(demo08.age);
      System.out.println(demo08.name);

      //类变量 static
      System.out.println(salary);
}

/*
10
0
null
2500.0
*/

三.常量

constant
初始化（initialize）后不能再改变值
修饰符：fianl

final 常量名 = 值；
final double PI = 3.14;//常量名一般用大写

public class Demo09{
    //修饰符 ，（final static）不存在先后顺序
    static fianl double PI = 3.14;

    public static void main(String[] args){
        System.out.println(PI);
    }
}

变量的命名规范

1.使用有意义的名字：变量名应该具有清晰的含义，能够准确地反映变量的用途。避免使用单个字符或无意义的缩写。

2.驼峰命名法（Camel Case）：在变量名中使用驼峰命名法，即将每个单词的首字母大写，除了第一个单词外，其余单词的首字母都采用大写形式。例如：myVariableName。

3.避免关键字：不要使用 Java 关键字（例如，class、int、boolean等）作为变量名。

4.区分大小写： Java 是大小写敏感的，因此变量名中的大小写字母被视为不同的符号。例如，myVariable 和 myvariable 是两个不同的变量。

5.不以数字开头：变量名不能以数字开头，但可以包含数字。

6.遵循命名约定：对于不同类型的变量（局部变量、实例变量、静态变量等），可以采用不同的命名约定，例如使用前缀或后缀来区分。

类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
名类：首字母大写和驼峰原则：Man ，GoodMan
方法名：首字母小写和驼峰原则：run（），runRun（）

运算符

算术运算符

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21（区别详见下文）
--	自减: 操作数的值减少1	B-- 或 --B 等于 19（区别详见下文）

关系运算符

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

位运算符

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
		如果相对应位都是 0，则结果为 0，否则为 1
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

逻辑运算符

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。

！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

赋值运算符

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
	=	按位或赋值操作符

条件运算符（?:）

variable x = (expression) ? value if true : value if false

instanceof 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

Java运算符优先级

类别	操作符	关联性
后缀	() [] . (点操作符)	左到右
一元	expr++ expr--	从左到右
一元	++expr --expr + - ～！	从右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>> <<	左到右
关系	> >= < <=	左到右
相等	== !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或
逻辑与	&&	左到右
逻辑或
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ =	=
逗号	，	左到右

posted on 2026-04-18 21:43 Snow$＿$ 阅读(6) 评论(0) 收藏举报

刷新页面返回顶部

snow0-0