01-java基础-语法入门-jdk目录介绍、java基本类型范围、cmd运行java、java接受命令行输入、类型转换、java七大类运算符

当初学的时候忘记写博客了，现在稍微花点时间补上，有自己的笔记终究是好点。

文章目录

1. Java概述

1.1 Java版本介绍（了解）

java语言的三个版本：
JavaSE: Java 语言的（标准版），用于桌面应用的开发，是其他两个版本的基础
JavaME: Java 语言的（小型版），用于嵌入式消费类电子设备
JavaEE: Java 语言的（企业版），用于 Web 方向的网站开发

1.2 Java语言跨平台原理（理解）

Java程序并非是直接运行的，Java编译器将Java源程序编译成与平台无关的字节码文件(class文件)，然后由Java虚拟机（JVM）对字节码文件解释执行。所以在不同的操作系统下，只需安装不同的Java虚拟机即可实现java程序的跨平台。

1.3 JRE和JDK（记忆）

JVM（Java Virtual Machine），Java虚拟机
JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（Java API）
JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具
总结：我们只需安装JDK即可，它包含了java的运行环境和虚拟机。

1.4 JDK的下载和安装（应用）

1.4.1 下载
1.4.2 安装

1.4.3 JDK的安装目录介绍

目录名称	说明
bin	该路径下存放了JDK的各种工具命令。javac和java就放在这个目录。
conf	该路径下存放了JDK的相关配置文件。
include	该路径下存放了一些平台特定的头文件。
jmods	该路径下存放了JDK的各种模块。
legal	该路径下存放了JDK各模块的授权文档。
lib	该路径下存放了JDK工具的一些补充JAR包。

2. 第一个演示程序

2.1 常用DOS命令（应用）

操作	说明
dir	查看当前路径下的内容。
cls	清屏
exit	退出命令提示符窗口。

2.2 Path环境变量的配置（应用）

2.2.1 为什么配置环境变量

cmd下输入命令，系统先在当前目录查找有无对应名称的.exe,然后到配置了环境变量的目录下查找
所以配置了环境变量后，不用在cmd下切换目录，打开cmd即可使用java javac等命令，因为虽然在当前目录下找不到java.exe和javac.exe,但是到环境变量指定的目录下能找到

2.3 HelloWorld案例（应用）

2.3.1 Java程序开发运行流程

开发Java程序，需要三个步骤：编写程序，编译程序，运行程序。

2.3.2 HelloWorld案例的编写

1、新建文本文档文件，修改名称为HelloWorld.java。
2、用记事本打开HelloWorld.java文件，输写程序内容。

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

2.3.3 HelloWorld案例的编译和运行

编译：javac 文件名.java

eg：javac HelloWorld.java

执行：java 类名

eg：java HelloWorld

2.4 HelloWorld案例详解（理解）

2.5 HelloWorld案例常见问题（理解）

2.5.3 HelloWorld案例常见问题

1、非法字符问题。Java中的符号都是英文格式的。
2、大小写问题。Java语言对大小写敏感（区分大小写）。
3、在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件。
4、编译命令后的java文件名需要带文件后缀.java
5、运行命令后的class文件名（类名）不带文件后缀

3. java基础语法1

3.2 关键字（理解）

关键字是指被java语言赋予了特殊含义的单词。
关键字的特点：
关键字的字母全部小写。
常用的代码编辑器对关键字都有高亮显示，比如现在我们能看到的public、class、static等。

3.4 变量的介绍(理解)

变量的定义格式：
数据类型 变量名 = 数据值；
数据类型：为空间中存储的数据加入类型限制。整数？小数？
变量名：自己要为空间起的名字，没有难度
数据值： 空间中要存储的数值，没有难度

3.5 数据类型（应用）

3.5.1 计算机存储单元

1B（字节） = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
1EB = 1024PB
1ZB = 1024EB
巧记： TPEZ =》 “调皮儿子”

3.5.2 Java中的数据类型

Java是一个强类型语言，Java中的数据必须明确数据类型。在Java中的数据类型包括基本数据类型和引用数据类型两种。

Java中的基本数据类型：

