java（二）基础 --- 注释/常量/运算符

最新推荐文章于 2024-07-22 11:47:21 发布

黑夜里的月亮

最新推荐文章于 2024-07-22 11:47:21 发布

阅读量193

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_39926166/article/details/108578085

版权

java 专栏收录该内容

18 篇文章 1 订阅

订阅专栏

一、注释

1、单行注释：\\ 单行注释内容
2、多行注释： \* 多行注释内容*
3、文本注释： \** 文本注释内容 *\

public class Hello{ // 单行注释：类Hello言语文件名一致
    /*多行注释  第一个Java程序
      它将打印字符串 Hello World
     */
    public static void main(String[] args) {
    		/** 文本注释：
				java程序执行
				是从main方法开始
			*/
        System.out.println("Hello World"); // 打印 Hello World
    }
} //class定义结束

二、变量

实例

public class variable {
	public static void main(String[] args) {
		int a = 12;//定义为整型的变量a,赋值为12
		System.out.println(a);
	}
}
//输出： 12

1、数据类型
① 整型: byte .shrot , int , long
② 浮点型：float ，double
③ 字符类型; char
④ 布尔：boolean
不同数据类型占用字节数： byte ： 1；short：2；int：4；long：8；float：4；double：8；char：2
a、整型

package variable;
public class variable {
	public static void main(String[] args) {
		int a = 12;
		int b =-12;//赋值负数
		int c = 2_000_000;//下滑线隔开易读
		int d = 0xff0000; //赋值16进制
		int e = 0b1000000;//赋值二进制
		//打印
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
	}

}
/*输出：
12
-12
2000000
16711680
64
*/

b、浮点型
float类型赋值时在后面需要加上f

public class variable {
	public static void main(String[] args) {
	//浮点型赋值
		float f = 1.003f;
		float g = 1.14e38f;//后面需要加上f
		double h = 1.66545646;
		double i = -2.564645;
		
		System.out.println(f);
		System.out.println(g);
		System.out.println(h);
		System.out.println(i);
	}
}
//输出：
/*
1.003
1.14E38
1.66545646
-2.564645
*/

c、布尔类型：boolean 只有 true 与 false

public class variable {
	public static void main(String[] args) {
	//boolean类型赋值
		boolean a = 5 > 3;
		int age = 12;
		boolean b = age > 18;
		
		System.out.println(a); //true
		System.out.println(b); //false
	}
}
//输出
/*
true
false
*/

d、char：字符类型
字符类型 char 表示一个字符，字符类型为 ‘’（单引号）；要与双引号（" "）的字符串区分开来

public class variable{
	public static void main(String[] args){
		//字符类型
		char a = 'A';
		char zh = '中';
		System.out.println(a);
		System.out.println(zh);
	}	
}
//输出
//A
//中

三、常量

定义变量时，加上final 修饰符，这个变量就变成了常量, 可简单理解为不变的量，既然不变就不能被修改，常量一般习惯为大写

...
		double final PAI = 3.14;

#四、var关键字（java10以上支持）

有些时候关键字过长时写起来比较麻烦，可以使用 var 关键字代替；好像在java1.8中没有此关键字，仅作为了解吧

var a = 10;

注意：变量的作用范围就是所包含的代码块中{}；如

...
		{
			...
			int a = 1;
			{
				...
				int b = 2;
			}//变量b在此作用结束
		}//变量a在此作用结束

四、整数运算

整型的最大范围：

byte：-128 ~ 127
short: -32768 ~ 32767
int: -2147483648 ~ 2147483647
long: -9223372036854775808 ~ 9223372036854775807

1、四则运算；+ - * /；其中的过程同数学中的加减乘除

。。。
		int num = 1 * 9 + 5 - 2 + 8 / 2; //16
		System.out.println(num);
//输出：16

2、溢出
如以 int 类型做运算，而计算结果超出了int的范围，虽然不会报错，但是结果就与预期不符，这时需要更改类型来进行计算，如使用long

int类型中运算超出最大范围，就显示为负数，显然错误：

。。。
		int number = 2147483640 + 20;
		System.out.println(number);
//输出： -2147483636

那么解决方法，换更大范围的整型long试试

。。。
		long first = 2147483640L;
		long second = 10L;
		long sum = first + second;
		System.out.print(sum);
//输出：2147483650

3、自增/自减

++ 自增，加1；–自减，减1

//自增自减
		int numone = 100;
		numone ++; //101, \相当于 numone = numone + 1
		numone --; //100, \相当于 numone = numone - 1

4、移位运算符

<< 为左移；>> 为右移

向左移：如数9的二进制的4字节表示;

00000000 00000000 00000000 00001001

 。。。
		//移位运算
		int a = 9;        //00000000 00000000 00000000 00001001 
		//向左移1位
		int b = a << 1;   //00000000 00000000 00000000 00010010 ---18
		//向左移2位
		int c = a << 2;   //00000000 00000000 00000000 00100100 ---36
		//向左移20位
		int d = a << 20;  //00000000 10010000 00000000 00000000 ---9437184
		System.out.println(c);
		System.out.println(d);
