393-JAVA-day1

最新推荐文章于 2024-08-18 21:36:31 发布

2401_84010326

最新推荐文章于 2024-08-18 21:36:31 发布

阅读量325

点赞数 4

分类专栏：程序员文章标签： java python 开发语言

本文链接：https://blog.csdn.net/2401_84010326/article/details/137982492

版权

程序员专栏收录该内容

237 篇文章 0 订阅

订阅专栏

2，public static void main(String[] args){} : main方法，表示程序的入口，固定写法，将来的程序执行，必须在main方法这对大括号中才能执行

3，System.out.print(“Hello World!”); ：系统的标准输出流语句，可以将print()后面括号中的内容，输出到控制台上。

编译：使用javac命令

javac HelloWorld.java

编译之后，如果没有错误的话，会在目录下生成一个 HelloWorld.class文件，.class后缀格式的文件，称为字节码文件

运行：使用java命令运行

java HelloWorld

练习：写一个Java文件，编译、运行后输出：我是xxx，我来自xx学校，我今年xx岁。

JVM的执行任务

1.加载：JVM会先把编译好的字节码文件，加载到内存中，然后将字节码文件，转变为可以直接执行的机器码，并将其存储在内存方法区中的运行时数据区域。

2.验证：JVM对加载的字节码进行验证，确保其能符合Java语言规范和JVM规范，验证类型、引用…

3.执行：JVM执行已经加载和验证过的字节码文件，通过解释执行字节码或者将其编译为本地机器码来实现。执行的过程中，JVM还负责内存管理，垃圾回收等。

Java注释

代码编写和注释的比例是1:1，注释是不会被编译的

注释分为单行注释和多行注释

单行注释：在注释内容前面，加上//

多行注释：将注释内容写在/* */内

标识符

标识符：指的是一些变量、方法、类等用户所定义的名称
   命名规范：
   标识符由数字0-9，字母a-z A-Z，美元符号$，下划线_组成，不能以数字开头
       比如：
       正确：hello123 _hello
               错误：123abc
其他规范：
   1.类名规范：首字母大写，后面每个单词首字母大写，大驼峰式比如HelloWorld
           2.变量名、方法名规范：首字母小写，后面每个单词首字母大写，小驼峰式比如helloWorld
           3.Java中区分大小写，hello和Hello是两个不同的标识符
           4.标识符不能与关键字重名
           关键字指的是在系统中有特殊含义的字符，比如之前使用的public、static…

常量的定义

定义：指的是在程序运行过程中，固定不变的量
           分类：字符串常量：双引号引起来的
           整数常量：整数数值
                   浮点数常量：带小数点的小数数值
                   字符常量：单引号引起来的单个字符
                   布尔常量：两个值，true和false
                   空常量：null，表示没有任何内容

public class DemoConst01{
	 public  static void main (String[] args){
	 
	 //字符串常量
		 System.out.println("abc");
		 System.out.println("你好");
	//整数常量
	     System.out.println("123");
	//浮点数常量
	    System.out.println("10.25");
	//字符常量
	    System.out.println('a');
		//System.out.println('abc');//报错
	//布尔常量
	    System.out.println(true);
		System.out.println(false);
	//空常量不能直接输出
	    //System.out.println(null);
		 
	 }
}

Java中数据类型

Java中的数据类型分为两大类：
1.基本数据类型：分为四类八种
               整数类：
                   byte：字节型占1字节 8位取值范围 -128 ~ 127
                           short：短整型占2字节 16位 -2^15 ~ 2^15-1
                           int：整型占4字节 32位 -2^31 ~ 2^31-1
                           long：长整型占8字节 64位 -2^63 ~ 2^63-1
浮点数类：
                   float：单精度浮点型占4字节 32位
                           double：双精度浮点型占8字节 64位
字符类：
                   char：字符型占2字节
布尔类：
                   boolean：布尔型占1字节 true或false