数据类型	关键字	内存占用(B)	取值范围
整数类型	byte	1	-128~127
	short	2	-32768~32767
	int(默认)	4	-2的31次方到2的31次方-1
	long	8	-2的63次方到2的63次方-1
浮点类型	float	4	负数：-3.402823E+38到-1.401298E-45 正数： 1.401298E-45到3.402823E+38
	double(默认)	8	负数：-1.797693E+308到-4.9000000E-324 正数：4.9000000E-324 到1.797693E+308
字符类型	char	2	0-65535
布尔类型	boolean	1	true，false

说明:

1、在java中整数默认是int类型，浮点数默认是double类型。

2、浮点数采用IEEE 754标准

那么我们就来计算验证一下表格中float和double的范围

public class HelloWorld{
  public static void main(String[] args) {
    /*double Math.pow(double,double)
      Math.pow(a,b); 返回 a^b     0<b<1就是开方
    */
    double a=Math.pow(1024,1.0/10);//2^10=1024
    System.out.println("测试API:"+a);
    double x=2-Math.pow(2,-23);
    double y=Math.pow(2,127);
    System.out.println("float最大值="+x*y);//2^123 * (2-2^-23)

    x=2-Math.pow(2,-52);
    y=Math.pow(2,1023);
    System.out.println("double最大值="+x*y);//2^1023 * (2-2^-52)
  }
}

完全一致

3.6 变量（应用）

3.7 变量的注意事项(理解)

1. 在同一对花括号中，变量名不能重复。
2. 变量在使用之前，必须初始化（赋值）。【尤其引用类型开始容易忽视】
3. 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型(int就不用加后缀了)，整数太大可能超出int范围。
4. 定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是
   double(double就不用加后缀了)， double的取值范围是大于float的，类型不兼容

3.8 键盘录入（理解）

关键字都小写，类名都大写开头(规范)

import java.util.Scanner;
public class ScannerDemo{
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.print("请输入a:");
    int a=sc.nextInt();
    System.out.println(a+"的三次方等于="+a*a*a);
  }
}

3.9 标识符（理解）

标识符是用户编程时使用的名字，用于给类、方法、变量、常量等命名。
Java中标识符的组成规则：
由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字。
不能使用java中的关键字作为标识符。
标识符对大小写敏感（区分大小写）。
Java中标识符的命名约定：
小驼峰式命名：变量名、方法名
首字母小写，从第二个单词开始每个单词的首字母大写。
大驼峰式命名：类名
每个单词的首字母都大写。
另外，标识符的命名最好可以做到见名知意
例如：username、studentNumber等。

3.10 类型转换

在Java中，一些数据类型之间是可以相互转换的。分为两种情况：自动类型转换和强制类型转换

3.10.1 隐式转换(理解)

把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即
可。例如：

double num = 10; // 将int类型的10直接赋值给double类型
System.out.println(num); // 输出10.0

类型从小到大关系图：

说明：

1. 整数默认是int类型，byte、short和char类型数据参与运算均会自动转换为int类型。

byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
// 第三行代码会报错，b1和b2会自动转换为int类型，计算结果为int，int赋值给byte需要强制类型转换。
// 修改为:
int num = b1 + b2;
// 或者：
byte b3 = (byte) (b1 + b2);

LX:

public class TypeDemo {
    public static void main(String[] args) {
        char c='a';
        System.out.println(c);
        System.out.println(c+1);
    }
}

问：为何第二行输出98，而不是输出‘b’
答：因为隐式类型转换 char + int = int 隐式转换是 范围小的向范围大的转换

2. boolean类型不能与其他基本数据类型相互转换。 ★

3.10.2 boolean类型不能与其他基本数据类型相互转换。

把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。
强制类型转换格式：目标数据类型 变量名 = (目标数据类型)值或者变量;
例如：

double num1 = 5.5;
int num2 = (int) num1; // 将double类型的num1强制转换为int类型
System.out.println(num2); // 输出5（小数位直接舍弃）

3.10.3 类型转换案例(理解)

案例代码：
两个个byte变量相加，会先提升为int类型

