java基础语法

1. Java概述

1.1 Java语言发展史（了解）

语言：人与人交流沟通的表达方式

计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言

Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言

Java之父：詹姆斯·高斯林（James Gosling）

2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可：https://www.oracle.com

当前，我们课程使用的JDK版本：11.0

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 下载

通过官方网站获取JDK

http://www.oracle.com

注意：针对不同的操作系统，需要下载对应版本的JDK。

具体下载步骤请参见《JDK下载及安装说明文档》

1.4.2 安装

傻瓜式安装，下一步即可。但默认的安装路径是在C:\Program Files下，为方便统一管理建议修改安装路径，将与开发相关的软件都安装到一个目录下，例如：E:\develop。

注意：安装路径不要包含中文或者空格等特殊字符（使用纯英文目录）。

具体安装步骤请参见《JDK下载及安装说明文档》

1.4.3 JDK的安装目录介绍

2. 入门程序HelloWorld

2.1 常用DOS命令（应用）

在接触集成开发环境之前，我们需要使用命令行窗口对java程序进行编译和运行，所以需要知道一些常用DOS命令。

1、打开命令行窗口的方式：win + r打开运行窗口，输入cmd，回车。

2、常用命令及其作用

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

2.2.1 为什么配置环境变量

开发Java程序，需要使用JDK提供的开发工具（比如javac.exe、java.exe等命令），而这些工具在JDK的安装目录的bin目录下，如果不配置环境变量，那么这些命令只可以在该目录下执行。我们不可能把所有的java文件都放到JDK的bin目录下，所以配置环境变量的作用就是可以使bin目录下的java相关命令可以在任意目录下使用。

注意：目前较新的JDK安装时会自动配置javac、java命令的路径到Path环境变量中去 ，所以javac、java可以直接使用。

但是以前下载的老版本的JDK是没有自动配置的，此时必需要自己配置Path环境变量。

①JAVA_HOME：告诉操作系统JDK安装在了哪个位置（未来其他技术要通过这个找JDK）

②Path：告诉操作系统JDK提供的javac(编译)、java(执行)命令安装到了哪个位置

注意：新版本的JDK只是自动配置了Path，没有自动配置JAVA_HOME。

2.3 HelloWorld案例（应用）

HelloWorld案例是指在计算机屏幕上输出“HelloWorld”这行文字。各种计算机语言都习惯使用该案例作为第一个演示案例。

2.3.1 Java程序开发运行流程

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

2.3.2 HelloWorld案例的编写

1、新建文本文档文件，修改名称为HelloWorld.java。

2、用记事本打开HelloWorld.java文件，输写程序内容。

publicclassHelloWorld {

   publicstaticvoidmain(String[] args) {

       System.out.println("HelloWorld");

   }

}

2.3.3 HelloWorld案例的编译和运行

存文件，打开命令行窗口，将目录切换至java文件所在目录，编译java文件生成class文件，运行class文件。

编译：javac 文件名.java

范例：javac HelloWorld.java

执行：java 类名

范例：java HelloWorld

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

2.4.1 BUG

在电脑系统或程序中，隐藏着的一些未被发现的缺陷或问题统称为bug（漏洞）。

2.4.2 BUG的解决

1、具备识别BUG的能力：多看

2、具备分析BUG的能力：多思考，多查资料

3、具备解决BUG的能力：多尝试，多总结

2.4.3 HelloWorld案例常见问题

1、非法字符问题。Java中的符号都是英文格式的。

2、大小写问题。Java语言对大小写敏感（区分大小写）。

3、在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件。

4、编译命令后的java文件名需要带文件后缀.java

5、运行命令后的class文件名（类名）不带文件后缀.class

...

3、IDEA安装使用

参见“IDEA安装详解.pdf”

4. java基础语法

4.1 注释（理解）

注释是对代码的解释和说明文字，可以提高程序的可读性，因此在程序中添加必要的注释文字十分重要。Java中的注释分为三种：

单行注释。单行注释的格式是使用//，从//开始至本行结尾的文字将作为注释文字。

// 这是单行注释文字

多行注释。多行注释的格式是使用/* 和 */将一段较长的注释括起来。

/*

这是多行注释文字

这是多行注释文字

这是多行注释文字

*/

注意：多行注释不能嵌套使用。

文档注释。文档注释以/**开始，以*/结束。（以后讲）

4.2 字面量（应用）

作用：告诉程序员，数据在程序中的书写格式。

publicclassDemo {

   publicstaticvoidmain(String[] args) {

       System.out.println(10); // 输出一个整数

       System.out.println(5.5); // 输出一个小数

       System.out.println('a'); // 输出一个字符

       System.out.println(true); // 输出boolean值true

       System.out.println("欢迎来到黑马程序员"); // 输出字符串

   }

}

