Java的基本语法

public class Test {
    public  static  void main(String[] args){
        // main 函数中书写各项指令
        System.out.println("this is a test");
    }
}

java 源代码中能出现的单词称为“词法单元” 或 “Token”，从 上方java 语言基本结构可以看出：

1. 每个 java 文件都必须书写一个 java 类 public class 类名{} 且类名和文件名一致
2. 在可直接运行的 java 类中，拥有一个叫 main() 的主方法，作为程序的主入口

如果将英文和编程语言对应起来就应该是：

• 字母 —— 符号

• 单词 —— 标识符

• 语句 —— 指令

• 文章 —— 程序

标识符分俩大类：

1. 语言已经预定义好的、被这项语言系统占用、有特定含义不可再用于其他地方的称为“关键字”
2. 开发者定义，设置能够更好识别功能的单词，自定义要求：

• 在使用别人已经定义好的 API 时必须保持定义者定义的名字
• 硬性要求：不能是关键字、保留字，大小写敏感，数字不能开头
• 软性要求：

1. 首当其冲的就是给标识符取名得见名知意，便于阅读和理解代码，特别要谨慎使用缩写，遵守程序界的公共规范
2. 类名使用帕斯卡命名法，首字母大写
3. 变量名小写，当有多个单词组合成变量名，则使用驼峰命名法 chineseNewYear
4. 常量（不可变的量 final）名，使用全大写 GENDER
5. 包名、工程名全小写
6. 方法名与变量名的要求一致，但应当从方法名体现其功能，通常为动词或动宾短语

注释

1. 单行注释 //
2. 多行注释 /**/      多行注释不能嵌套
3. 文档注释/**    */

数据类型

由于计算机中只能识别 0 和 1，所以在计算机中能单独存放 “0” 或 “1” 的一个空间作为最小存储单位，称为“位”

对于’‘2’‘日常生活中用10进制，所以十进制和二进制是需要转换的，’‘2’‘二进制写作10（一零）

8个位bit组成一个字节Byte

以下是字节的换算列表

单位	换算
bit	-
Byte	1Byte=8bit
KB	1KB=1024Byte
MB	1MB=1024KB
GB	1GB=1024MB
TB	1TB=1024GB

从换算表里好像老出现了 1024，那为什么是 1024 呢？因为 2^10=1024 才是程序员所“认为”的整数。

数据类型的作用

1. 告知计算机使用哪种方式完成数据量的二进制转换。整数、实数、字符串等其转换方式各不相同
2. 计算机会确定为该类型的数据分配多大的、适合的内存空间，以免造成内存浪费或空间不够

数据类型的分类

Java中数据类型分为俩大类

1.基本数据类型，四类八种为重点

• 整型

字节	Byte	1	-2^7~2^7-1
短整型	short	2	-2^15~2^15-1
整型	int（默认）	4	-2^31~2^31-1
长整型	long	8	-2^63~2^63-1

• 浮点型

浮点数就是小数，分俩种，double默认，常用

类型	关键字	所占空间	范围
单精度浮点数	float	4个字节	1.4013E-45 ~ 3.4028E+38
双精度浮点数	double（默认）	8个字节	4.9E-324 ~ 1.7977E+308

因为小数被保存在计算机中都是转为二进制，存在除不尽的情况，所以天生存在一定的精度问题

• 字符

注意区分字符和字符串

类型	关键字	所占空间
字符	char	2个字节

键盘上所有字母、标点、所有按键都在字符编码表上ASCII码（美国信息交换标准码）

一般需要记住，编码65表示大写的A，编码97是小写的a        

字符字面量还可以使用转义序列表示无法用键盘输入的特殊字符。常用转义字符包括：