注意：
Java中，整数类型转为二进制后，首位都是符号位，表示正负，
                       0表示整数，1表示负数，负数以正数的补码形式表示
                           5=1111 0101 -5= 1111 1011
           机器数：分为原码、反码、补码、移码
原码：正、负数的原码都是其本身
                               反码：正数的反码是其本身，负数的反码，符号位不变，其余位置取反
                               补码：正数的补码是其本身，负数的补码->取反-> +1
                               移码：正数的移码是补码符号位取反，负数的移码是补码符号位取反，
                   1.一般整数都默认是int类型
                   2.浮点数 float 32位（1位符号位 + 8位指数位 + 23位尾数位）
                   指数位决定了float的整数部分的取值范围，
                               指数位用8位的移码表示，8位数值的范围是0~255，转为移码之后的返回是 -127 ~ 128，将来计算的时候还需要转为十进制原码进行计算，转为十进制原码就是-126 ~127

                               尾数位指的就是float的小数部分的值的精度

                   3.float转为二进制的方式
                   40.375
                       第一步：看符号位 0
                       第二步：整数部分转二进制 40=0010 1000
                       第三步：小数部分部分转二进制小数部分做乘法 *2
                       0.375 *2=0.75 0
                               0.75 *2=1.5 1
                               0.5 *2 =1 1
                       组合：0 0010 1000 .011
                       第四步：小数点位移，位移最左面的1的后面
                       结果：0001.01000 011
                       第五步：位移位数5 +127 =132
                        最终的二进制：符号位 + 132转的二进制 + 小数点后位数补齐32位，不足为0
                       0 1000 0100 0100 0011 0000 0000 0000 000
               30.125 位移位数4 +127 =131
                   符号位 + 131转的二进制 + 小数点后位数补齐32位，不足为0
       0 0001 1110 .001
       0 0001.1110 001
                   0 1000 0011 1110 0010 0000 0000 0000 000

public class DemoConst01{
	 public  static void main (String[] args){
		
         //40.375
        int i=0b01000010001000011000000000000000;
		System.out.println(Float.intBitsToFloat(i)); 
		
		//30.125
		//0 0001 1110 .001
		//0 0001.1110 001
		//0 1000 0011 1110 0010 0000 0000 0000 000
		int j=0b01000001111100010000000000000000 ;
		System.out.println(Float.intBitsToFloat(j));
	 }
}

4.double 类型 64位（1位符号位 + 11位指数位 + 52位尾数位）
                   指数的取值范围2^1023 ~ 2^1024
                               将来声明的浮点数（小数），默认一般都是double类型
                               如果要声明float类型的浮点数，需要在数字后面加上F或f

                       float和double主要区别就是所占内存大小不同
                   浮点数的位数表示他的精度
所以，float类型的取值范围比int大，但是精度比int小。

5.字符型就是一个字符，由单引号印起来。

6.布尔型只有两个值，true和false，表示正确和错误的意思。

2.引用数据类型

Java中引用数据类型包含：字符串、数组、类…

变量的定义

定义：指的是，在程序运行期间，值可以改变的量
       变量的本质是在内存中开辟的一块空间，这个空间用来存放指定数据类型的数据。
       声明变量的语法：
       语法1：声明的同时就赋值
           数据类型变量名 = 值；
                   示例：byte b1 = 123; int i1 = 200; i1=300;
           语法2：先声明，再赋值
            数据类型变量;
                   变量 = 值;
                   示例：int i2; i2 = 100;

语法3：同时声明多个变量
数据类型变量1 ，变量2，变量3;
或数据类型变量1 =值1，变量2 = 值2，变量3=值3；

