JavaSE_02_basic

最新推荐文章于 2024-06-21 22:23:19 发布

weixin_46209942

最新推荐文章于 2024-06-21 22:23:19 发布

阅读量348

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_46209942/article/details/122224981

版权

1 _01_DateType

1.1 DT_01_int

整数型使用

// long 声明如果没有加L , 后面的值默认为int值
// 会发生一次转换,会把int值转换为long类型

// long l0 = 2147483648;
// 如果加L , 则不会转换,值就是long类型
// L不区分大小写 L / l 都可以 , 建议大写,因为小写的l和1不太容易区分

// 根据名字使用保存的数据

package _01_DateType;
public class DT_01_int {
    public static void main(String[] args){
        byte byte1 = 127;
        short short1 = 12345;
        int int1 = 2147483647;
        long long1 = 2147483647;
        long long2 = 2147483648L;
        System.out.println(long1);
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Long.MAX_VALUE);
        int i_2 = 012;
        System.out.println(i_2);
        int i_3= 0x1f;
        System.out.println(i_3);
    }
}

1.2 DT_02_double

/**
* 浮点型
*
* float : 单浮点 32位
*
* double : 双浮点 64位
*
* 整数保存的是二进制 , 比如 123456 浮点数保存的是科学计数法比如 123+E21
*
*/

// float 声明值必须加F , 不区分大小写

// double 声明值需要加D , 不区分大小写

// java中整数默认是int,小数默认是double,所以在声明double的时候,D可以省略

package _01_DateType;
public class DT_02_double {
    public static void main(String[] args){
        float float1 = 1.2F;
        double double1 = 13.123D;
        double double2 = 123.321;
        System.out.println(float1);
    }
}

1.3 DT_03_char

/**
* 字符型使用
*
* Java中字符型占用两个字节也就是16位并且以英文单引号表示且只能有一个字符
*
* short 也是16位 : -32768~32767
*
* char 也是16位 : 0-65535 因为char没有负数,所以不需要符号位
*
*/

// 引号中只能有一个字符空格也算

// 字符可以转换为对应的整数 ASCII

package _01_DateType;
public class DT_03_char {
	public static void main(String[] args) {
		short short1 = 32767;
		System.out.println(short1);
		char char1 = 45535;
		System.out.println(char1);
		char char2 = '张';
		int i1 = char2;
		System.out.println(i1);
	}
}

1.4 DT_04_char

/**
* 转义符 : 把有意义字符转换为无意义字符
* 并且java中char采用unicode编码 \ uxxxx;
*/

// 单引号设置

// \设置
//       c_1 = '\\';
//       i_1 = c_1;
//       // 制表符
//       c_1 = '\t';
//       i_1 = c_1;
//       // 换行符
//       c_1 = '\n';
//       i_1 = c_1;

// 支持unicode编码

package _01_DateType;
public class DT_04_char {
	public static void main(String[] args) {
		char c_1 = 'A';
		int i_1 = c_1;
		System.out.println(i_1);
		System.out.println(c_1);
		char c_2 = '\n';
		int i_2 = c_2;
		System.out.println(i_2);
		System.out.println(c_2);
		char c_3 = '\t';
		int i_3 = c_3;
		System.out.println(i_3);
		System.out.println(c_3);
		char c_4 = '\\';
		int i_4 = c_4;
		System.out.println(i_4);
		System.out.println(c_4);
		c_1 = '\u4e3e';
		i_1 = c_1;
		System.out.println(i_1);
		System.out.println(c_1);
	}
}

1.5 DT_05_boolean

布尔型使用

// java 中布尔类型不参与任何转换,只有true和false,没有其他的
// 在内存中占用1字节,全0为false,00000001 为true
// 主要应用在流程控制

package _01_DateType;
public class DT_05_boolean {
	public static void main(String[] args){
		boolean boolean1 = true;
		boolean1 = true;
		System.out.println(boolean1);
	}
}

1.1.6 DT_06_dateChange

/**
* java中,八种基本类型,除了布尔型,其他的均可进行转换
*
* 自动类型转换 : 低精度到高精度为自动转换比如 byte 到 int 就是自动转换
*
* 强制类型转换 : 高精度到低精度为强制转换比如 int 到 byte
*
* 自动类型转换 byte -> short -> int -> long -> float -> double
* char -> int -> long ->
* float -> double
*

*/

/ 整数保存二进制,而浮点数保存科学计算法,所以float虽然是32位,但是最大值远大于long

// 强制转换可能导致数据出错,需谨慎

