从0开始学Java (1)

chenluo10086

已于 2022-10-23 16:57:43 修改

阅读量153

点赞数

文章标签： java jvm

于 2022-10-21 09:47:41 首次发布

本文链接：https://blog.csdn.net/chenluo10086/article/details/127411816

版权

新手上路

开个坑记录一下Java学习进度，隔几天进行一次小结

1、计算机基础

1.1计算机的结构基础

冯诺依曼体系结构

通过CPU的控制器将输入设备中的数据读取到CPU的存储器中，然后通过运算器将存储器的数据进行运算，最后再由控制器将运算器的结果显示到输出设备中
![图片来源：https://www.iteye.com/blog/yangweixu-2303785

2、Java环境搭建

2.1 Java技术体系

JDK: java development kit java开发工具包，作为程序员需要安装的就是JDK。里面包含了JRE + 工具集
JRE:java runtime environment java运行时环境，如果你在自己的电脑上想要运行一个java程序，必须要保证存在JRE。JRE中包含了JVM+Libs类库信息
JVM:java virtual machinejava虚拟机，这个东西是一个虚拟的计算机。这个虚拟的计算机是用来专门处理.class文件（也叫字节码文件或者bytecode文件）。它是Java跨平台的基础。

图片来源: https://www.iteye.com/blog/yangweixu-2303785 图片来源:https://www.iteye.com/blog/yangweixu-2303785

2.2 Java跨平台

程序员编写.java程序，然后通过编译器将.java编译为对应的.class字节码文件，然后电脑上都会安装JDK，所以电脑上会存在JVM，JVM获取到用户发送的字节码文件之后，开始解释执行字节码文件。执行过程就是将字节码文件解释为对应平台上可以识别的汇编指令或者是机器码。
在这里插入图片描述

3、第一条代码

public 	class HelloWorld{
	public static void main(String[] args){
		System.out.println("hello World");
	}
}

编译期间发生的错误
- 单词拼写 (多敲)
- 中英文符号问题 (全部是英文符号)
- 当一个类被public修饰了之后，就是主类，主类的名称要和文件的文件名保持一致
- 大小写问题
运行时发生的错误
- main方法的定义不要写错了 (最常写错的就是main)

4、注释

注释分类	编写格式	注意事项
单行注释	//注释内容	只能注释一行内容
多行注释	/* 注释内容*/	可以编写多行注释信息
文档型注释	/**注释内容 * /	不能和多行注释嵌套使用它可以用来生成帮助文档

5、标识符

Java中用来给各个类、变量、常量、接口等等起名字的

5.1 标识符起名规则

3个规则
- 不能以数字开头，可以用字母，下划线 _ 美元符号 $开头，后接字母、数字、下划线、美元符号
- 严格区分大小写
- 不能使用Java中预留关键词
2个标准
- 见名知意
- 驼峰原则
1个注意事项
- Java采用的字符集合是Unicode，所以我们这里所说的字母不只是26个英文字母，它代表的是各个国家通用字符信息。这里我们需要记住的是可以使用中文命名。

5.2 字符集合

用来存储字符信息和数字型的一张转换表。

图片来源： http://sc.xue63.com/wendangku/z0s/f04g/j8669496ad9v/k7f192279168884868762caaebbb3l.html 请添加图片描述

上面的这张表叫做ASICC表，也叫作美国标准信息转换码表。
随着时间的推演，越来越多的国家开始使用自己的字符集合，用来让计算机可以识别自己国家的字符信息，所以字符集合越来越多。

5.2.1 字符集合在数据传递中的作用

图片来源：https://www.yuque.com/iongst/nr3vi5/rwav5v
请添加图片描述

每一次用户在输入字符信息或者进行数据传递的时候，都需要做查表操作，也就是我们说的字符信息需要转换为对应的数字信息被存储到计算机中，那么如果在数据传递过程中，表是不一致，就会造成乱码问题。
解决方式就是保证字符集合统一。

5.2.2 字符集合造成的问题以及解决方案

在工具中修改字符编码
编译的时候指定字符集合 javac -encoding utf-8 java文件名

6、变量/常量

6.1 变量

在程序运行期间，其值可以发生改变的计量单位。

6.1.1 变量的声明以及使用

// 测试变量的声明以及使用
public class text01{
	public static void main(String[] args){
		int a;   //  变量声明完成之后无法直接使用，想要使用必须要保证初始化
		a = 10；  //初始化的方式就是通过 = 进行赋值动作
		System.out.println(a);
		a = 1;  // 当声明完成变量之后，我们不需要再重新声明该变量了，只需要直接使用即可
		System.out.println(a);
		int a = 50;  //在一个{}中是不能够定义同名变量的
	}
}

6.1.2 变量的三要素

变量类型
变量名
生命周期

6.2 数据类型

Java是强类型语言，所以它对于所有数据都限定了具体的类型

6.2.1 数据类型分类

6.2.2 整数型

字节型 byte

// 测试byte数据类型
public class ByteTest{
	public static void main(String[] args){	
		//1： 测试byte这种数据类型他能够存储的范围	
		// 声明一个byte类型的变量 存储数值
		byte b = 100;
		// 打印输出
		System.out.println(b);
		// 修改b的值的
		/*
			ByteTest.java:14: 错误: 不兼容的类型: 
			从int转换到byte可能会有损失
                b = 128;
		*/
		b = 128;
		System.out.println(b);
	}
}