public class Demo02Variable{
	public static void main (String[] args){
		//声明变量
		int num1=100;
		System.out.println(num1); //100
		
		//重新赋值
		num1=200;
		System.out.println(num1); //200
		
		//声明变量2
		int num2;
		//System.out.println(num2);  没有初始化的变量不能直接使用
		
		num2=300;
		System.out.println(num2); //300
		
		//多个变量同时声明
		int num3=400,num4=500,num5=600;
		System.out.println(num3); //400
		System.out.println(num4); //500
		System.out.println(num4); //600
		
		//变量不能被提前使用
		//System.out.println(num6); 
		int num6=700;
		
		//变量的作用域，就是它所在的那对大括号中
		{System.out.println(num1)； //外面声明的变量，里面可以用
		int num7=800;
		System.out.println(num7);
		}
		//System.out.println(num7);//里面声明的变量，外面不能用
		
		//变量声明尽量不要超出取值范围
		//byte b1 = 200;
		//System.out.println(b1);
		
		//声明long类型，需要加 L 后缀
		long num8=900L;
		
		float f1=10.25F;
		System.out.println(f1);
		
		char c1='a';
		//char c2='ab';//字符类型有且仅有一个字符
		System.out.println(c1);
		
		
	}
}

注意事项：
       1.变量的命名，尽量望文生义
           2.创建多个变量，变量之间不能重名
           3.变量必须赋值之后才能使用，没有赋值的变量不能使用
           4.变量的值必须在类型的取值范围内，特别byte 和 short 要注意
           5.变量使用不能超过它所在的作用域（所在的大括号）

基本类型数据的相互转换

隐式转换：小的类型向大的类型转换，会自动完成转换，称为隐式转换
           byte -> short -> int -> long -> float -> double
                   int 和 char 在特定情况下，可以完成转换
           显示转换：大的类型数值，需要当作小的类型来使用的时候，需要用到显示转换

写法：

小数据类型变量名 = （小数据类型）大数据类型的值
           转换的时候，如果大类型的值，是在小类型的范围内，那么转换没有问题;
                   如果大类型的值，超过小类型的范围，就会产生数据的溢出
           注意事项：
1.一般将来如果不确定大类型的值是否在小类型值的范围内，就尽量不要做强制转换
               2.byte short char 这三个类型在运算之后，都会被提升为int类型计算，计算结果也会是int，如果要运算，要注意类型变化。

//
               double d = 12.34;
               float f =d ; //报错，大数据类型赋值给小数据类型，得强制转换
               System.out.println(f);

               //f1和f2的定义有区别吗？
              float f1 = (float)12.34;  --f1是由一个double类型的值转换过来的
             float f2 = 12.34f;        --f2本身就是一个float类型
             有区别

public class Demo03Variable{
	public static void main(String[] args){
		
		//隐式转换
		byte b =100;
		System.out.println(b);
		short s=b;
		System.out.println(b);
		int i=s;
		System.out.println(i);
		long l=i;
		System.out.println(l);
		float f=l;
		System.out.println(f);
		double d=f;
		System.out.println(d);
		
		//注意防止精度丢失问题
		long l1=123456789L;
		
		float f1=l1;
		System.out.println(f1);//123456792E8
		
		//字符类型在做计算的时候，可以被当作int使用
		char c1='a';
		System.out.println(c1+100);
		
		//byte在做计算的时候，返回结果会被当作int类型
		//这种情况下，不能直接赋值给byte类型
		//byte b1=50;
		//byte b2=b1*2;
		//System.out.println(b2);//报错
		
		
		System.out.println("-----------------------------------");
		//显示转换
		int i1=100;
		byte b3=(byte) i1;
		System.out.println(b3);
		
		int i2=129; //0000 0000 1000 0001
		byte b4=(byte) i2;  //1000 0001 取反码 + 1 => 1111 1110 + 1 => 1111 1111
		System.out.println(b4);//-127 
		
		
		
	}
}

运算符