// --------- 混合运算
       // 在进行混合运算时,结果的类型是当前运算中最大的类型
       // 比如 int 和 long相加, 结果是long类型
       // 比如 int 和 double相加结果是 double

// 注意 : 当 byte,short,char,int四种类型中,任意一种或多种进行运算,结果都是int
// 比如两个byte相加结果为int
// 比如 byte和char相加结果为int

package _01_DateType;

public class DT_06_dateChange {

	public static void main(String[] args) {
		byte byte_1 = 14;
		short short_1 = byte_1;
		int int_1 = short_1;
		long long_1 = int_1;
		
		byte_1 = (byte)short_1;
		
		float float_1 =long_1;
		double double_1 = float_1;
		
		float_1 = (float)double_1;
		
		char char_2 = 'a';
		int_1 = char_2;
		System.out.println(char_2);
		System.out.println(int_1);
		
		int int_2 = 124;
		byte byte_2 = (byte)int_2;
		System.out.println(byte_2);
		
		int a = 1;
		short b = 2;
		double c = 3.3;
		double result = a+b+c;
		System.out.println(result);
		
		short s = 1;
		double result1 = b+s;
		System.out.println(result1);
		
		
		

	}

}

2_02_Var

Var_01

// 字面量
// 整数默认是int , 小数默认是double

// 使用final修复,称为常量,值不能更改

package _02_Var;

public class Var_01 {
	public static void main(String[] args){
		System.out.println(10);
		int a = 10;
		System.out.println(a);
		a = 11;
		System.out.println(a);
		final int i = 13;
		System.out.println(i);
		
	}

}

Var_02

/**
* 变量声明 :
*
* 数据类型变量名 = 值;
*
* 作用域一个大括号就是一个作用域

// 变量不能先使用后声明
// System.out.println(i_1);

// 字符串,用双引号表示,String是引用类型

// 通过名字找到对应的变量

// 访问不到,因为一个变量的使用作用域,不会超过包含它的这个大括号
// System.out.println(a);

package _02_Var;

public class Var_02 {
	public static void main(String[] args){
		int i_1 = 10;
		System.out.println(i_1);
		char c_1 = '张';
		i_1 = c_1;
		boolean b_1 = true;
		String str = "我叫刘世龙";
		System.out.println(i_1);
		{
			System.out.println(c_1);
			int a = 10;
			System.out.println(a);
		}
		
		
		
	}

}

Var_03

/**
* 根据声明的位置不同,划分了不同的分类,分别解决不同的问题
*
* 局部变量和成员变量 , 而成员变量分为成员和静态成员,静态成员又称为静态变量
*
* 局部变量 : 在方法中声明的变量称为局部变量,该变量只能在该方法中被使用
*        并且直接通过名字调用该变量即可且局部变量没有默认值,必须赋值
*
* 静态变量 : 在类体中使用 static声明的变量,和方法是平级关系
*        并且需要通过类名.静态变量名才能调用另外在当前类中调用当前类的静态变量时,类名可以省略
*        默认值 : 整数默认是 0 , 小数默认 0.0 , 布尔型默认 false , 字符型默认 \u0000 , 引用类型默认 null
*
* 成员变量 : 在类体中没有使用 static声明的变量,和方法是平级关系
*        并且成员变量需要通过对象引用.成员变量才能调用
*        默认值 : 整数默认是 0 , 小数默认 0.0 , 布尔型默认 false , 字符型默认 \u0000 , 引用类型默认 null
*
*/

// 局部变量没有默认值,不赋值不能使用
// System.out.println(a);
// 调用静态变量

// 调用当前类中的静态变量时,类名可以省略

package _02_Var;

public class Var_03 {
	static int age=22;
	static String name="大傻逼";
	double score = 100;
	public static void main(String[] args) {
		int a= 1;
		System.out.println(a);
		System.out.println(age);
		System.out.println(name);		
		
	}

		
	

}

3_03_Operator

3.1 Operator_01

// 注意小数相加
// 一定要注释,千万不要判断小数是否相等

// 注意 : 优先级单目 > 双目 > 三目 (三元)
       // ++ : 把值拿出来 +1 再放回去 (会发生赋值)
       // i++ : 先赋值再自身+1(先确定I的值)
       // ++i : 先自身+1 再赋值

// 如果 k++和 ++k单独出现没有任何区别,自身+1 完事