4.3 数据类型（记忆、应用）

3.4.1 计算机存储单元

l计算机底层都是一些数字电路(理解成开关)，用开表示0、关表示1，这些01的形式就是二进制。

数据在计算机底层都是采用二进制存储的，l在计算机中认为一个开关表示的0|1称为1位（b），每8位称为一个字节（B）， 所以1B=8b

字节是计算机中数据的最小单位。

我们知道计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母”b”表示。而计算机中最基本的存储单元叫“字节（byte）”，

通常用大写字母”B”表示，字节是由连续的8个位组成。

除了字节外还有一些常用的存储单位，其换算单位如下：

1B（字节） = 8bit

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

3.4.2 Java中的数据类型

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

Java中的基本数据类型：

说明：

e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。

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

4.4 变量（应用）

3.5.1 变量的定义

变量：在程序运行过程中，其值可以发生改变的量。

从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。

变量的定义格式：

数据类型变量名=初始化值; // 声明变量并赋值

intage=18;

System.out.println(age);

或者

// 先声明，后赋值（使用前赋值即可）

数据类型变量名;

变量名=初始化值;

doublemoney;

money=55.5;

System.out.println(money);

还可以在同一行定义多个同一种数据类型的变量，中间使用逗号隔开。但不建议使用这种方式，降低程序的可读性。

inta=10, b=20; // 定义int类型的变量a和b，中间使用逗号隔开

System.out.println(a);

System.out.println(b);

intc,d; // 声明int类型的变量c和d，中间使用逗号隔开

c=30;

d=40;

System.out.println(c);

System.out.println(d);

变量的使用：通过变量名访问即可。

3.5.2 使用变量时的注意事项

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

4.5 关键字、标志符（记忆、理解）

关键字

Java自己保留的一些单词，作为特殊功能的，例如：public、class、byte、short、int、long、double…

我们不能用来作为类名或者是变量名称，否则报错。

注意：关键字很多，不用刻意去记。

标志符

标志符就是由一些字符、符号组合起来的名称，用于给类，方法，变量等起名字的规矩。

基本要求：由数字、字母、下划线(_)和美元符($)等组成

强制要求：不能以数字开头、不能是关键字、区分大小写

基本命令规范

变量名称：满足标识符规则，建议全英文、有意义、首字母小写，满足“驼峰模式”，例如：int studyNumber = 59。

类名称： 满足标识符规则，建议全英文、有意义、首字母大写，满足“驼峰模式”，例如：HelloWorld.java。

day02 - Java基础语法

0、类型转换问题

类型转换（理解）

在Java中，会存在不同类型的数据需要一起参与运算，所以这些数据类型之间是需要相互转换的，分为两种情况：自动类型转换和强制类型转换。

自动类型转换

*类型范围小的变量，可以直接赋值给类型范围大**的变量。

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

doublenum=10; // 将int类型的10直接赋值给double类型

System.out.println(num); // 输出10.0

bytea=12 ;

intb=a;

System.out.println(b); // 12

表达式的自动类型转换

在表达式中，小范围类型的变量会自动转换成当前较大范围的类型再运算。

注意事项：

表达式的最终结果类型由表达式中的最高类型决定。

在表达式中，byte、short、char 是直接转换成int类型参与运算的。

强制类型转换

类型范围大的数据或者变量，不能直接赋值给类型范围小的变量，会报错，把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量必须进行强制类型转换。

强制类型转换格式：目标数据类型 变量名 = (目标数据类型)值或者变量;

例如：

double num1 = 5.5;

int num2 = (int) num1; // 将double类型的num1强制转换为int类型

System.out.println(num2); // 输出5（小数位直接舍弃）

说明：

1. char类型的数据转换为int类型是按照码表中对应的int值进行计算的。比如在ASCII码表中，'a'对应97。
   

int a = 'a';

System.out.println(a); // 将输出97

2. 整数默认是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);

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

1. 运算符

1.1 算术运算符（理解）

1.1.1 运算符和表达式

运算符：对常量或者变量进行操作的符号

表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。

                   不同运算符连接的表达式体现的是不同类型的表达式。

举例说明：

int a = 10;

int b = 20;

int c = a + b;

 +：是运算符，并且是算术运算符。

 a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。

1.1.2 算术运算符

注意：

/和%的区别：两个数据做除法，/取结果的商，%取结果的余数。

整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

int a = 10;

int b = 3;

System.out.println(a / b); // 输出结果3

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

1.1.3 字符的“+”操作

char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值：

'a'  --  97a-z是连续的，所以'b'对应的数值是98，'c'是99，依次递加

'A'  --  65A-Z是连续的，所以'B'对应的数值是66，'C'是67，依次递加

'0'  --  480-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类型