运算符主要就是用来连接值，完成运算的；
表达式：使用运算符连接起来的式子。(a+b)&(a>b)
       常见的运算符
       一元运算符、二元运算符、三元运算符：有几个变量参与运算，就称为几元
           1.算术运算符
           一元运算符：+/— 正负，++自增，–自减
           ++自增：表示给变量自身加1，写法：a++或者++a
           --自减：表示给变量自身减1，写法：a–或者–a

单独运算的时候，++/–在变量前和变量后，没区别

和其他的表达式一起运算的时候，
如果++/-- 符号在变量前面，++a表示先把a加1，再参与计算
如果++/-- 符号在变量后面，a++表示先把a参与表达式的计算，a再加1
二元运算符：

+ 加，除了可以用来做数学计算，还可以用来连接字符串

- 减

* 乘

/ 除 Java除法计算后得到的是整数

%   求余计算整除后，余下的结果
           2.比较运算符
           比较运算符的结果都是布尔型,只有true和false
               <、>、<=、>=、==、!=
           3.逻辑运算符
           用来连接多个布尔表达式的
               & 逻辑与连接的表达式中，必须都是true，结果才为true
               && 短路与如果第一个表达式是false，结果就是false，后面的表达式不参与计算
               | 逻辑或连接的表达式中，有一个为true，结果就是true
               || 短路或如果第一个表达式是true，结果就是true，后面的表达式不参与计算
               ！逻辑取反  表达式为true ，取反后，就为false
表达式为false，取反后，就为true
           4.赋值运算符
           = 赋值， a=b，表示把b赋值给a
               += a += b,表示a=a+b，a的新值为原来a的值+b的值
               -= a -= b,表示a=a-b，a的新值为原来a的值-b的值
               *= a *= b,表示a=a*b，a的新值为原来a的值*b的值
               /= a /= b,表示a=a/b，a的新值为原来a的值/b的值
               %= a %= b,表示a=a%b，a的新值为原来a的值%b的值

public class Demo04Operator{
	public static void main(String[] args){
		
		//自增++，自减-- 的测试
		int num1=10;
		num1++;
		System.out.println(num1);//11
		
		++num1;
		System.out.println(num1);//12
		
		System.out.println(num1++);//12
		
		System.out.println(++num1);//14
		
		int num2 = num1++;
		System.out.println(num2);//14
		
		int a=10;
		int b=a++;//10
		int c=--b;//9
		int d=c++ + b--; //9++ + 9--  
		//求 a b c d
		//11  8  10  19  d错误！
		System.out.println(a);//11
		System.out.println(b);//8
		System.out.println(c);//10		
		System.out.println(d);//18
		
		
		System.out.println(a + "--" + b + "--" + c + "--" + d);
		
		System.out.println(10+20);//连接数字表示加法
		
		System.out.println("123" + 100);//表示把内容拼接到字符串后面
		
		//整数做除法
		System.out.println(10/3);//3
		//浮点数做除法
		System.out.println(10.36/2,58);//4.015503875
		
		//求余
		System.out.println(10%4);//2
		
		//已知一个四位数，1234，通过除法或者求余，和10做运算
		//得到它的个、十、百、千位的单独的值
		System.out.println(1234/10/10/10);//千位
		System.out.println(1234/10/10%10);//百位
		System.out.println(1234/10%10);//十位
		System.out.println(1234%10);//个位
		
		
		
	}
}