k++ : 需要占用两块空间 ,一个是k空间,一个是临时空间用来保存+1之前的数据
       // ++k : 需要占用1块空间,只需要保存+1之后的数据即可
       // 但是基本可以忽略,因为编译器也会帮我们进行优化
       // 在编译器优化之后，++i和i++在这里没有区别。而i++看起来更美观,所以会把单独出现的++i转换为i++

// 编译之后 class文件中是这样
       // int i = 2;
       // i++;
       // 因为是单独出现的,所以把++i也转换成了 i++
       // i++;
       // 因为是混合运算,所以 ++i 就是 ++i , i++就是 i++ 不会进行转换
       // i = ++i + 2;
       // i = i++ +2;

// 运算时先把所有++ 和 -- 去掉在进行运算

package _03_Operator;

public class Operator_01 {
public static void main(String[] args){
	int a = 6;
	int b = 2;
	System.out.println(a / b);
	System.out.println(a % b);
	
	double a1 = 0.3;
	double b1 = 0.4;
	System.out.println(a1+b1);
	
	int s = 99;
	s = s++ + ++s;
	System.out.println(s);
	
	int k = 100;
	k++;
	++k;
	System.out.println(k);
	
	int w = 3;
	w++;                                 
	++w;
	w = w++ + ++w;
	System.out.println(w);
	
	int p =4;
	p = ++p + p++ + p + ++p;
	System.out.println(p);
	
	int x =10;
	x = x++ + ++x + (10*++x) + ++x;
	System.out.println(x); 
	
	
	
}
}

3.2Operator_02

/**
* 关系运算符
*
* > >= < <=
*
* == : 判断相等,基本类型比较值,引用类型比较地址 != : 判断不相等
*
* 关系运算的结果是布尔型 true/false
*
*/

package _03_Operator;

public class Operator_02 {

	public static void main(String[] args) {
		int a =1;
		int b =2;
		boolean result = a>b;
				System.out.println(result);
				System.out.println(a>=b);
				System.out.println(a<b);
				System.out.println(a<=b);
				System.out.println(a==b);
				System.out.println(a!=b);
				
			

	}

}

3.3 Operator_03

/**
* & 位与 , 两边都是真结果才是真,如果两把是数值,则是与运算
* | 位或 , 两边一个为真,结果就是真
* ! 位非 , 取反,真就是假,假就是真
* ^ 位异或 ,两边不一样结果就是true
* ~ 按位非 , 0 二进制 0000 0000 按位非(按位取反) 1111 1111
*        1111 1111 补码 1111 1110 反码 1000 0001 源码
* >> : 右移运算符(考虑符号位,再怎么移动,符号位不变)
*        向右移动一次就等于除以2
*            8 >> 2 : 000000 10
*            如果是正数左边补0(符号位之后补0) , 如果是负数左边补1
* << : 左移运算符(考虑符号位,再怎么移动,符号位不变)
*        向左移动一次,.就等于乘以 2
*        2<<2 向左移动两次,向右补0(正负数都补0)
* >>> : 右移运算符(不考虑符号位,符号位之前补0,并且不管正负数只补0)
*        8 >> 2 和 8 >>> 2 没有区别
*        -8 >> 2 和 -8 >>> 2 就有区别了
*
* && : 短路与,且两边都是真结果才是真,
* || : 短路或 , 或两边一个为真,结果就是真
*/

// 如果两边是数字,则会进行与运算
// 先把两个数转换为对应的二进制,然后每位进行比较,都是1则取1,反之取0

// 测试短路和非短路

package _03_Operator;

public class Operator_03 {

	public static void main(String[] args) {
		System.out.println(false&true);
		System.out.println(2>1&2<3);
		System.out.println(1>2 | 2<3);
		System.out.println(!true);
		System.out.println(!false);
		System.out.println(3>2^2>1);
		System.out.println(~8);
		System.out.println(2>>2);
		System.out.println(-8>>2);
		System.out.println(-1>>1);
		
		int a1 = 10;
		int b1 = 11;
		System.out.println(a1<=b1 | a1==b1);
		boolean result = (a1 == b1&a1 != b1);
		System.out.println(result);
		
	}

}

weixin_46209942

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE_02_basic

1_01_DateType1.1 DT_01_int整数型使用// long 声明如果没有加L , 后面的值默认为int值 // 会发生一次转换,会把int值转换为long类型// long l0 = 2147483648; // 如果加L , 则不会转换,值就是long类型 // L不区分大小写 L / l 都可以 , 建议大写,因为小写的l和1不太容易区分// 根据名字使用保存的数据package _01_DateTy...
复制链接

扫一扫