Java基础

绿仔牛奶_

已于 2022-07-14 23:59:12 修改

阅读量162

点赞数

分类专栏： Java核心技术文章标签： java jvm 开发语言

于 2022-07-14 23:28:54 首次发布

本文链接：https://blog.csdn.net/yuqu1028/article/details/125795034

版权

Java核心技术专栏收录该内容

35 篇文章 0 订阅

订阅专栏

环境变量

classpath

classpath直译过来就是类路径，指的是Java程序编译后生成的.class文件的路径
JVM运行Java程序时将会从此路径找.class文件
在JDK1.5之前没有classpath默认值，JDK1.5之后Sun公司进行了改进。JRE会自动搜索当前路径下的Jar包并自动加载dt.jar和tools.jar，不需要再另外设置classpath变量

path

我们不能每次在命令行编译和运行Java程序时都去JDK目录下找到javac.exe和Java.exe工具,配置环境变量可以让我们在任意目录下都可以使用JDK的bin目录下的工具
在命令行使用javac.exe等工具时，任意目录下都可以找到这个工具所在的目录

JavaDoc

JavaDoc主要用于生成API帮助文档
API文档主要用于说明类、方法、成员变量的功能
常用的JavaDoc标记如下：

@author：指定Java程序的作者。
@version：指定源文件的版本。
@deprecated: 不推荐使用的方法。
@param：方法的参数说明信息。
@return：方法的返回值说明信息。
@see："参见"，用于指定交叉参考的内容。
@exception: 抛出异常的类型。
@throws：抛出的异常，和@exception同义。
    //生成API文档指令：
    javadoc -d apidoc -windowtitle 测试 -doctitle 学习 javadoc 工具的测试API文档 -header 我的类 -version -author *HelloTest.java

驼峰命名法

小驼峰式命名规则：首字母小写，后面每个单词首字母大写。
大驼峰式命名规则：首字母大写，后面每个单词首字母也大写。
类名、接口名：大驼峰法。
变量名、方法名：小驼峰法。
常量名：全部大写，用 “__”连接两个单词之间

JDK、JRE、JVM

三者的包含关系：JDK>JRE>JVM

JDK：
- 提供给Java开发人员使用
- 包含了JRE和Java的开发工具
- 开发工具包含：编译工具(javac.exe) 打包工具(jar.exe)
JRE：
- 属于JDK的子集
- JRE 提供了库、Java 虚拟机（JVM）和其他组件，用于运行 Java 编程语言、小程序、应用程序
JVM：
- 虚拟机，具备计算机的基本计算能力
- 能够将Java程序编译产生的.class字节码文件解释成具体平台系统上的机器指令，可以在各个平台上运行

常量

public class Demo01 {
    //static静态变量声明
    // final常量名称(修饰符，不区分先后)  一般大写字母定义常量
    static final double _1 = 1;//定义常量_1
    final static int num1 = 1999;//定义一个常量num1
}

数据类型、字节范围

八大数据类型:
进制转换与整型


public class IntegerValTest
{
	public static void main(String[] args)
	{
		// 下面代码是正确的，系统会自动把56当成byte类型处理
		byte a = 56;
		/*
		下面代码是错的，系统不会把9999999999999当成long类型处理，
		所以超出int的表数范围，从而引起错误
		*/
		// long bigValue = 9999999999999;
		// 下面代码是正确的，在巨大的整数值后使用L后缀，强制使用long类型
		long bigValue2 = 9223372036854775807L;

		// 以0开头的整数值是8进制的整数
		int octalValue = 013;
		System.out.println(octalValue);
		// 以0x或0X开头的整数值是16进制的整数
		int hexValue1 = 0x13;
		int hexValue2 = 0XaF;

		// 定义二个8位的二进制数
		int binVal1 = 0b11010100;
		byte binVal2 = 0B01101001;
		// 定义一个32位的二进制数,最高位是符号位。
		int binVal3 = 0B10000000000000000000000000000011;
		System.out.println(binVal1); // 输出212
		System.out.println(binVal2); // 输出105
		System.out.println(binVal3); // 输出-2147483645
		/*
		 定义一个8位的二进制，该数值默认占32位，因此它是一个正数。
		 只是强制类型转换成byte时产生了溢出，最终导致binVal4变成了-23
		 */
		byte binVal4 =  (byte)0b11101001;
		/*
		  定义一个32位的二进制数,最高位是1。
		  但由于数值后添加了L后缀，因此该整数的实际占64位，第32位的1不是符号位。
		  因此binVal5的值等于2的31次方 + 2 + 1
		 */
		long binVal5 = 0B10000000000000000000000000000011L;
		System.out.println(binVal4); // 输出-23
		System.out.println(binVal5); // 输出2147483651
		int i1=200;
		System.out.println((byte)i1);
	}
}