5.位运算符
           用来连接数值，将数值转为二进制后进行运算
               & 位与：连接两个数值，转为二进制后，按位做与运算，位上的值如果都为1，结果为1，有一个为0，则为0
               100 & 0 = 0
                       0110 0100 100
                       0000 0000 0
                       0000 0000 0
               | 位或：连接两个数值，转为二进制后，按位做与运算，位上的值有一个为1，结果为1，否则为0
               100 | 10
                           0110 0100 100
                       0000 1010 10
                       0110 1110
               ^ 位异或：连接两个数值，转为二进制后，按位做与运算，位相同为0，不同为1
               100 ^ 10 =110
                           0110 0100 100
                       0000 1010 10
                           0110 1110
               ~ 位取反：对一个数值运算，数值转为二进制对补码进行运算，运算完后，要将补码变为原码
               ~100 =-101
                           0110 0100 100原码
                           0110 0100 100补码
                           1001 1011 取反
                           先减1 1001 1010
                           再取反 1110 0101 =-101
           6.位移运算符
           将数值转为二进制后，按照指定的值，移动对应的位数
           >> 右位移运算符
               8>>2 表示把8转为二进制后，1的值往右移动2位
                   1000 >> 0010 =2

                   a>>b == a / 2^b

               << 左位移运算符
               8<<2 表示把8转为二进制后，1的值往左移动2位
                   0000 1000 >> 0010 0000 =32

                   a<<b == a * 2^b

                   //1怎么样计算得到结果为8，效率最快
                   1<<3

7.三元表达式
               语法：表达式？值1 ：值2 ；
               如果前面表达式的结果为true，那么整个三元表达式的结果为值1；
                   如果前面表达式的结果为false，那么整个三元表达式的结果为值2；

public class Demo01Operator{
	public static void main(String[] args){
		
		int num1=10;
		int num2=20;
		System.out.println(num1>num2);//false
		System.out.println(num1<=num2);//true
		System.out.println(num1<=num2);//false
		System.out.println(num1!=num2);//true
		
		//逻辑运算符
		System.out.println((3>2)&(5>4));//true&true=true
		System.out.println((3>2)&&(5>4));//true&&true=true
		
		//测试短路效果
		System.out.println((num1<0)&(++num1>0));//false&true=false
		System.out.println(num1);//11
		
		System.out.println((num2<0)&&(++num2>0));//false&true=false
		System.out.println(num2);//20
		
		System.out.println((num1>0)|(++num1>0));//true | true=true
		System.out.println(num1);//12
		
		System.out.println((num2>0)||(++num2>0));//true || true=true
		System.out.println(num2);//20
		
		System.out.println(!(num2>0));//false
		
		
		//赋值运算符
		int a=10;
		int b=20;
		
		a += b;
		System.out.println(a); //30
		
 **自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

**因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

![img](https://img-blog.csdnimg.cn/img_convert/1fa04624c63162f4ddf93c8a47077e12.png)

![img](https://img-blog.csdnimg.cn/img_convert/dec9d05b3eb94eec3c325d84bd388fe2.png)

![img](https://img-blog.csdnimg.cn/img_convert/761278169ca825e521c0fe188654b35f.png)

![img](https://img-blog.csdnimg.cn/img_convert/8147d47227d51fc5fe19e99d2ffdd214.png)

![img](https://img-blog.csdnimg.cn/img_convert/6c361282296f86381401c05e862fe4e9.png)

![img](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！**

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

**如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）**

thon开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

[外链图片转存中...(img-3Ff1nQnO-1713546784455)]

[外链图片转存中...(img-EiQpaSp1-1713546784456)]

[外链图片转存中...(img-hsCf4vFT-1713546784457)]

[外链图片转存中...(img-ykc67NB0-1713546784457)]

![img](https://img-blog.csdnimg.cn/img_convert/6c361282296f86381401c05e862fe4e9.png)

![img](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！**

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

**如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）**

![](https://img-blog.csdnimg.cn/img_convert/f174833d9b381d525c1d9bbda6a3c192.jpeg)

2401_84010326

关注

4
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
393-JAVA-day1

定义：指的是在程序运行过程中，固定不变的量分类：字符串常量：双引号引起来的整数常量：整数数值浮点数常量：带小数点的小数数值字符常量：单引号引起来的单个字符布尔常量：两个值，true和false空常量：null，表示没有任何内容//字符串常量System.out.println("你好");//整数常量//浮点数常量//字符常量//报错//布尔常量//空常量不能直接输出定义：指的是，在程序运行期间，值可以改变的量。
复制链接

扫一扫