第2章.基础语法

喜欢的文章

本章小结
1.程序注解
2.关键字
3.常量
4.变量
5.标识符
6.数据类型

程序注释

注释：程序源代码中解释说明性的文字，对程序运行没有影响。

单行注释：以“//”开头，直到本行结束为止。（Comment）

多行注释：以“/”开头，以“/”结尾，中间的内容都属于注释。（Comment）

文档注释：以“/****”开头，以“/*”结尾，中间的内容都属于注释。（Javadoc）

HelloWorld代码解释

  • 第一行代码：public class HelloWorld {...}。代表创建一个名称为HelloWorld的类，类是Java中代码组织的基本单位。注意第三个单词必须和文件名完全一样。
  • 第二行代码：public static void main(String[] args) {...}。这是一行固定写法，是程序执行的起点位置。
  • 第三行代码：System.out.println(“Hello, World!”);。这是一行输出语句，也叫打印语句，也就是在屏幕当中显示一行内容。英文双引号中间是需要显示的内容。

关键字

  • 概念：关键字是被Java语言赋予特殊含义，具有专门用途的单词。 比如之前接触的class，public，static，void均为Java已经预设好的。

  • 特点：

  1. 完全由小写字母组成；

  2. 在增强版记事本（例如Notepad++）当中有特殊颜色。

  • Java中所有的关键字列表：（现阶段不要背，随着学习内容逐步深入，慢慢了解含义）

常量

  • 概念：程序运行期间，固定不变的量。

  • 分类：

  1. 字符串常量，使用英文双引号引起来的内容。

  2. 整数常量，例如100、120、-250等。

  3. 浮点数（小数）常量，例如3.14、-2.5等。

  4. 字符常量，使用英文单引号引起来的单个字符，例如’A’、’b’、’中’等。必须有且仅有一个字符。

  5. 布尔常量，只有两种取值：true和false。通常用于条件判断和流程控制。

  • 代码：
**public class** DemoConst {

  **public static void** main(String[] args) {

  // 字符串常量

  System.***out***.println("Hello, World!");

  // 整数常量

 System.***out***.println(100);

 System.***out***.println(-150);

  // 浮点数常量

 System.***out***.println(3.14);

 System.***out***.println(-2.5);

  // 字符串常量使用双引号，中间可以有0-n个字符都行

 System.***out***.println(""); // 中间没有内容，但是为双引号字符串，所以也可以

  // 字符常量

 System.***out***.println('A');

 System.***out***.println('b');

 System.***out***.println('*');

 System.***out***.println('中');

  // System.out.println(''); // 中间什么内容都没有，错误写法！

  // System.out.println('<u>ab</u>'); // 单引号中间有多个字符，错误写法！

  // 布尔常量

 System.***out***.println(**true**); // 真，对

 System.***out***.println(**false**); // 假，错

 }

}

变量与数据类型

变量的概念

常量是指程序运行期间，内容不可发生改变的量。

变量是指程序运行期间，内容在一定范围内可以改变的量。

变量其实是用来存放数据的内存当中的一小块空间，特点：

  1. 用来存放数据的；

  2. 内容可以发生改变；

  3. 一次只能存放一个数据，如果放入新数据，将会替换掉老数据；

  4. 可以通过变量名称使用其中的数据；

  5. 数据一定要符合数据类型的要求。

变量的格式

  • 方案一（两个步骤）
  1. 创建一个变量，格式： 数据类型 变量名称; 
int a ;
  1. 放入一些数据，格式： 变量名称 = 数据值; 
a =5;
  • 方案二（一个步骤）
  1. 创建变量的同时立刻放入数据，格式： 数据类型 变量名称 = 数据值; 
int a =5;
图片.png

标识符

  • 作用：给类、变量、包、方法等起名字。

  • 组成规则（硬性规定）

  1. 只能由字符、下划线_、美元符$组成。 这里的字符包括大小写字母、中文字符、数字字符等，但符号只能有两个：下划线 _ 和美元符号组成；

  2. 不能以数字开头；

  3. 不能是Java中的关键字。

  • 命名规则（软性建议）

   1. 基本要求：见名知意。

   2. 建议只使用英文字母和数字。

  1. 常见命名的规则：

   a) 类 每个单词首字母大写，例如Student、HelloWorld。

   b) 变量 第一个单词完全小写，后续更多单词首字母大写，例如age、ageOfMyGirlfriend。

   c) 方法 与变量规则一样，例如show()、getAge()。

   d) 包（其实就是文件夹，用于对类进行管理） 全部小写，多级包用点隔开。公司域名的反写。 cn.itcast （相当于两级文件夹：cn\itcast） com.itheima （相当于两级文件夹：com\itheima）

类名称

HelloWorld正确，很好；Hello123正确，很好；123Hello错误，数字不能开头；helloworld正确，很不好。

变量名称

age正确，很好；ageOfMyFather正确，很好；year100正确，很好；100year错误，数字不能开头；ageOfMymother正确，不好。

数据类型 (4类8种)

在Java 9（2017年9月发布）或更早版本的JDK中，数据类型只有两种：

  • 基本类型，包括8种：byte、short、int、long、float、double、char、boolean。

  • 引用类型（除了基本，都算引用），包括：数组、类、接口、Lambda等。

其中的8种基本数据类型：

图片.png

注意事项

  1. 整数类型有4种，默认为int类型。

  2. 浮点数类型有2种，默认为double类型。

  3. 定义一个long型数据，在数值后面要用字母L作为后缀（大小写均可，推荐大写）。 5200000000L

  4. 定义一个float型数据，在数值后面要用字母F作为后缀（大小写均可，推荐大写）。 3.14F

  5. 字符char型数据，是可以包含中文的。

基本数据类型的转换

  • 自动转换
    规则：
    1.范围小的类型向范围大的类型
    2.整数向浮点数类型
    3.char型向int型
    4.布尔值不能进行任何的转换


byte b = 28;
int a = b; //自动转换OK  范围小->范围大
System.out.println(a);
        
long o = 1222;
float f = o; //自动转换OK   正数->浮点数
System.out.println(f);
        
char c = '啊';
int x = c; //自动转换OK    char -> int
System.out.println(x); //ASC码
  • 强制转换
    当需要反向类型转换时，需要利用强制转换，强制有可能造成数据的精度丢失。
    精度丢失：数据丢失了位数据或者浮点数部分
//强制转换成功
int a = 97;
byte b =  (byte) a;
System.out.println(b);
        
//精度丢失
int x = 200;  // 11001000 -> -56
byte y = (byte) x;
System.out.println(y);
        
//精度丢失
double d = 3.14; //丢失浮点数部分
int z = (int) d;
System.out.println(z);
        
//int -> char  可以正常转换
int i = 65;
char j = (char)i;
System.out.println(j);

变量的基本使用

按照变量的格式，指定不同的数据类型，并且赋予不同的数值即可。
请参考对应的源代码。

变量的注意事项

  1. 创建的多个变量不能重名。
  2. 变量一定要赋值之后才能使用。
  3. 变量的作用域问题。
    变量定义在哪个大括号中，就只能用于哪个大括号中。超出直接所属的大括号，将无法使用。
  4. 可以在一个语句中同时定义类型相同的多个变量。

运算符

概述
运算符：对常量或变量进行操作的符号，叫做运算符。例如“+”。
表达式：用运算符将多个常量或变量连起来的式子，叫做表达式。“例如a + b”。

常用的运算符分类有：
 算术运算符
 赋值运算符
 比较运算符
 逻辑运算符
算术运算符
四则运算
加（+）减（-）乘（*）除（/），与数学中的用法基本一致。但是有两点注意事项：

  1. 对于整数来说，除法是进行“整除”，只看商，不看余数。
  2. 一旦有浮点数参与运算，那么结果就是浮点数。
    取模运算
    如果对于整数的除法，希望得到余数而不是商，那么可以使用取模运算（%）。
    注意，只有对整数使用取模运算，才有余数的数学意义。
    字符串连接
    如果将加号（+）用于字符串，那么将不再是数学运算，而是字符串连接。
    任何数据类型与字符串进行连接，结果都将是字符串类型。
    自增自减运算
    自增运算符 ++ 在原有的基础上，累加一个数字1
    自减运算符 -- 在原有的基础上，累减一个数字1

使用格式：
前++：在变量的名称之前，写上++符号。例如：++num
后++：在变量的名称之后，写上++符号。例如：num++

使用方式：
单独使用：自己独立成为一个步骤，不和其他操作混合。
混合使用：和打印语句、赋值语句等各种其他操作混合使用。

前后++的区别：

  1. 在单独使用的时候，前++和后++没有任何区别。
  2. 在混合使用的时候，前++和后++存在【重大区别】：
    a) 如果是【前++】，那么变量立刻马上+1，然后拿着结果进行使用。【先加后用】
    b) 如果是【后++】，那么首先使用变量当前本来的数值，然后变量再+1。【先用后加】

注意：自增自减运算符只能用于变量，不能用于常量。
赋值运算符
 基本赋值运算符：等号（=），代表将右侧的数据交给左侧的变量。
 复合赋值运算符：

  1. a += 3 相当于 a = a + 3
  2. b -= 4 相当于 b = b - 4
  3. c *= 5 相当于 c = c * 5
  4. d /= 6 相当于 d = d / 6
  5. e %= 7 相当于 e = e % 7
    注意：赋值运算符左侧必须是变量，不能是常量。
    比较运算符
    用于比较两个数据的关系，运算结果一定是boolean型数据。
  6. 大于： >
  7. 小于： <
  8. 大于等于： >=
  9. 小于等于： <=
  10. 等于： ==
  11. 不等于： !=
    注意：两个等号连写，才是数学中相等的含义。
    逻辑运算符
    基本使用
    与（并且） & 全都是true才是true；否则是false。
    或（或者） | 有一个true就是true；全都false才是false。
    亦或 ^ 相同就是false；不同就是true。
    非（取反） ! 本来是true变成false；本来是false变成true。
    短路使用
    短路与 &&
    短路或 ||
    如果表达式左边已经可以确定最终结果，那么右边的代码将不再执行，提高程序效率。
    Scanner键盘输入
    使用引用类型
    在Java 9或更早的版本中，除了8种基本类型，其他类型都属于引用类型。
    如果希望使用引用类型中的“类”，那么典型用法的一般步骤为：
  12. 导包。
    指定需要使用的目标在什么位置。在public class之前一行写代码：
    import 包路径名;
  13. 创建。
    通常需要创建之后才能使用，格式：
    数据类型 变量名称 = new 数据类型();
  14. 使用。
    需要使用什么功能，就点儿一个功能名称（方法名），格式：
    变量名称.方法名();
    使用Scanner
    Scanner就是一种引用类型，JDK已经写好了这个类供我们直接使用。步骤有三个：
  15. 导包。
    import java.util.Scanner;
  16. 创建。
    Scanner sc = new Scanner(System.in);
    PS：其中System.in代表从键盘输入。
  17. 使用。
    a) 获取键盘输入的int数字：
    int num = sc.nextInt();
    b) 获取键盘输入的字符串：
    String str = sc.next();

知识总结

  1. 程序注释：

   a) 概念：对程序代码进行解释说明的文字，不影响程序运行。

   b) 单行注释：“//”开头，直到本行结束为止。

   c) 多行注释：/开头，/ 结尾，中间的都是注释。

   d) 文档注释：/*开头，“/”结尾。

  1. 关键字

   a) 概念：被保留的、有特殊含义的词汇。

   b) 特点1：完全是小写字母。

   c) 特点2：在增强记事本当中有特殊的颜色。

  1. 常量概念：程序运行期间，不可以发生改变的量。

  2. 常量的分类：

   a) 字符串常量：双引号，可以包含0-n个字符。

   b) 整数常量：100、200、1024

   c) 浮点数常量：3.14、-2.5

   d) 字符常量：单引号，有且仅有一个字符

   e) 布尔常量：true、false，只有两个。

   f) 空常量：null（不能直接用来打印输出）。

变量的基本使用

按照变量的格式，指定不同的数据类型，并且赋予不同的数值即可。

请参考对应的源代码。

变量的注意事项

  1. 创建的多个变量不能重名。

  2. 变量一定要赋值之后才能使用。

  3. 变量的作用域问题。 变量定义在哪个大括号中，就只能用于哪个大括号中。超出直接所属的大括号，将无法使用。

  4. 可以在一个语句中同时定义类型相同的多个变量。

运算符

概述

运算符：对常量或变量进行操作的符号，叫做运算符。例如“+”。

表达式：用运算符将多个常量或变量连起来的式子，叫做表达式。“例如a + b”。

常用的运算符分类有：

  • 算术运算符

  • 赋值运算符

  • 比较运算符

  • 逻辑运算符

算术运算符

四则运算

加（+）减（-）乘（*）除（/），与数学中的用法基本一致。但是有两点注意事项：

  1. 对于整数来说，除法是进行“整除”，只看商，不看余数。

  2. 一旦有浮点数参与运算，那么结果就是浮点数。

取模运算

如果对于整数的除法，希望得到余数而不是商，那么可以使用取模运算（%）。

注意，只有对整数使用取模运算，才有余数的数学意义。

字符串连接

如果将加号（+）用于字符串，那么将不再是数学运算，而是字符串连接。

任何数据类型与字符串进行连接，结果都将是字符串类型。

自增自减运算

自增运算符 ++ 在原有的基础上，累加一个数字1

自减运算符 -- 在原有的基础上，累减一个数字1

使用格式：

前++：在变量的名称之前，写上++符号。例如：++num

后++：在变量的名称之后，写上++符号。例如：num++

使用方式：

单独使用：自己独立成为一个步骤，不和其他操作混合。

混合使用：和打印语句、赋值语句等各种其他操作混合使用。

前后++的区别：

  1. 在单独使用的时候，前++和后++没有任何区别。

  2. 在混合使用的时候，前++和后++存在【重大区别】：

a) 如果是【前++】，那么变量立刻马上+1，然后拿着结果进行使用。【先加后用】

b) 如果是【后++】，那么首先使用变量当前本来的数值，然后变量再+1。【先用后加】

注意：自增自减运算符只能用于变量，不能用于常量。

赋值运算符

  • 基本赋值运算符：等号（=），代表将右侧的数据交给左侧的变量。

  • 复合赋值运算符：

  1. a += 3 相当于 a = a + 3

  2. b -= 4 相当于 b = b - 4

  3. c *= 5 相当于 c = c * 5

  4. d /= 6 相当于 d = d / 6

  5. e %= 7 相当于 e = e % 7

注意：赋值运算符左侧必须是变量，不能是常量。

比较运算符

用于比较两个数据的关系，运算结果一定是boolean型数据。

  1. 大于： >

  2. 小于： <

  3. 大于等于： >=

  4. 小于等于： <=

  5. 等于： ==

  6. 不等于： !=

注意：两个等号连写，才是数学中相等的含义。

逻辑运算符

基本使用

与（并且） & 全都是true才是true；否则是false。

或（或者） | 有一个true就是true；全都false才是false。

亦或 ^ 相同就是false；不同就是true。

非（取反） ! 本来是true变成false；本来是false变成true。

短路使用

短路与 && 短路或 ||
如果表达式左边已经可以确定最终结果，那么右边的代码将不再执行，提高程序效率。

    //1.短路：如果左侧已经可以判断到最终的结果，那么右侧将不在执行
        //2.凡是用到了与，或这两个逻辑运算符，都非常推荐双写，因为双写可以提高代码执行效率
        
        System.out.println(3<2 & 10<20);//false,一个符号，左右都会执行
        System.out.println(3<2 && 10<20);//false, 双写，左右两边都会执行
        System.out.println("-------------------------------");
        int num1 =100;
        System.out.println(3>10 && +num1<200);
        //短路&&有一个假后面就不执行了
        System.out.println(num1);//100
        System.out.println("-------------------------------");
        int num2 =20;
        System.out.println(3<10 ||++num2>3);//true
        System.out.println(num2);//20
        System.out.println("-------------------------------");
        int num3 =300;
        System.out.println(3>10 || ++num3<1000);
        System.out.println(num3);//301

Scanner键盘输入

使用引用类型

在Java 9或更早的版本中，除了8种基本类型，其他类型都属于引用类型。

如果希望使用引用类型中的“类”，那么典型用法的一般步骤为：

  1. 导包。 指定需要使用的目标在什么位置。在public class之前一行写代码： import 包路径名;

  2. 创建。 通常需要创建之后才能使用，格式： 数据类型 变量名称 = new 数据类型();

  3. 使用。 需要使用什么功能，就点儿一个功能名称（方法名），格式： 变量名称.方法名();

使用Scanner

Scanner就是一种引用类型，JDK已经写好了这个类供我们直接使用。步骤有三个：

1. 导包。 **import java.util.Scanner;**

2. 创建。 **Scanner sc = new Scanner(System.in);** PS：其中System.in代表从键盘输入。

3. 使用。

a) 获取键盘输入的int数字： **int num = sc.nextInt();**

b) 获取键盘输入的字符串： **String str = sc.next();**
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容