数据类型	占用空间	表数范围
字节型 byte	1个字节 1B=8b	-128,127

短整型 short


// 测试short数据类型
public class ShortTest{
	public static void main(String[] args){		
		// 声明一个short类型的变量 存储数值
		short b = 128;
		// 打印输出
		System.out.println(b);
		// 修改short的值
		/*
			ShortTest.java:12: 错误: 不兼容的类型: 
			从int转换到short可能会有损失
                b = -32769;
                    ^
				1 个错误
		*/
		b = -32769;
		System.out.println(b);
	}
}

数据类型	占用空间	表数范围
短整型 short	2个字节 2B=16b	-32768,32767

整型 int

// 测试int数据类型
public class IntTest{
	public static void main(String[] args){		
		// 声明一个int类型的变量 存储数值
		int b = 32768;
		// 打印输出
		System.out.println(b);	
		//修改变量b的值
		/*IntTest.java:12: 错误: 整数太大
                b = 2147483648;
                    ^
			1 个错误
		*/
		b = 2147483648;
		System.out.println(b);
	}
}

数据类型	占用空间	表数范围
整型 int	4个字节 4B=32b	±21亿左右

长整型 long

// 测试long数据类型
public class LongTest{
	public static void main(String[] args){		
		// 声明一个long类型的变量 存储数值
		long b = 2147483647;
		// 打印输出
		System.out.println(b);		
		// 重新给b赋值
		/*
			LongTest.java:12: 错误: 整数太大
                b = 2147483648;
                    ^
				1 个错误
		*/
		b = 2147483648L;
		System.out.println(b);
	}
}

数据类型	占用空间	表数范围
长整型 long	8个字节 8B=64b	$2^{63}$ ， $2^{63}-1$

6.2.3 整数的赋值方式

// 测试整数的赋值方式
public class InitValue{
	public static void main(String[] args){
		
		//1： 正常赋值 10进制数
		int num = 190;
		System.out.println(num);
		
		//2： 可以通过二进制进行赋值  JKD7之后的
		num = 0B1101; // 0B 0b 开头
		System.out.println(num);
		
		//3： 可以通过8进制进行赋值  
		num = 023; // 0开头
		System.out.println(num);
		
		//4： 可以通过16进制进行赋值  
        //A：10 B：11 C:12 D:13 E：14 F：15
		num = 0x2C; // 0x oX开头  
		System.out.println(num);
		
		// 为了能好看一点赋值时 字面值中可以通过_分割
		// JDK7之后
		num = 123_456_789;
		System.out.println(num);
	}
}

Tips：
1.在Java中所有整数的字面值默认类型是int。
2.当我们讲一个int类型的字面整数赋值给yte，short类型的变量是，如果没有超过byte，short的范围可以正常复制成功，但是如果超过了，那么此时会报错，因为 = 赋值符号右侧十一个大类型的值，左侧是一个小类型，放不下，所以会有报错信息：
不兼容的类型:
从XX类型转换到XX类型可能会有损失。

6.2.4 小数型

I、双精度

// 测试double类型的变量
public class DoubleTest{
	public static void main(String[] args){
		
		//1: 声明一个double类型的小数
		double d = 3.14;
		System.out.println(d);
		
		//2:  测试小数的问题  不要使用小数进行四则运算
		System.out.println((0.6*10-0.5*10)/10); //0.09999999999999998

		
		System.out.println(1/0.0); // 1/0 => 错误 Infinity
		System.out.println(-1/0.0); // 1/0 => 错误 -Infinity
		// 0是不可以作为除数的 所以下面式子是不合法的
		// 但是在计算机中0是无法通过小数进行精确表示的 所以
		// 理论上而言这个0.0/0.0合理的 通过NaN描述了这种合法
		// 但是不合理的状态 NaN是一个数字 not a number 
		System.out.println(0.0/0.0);//NaN 是一个数表示的是一个状态
	}
}

数据类型	占用空间	精度范围
双精度 double	8个字节 8B=64b	小数点后14位左右

Tips：
1.进行运算的过程中，小数有几个特殊的值：infinity -infinity NaN
2.NaN是一个状态信息，0是可以作为除数的，所以下面式子是不合法的，但是在计算机中0是无法通过小数进行精确表示的，座椅理论上而言这个0.0/0.0是合理的，通过NaN描述了这种合法但是不合理的状态，NaN是一个数字 not a number。
3.我们在进行小数运算的时候一定要特别注意，因为计算机描述小数是不精准的，所以我们采取的办法是：

