JAVA基础语法
文章目录
01 注释
-
平时编写代码，当项目结构一旦复杂起来，我们就需要用到注释了
-
注释不会被执行，是给写代码的人看的
-
书写注释是一个非常好的习惯
-
平时写代码一定要注意规范。
-
Java中的注释有三种：
- 单行注释Line comment：注释一行文字 //
- 多行注释Block comment：可以注释一段文字 /* */
- 文档注释Java Doc：文档注释 /** */ 生成帮助文档
IDEA . C:\Users\KT 166\Desktop\java\java SE\基础语法\src\base\Hello World
//单行注释：注释一行文字 :/ /
//输出一个Hello
System.out.println("Hello World!");
//多行注释：可以注释一段文字 : /* */
/* 多行注释
多行注释 */
//文档注释：文档注释 : /** */
/**
* @Description(描述) HelloWorld
* @Author 庄哈哈
*/
//有趣的代码注释
idea注释颜色设置：File–>settings–>Editor–>Color Scheme–>java–>Comments
02 标识符和关键字
2.1 关键字和保留字
- 关键字 keyword：
| 关键字 | 含义 |
|---|---|
| abstract | 表明类或者成员方法具有抽象属性 |
| assert | 断言，用来进行程序调试 |
| boolean | 基本数据类型之一，声明布尔类型的关键字 |
| break | 提前跳出一个块 |
| byte | 基本数据类型之一，字节类型 |
| case | 用在switch语句之中，表示其中的一个分支 |
| catch | 用在异常处理中，用来捕捉异常 |
| char | 基本数据类型之一，字符类型 |
| class | 声明一个类 |
| const | 保留关键字，没有具体含义 |
| continue | 回到一个块的开始处 |
| default | 默认，例如，用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现 |
| do | 用在do-while循环结构中 |
| double | 基本数据类型之一，双精度浮点数类型 |
| else | 用在条件语句中，表明当条件不成立时的分支 |
| enum | 枚举 |
| extends | 表明一个类型是另一个类型的子类型。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口 |
| final | 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量 |
| finally | 用于处理异常情况，用来声明一个基本肯定会被执行到的语句块 |
| float | 基本数据类型之一，单精度浮点数类型 |
| for | 一种循环结构的引导词 |
| goto | 保留关键字，没有具体含义 |
| if | 条件语句的引导词 |
| implements | 表明一个类实现了给定的接口 |
| import | 表明要访问指定的类或包 |
| instanceof | 用来测试一个对象是否是指定类型的实例对象 |
| int | 基本数据类型之一，整数类型 |
| interface | 接口 |
| long | 基本数据类型之一，长整数类型 |
| native | 用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的 |
| new | 用来创建新实例对象 |
| package | 包 |
| private | 一种访问控制方式：私用模式 |
| protected | 一种访问控制方式：保护模式 |
| public | 一种访问控制方式：共用模式 |
| return | 从成员方法中返回数据 |
| short | 基本数据类型之一,短整数类型 |
| static | 表明具有静态属性 |
| strictfp | 用来声明FP_strict（单精度或双精度浮点数）表达式遵循[IEEE 754](https://baike.baidu.com/item/IEEE 754)算术规范 |
| super | 表明当前对象的父类型的引用或者父类型的构造方法 |
| switch | 分支语句结构的引导词 |
| synchronized | 表明一段代码需要同步执行 |
| this | 指向当前实例对象的引用 |
| throw | 抛出一个异常 |
| throws | 声明在当前定义的成员方法中所有需要抛出的异常 |
| transient | 声明不用序列化的成员域 |
| try | 尝试一个可能抛出异常的程序块 |
| void | 声明当前成员方法没有返回值 |
| volatile | 表明两个或者多个变量必须同步地发生变化 |
| while | 用在循环结构中 |
-
Java 所有的组成部分都需要有名字。类名、变量名以及方法名都被称为标识符。
-
保留字（reserved word）：goto、const
-
用于定义数据类型值的字面值：true、false、null
2.2 标识符 Identifier
- 标识符：Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符。
定义合法标识符规则：
- 所有的标识符首字符都应该以字母（ A-Z 或 a-z ）、美元符（$）或者下划线（_）开始；
- 首字符之后可以是字母（ A-Z 或 a-z ）、美元符（$）、下划线（_）或数字的任何字符组合；
- 不能使用关键字作为变量名或方法名；
- 标识符是大小写敏感的；
- 合法标识符举例：age、$salary、_value、__1_value
- 非法标识符举例：123abc、-salary、#abc
- 可以使用中文命名，但是一般不建议这样去使用，也不建议用拼音，low
package com.haha.base;
public class Demo01 {
public static void main(String[] args) {
String Ahello = "haha";
String hello = "haha";
String $hello = "haha";
String _hello = "haha";
String _1hello = "haha";
//大小写十分敏感
String Man = "haha";
String man = "haha";
//尽量不用中文名字，用单词表示
String 王者荣耀 = "百星王者";
System.out.println(王者荣耀);
/*报错
String _#hello = "haha";
String 1hello = "haha";
String #hello = "haha";
String *hello = "haha";
String -hello = "haha";
String class = "haha";
*/
}
}
IDEA . C:\Users\KT 166\Desktop\java\java SE\基础语法\src\base\Demo 01
规范（可不遵守，编译通过）
- 包名：多单词组成时，所有字母都小写：xxxyyyzzz
- 类名、接口名：多单词组成时，所有单词首字母大写：XxxYyyZzz
- 变量名、方法名：多单词组成时，第一个单词首字母小写，之后首字母大写：xxxYyyZzz
- 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
03 数据类型讲解
3.1 数据类型
-
强类型（定义）语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
- 安全性高、速度慢
-
弱类型语言：要求变量的使用可以不符合规定（VB、JS）
-
type varName [=value] [ { , varName [ =value ] } ];
//数据类型 变量名 = 值； 可以使用逗号隔开来声明多个同类型变量。
-
Java的数据类型分为两大类
- 基本类型（primitive type）
- 引用类型（reference type）：class类、Interface接口、Array数组
-
浮点数可表示的范围非常大，float 类型范围在 ±3.4 x 10³⁸ 之间，而 double 类型范围在 ±1.79 x 10³⁰⁸ 之间。
float：单精度，尾数可以精确到7位有效数字。
double：双精度，精度是 float 的两倍。
-
浮点数
0.1在计算机中就无法精确表示，因为十进制的0.1换算成二进制是一个无限循环小数，无论使用float还是double，都只能存储一个0.1的近似值。但是，0.5这个浮点数又可以精确地表示。因为浮点数常常无法精确表示，所以浮点数运算会产生误差。 -
char 类型：一个字符=两个字节，Java中所有字符都使用 Unicode 编码，所以char 类型是可以进行运算的。
三种表现形式：
-
用单引号 (’ ') 括起来单个字符
-
Java中还允许使用转义字符 ‘ \ ’ 来将其后的字符转变为特殊字符型常量。
例如：char c = ’ \n '; \n表示换行符，\t表示制表符（相当于一个Tab），\r表示回车符
-
直接使用\u+Unicode 值来表示字符型常量：’\uXXXX’。XXXX代表一个十六进制整数。’\u000a’=\n
-
要显示一个字符的Unicode编码，只需将char类型直接赋值给int类型即可
-
int n1 = 'A'; // 字母“A”的Unicodde编码是65
int n2 = '中'; // 汉字“中”的Unicode编码是20013
char c = 97；//输出a
System.out.println("包装类：java.lang.Character");
// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
System.out.println("最小值：Character.MIN_VALUE="
+ (int) Character.MIN_VALUE);
// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
System.out.println("最大值：Character.MAX_VALUE="
+ (int) Character.MAX_VALUE);
/*
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535
System.out.println("基本类型：XXX 二进制位数：" + XXX.SIZE);
System.out.println("包装类：java.lang.XXX");
System.out.println("最小值：XXX.MIN_VALUE=" + XXX.MIN_VALUE);
System.out.println("最大值：XXX.MAX_VALUE=" + XXX.MAX_VALUE); */
| 数据类型 | 默认值 |
|---|---|
| byte、short、int | 0 |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
| char | ‘u0000’ |
| String (or any object) | null |
| boolean | false |
- 引用类型的变量类似于C语言的指针，它内部存储一个“地址”，指向某个对象在内存的位置
- 引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
- 所有引用类型的默认值都是null。
- 一个引用变量可以用来引用任何与之兼容的类型。
- 例子：Site site = new Site(“Runoob”)。
//八大基本数据类型
//整数
int num1 = 10;//最常用
byte num2 = 20;
short num3 = 30;
long num4 = 40L;//long类型要在数字后面加个L
//小数：浮点数
float num5 = 50.1F;//float类型要在数字后面加个F
double num6 = 3.141592653589793238462643;
//字符
char name = 'a';
//字符串，String不是关键字，是类
String namea ="庄哈哈";
//布尔值；是非
boolean flag =ture;
//boolean flag =false;
//请将一组int值视为字符的Unicode编码，然后将它们拼成一个字符串：
public class Main {
public static void main(String[] args) {
// 请将下面一组int值视为字符的Unicode码，把它们拼成一个字符串：
int a = 72;
int b = 105;
int c = 65281;
// FIXME:
String s = "" + (char)a + (char)b + (char)c;
System.out.println(s);
}
}
IDEA . C:\Users\KT 166\Desktop\java\java SE\基础语法\src\base\Demo 02
3.2 什么是字节
-
位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制数；
-
字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示；
-
字符：是指计算机中使用的字母、数字、字和符号。
-
1 bit表示1位
1 Byte表示一个字节，1 B = 8 bit
1024 B =1 KB
1024 KB = 1 M
1024 M = 1 G
1024 G =1 TB PB··· ···
-
电脑的32位和64位的区别是什么？
寻址能力、64位支持128 G的内存，32位支持4 G的内存
-
计算机内存的最小存储单元是字节（byte），一个字节就是一个8位二进制数，即8个bit。它的二进制表示范围从
00000000`11111111`，换算成十进制是0255，换算成十六进制是00~ff。 -
同一个数的不同进制的表示是完全相同的，例如
15=0xf＝0b1111。
内存单元从0开始编号，称为内存地址。每个内存单元可以看作一间房间，内存地址就是门牌号。
0 1 2 3 4 5 6 ...
┌───┬───┬───┬───┬───┬───┬───┐
│ │ │ │ │ │ │ │...
└───┴───┴───┴───┴───┴───┴───┘
3.3 转义字符序列
| 符号 | 字符含义 |
|---|---|
| \n | 换行 (0x0a) |
| \r | 回车 (0x0d) |
| \f | 换页符(0x0c) |
| \b | 退格 (0x08) |
| \0 | 空字符 (0x0) |
| \s | 空格 (0x20) |
| \t | 制表符 |
| " | 双引号 |
| ’ | 单引号 |
| \ | 反斜杠 |
| \ddd | 八进制字符 (ddd) |
| \uxxxx | 16进制Unicode字符 (xxxx) |
04 数据类型扩展及面试题讲解
//整数拓展 进制 二进制0b开头 十进制 八进制0 十六进制0x
int i = 10;
int i2 = 010; //八进制0
int i3 = 0x10; //十六进制0x 0~9 A~F 16
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
System.out.println("==========================================");
//================================================================================
// 浮点数拓展? 银行业务怎么表示？ 钱
// BigDecimal 数学工具类
//================================================================================
//float 有限 离散 舍入误差 大约 接近但不等于
//double
//最好完全避免使用浮点数进行比较
float f = 0.1f; //0.1
double d = 1.0/10; //0.1
System.out.println(f==d);//false
float d1 = 2132112132f;
float d2 = d1 + 1;
System.out.println(d1==d2);//truel
System.out.println("=======================================");
//================================================================================
// 字符拓展?
//================================================================================
char c1 ='a';
char c2 ='中';
System.out.println(c1);
System.out.println((int)c1);//强制换行
System.out.println(c2);
System.out.println((int)c2);//强制换行
//所有的字符本质还是数字
//编码 Unicode 表：（97=a 65=A） 2字节 0-65536 Excel 2^16=65536
//U0000 UFFFF
char c3 ='\u0061';
System.out.println(c3);//a
System.out.println("=======================================");
//转义字符
// \t 制表符
// \n 换行
// \r 回车符
//···
System.out.println("Hello\tWorld");
System.out.println("Hello\nWorld");
System.out.println("=======================================");
String sa =new String("hello world");
String sb =new String("hello world");
System.out.println(sa==sb);
String sc ="hello world";
String sd ="hello world";
System.out.println(sc==sd);
//对象 从内存分析
//布尔值扩展
boolean flag = ture;
if (flag==true){} //新手
if (flag){} //老手
//Less is More! 代码要精简易读
IDEA . C:\Users\KT 166\Desktop\java\java SE\基础语法\src\base\Demo 03
05 类型转换
-
由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。
-
在运算过程中，如果参与运算的两个数类型不一致，那么计算结果为较大类型的整型。
-
小范围 ------------自动转换----------> 大范围
byte,short,char—> int—> long—> float—> double
-
运算中，不同类型的数据先转化为同一类型，然后进行运算。
强制类型转换
大范围 转型为 小范围。
自动类型转换
int i = 128;
byte b = (byte)i; //内存溢出 最高为 127
double c = i;
//boolean x = ：报错
//强制转换 （类型）变量名 大范围-->小范围
//自动转换 小范围-->大范围
System.out.println(i);//128
System.out.println(b);//-128
System.out.println(c);//128.0
System.out.println("======================================");
System.out.println((int)23.7); //23
System.out.println((int)-45.89f); //-45
System.out.println("======================================");
char d = 'a';
int e = d + 1 ;
System.out.println(e);//98
System.out.println((char)e);//b
/*
注意点；
1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量的时候，强制转换
4. 转换的时候可能存在内存溢出，或者精度问题
*/
//操作比较大的数的时候，注意溢出的问题
//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000;
int years = 20;
int total1 = money*years; //-1474836480 计算的时候溢出了
long total2 = money*years; //默认是int，转换之前已经存在问题了
long total3 = money*((long)years);//先把一个数转换为long
System.out.println(total3);//200_0000_0000
//L l
06 变量、常量、作用域
6.1 变量
-
变量：可以变化的量
-
Java是一种强类型语言，每个变量都必须声明其类型；
-
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
-
type varName [=value] [ { , varName [ =value ] } ];
//数据类型 变量名 = 值； 可以使用逗号隔开来声明多个同类型变量。
-
注意事项：
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型
- 变量名必须是合法的标识符
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束
//int a,b,c
//int a=1,b=2,c=3; //程序可读性
String name = "haha";
char x ='X';
double pi= 3.14;
6.2.1 变量之进制（了解）
-
关于进制
所有数字在计算机底层都以***二进制*** 形式存在。
-
对于整数，有四种表示方式：
-
二进制（binary）：0，1， 以 0b 或 0B 开头。
-
十进制（decimal）：0-9，满十进1.
-
八进制（octal）：0-7，以数字 0 开头表示
-
十六进制（hex）：0-9 及 A-F（不区分大小写，表示10-15），满16进一，以 0x 或 0X 开头表示。
如：0x219F + 1 = 0X21A0
-
-
-
二进制：计算机底层都以补码的方式来存储数据
在二进制码中，为了区分正负数，采用最高位是符号位的方法来区分，正数的符号位为0、负数的符号位为
-
二进制的整数有三种形式：
- 原码：二进制数。最高位是符号位（正数的原码、反码、补码都相同：三码合一）
- 负数的反码：是对其原码按位取反，只是最高位为（符号位）确定为1。
- 负数的补码：其反码+1
例子：（二进制转十进制：乘以2的幂数）
0 000 1110 ：1 * 2^3 + 1 * 2^2 + 1 * 2^1 = 14（三码合一）
1 000 1110 ：-14的原码
1 111 0001 ：-14的反码
1 111 0010 ：-14的补码
byte最大为127
0 111 1111 ：127 —+1---->1 000 0000 ：-128（+1 byte溢出）
1 000 0001 ：-127的补码
1 000 0000 ：-128的补码
-
十进制转化为二进制：除以2取余的逆
13÷2=6……1
6÷2=3……0
3÷2=1……1
1÷2=0……1
0÷2=0……0
……
所以 13 转换为二进制为：0000 1101
-
进制间转化
二进制转八进制：2^3 三个二进制位表示一个八进制位
0000 1110 1001 ：八进制表示为：0351（011 ：3、101 ：5、001 ：1）
二进制转十六进制：2^4 四个二进制位表示一个十六进制位
0000 1110 1001 ：十六进制表示为：0XE9（1110 ：14=E、1001 ：9）
-
Integer 类
- toBinaryString(int i) ：二进制
- toHexString(int i) ：十六进制
- toOctalString(int i) ：八进制
- 实现 60 的二进制到十六进制的转换：
//方式一：自动实现
String str1 = Integer.toBinaryString(60);//输出60的二进制
String str2 = Integer.toHexString(60);//输出60的十六进制
//方式二：手动实现
int i1 = 60; //0011 1100
int i2 = i1 & 15;//单独提出最后四位数 15的二进制1111，提取出60二进制的1100
String j = (i2 > 9) ? (char)(i2-10+'A') + "" : i2 + "";
int temp = i1 >>>4; //把60二进制的0011往后靠四位
i2 = temp & 15; //在提取出0011
String k = (i2 > 9) ? (char)(i2-10+'A') + "" : i2 + "";
System.out.println(k + "" + j);
6.2 var关键字（了解）
有些时候，类型的名字太长，写起来比较麻烦。例如：
StringBuilder sb = new StringBuilder();
这个时候，如果想省略变量类型，可以使用var关键字：
var sb = new StringBuilder();
编译器会根据赋值语句自动推断出变量sb的类型是StringBuilder。对编译器来说，语句：
var sb = new StringBuilder();
实际上会自动变成：
StringBuilder sb = new StringBuilder();
因此，使用var定义变量，仅仅是少写了变量类型而已。
6.3 变量作用域
-
变量的作用域：一对{ }内
-
变量都定义在其作用域内，同一个作用域内，不可以声明两个同名变量。
-
使用变量前，需要给变量赋初始值
- 类变量：独立于方法之外的变量，用 static 修饰。
- 实例变量：独立于方法之外的变量，不过没有 static 修饰。
（一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见） - 局部变量：类的方法中的变量，是在栈上分配的。
public class Demo05 {
//属性：变量
// 1. 类变量 static
static double salary = 2500;
// 2. 实例变量：从属于对象Demo05；如果不自行初始化，这个类型的默认值 0 0.0 u0000;
// 布尔值：默认是false;
// 除了基本类型，其余的默认值都是null;
String name;
int age;
boolean a;
//① main方法
public static void main(String[] args) {
// 3. 局部变量：必须声明和初始化值
int i = 10;
System.out.println(i);
//实例变量： 变量类型 变量名字 = new 类名(); [new 类名();Alt＋回车键]
Demo05 demo05 = new Demo05();
System.out.println(demo05.name);//null
System.out.println(demo05.age);//0
System.out.println(demo05.a);//false
//类变量
System.out.println(salary);//2500.0
}
//② 其他方法
public void add(){}
}
6.4 常量
-
常量（Constant）：初始化（initialize）后不能再改变值！不能重新赋值。
整数型常量默认为 int 型，浮点型常量，默认为 double 类型
-
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
final 常量名=值；
final double PI=3.14；
-
常量名一般使用大写符号
public class Demo06 {
//修饰符，不存在先后顺序：static 和 final 可互换位置；
static final double PI = 3.14;
public static void main(String[] args) {
System.out.println(PI);
}
PI = 300; // compile error!编译报错
}
6.5 变量的命名规范
-
所有的变量、方法、类名：见名知意
驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写
-
变量、方法名：首字母小写和驼峰原则：runRun()
-
类名、接口：首字母大写和驼峰原则：Man，GoodMan 如：Demo 01
-
常量：大写字母和下划线：MAX_VALUE
-
包名：小写字母
07 基本运算符
- Java语言支持如下运算符：优先级（）
- 算术运算符：+，-，*，/，%，++，-- Demo 01、02、04
- 赋值运算符：=
- 关系运算符：>，<，>=，<=，==，!=，instance of Demo 03
- 逻辑运算符：&&，||，! Demo 05
- 位运算符：&，|，^，~，>>，<<，>>>（了解!!!） Demo 06
- 条件运算符 ： ？，： Demo 08
- 扩展赋值运算符：+=，-=，*=，/= Demo 07
- 在Java的计算表达式中，运算优先级从高到低依次是：
(){};,.!~++--*/%+-<<>>>>>instanceof==!=&^|&&||? :=+=-=*=/=%=^=~=<<=>>=>>>=&=|=
IDEA . C:\Users\KT 166\Desktop\java\java SE\基础语法\src\operator
public class Demo01 {
public static void main(String[] args) {
// 二元运算符
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/b);//int 类型 输出为0
System.out.println(a/(double)b);//0.5
}
}
public class Demo02 {
public static void main(String[] args) {
long a = 123123123123L;
int b = 123;
short c = 10;
byte d = 8;
//如果混合运算中有long，运算结果为long类型；如果混合运算中有double，运算结果为double类型；
//byte、short、char用运算符运算后自动转型为int类型
System.out.println(a+b+c+d);//Long
System.out.println(b+c+d);//int
System.out.println(c+d);//int cast：转换
//short c = 32767
//System.out.println(c+d); 输出为32775 int类型
//System.out.println((short)(c+d)); 输出为-32761，运算溢出short最大值32767
}
}
public class Demo03 {
//关系运算符
public static void main(String[] args) {
//关系运算符返回的结果：正确，错误 布尔值
//if
int a = 10;
int b = 20;
int c = 22;
System.out.println(a>b);//false
System.out.println(a<b);//true
System.out.println(a==b);//false
System.out.println(a!=b);//true
// % 取余 模运算
System.out.println(c%a);//2 c / a 21 / 10 = 2 … 2
//结果的符号与被模数的符号相同\
//开发中，经常使用 % 来判断能否被除尽的情况
int m1 = 12;
int n1 = 5;
System.out.println(m1 % n1);//2
int m2 = -12;
int n2 = 5;
System.out.println(m2 % n2);//-2
int m3 = 12;
int n3 = -5;
System.out.println(m3 % n3);//2
int m4 = -12;
int n4 = -5;
System.out.println(m4 % n4);//-2
//获取一个数的百位、十位、个位数
int num = 187;
int bai = num / 100;
int shi = num % 100/10;//或者int shi = num / 10 % 10;
int ge = num % 10;
System.out.println("百位：" + bai);//1
System.out.println("十位：" + shi);//8
System.out.println("个位：" + ge); //7
//instance of：检查是否是类的对象
String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真
}
}
溢出
整数运算在除数为0时会报错，而浮点数运算在除数为0时，不会报错，但会返回几个特殊值：
NaN表示Not a NumberInfinity表示无穷大-Infinity表示负无穷大
例如：
double d1 = 0.0 / 0; // NaN
double d2 = 1.0 / 0; // Infinity
double d3 = -1.0 / 0; // -Infinity
08 自增自减运算符、初识Math类
//自增自减运算符
public class Demo04 {
public static void main(String[] args) {
// ++ -- 自增， 自减 一元运算符
int a = 3;
int b = a++; //执行完这行代码后，先给b赋值，再自增 b = 3，a = 4
//a++ a = a + 1
System.out.println(a);//4
//++a a = a + 1
int c = ++a; //执行完这行代码前，先自增，再给c赋值 a = 5，c = 5
System.out.println(a);//5
System.out.println(b);//3
System.out.println(c);//5
//幂运算 2^3 2*2*2 = 8 [Math.pow(x,y);Alt+回车 = x^y]
double pow = Math.pow(2, 3);
System.out.println(pow);//8.0
}
}
Math.abs(x - y);//绝对值
Math.sqrt(); //求平方根
- 练习
根据一元二次方程ax²+bx+c=0的求根公式：
计算出一元二次方程的两个解：
// 一元二次方程
public class Main {
public static void main(String[] args) {
double a = 1.0;
double b = 3.0;
double c = -4.0;
// 求平方根可用 Math.sqrt():
// System.out.println(Math.sqrt(2)); ==> 1.414
// TODO:
int r1 = 0;
int r2 = 0;
r1=(int)((-b + Math.sqrt(b*b - 4*a*c)) / 2*a);
r2=(int)((-b - Math.sqrt(b*b - 4*a*c)) / 2*a);
System.out.println(r1);//1
System.out.println(r2);//-4
System.out.println(r1 == 1 && r2 == -4 ? "测试通过" : "测试失败");
}
}
09 逻辑运算符、位运算符
-
区分 & 与 &&：
相同点：运算结果相同；当符号左边是 true 时，二者都会执行符号右边的运算
不同点：当符号左边是 false 时，& 会执行符号右边的运算，&& 不再执行符号右边的运算
-
区分 | 与 ||：
相同点：运算结果相同；当符号左边是 false 时，二者都会执行符号右边的运算
不同点：当符号左边是 true 时，| 会执行符号右边的运算，|| 不再执行符号右边的运算
//逻辑运算符
public class Demo05 {
public static void main(String[] args) {
// 与（and） 或（or） 非（取反）
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a&&b));//逻辑与运算：两个变量都为真，结果才为true
System.out.println("a || b:"+(a||b));//逻辑或运算：两个变量有一个为真，结果才为true
System.out.println("!(a && b):"+!(a&&b));//如果是真，则变为假；如果是假，则变为真
//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4);//与运算中，前边（c<4）运算为false,则不运算后面的程序(c++<4), 短路了
System.out.println(d);//false
System.out.println(c);//5 ， c++ = 6
}
}
//位运算
public class Demo06 {
public static void main(String[] args) {
/*
A = 0011 1100
B = 0000 1101
--------------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~B = 1111 0010
2*8 = 16 2*2*2*2
效率极高！！！
<< *2
>> /2
*/
/*
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
*/
System.out.println(2<<3);//16
//可以对整数进行移位运算。对整数7左移1位将得到整数14，左移两位将得到整数28：
int n = 7; // 00000000 00000000 00000000 00000111 = 7
int a = n << 1; // 00000000 00000000 00000000 00001110 = 14
int b = n << 2; // 00000000 00000000 00000000 00011100 = 28
int c = n << 28; // 01110000 00000000 00000000 00000000 = 1879048192
int d = n << 29; // 11100000 00000000 00000000 00000000 = -536870912
//左移29位时，由于最高位变成1，因此结果变成了负数。
//对整数28进行右移，结果如下：
int n = 7; // 00000000 00000000 00000000 00000111 = 7
int a = n >> 1; // 00000000 00000000 00000000 00000011 = 3
int b = n >> 2; // 00000000 00000000 00000000 00000001 = 1
int c = n >> 3; // 00000000 00000000 00000000 00000000 = 0
//如果对一个负数进行右移，最高位的1不动，结果仍然是一个负数：
int n = -536870912;
int a = n >> 1; // 11110000 00000000 00000000 00000000 = -268435456
int b = n >> 2; // 11111000 00000000 00000000 00000000 = -134217728
int c = n >> 28; // 11111111 11111111 11111111 11111110 = -2
int d = n >> 29; // 11111111 11111111 11111111 11111111 = -1
//使用>>>，它的特点是不管符号位，右移后高位总是补0，因此，对一个负数进行>>>右移，它会变成正数，原因是最高位的1变成了0：
int n = -536870912;
int a = n >>> 1; // 01110000 00000000 00000000 00000000 = 1879048192
int b = n >>> 2; // 00111000 00000000 00000000 00000000 = 939524096
int c = n >>> 29; // 00000000 00000000 00000000 00000111 = 7
int d = n >>> 31; // 00000000 00000000 00000000 00000001 = 1
//对byte和short类型进行移位时，会首先转换为int再进行位移。
}
}
10 三元运算符及小结
- 自增自减和 +=、-=、/=、*= 不会改变变量本身的数据类型
- 凡是可以使用三元运算符的地方，都可以写成 if-else ；反之，不成立。
如果程序既可以使用三元运算符，又可以使用 if-else 结构，那么优先选择三元运算符。简洁、执行效率高。
//扩展赋值运算符
public class Demo07 {
public static void main(String[] args) {
int a = 10;
int b = 20;
a+=b;//a = a + b = 30
a-=b;//a = a - b = 10
System.out.println(a);//10
//字符串连接符 + String
System.out.println(a+b);//30
System.out.println(""+(a+b));//30 , 先运算括号里的
//面试题 +号前后有字符串类型，输出的结果会转换成字符串
System.out.println(""+a+b);//1020
System.out.println(a+b+"");//30， 按程序先走a + b，在成字符串
System.out.println(a+b+""+a+b);//301020
//从Java 13开始，字符串可以用"""..."""表示多行字符串（Text Blocks）了。
String s = """
SELECT * FROM
users
WHERE id > 100
ORDER BY name DESC
""";
System.out.println(s);
//num1 和 num2 交换变量值
int num1 = 1 , num2 = 2;
//方式一：定义临时变量，推荐方式
int temp = num1;//1
num1 = num2;//2
num2 = temp;//1
//方式二：好处：不用定义临时变量，减少空间
// 坏处：相加操作可能超出存储范围；只能适用于数值类型
//num1 = num1 + num2;//3
//num2 = num1 - num2;//1
//num1 = num1 - num2;//2
//方式三：使用位运算符；局限性：只能适用于数值类型
//num1 = num1 ^ num2;//3
//num2 = num1 ^ num2;//1
//num1 = num1 ^ num2;//2
/*
0000 1101 m = 13
^0000 0101 n = 5
=0000 1000 k = m ^ n = 8
^0000 0101 n = 5
=0000 1101 m = 13
*/
}
}
//三元运算符 条件运算符 练习：比较两个数值的大小，比较三个数值的大小
public class Demo08 {
public static void main(String[] args) {
// x ? y : z
//如果 x == true ,则只计算 y ，否则只计算 z，且 y 和 z 的类型必须相同
int score = 88;
String type = score <60 ?"不及格":"及格"; // 必须掌握
// if
System.out.println(type);//及格
}
}
// 布尔运算 判断指定年龄是否是小学生（6～12岁）：
public class Main {
public static void main(String[] args) {
int age = 7;
// primary student的定义: 6~12岁
boolean isPrimaryStudent = age >= 6 && age <= 12;
System.out.println(isPrimaryStudent ? "Yes" : "No");
}
}
11 包机制
-
为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
-
包语句的语法格式为：
package pkg1[. pkg2[. pkg3…]]; -
一般利用公司域名倒置作为包名；com.baidu.www
-
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。
使用import语句可完成此功能
import package1[.package2…].（classname|*）；//如import com.haha.xxx //import必须在package下方 //import com.haha.xxx.* ：*通配符：导入这个包下所有的类
12 JavaDoc生成文档
- JavaDoc命令是用来生成自己API文档的
- 参数信息
- @author：作者名
- @version：版本号
- @since：指明需要最早使用的jdk版本
- @param：参数名
- @return：返回值情况
- @throws：异常抛出情况
package com.haha.base;
/**
* @author Zhuanghaha
* @version 1.0
* @since 1.8
*/
public class Doc {
String name;
/**
* @author Zhuanghaha
* @param name
* @return
* @throws Exception
*/
public String test(String name) throws Exception{
return name;
}
//通过命令行 javadoc 参数 Java文件
//作业：查找学会使用IDEA生产JavaDoc文档！ 面向百度编程！
}
- 命令行生成文档javadoc -encoding UTF-8 -charset UTF-8 Doc.java -->inedx.html
-
IDEA生成文档：
-
找到工具栏点击Tools–>Generate JavaDoc–>打开生成javadoc文档的配置页面。
-
进行配置：
-
Generate JavaDoc Scope：配置JavaDoc的范围
Output directory：输出文件夹路径
Other command line arguments：命令行参数
-encoding UTF-8 -charset UTF-8 -windowtitle "test"
只有使用utf-8编码才能保证生成时可以正常处理中文字符
-encoding是java代码编码，-charset是对生成文档所用的编码。-windowtitle就是对应html的
- 配置好后，点击生成按钮，生成好后就会自动在浏览器打开进行查看–>inedx.html
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