浮点数

float可以保证十进制科学计数法小数点后6位有效精度和第7位的部分精度
double可以保证十进制科学计数法小数点前15位有效精度（包括15位）
依赖于java.math.BigDecimal类实现浮点高精度
Java 的三个特殊的浮点数值:正无穷大,负无穷大和非数

所有的正无穷大都是相等,负无穷大都是相等,而非数不与任何数值相等,与自己也不相等,只有浮点数除0 才可以得到这三个数,整数除0将报错;


import java.math.BigDecimal;

public class FloatTest
{
	public static void main(String[] args)
	{
        
		float af = 5.2345556f;
		// 下面将看到af的值已经发生了改变
		System.out.println(af);
        System.out.println(new BigDecimal(Double.toString(5.2345556898989)));
        
		double a = 0.0;
		double c = Double.NEGATIVE_INFINITY;
		float d = Float.NEGATIVE_INFINITY;
		// 看到float和double的负无穷大是相等的。
		System.out.println(c == d);
		// 0.0除以0.0将出现非数
		System.out.println(a / a);
		// 两个非数之间是不相等的
		System.out.println(a / a == Float.NaN);
		// 所有正无穷大都是相等的
		System.out.println(6.0 / 0 == 555.0/0);
		// 负数除以0.0得到负无穷大
		System.out.println(-8 / a);
		// 下面代码将抛出除以0的异常
//		System.out.println(0 / 0);
	}
}

自动类型转换

在这里插入图片描述

（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时，

int i = 'A';//char自动升级为int
double d = 10;//int自动升级为double

byte b = 127; //右边的整数常量值必须在-128~127范围内
//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型一起混合运算时，会按照其中最大的类型运算

int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double

（3）当byte,short,char数据类型进行算术运算时，按照int类型处理

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
System.out.println(c1 + c2);//113

（4）boolean类型不参与

强制转换

（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围小的变量时，需要强制类型转换，提示：有风险，可能会损失精度或溢出

int i = (int)3.14;//强制类型转换，损失精度

double d = 1.2;
int num = (int)d;//损失精度

int i = 200;
byte b = (byte)i;//溢出

（2）boolean类型不参与

（3）当某个值想要提升数据类型时，也可以使用强制类型转换

int i = 1;
int j = 2;
double shang = (double)i/j;

特殊转换

任意数据类型的数据与String类型进行“+”运算时，结果一定是String类型

// 下面代码是错的，因为5是一个整数，不能直接赋给一个字符串
// String str1 = 5;
// 一个基本类型值和字符串进行连接运算时，基本类型值自动转换为字符串
String str2 = 3.5f + "";
// 下面输出3.5
System.out.println(str2);
// 下面语句输出7Hello!
System.out.println(3 + 4 + "Hello！");
// 下面语句输出Hello!34，因为Hello! + 3会把3当成字符串处理，
// 而后再把4当成字符串处理
System.out.println("Hello！" + 3 + 4);

String类型转换整型