tips：正是由于上述原因，所以在程序开发中我们很少使用byte或者short类型定义整数。也很少会使用char类型定义字符，而使用字符串类型，更不会使用char类型做算术运算。

1.1.4 字符串的“+”操作

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

System.out.println("itheima"+ 666); // 输出：itheima666

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

System.out.println(1 + 99 + "年黑马"); // 输出：199年黑马

System.out.println(1 + 2 + "itheima" + 3 + 4); // 输出：3itheima34

// 可以使用小括号改变运算的优先级

System.out.println(1 + 2 + "itheima" + (3 + 4)); // 输出：3itheima7

1.2 赋值运算符（应用）

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

注意：

扩展的赋值运算符隐含了强制类型转换。

short s = 10;

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

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

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

注意事项：

++和-- 既可以放在变量的后边，也可以放在变量的前边。

单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。

参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者--。

参与操作的时候，如果放在变量的前边，先拿变量做++或者--，后拿变量参与操作。

最常见的用法：单独使用。

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的值是多少？

/*

解析，三个表达式都是++在后，所以每次使用的都是自增前的值，但程序自左至右执行，所以第一次自增时，使用的是10进行计算，但第二次自增时，x的值已经自增到11了，所以第二次使用的是11，然后再次自增。。。

所以整个式子应该是：int y = 10 + 11 + 12;

输出结果为33。

*/

注意：通过此练习深刻理解自增和自减的规律，但实际开发中强烈建议不要写这样的代码！小心挨打！

1.4 关系运算符（应用）

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

注意事项：

关系运算符的结果都是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

1.5 逻辑运算符（应用）

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

//定义变量

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

短路逻辑运算符

在逻辑与运算中，只要有一个表达式的值为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

1.6 三元运算符（理解）

三元运算符语法格式：

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

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

举例：

int a = 10;

int b = 20;

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

三元运算符案例：

1、需求：动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。

public class OperatorTest01 {

public static void main(String[] args) {

//1：定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。

int weight1 = 180;

int weight2 = 200;

//2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则，返回false。

boolean b = weight1 == weight2 ? true : false;

//3：输出结果

System.out.println("b:" + b);

}

}

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

public class OperatorTest02 {

public static void main(String[] args) {

//1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。

int height1 = 150;

int height2 = 210;

int height3 = 165;

//2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。

int tempHeight = height1 > height2 ? height1 : height2;

//3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。

int maxHeight = tempHeight > height3 ? tempHeight : height3;

//4：输出结果

System.out.println("maxHeight:" + maxHeight);

}

}

2. 数据输入（应用）

我们可以通过 Scanner 类来获取用户的输入。使用步骤如下：

1、导包。Scanner 类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。

import java.util.Scanner;

2、创建Scanner对象。

Scanner sc = new Scanner(System.in);// 创建Scanner对象，sc表示变量名，其他均不可变

3、接收数据

int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。

示例：

import java.util.Scanner;

public class ScannerDemo {

public static void main(String[] args) {

//创建对象

Scanner sc = new Scanner(System.in);

//接收数据

int x = sc.nextInt();

//输出数据

System.out.println("x:" + x);

}

}

改写三个和尚案例，数据使用键盘录入。

import java.util.Scanner;

public class ScannerTest {

public static void main(String[] args) {

//身高未知，采用键盘录入实现。首先导包，然后创建对象。

Scanner sc = new Scanner(System.in);

//键盘录入三个身高分别赋值给三个变量。

System.out.println("请输入第一个和尚的身高：");

int height1 = sc.nextInt();

System.out.println("请输入第二个和尚的身高：");

int height2 = sc.nextInt();

System.out.println("请输入第三个和尚的身高：");

int height3 = sc.nextInt();

//用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。

int tempHeight = height1 > height2 ? height1 : height2;

//用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。

int maxHeight = tempHeight > height3 ? tempHeight : height3;

//输出结果。

System.out.println("这三个和尚中身高最高的是：" + maxHeight +"cm");

}

}

import java.util.Scanner;

public class IfTest02 {

public static void main(String[] args) {

//小明的考试成绩未知，可以使用键盘录入的方式获取值

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个分数：");

int score = sc.nextInt();

//由于奖励种类较多，属于多种判断，采用if...else...if格式实现

//为每种判断设置对应的条件

//为每种判断设置对应的奖励

//数据测试：正确数据，边界数据，错误数据

if(score>100 || score<0) {

  System.out.println("你输入的分数有误");

} else if(score>=95 && score<=100) {

  System.out.println("山地自行车一辆");

} else if(score>=90 && score<=94) {

  System.out.println("游乐场玩一次");

} else if(score>=80 && score<=89) {

  System.out.println("变形金刚玩具一个");

} else {

  System.out.println("胖揍一顿");

}

}

}