1.Java基本概念数据类型

兮寒wr

已于 2024-05-02 18:26:50 修改

阅读量980

点赞数 19

分类专栏： 393 文章标签： java

于 2024-03-28 13:52:39 首次发布

本文链接：https://blog.csdn.net/weixin_50975714/article/details/137064585

版权

393 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

Java起源

1991=>SUN公司 => 高斯林=>物联网

1995=>互联网兴起=>java（爪洼岛）

计算机语言的发展阶段

1.纯机器语言，只有机器能读懂，人类读不懂 0101

2.汇编语言，计算机能读懂，人类也能读懂，比较难懂 0x12 ADD12

3.第三代语言，计算机能读懂，也有利于人类阅读

C语言：面向过程的语言

C++ ：面向过程/面向对象

java：跨平台的纯面向对象的语言,目前应用较为广泛

二进制转换

生活中是10进制，计算机用的是二进制，二进制只能包含0、1，每个0、1表示一位（bit）

一个字节 1byte=8bit

1kb = 1024byte

1MB=1024kb

1GB=1024MB

1TB=1024GB

PB 、EB、ZB

10进制转2进制：除2取余

二进制转10进制：二进制值乘以 2的n次方(n表示二进制的位数) ，再求和

命令提示符操作

win + R 输入cmd

切换盘符：盘名 :

切换目录位置： cd 文件夹名称

cd ..

cd /

查看当前目录下的内容： dir

Java版本

1995 => Java1.0

1997 => 1.1

1998：1.2

J2SE：桌面应用开发 J2EE：面向企业应用开发 J2ME：手机终端应用开发

2000：1.3

2002：1.4

2004：jdk5版本

2006：jdk6（javaSE，javaEE，javaME）

2009：Oracle（甲骨文）收购了SUN

2011：jdk7

2014：jdk8（目前市面上使用较多）

2017：jdk9

2018年3月：jdk10

2018年9月：jdk11

....每隔半年更新一次

Java跨平台原理

跨平台：这里的平台指的是操作系统

不管什么软件应用，都需要运行在操作系统上，跨平台指的是，同java编写的软件，可以在任何操作系统上运行。

java跨平台的特性：依靠JVM虚拟机实现

跨平台原理：通过不同操作系统上安装jdk，实现Java应用的使用

JDK-JRE-JVM

JDK：Java Development Kit

java工具开发包，包含了JRE和开发人员使用的工具

将来如果需要开发一个Java程序，必须要在计算机上安装JDK

JRE：Java Runtime Environment

Java程序运行时的环境，包含了JVM和运行时需要的核心的类库

如果想要运行某个Java程序，就需要安装JRE

JVM：Java virtual machine

Java虚拟机，简称JVM，Java程序运行的假想计算机，是Java程序的运行环境，将来编写的所有Java代码，都是运行在JVM上的

搭建JDK环境

1.下载JDK安装包

2.配置环境

环境是什么意思？

在计算机中环境指的是，可以在任意的位置，运行任意的程序

3.JDK环境配置步骤

右击我的电脑 -> 属性 -> 高级系统设置

编写完后点击确定，全部确定后，重新打开cmd窗口

输入命令，测试版本

jdk环境安装完成

Java的第一个HelloWorld

1.Java程序开发的步骤：编写、编译、运行

编写：

在指定文件夹中，新建一个文本文档文件，然后改名为HelloWorld.java

以记事本打开HelloWorld.java文件，编写代码，然后保存

注意事项：

1，public class HelloWorld 表示声明一个公开的类，可以被编译，访问，

class后面的名字称为类名，类名必须和文件名相同

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
		
		a -= b;
		System.out.println(a); //10
		
		a *= b;
		System.out.println(a); //200
		
		a /= b;
		System.out.println(a); //10
		
		a %= b;
		System.out.println(a); //10
		
		
		//1+2+...+99+100
		//int i = 1;
		//int sunm = 0;
		//sum += i;
		
		
		//三元表达式
		//已知三个数值，x=10，y=20，z=30，求这三个值中的最大值
		int x,y,z;
		x=10;
		y=20;
		z=30;
		int i= (x>y) ? x : y ;
		int j= (i>z) ? i : z;
		System.out.println(j);
		
		
		int max1=((x>y) ? x : y)>z ? ((x>y) ? x : y) : z;
		System.out.println(max1);
		
		//练习 已知m=10 ，n=20 ，请将m和n的值做交换后输出
		int m=10,n=20;
		int t=m;
		m=n;
		n=t;
		System.out.println("m="+m+",n="+n);
		
		
		int m1=10,n1=20;
		n1=m1^n1;
		System.out.println(n1);
		m1=m1^n1;
		n1=m1^n1;
		System.out.println("m="+m1+",n="+n1);
		
		
		
	}
}

兮寒wr

关注

19
点赞
踩
20

收藏

觉得还不错? 一键收藏
1
评论
1.Java基本概念数据类型

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

扫一扫