byte a = 3;
byte b = 4;
byte c = a + b; //错误。因为两个byte变量相加，会先提升为int类型
byte d = 3 + 4; //正确。常量优化机制

1、为什么byte c = a + b;就报错呢？

答： 这是java的机制导致的，java在对byte这种类型进行“运算”时，会将其转换为int类型，两个int类型相加，赋 值给byte类型肯定会报错的。

2、为什么byte = 3 + 4；又不会报错呢？

答：3+4是常量的计算，会优先执行(编译时就计算)，执行结果再赋值给byte，此时判断数值是否满足该类型范围，满足就直接赋值了。

▲ 总结：
两个变量相加，先对类型进行提升，然后运算，再将运算结果赋值。
两个常量相加，先计算常量数值，然后判断是否满足类型范围，再赋值。

java常量优化机制： 在编译时，整数常量的计算会直接算出结果，并且会自动判断该结果是否在byte取值范围内，
在：编译通过
不在：编译失败

3.11 运算符

3.11.1 算术运算符

符号	作用	说明
+	加	参看小学一年级
-	减	参看小学一年级
*	乘	参看小学二年级，与“×”相同
/	除	参看小学二年级，与“÷”相同
%	取余	获取的是两个数据做除法的余数

注意：

1. /和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
2. 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

int a = 10;
int b = 3;
System.out.println(a / b); // 输出结果3
System.out.println(a % b); // 输出结果1

1、字符的“+”操作（理解）

char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值：
‘a’ – 97 a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加
‘A’ – 65 A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加
‘0’ – 48 0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加

// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
char ch1 = 'a';
System.out.println(ch1 + 1); // 输出98，97 + 1 = 98
char ch2 = 'A';
System.out.println(ch2 + 1); // 输出66，65 + 1 = 66
char ch3 = '0';
System.out.println(ch3 + 1); // 输出49，48 + 1 = 49

算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。
提升规则：
byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。
整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型
等级顺序：byte,short,char --> int --> long --> float --> double

例如：

byte b1 = 10;
byte b2 = 20;
// byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度
int i3 = b1 + b2; // 应该使用int接收
byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型
-------------------------------
int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型

2、字符串的“+”操作（理解）

当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。

System.out.println("hello"+ 666); // 输出：hello666

在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。

深刻理解:按优先级运算发现字符串+才开始转变功能

System.out.println(1 + 99 + "年大党"); // 输出：100年大党
System.out.println(1 + 2 + "hello" + 3 + 4); // 输出：3hello34
// 可以使用小括号改变运算的优先级
System.out.println(1 + 2 + "hello" + (3 + 4)); // 输出：3hello7

3、数值拆分（应用）

需求：键盘录入一个三位数，将其拆分为个位，十位，百位，打印在控制台
示例代码：

import java.util.Scanner;
public class TypeDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x= sc.nextInt();
        System.out.println(x/100);
        System.out.println(x/10%10);
        System.out.println(x%10);
    }
}

3.11.2 自增自减运算符（理解）

符号	作用	说明
++	自增	变量的值加1
–	自减	变量的值减1

注意事项：
++和-- 既可以放在变量的后边，也可以放在变量的前边。
单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。
参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–。
参与操作的时候，如果放在变量的前边，先拿变量做++或者–，后拿变量参与操作。
最常见的用法：单独使用。

int i = 10;
i++; // 单独使用
System.out.println("i:" + i); // i:11
int j = 10;
++j; // 单独使用
System.out.println("j:" + j); // j:11
int x = 10;
int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11，y:10
int m = 10;
int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
System.out.println("m:" + m + ", m:" + m); // m:11，m:11

练习：

int x = 10;
int y = x++ + x++ + x++;
System.out.println(y); // y的值是多少？

x=10;
System.out.println(x++ + ++x); // 输出是多少？  

/*
解析，三个表达式都是++在后，所以每次使用的都是自增前的值，但程序自左至右执行，所以第一次自增时，使用的是
10进行计算，但第二次自增时，x的值已经自增到11了，所以第二次使用的是11，然后再次自增。。。
所以整个式子应该是：int y = 10 + 11 + 12; 输出结果为33。

同理： 第二个输出： 10+(11+1) = 22
*/