//输出：
//18
//36
//9437184

向右移：如：00000000 10010000 00000000 00000000 —9437184

。。。
		int m = 9437184;
		//向右移18位，     //00000000 10010000 00000000 00000000  ---9437184
		int n = m >> 18;  //00000000 00000000 00000000 00100100 ---36
		System.out.println(n);
//输出：36

注意：对负数的移位运算是一样的，最高位1表示负数不能变，其他操作同上，计算完毕还是为负数。

5、位运算
位运算是按位进行与、或、非和异或的运算

与：& ：同时为 1 ，结果才为 1 ，同时为0 就为0 ，两数不同也为 0

或： | ：任意一个为 1，结果就为 1，其中有出现 0 | 0 结果为 0，如果出现 1 | 1 结果为 1
非：~ ： 0 和 1 互换
异或：^ ：连个数相同就为 1，不同就为 0

...
//位运算 与: &; /或: | ; 非: ~ ; 异或: ^
		//7的二进制：          00000000 00000000 00000000 00000111
		//9的二进制：          00000000 00000000 00000000 00001001 
		
        int abc = 7 & 9; //00000000 00000000 00000000 00000001 --1
        System.out.println(abc); //1
        
        int cba = 7 | 9; //00000000 00000000 00000000 00001111 --15
        System.out.println(cba); //15
        /* 再用~ 进行执行时结果为负数,与理解的不一致,待查找原因,是否可以这样表示?
        int one =  ~ 7; 
        int two =  ~ 9; 
        System.out.println(one);//-8
        System.out.println(two);//-10
        */
        int df = 7 ^ 9;  //00000000 00000000 00000000 00001110 --14
        System.out.println(df);//14
        ...

6、类型的自动转换
如： short 类型与 int类型计算，结果总为 int ；如果使用short就会报错，如图：
在这里插入图片描述

五、浮点数运算

浮点数可以表示的范围是非常大的

float类型: 可最大表示3.4x10^38，
double类型: 可最大表示1.79x10^308

浮点数无法精确表示, 如 0.1,只能储存0.1的近似值,0.5又可以精确到表示, 由于浮点数有时表示不精确;因此在浮点数运算中会出现误差

...
//浮点数运算
        double fl = 1.0/10;
        double f2 = 1.0 - 9.0/10;
        System.out.println(fl);//0.1
        System.out.println(f2);//0.09999999999999998
        //计算出来就有误差

判断两个浮点数是否相等，正确的方法是判断他们相差的就对值是否小于一个很小的数

double d = Math.abs(fl - f2);
        //判断绝对是是否足够小
        if(d < 0.00001) {
        	System.out.println("可以认为相等");
        } else {
        	System.out.println("不相等");
        }
//输出：可以认为相等

2、类型的提升
① 在参与运算时两数以后一个整型时，那个这个整型会自动变为浮点型
② 参与计算中，两个都为整型的运算是不会i自动变为浮点型，那么计算出来的结果就有误差

        //参与运算包含浮点数 24.0/5
        int  n1 = 5;
        double m1 = 1.3 + 24.0/n1;
        System.out.println(m1);  //6.1
        //参与运算24/n1 都是整数，那么24/5 结果就为4了
        double m2 = 1.3 + 24/n1;
        System.out.println(m2);  //5.3

3、强制转型
可以将浮点型强制转换位整型，转型时，浮点数会把小数部分去掉，如果结果超出整型的最大范围，那么就返回正整型的最大值

//强制转换
        int g1 = (int) 5.3;
        int g2 = (int) 5.8;
        int g3 = (int) -5.8;
        int g4 = (int) ( 5.8 + 0.5 );
        int g5 = (int) 1.5e20;
        
        System.out.println(g1); //5
        System.out.println(g2); //5
        System.out.println(g3); //-5
        System.out.println(g4); //6
        System.out.println(g5); //2147483647 ；返回int类型的最大值

六、布尔运算符

1、布尔类型 boolean，只有true和false

比较运算符：>，>=，<，<=，==，!=
与运算符：&&
或运算符：||
非运算符：！

2、短路
在进行boolean运算时可能会出现短路的情况

//短路
        boolean x1 = 5 < 2; //false
        boolean x2 = x1 && ( 2 / 0 ) > 0;
        System.out.println(x2);//false

因为 x1显然为false ，（ 2 / 0 ）不符合数学逻辑在java中会报错的，但是在运行到&&就停止运行了，输出了x1的结果；若x1为true的话，就会继续循行下去的，这时java就会报错的；

3、三元运算符
三元运算符：b ? x : y；简单理解就是 b为true，就返回 x，b为false，返回y；x 与 y 必须是同一类型

  //三元运算符
        int y1 = -1;
        int numone1 = y1 < 0 ? y1 : -y1;
        System.out.println(numone1); //-1 ；返回的是y1

黑夜里的月亮

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录