扩大和缩小倍数
使用BigDecimal完成小数运算(定点数)
4.如果遇到了精确度要求比较高的需求，解决方案，要么使用BigDecimal还有一种就是降低单位

II、单精度

// 测试float类型的变量
public class FloatTest{
	public static void main(String[] args){
		
		//1: 声明一个float类型的小数
		/*
			FloatTest.java:6: 错误: 不兼容的类型: 从double转换到float可能会有损失
                float d = 3.14;
                          ^
			1 个错误
		*/
		float d = 3.14F;
		System.out.println(d);

        // 修改d变量的值
		d = 1/0.3F; // 1 int   0.3 double  ==> double
		System.out.println(d);
		
	}
}

数据类型	占用空间	精度范围
单精度 float	4个字节 4B=32b	小数点后7位左右

在Java中所有的小数字面值都是double类型，当把一个小数赋值给float类型变量的时候，需要在给这个字面值后面加f 或者是F。

扩展知识：

在计算机中，小数的存储有两种方式，一种称之为定点数，一种称之为浮点数
* 浮点数：小数点在存储的时候固定位置，更加精准但是浪费内存
* 浮点数：小数点在存储的时候不固定，精准度差一点，但是节省内存

6.2.5 boolean 逻辑型

// 测试boolean类型的变量
public class BooleanTest{
	public static void main(String[] args){	
		// 声明一个boolean类型
		boolean flag = 1;
		System.out.println(flag);
	}
}

数据类型	占用空间	取值
逻辑型 boollean	1个字节实际只需要1b	ture(1) false(0)

6.2.6 char 字符型

/**
 1. 测试使用char类型
 */
public class CharTest {
    public static void main(String[] args) {
        // 1:声明一个char类型的变量
        char ch = ' '; // char类型的变量 赋值的时候只能通过单引号引起的单个字符
        System.out.println(ch);
        //可以给ch变量重新赋值 赋值int类型的数字
        ch = 65535;
        System.out.println(ch);
        // 赋值方式
        ch = '\u1235';
        System.out.println(ch);
    }
}

数据类型	占用空间	赋值方式
char 字符型	2个字节	1.通过单引号引起的单个字符
		2.通过赋值一个正整数[0,65535]
		3.通过 \u 开头后一个四位的16进制数 Unicode代码点

6.3类型转换

在任何编程语言中，不同的数据类型之间是可以相互转换的,
不会管基本数据类型的类型转换，我们最多用的是引用类型的类型转换

/**
 * 测试类型转换：
 */
public class Convert {
    public static void main(String[] args) {
        //1： 自动类型转换
        // 声明一个小类型的变量
        byte b = 12;
        // 声明一个大类型的变量
        int n = b; // 12
        //2：自动类型转换是  在做四则运算的时候触发类型转换
        System.out.println(1/0.3);//int / double ==> 大类型靠拢
        System.out.println(10/3); // 3
        // 笔试题
        char ch = 'A'+1; // 编译阶段 这个'A'+1的值就已经确定了 是66
        b = 10;
        ch = 'A'+b; // char = int 编译阶段不确定值  只能确定类型
        ch = 'A';
        n = ch+1;
        System.out.println(n);
       System.out.println(ch+1);
    }
}

小变大自动转
* 在四则运算过程中，类型会自动提升。
* 如果字面值在做四则运算，那么编译阶段会确定这个字面值以及类型（常量折叠），但是如果存在变量做四则运算的话，那么只能确定类型，不能确定值
图片来源：https://www.yuque.com/iongst/nr3vi5/nqmwzg#JonTZ
在这里插入图片描述

强制类型转换

/**
 * 强制类型转换
 */
public class Convert02 {
    public static void main(String[] args) {
        // 声明一个大类型
        int n = 130;
        // 将大类型变量的值赋值给小类型变量
        byte b = (byte)n;
        System.out.println(b);
        short sh = 128;
        // s = sh+1 会报错滴
        short s = 128+1;
    }
}

大变小需强转

小类型 = (小类型)大类型；
强转过程中，会使得值发生改变，所以应该小心使用。

6.4 常量

在程序运行期间，其值不可以发生改变的计量单位。
通过**final**姿势的变量称之为常量，常量在整个程序的值是不可以修改的。

/**
 * 测试常量
 */
public class Immutable {
    public static void main(String[] args) {
        //声明一个char类型的变量 来存储你的性别
        final char GENDER = '男';
        System.out.println(GENDER);
        System.out.println("1年过去了。。。。。。");
        System.out.println("1年过去了。。。。。。");
        System.out.println("1年过去了。。。。。。");
        System.out.println("1年过去了。。。。。。");
        System.out.println("1年过去了。。。。。。");
        System.out.println("1年过去了。。。。。。");
       /* gender = '女';
        System.out.println(gender);*/
    }
}