3.11.3 赋值运算符（应用）

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。

符号	作用	说明
=	赋值	a=10，将10赋值给变量a
+=	加后赋值	a+=b，将a+b的值给a
-=	减后赋值	a-=b，将a-b的值给a
*=	乘后赋值	a*=b，将a×b的值给a
/=	除后赋值	a/=b，将a÷b的商给a
%=	取余后赋值	a%=b，将a÷b的余数给a

注意：

扩展的赋值运算符隐含了强制类型转换。 没用的冷门知识点

short s = 10;
s = s + 10; // 此行代码报错误，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度

s += 10; // ★ 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);   ★

public class TypeDemo {
    public static void main(String[] args) {
        short s = 10;
        //s = s + 10; // 此行代码报错误，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度
        s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10); 

        System.out.println(s);
        System.out.println(((Object)s).getClass());//s = (short) (s + 10);  还是short
    }
}

3.11.4 关系运算符（应用）

关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。

符号	说明
==	a==b，判断a和b的值是否相等，成立为true，不成立为false
!=	a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>	a>b，判断a是否大于b，成立为true，不成立为false
>=	a>=b，判断a是否大于等于b，成立为true，不成立为false
<	a<b，判断a是否小于b，成立为true，不成立为false
<=	a<=b，判断a是否小于等于b，成立为true，不成立为false

注意事项：

关系运算符的结果都是boolean类型，要么是true，要么是false。

int a = 10;
int b = 20;
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a > b); // false
System.out.println(a >= b); // false
System.out.println(a < b); // true
System.out.println(a <= b); // true

// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
boolean flag = a > b;
System.out.println(flag); // 输出false

3.11.5 逻辑运算符（应用）

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断
的结果是 true 或 false

符号	作用	说明
&	逻辑与	a&b，a和b都是true，结果为true，否则为false
|	逻辑或	a|b，a和b都是false，结果为false，否则为true
^	逻辑异或 ▲	a^b，a和b结果不同为true，相同为false
!	逻辑非	!a，结果和a的结果正好相反

//定义变量
int i = 10;
int j = 20;
int k = 30;

//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((i > j) & (i > k)); //false & false,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
System.out.println((i < j) & (i < k)); //true & true,输出true
System.out.println("--------");

//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((i > j) | (i > k)); //false | false,输出false
System.out.println((i < j) | (i > k)); //true | false,输出true
System.out.println((i > j) | (i < k)); //false | true,输出true
System.out.println((i < j) | (i < k)); //true | true,输出true
System.out.println("--------");

//^ “异或”，相同为false，不同为true
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
System.out.println("--------");

//! “非”，取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false，,输出true

|与&单个用不会短路

//定义变量
int i = 10;
System.out.println((i > 10) & (++i>10));//false
System.out.println(i);//输出11说明 '&'不会短路
i = 10;
System.out.println((i > 10) && (++i>10));//false
System.out.println(i);//输出10说明 '&&'会短路

System.out.println("-----------------");
i = 10;
System.out.println((i > 9) | (++i>10));//true
System.out.println(i);//输出11说明 '|'不会短路
i=10;
System.out.println((i > 9) || (++i>10));//true
System.out.println(i);//输出9说明 '||'会短路

3.11.6 短路逻辑运算符（理解）

符号	作用	说明
&&	短路与	作用和&相同，但是有短路效果
||	短路或	作用和|相同，但是有短路效果

在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

• 逻辑与&，无论左边真假，右边都要执行。
• 短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
• 逻辑或|，无论左边真假，右边都要执行。
• 短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算
System.out.println(x); // 4
System.out.println(y); // 5

System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算
System.out.println(x); // 4
System.out.println(y); // 4

3.11.7 三元运算符（理解）

三元运算符语法格式：

关系表达式 ? 表达式1 : 表达式2;

解释：问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。

举例：

int a = 10;
int b = 20;
int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值      最大值c=20

>>三元运算符案例(应用)

需求：
一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最
高身高。

int h1=150,h2=210,h3=165;
int mh=(h1>h2?h1:h2);
mh= mh>h3?mh:h3;
System.out.println(mh);