//字符串String数据类型与double类型相互转换
		double a1 = 12.35;
		String a2 = "12.23";
		System.out.println(String.valueOf(a1));//返回字符串
//String.valueOf();该方法接收double类型，返回值为string字符串类型
		System.out.println(Double.valueOf(a2));
//Double.valueOf();该方法接受String类型，返回值为double类型
//其他int、short等与String类型转换方法相同，可以参考Java帮助文档API

关于原码、反码、补码

正数补码、反码、原码都一样
负数的补码与反码、原码不一样：

负数的原码：把十进制转为二进制，然后最高位设置为1

负数的反码：在原码的基础上，最高位(符号位)不变，其余位取反（0变1,1变0）

负数的补码：反码+1

数据丢失：

int i1 = 200;
System.out.print((byte)i1);
//-56
原理:200原码为1100 1000，最高位为1是负数，--->1011 0111反码--->补码1011 1000
    原码int 为4字节在1100 1000前面全部补1
    	1111 1111 1111 1111 1111 1111 1111 1111
    	1111 1111 1111 1111 1111 1111 1100 1000
300  0001 0010 1100原码----->0110 1101 0011反码----->0110 1101 0100补码
    byte是1字节，300（0010 1100）强转只取后八位源码得到44
    25  0001  1001正数
-25  1001  1001原码------> 1110 0110反码------>1110  0111补码

转义符

在这里插入图片描述

unicode、ASICC编码

unicode
将所有的英文字母，数字，符号都和十进制进行了对应，因此产生了世界上第一张编码表ASCII
ASCII编码表
网址查询unicode编码表：

https://www.4qx.net/Unicode_Conversion.php
Unicode(统一码、万国码、单一码)是计算机科学领域里的一项业界标准，包括字符集、编码方案等。Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。

运算符

”与“和”或“的短路问题

逻辑运算符	符号解释	符号特点
`&`	与，且	有`false`则`false`
`	`	或
`^`	异或	相同为`false`，不同为`true`
`!`	非	非`false`则`true`，非`true`则`false`
`&&`	双与，短路与	左边为false，则右边就不看
`		`

&&和&区别，||和|区别

**&&和&**区别：
- &&和&结果一样，&&有短路效果，左边为false，右边不执行；&左边无论是什么，右边都会执行。
**||和|**区别：
- ||和|结果一样，||有短路效果，左边为true，右边不执行；|左边无论是什么，右边都会执行。

三目运算符

条件表达式？结果1：结果2

条件运算符计算方式：
- 条件判断的结果是true，条件运算符整体结果为结果1，赋值给变量。
- 判断条件的结果是false，条件运算符整体结果为结果2，赋值给变量。

public static void main(String[] args) {
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    int j = (3<=4 ? 500 : 600);
    System.out.println(j);//500
}

while循环


while循环扩展格式
初始化语句①；
while (循环条件语句②) {
    循环体语句③；
    迭代语句④；
}


do--while循环扩展格式
初始化语句①
do {
    循环体语句②；
    迭代语句③；
} while (循环条件语句④)；

注意：
（1）while(循环条件)中循环条件必须是boolean类型
（2）do{}while();最后有一个分号
（3）do…while结构的循环体语句是至少会执行一次，这个和for和while是不一样的

跳转语句

break

在switch条件语句以及循环语句中都可以使用break语句
switch：break用于终止某个case并且跳出switch结构

循环：用于跳出循环语句，执行循环后代码

public static void main(String[] args) {
        int i = 0;
        for (i=0;i<=9;i++){   
            if (i==7){
                break;    //i=7跳出循环
            }
            System.out.println(i);//0123456
        }
        System.out.println("=============================================");
        System.out.println(i);//7
    }

continue

continue用作循环语句当中，它的作用是终止本次循环

实例（计算100内奇数之和）：

 //100以内奇数之和
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i<=100;i++){
            if (i%2==0){
                continue;//跳出本次循环
            }else{
                sum += i;
            }
        }
        System.out.println(sum);//2500
    }