• '\b'：退格符
• '\t'：Tab 字符
• '\'：反斜线
• '''：单引号
• '"'：双引号
• '\n'：换行符
• '\r'：回车键

• 布尔

布尔只有true和false俩个值用于表示真假，多作用于判断

boolean 类型专用于表示逻辑状态，即 yes or no，true or false。所占大小不固定，JVM 会根据情况自动去分配 1 位或 1 个字节。

在编码过程中通常需要根据某些情况指定程序做相对应的指令，或者是程序会根据指令返回的结果给开发人员，都会去使用到布尔值。

类型	关键字	所占空间
布尔	boolean	1个字节

2.引用数据类型

分俩类

1. Java API为我们提供的类，比如：Scanner、Random等

2. 自定义类，我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。

变量

拥有了数据类型，就可以把各种类型的数据放进容器（变量）里。使用声明指令让计算机在内存里开辟一块空间储存之

变量可以被修改

语法：

  //1.声明，告诉计算机开辟int=4个字节的空间
        int number;
        //声明后，将3放进变量number中
        number=3;

        //告诉计算机开辟8个字节的空间，将数据3.5存放进 下·price（商品）变量里去
        double price=3.5;

        //告诉计算机开辟2个字节的空间，将数据a存放进 ele 变量里去
        char ele='a'; //区分字符'k'和字符串“双引号”

        //小心float和long类型，在数字后面加上 f 或 l 大小写即可
        float f = 3.5f;
        long l = 18645328678l;

        //注意不能把布尔写成字符串
        boolean flag = true;// "true"

• 声明后赋值称为 变量的初始化

• 赋给变量的值必须与数据类型匹配（跟js有很大区别）

• 跟 javascript 这个弱类型语言的不同之处在于，在 java 中，若一个变量只声明没有赋值就被使用，是不允许被使用的，会报错 可能尚未初始化变量。所以在 java 语言中，变量必须声明+初始化值

• 同样也存在作用域的限制（作用:用处 域：地方）

常量

分为

1.字面常量

int number = 20; // “20”就是一个字面常量。论谁来认都是 20
double pi = 3.14; // 3.14 就是类型为 double 的常量
float f = 1.5f; // float 类型的常量 1.5
boolean flag = true; // 布尔类型就只有 true 和 false 两种字符常量了
char str = 'a'; // char 常量必须使用单引号表示，并且只能存放一个字符

注意区分字符和字符串，字符串常量使用关键字 String + 双引号""去声明：

String s = "hello";

2.符号常量

    语法：

final 数据类型 常量名 = 字面常量值;
final double PI = 3.1415926; 

使用final关键字，可以使得一处变处处变，常量值不可以被修改，声明之后立即赋值给常量名，右一旦声明，右边常量值不可以被修改

运算符

数据量有了以后就可以对数据量进行运算操作得到结果，基于操作数的数量，可以把运算符分为三种类型：

• 一元运算符：只有一个操作数。一元运算符可以是作为操作数的前缀（比如，++i），也可以是作为操作数的后缀（比如，i++）。
• 二元运算符：有两个操作数。二元运算符一般采用中置表示法，放在两个操作数之间（比如， 4 + 6）。
• 三元运算符：有三个操作数。三元运算符也是采用中置表示法，运算符放在三个操作数之间（比如，(age < 18) ? "Childen" : "adult"），年龄小于18吗，小于就是未成年，否则成年

算数运算符

表达式由运算符和操作数（变量常量皆可）组成，最终会有一个运算结果。包含 +、-、*、/、%

其中 + 号前后的任意操作数是字符串时 + 号作为字符串拼接。

// 注意各数据类型
int a = 5, b = 6, sum = a + b;
System.out.println(sum); // 11

int a = 5, b = '6', sum = a + b;
System.out.println(sum); // 59 '6' 作为了字符，数字 6 在 ASCII 表中编号为 54，等于作了 5+54

int a = 5;
String b = "A";
String c = a + b;
System.out.println(sum); // 5A

需要注意/除法是得到商，取模%得到余数

运算过程中可能存在类型提升，也就是整数+小数 会得到小数类型。小数同样有精度问题

所以取余仅在整数运算下才有意义。

在 % 中余数的正负号只跟被除数有关，被除数是正数余数就是正，被除数是负数余数就是负数

int a = 10, b = 3, c = a % b;
System.out.println(c); // 1，因为会存在精度问题，声明的俩个变量为整型，输出结果也为整型

int a = -10, b = 3, c = a % b;
System.out.println(c); // -1，根据在 % 中余数的正负号只跟被除数有关，被除数是正数余数就是正，被除数是负数余数就是负数，得出的结果也是负数

int a = 10, b = -3, c = a % b;
System.out.println(c); // 1，跟上例理论相同

 赋值运算符

包含 =、+=、-=、*=、/=、%=、++、--

a++ 表示变量 a 在自身基础上加 1，等同于 a += 1 或 a = a + 1。也可以写作 ++a

区别：++a 前置操作是先完成自增自减，再执行表达式其他部分；a-- 后置操作是先完成整个表达式的操作得到结果再进行变量的自增自减。

int a = 5;
int sum = a++ + 10;
System.out.println(sum); // 15

int a = 5;
int sum = ++a + 10;
System.out.println(sum); // 16

比较运算符

包含相等 ==、不等 !=、>、<、>=、<=

在比较之后会得到布尔型的结果，参与比较的表达式不能为布尔类型，多用于判断

三目

可以理解为比较运算符和布尔的结合

语法 ：

布尔表达式 ? 表达式 1 : 表达式 2;

在布尔表达式得到布尔类型值后，若为真执行表达式1，若为假执行表达式2。

int age = 19;
boolean result = age > 18 ? true : false;
System.out.println(result); // true

逻辑运算符

布尔逻辑运算符包含以下，但只常用前 3 个：

• 逻辑短路与 &&

• 逻辑短路或 ||

• 逻辑非 !

• 逻辑与 & 读作“位与”

• 逻辑或 | 读作“位或”

• 逻辑异或 ^

1. 与: && 和 &

&& 是短路运算符，当左边表达式为 false 不会执行右边表达式，就像结婚领证，俩边都要满足才可以

int male = 20;//男 20
int female = 21;女 21
boolean result；
result = （male>22&&female>20）;//male不大于22，不会执行右边表达式
System.out.println("result = " + result);  //  false

& 即使左操作数为 false 也会计算右操作数

int i = 10;
int j = 15;
boolean result;
// b = (i > 5 & j > 10);  // 把true赋值给b
result = (i > 25 & ((j = 20) > 15));  // 即使 i>25返回false，还要计算右边的
System.out.println("result = " + result);  //  b = false
System.out.println("j = " + j);  // j = 20

     2.或：|| 和 |

•  || 是短路运算符，当左边表达式为 true 不会计算右边表达式

int i = 10;
int j = 15;
boolean result = i > 5 || ((j = 0) < 5);
System.out.println(result);//true
System.out.println(j); // 0

• ｜ 本质也是位运算符，只是当它左右两端是 boolean 时表现出和 “||” 相同效果

int i = 10;
int j = 15;
boolean result = i > 5 | ((j = 0) < 5);
System.out.println(result);//ture
System.out.println(j); // 0

     3.非：! 即 取反

下一章到分支，和布尔值相配合，方便演示

     4.异或：^ 左右表达式相同为 false，不同为 true

int i = 10; 
boolean b; 
b = true ^ true; // b为false 
b = true ^ false; // b为true
b = false ^ true; // b为true
b = false ^ false; // b为false
b = (i > 5 ^ i < 15); // b为false

数据类型转换

当不同数据类型在进行运算、比较时，会发生数据类型转换。数据类型转换分为：

• 隐式（自动）转换
• 强制转换

在进行转换前我们需要知道基本数据类型的大小排序：

低到高自动转换，高到低需要强转

byte < short = char < int < long < float < double

自动类型转换（隐式）

当俩个值不为同一种时，例如3 + 2.5，答案为5.5，3为整数，2.5为浮点数，答案为浮点数，由此可看出，我们需要考虑相加后数值类型，那么 5.5 应该是 double 类型的，所以在声明值时，就应该是：

double sum = 3 + 2.5;//应声明double类型的变量来接收这俩个不同类型的值

可以得出自动类型转换会自动往大数据类型方向转换（低转高）。

进行算数操作时：

• 不同类型数据进行算数操作，结果就是该类型。例如 5/2得到2，都是 int 类型，而不是 2.5 float 类型
• 不同类型的数据进行算数操作，结果就是大类型的结果，例如 5/2.0 或5.0/2 都会得到2.5

赋值操作时：

• 同类型赋值或小数据赋值给大类型变量，都会发生自动类型转换
• 大类型数据赋值给小类型变量，需要强转

强制类型转换

语法：(目标类型)数据 注意精度的丢失，不会四舍五入，boolean 不参与转换。

// float 转 int
int number = (int)3.14; // 3

// int 转 char
int a = 65;
char str = (char) a; // A，在ASCLL码里，65代表大写的A

// double 转 int
double d = 1.234;
int a = (int) d; // 1

输入与输出

输入语句

Scanner

产生一个 scanner 对象（默认情况下 java 只会自动导入 java.lang 包中的类，而输入功能 Scanner 属于 java.util 包，所以需要额外引用）

import java.util.Scanner;

调用该对象的方法完成输入，根据接受的数据类型决定调用哪种方法

Scanner scan = new Scanner(System.in);

• 需要接受 int 类型：Int age = scan.nextInt();
• 需要接受 double 类型：Double height = scan.nextDouble();
• 需要接受 string 类型：String name = scan.next();

关闭Scanner

// 引入 Scanner 功能
import java.util.Scanner;

// new 出一个 Scanner 类型对象取名叫 scan
Scanner scan = new Scanner(System.in); 

System.out.println("请输入");
String name = scan.next();
System.out.println(name);

scan.close(); // 关闭了就不可以再使用了

输出语句

输入值，或给变量赋值后，通常需要输出来查看结果。

使用 java 内置类 System 语法：System.out.println(查看的数据);

// sout 快捷键
System.out.println(3); // 常量
System.out.println(number); // 变量
System.out.println(5 > 3); // 表达式
System.out.println("number 的值是：" + number); // 字符串拼接，加号一侧有字符就为字符串拼接

        （本文为接触Java不久的菜鸟所写，如有误区，还望各位大佬多多指教，菜鸟虚心受教）