JAVA基础（三）JAVA基础语法

最新推荐文章于 2022-06-27 13:03:49 发布

背影lmc

最新推荐文章于 2022-06-27 13:03:49 发布

阅读量407

点赞数 1

分类专栏： Java学习文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_43879841/article/details/122203234

版权

Java学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

JAVA基础语法

基本概念

入门概念

一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。

**属性:**事物固有的一些特征，例如人的年龄、性别、姓名；
**方法：**完成某种特定行为或者功能，例如人会唱歌，吃饭等等行为；
对象：对象是类的一个实例，有属性和方法。例如，一条狗是一个对象，它的属性有：颜色、名字、品种；方法有：摇尾巴、叫、吃等。
类：类是一个模板，它描述一类对象的属性和方法，一条黑背狗是一个对象，而所有的黑背就是一个类。
实例变量：每个对象都有独特的实例变量，对象的属性由这些实例变量的值决定。

基本语法

编写 Java 程序时，应注意以下几点：

大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
类名：对于所有的类来说，类名的首字母应该大写。驼峰原则（除了第一个单词之外，所有单词首字母大写）
方法名：所有的方法名都应该以小写字母开头。驼峰原则
源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存，文件名的后缀为 .java。
主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

修饰符

访问控制修饰符 : default（默认）, public（共有） , protected（保护）, private（私有）
非访问控制修饰符 : final（常量）, abstract（抽象）, static（静态）, synchronized

关键字

这些关键字不需要死记，用到的时候记住即可。

关键字	说明
private	私有的
protected	受保护的
public	公共的
default	默认
abstract	声明抽象
class	类
extends	扩充,继承
final	最终值,不可改变的
implements	实现（接口）
interface	接口
native	本地，原生方法（非 Java 实现）
new	新,创建
static	静态
strictfp	严格,精准
synchronized	线程,同步
transient	短暂
volatile	易失
break	跳出循环
case	定义一个值以供 switch 选择
continue	继续
default	默认
do	运行
else	否则
for	循环
if	如果
instanceof	实例
return	返回
switch	根据值选择执行
while	循环
assert	断言表达式是否为真
catch	捕捉异常
finally	有没有异常都执行
throw	抛出一个异常对象
throws	声明一个异常可能被抛出
try	捕获异常
import	引入
package	包
boolean	布尔型
byte	字节型
char	字符型
double	双精度浮点
float	单精度浮点
int	整型
long	长整型
short	短整型
super	父类,超类
this	本类
void	无返回值
goto	是关键字，但不能使用
const	是关键字，但不能使用

**注意：**Java 的 null 不是关键字，类似于 true 和 false，它是一个字面常量，不允许作为标识符使用。

注释

单行注释：// xxxxxx

多行注释：

/* xxxxxx

……

xxxxxx*/

文档注释：/** 主要是对文档进行描述 */

标识符

Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

注意：

所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始；
首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合；
关键字不能用作标识符
标识符是大小写敏感的

可以使用中文命名，但是不建议

第一个程序

public class HelloWorld {
    /* 第一个Java程序
     * 它将输出字符串 Hello World
     */
    public static void main(String[] args) {
        System.out.println("Hello World"); // 输出 Hello World
    }
}

public是访问修饰符，class是说明在声明一个类,HelloWord是类名，且必须与Java文件名相同。一个类必须有且只能由一个main方法，main方法的介绍如下图，每个参数的含义都会在后续介绍到。

在这里插入图片描述

数据类型

Java 基本数据类型 | 菜鸟教程 (runoob.com)

强类型语言与弱类型语言

**强类型语言：**强类型语言也称为强类型定义语言。是一种总是强制类型定义的语言，要求变量的使用要严格符合定义，所有变量都必须先定义后使用。java、.NET、C/C++等都是强制类型定义的。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换（后续会介绍），那么它就永远是这个数据类型了。

**弱类型语言：**弱类型语言也称为弱类型定义语言。与强类型定义相反。像vb，php等就属于弱类型语言。

强类型语言_百度百科 (baidu.com)

弱类型语言_百度百科 (baidu.com)

Java数据类型

Java的数据类型分为两大部分，基本数据类型（又叫做内置数据类型）和引用类型。为了说明数据类型，首先介绍字节的概念：

字节

位（bit）：是计算机存储数据的最小单位；
字节（byte)：一个字节（1B)等于8个位；
字符：计算机使用的字母、数字和符号

基本类型

基本数据类型（primitive type)又叫做内置数据类型，一共有8钟基本数据类型，其中6种是数值类型（四种整数两种浮点数）。

整数

整数一共有四种类型，根据占用内存的不同，具体如下：

byte：

byte 数据类型是8位（1个字节）、有符号的以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一。

short：

short 数据类型是 16 位（2个字节）、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0。

int：

int 数据类型是32位（4个字节）、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
一般地整型变量默认为 int 类型；
默认值是 0 。

long：

long 数据类型是 64 位（8个字节）、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；
注意long类型后边一般用大写L，因为小写l和数字1容易混淆。

浮点型

浮点型有两种，分为单精度和双精度：

float：

float 数据类型是单精度、32位（4个字节）、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币。

double：

double 数据类型是双精度、64 位（8个字节）、符合 IEEE 754 标准的浮点数；
浮点数的默认类型为 double 类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
例子：7D也是double量。

银行系统中表示货币会有一个专门的类型

布尔型

boolean数据类型表示一个字节的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false。

字符型

char 类型是一个单一的 16 位（2个字节） Unicode 字符；
最小值是 \u0000（十进制等效值为 0）；
最大值是 \uffff（即为 65535）；
char 数据类型可以储存任何字符；
例子：char letter = ‘A’;。

字符类型和整数类型是可以互换的

字符串String不是一个关键词，是一个类

各种类型默认值

数据类型	默认值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	‘u0000’
String (或者其他任何对象)	null
boolean	false

引用类型

在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型。变量一旦声明后，类型就不能被改变了。
对象、数组、字符串都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用任何与之兼容的类型，例如父类的引用变量可以指向子类的对象。
例子：Site site = new Site(“Runoob”)。

常量

常量在程序运行时是不能被修改的。在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似，常量名一般用大写：

final double PI = 3.1415927;

Java的字符串常量也是包含在两个引号之间的字符序列：

"Hello World"
"two\nlines"
"\"This is in quotes\""

字符串常量和字符常量都可以包含任何Unicode字符。例如：

char a = '\u0001';
String a = "\u0001";

Java数据类型扩展

基本数据类型扩展

整数

所有的整数类型（byte、int、long、和short）都可以用十进制、16进制以及8进制的方式来表示。二进制以0b开头八进制以0开头，十六进制以0x开头：

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

例子

public class Demo02 {
    public static void main(String[] args) {
        //整数类型
        int i=10;
        int i2=010;
        int i3=0x10; //十六进制  0！0 A！F
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("=============");
    }
}

浮点型

银行业务中，float和double是有问题的，因为两者表示范围有限、离散的，有舍入误差，两个数接近但是不等于，所以银行中用以一个类BigDecimal。

public class Demo02 {
    public static void main(String[] args) {
        //浮点数拓展
        //银行业务中，float和double是有问题的
        // float 表示范围有限、离散的，有舍入误差，接近但是不等于，所以银行中用以一个类BigDecimal
        float f=0.1f;
        double d=1.0/10;
        System.out.println(f==d);

        float d1=43728974291794f;
        float d2=d1+1;
        System.out.println(d1==d2);

        
    }
}

字符型

字符类型和整数类型可以转换，编码 Unicode表；每个字符都有一个对应的数字 2字节 65536个字符，范围 U0000~UFFFF。

public class Demo02 {
    public static void main(String[] args) {
        //字符拓展
        //字符类型和整数类型可以强制转换
        // 编码 Unicode表；每个字符都有一个对应的数字 2字节 65536个字符，
        //范围 U0000~UFFFF
        char c3='\u0061';
        System.out.println(c3);
    }
}

布尔类型

一般用布尔类型作标志位时候，用如下书写方式：

boolean flag=true;
if(flag)
{
  System.out.println("flag=true");
}

String

用New建立的String涉及到内存，所以即使两个相等的字符串也，再程序看来也是不相等的

转义字符

转义字符	意义	ASCII码值（十进制）
\a	响铃(BEL)	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个TAB位置）	009
\v	垂直制表(VT)	011
\	代表一个反斜线字符’’'	092
’	代表一个单引号（撇号）字符	039
"	代表一个双引号字符	034
\0	空字符(NULL)	000
\ddd	1到3位八进制数所代表的任意字符	三位八进制
\xhh	1到2位十六进制所代表的任意字符	二位十六进制

类型转换

自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算，自动类型转换发生在由低级类型到高级类型的转换，所谓的低级与高级是通过占用内存的多少区分的：

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

注意两点

不能对boolean类型进行类型转换。
不能把对象类型转换成不相关类的对象

强制类型转换

在把高级（容量大的）类型转换为低级（容量小的）类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度，例如：
```
int i = 128;   
byte b = (byte)i;
```
因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
```
(int)23.7 == 23;        
(int)-45.89f == -45
```

隐含强制类型转换

整数的默认类型是 int。
小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或者 f。

注意

操作比较大的数时候，注意溢出的问题

JDK7新特性，数字中间可以用下划线分割：10_0000_0000

变量

Java 变量类型 | 菜鸟教程 (runoob.com)

基本概念

变量就是可以变化的量，在程序运行过程中可以修改变量的值。在Java语言中，所有的变量在使用前必须声明（强类型语言），声明变量的基本格式如下：

type identifier [ = value][, identifier [= value] ...] ;

**格式说明：**type为Java数据类型。identifier是变量名，可以使用逗号隔开来声明多个同类型变量。

Java是一种强类型语言，每个变量都必须声明类型，Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

注意事项

每个变量都有类型，可以是基本类型，也可以是引用类型；
变量名必须是合法的标识符；
变量声明是一条完整的语句，每一个声明都必须以分号结束。

变量作用域

类变量：

static关键词修饰，也被称为静态变量，放在方法之外，类之内；
无论一个类创建多少实例对象，类值拥有变量的一份拷贝；
一般初始化为常量，不可修改；
存储在静态存储区；
第一次访问时创建，程序结束时销毁；
大多数声明为public类型；
有默认值，数值类型为0，布尔为false，其余为null；
可以在构造方法中指定，也可以在静态语句块中指定；
可以通过ClassName.VariableName的方式访问；

实例变量：

无static修饰符；
实例变量声明在一个类中，但在方法、构造方法和语句块之外；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁，当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的，一般情况下应该把实例变量设为私有；
实例变量具有默认值，同类变量；
实例变量可以直接通过变量名访问，但在静态方法、类外以及其他类中，就应该使用完全限定名：Obeject.VariableName。

局部变量:

局部变量声明在方法、构造方法或者语句块中；
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；
局部变量只在声明它的方法、构造方法或者语句块中可见；
局部变量是在栈上分配的；
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

变量命名规范

见名知意
驼峰原则
常量大写
类名：首字母大写和驼峰原则
方法名：首字母小写和驼峰原则

运算符

Java 运算符 | 菜鸟教程 (runoob.com)

算术运算符

概述

包括+，-，*，/，%（取余），++，–

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21（区别详见下文）
–	自减: 操作数的值减少1	B-- 或 --B 等于 19（区别详见下文）

**不同操作数进行运算:**多个整数操作数有一个位long，结果为long，其余的都为int类型,如果有一个操作数为double，则结果为double；

自增自减运算符

自增运算符：

a++是先进行表达式运行，再进行自增运算；
++a是先进行自增运算，再进行表达式运算；

自减运算符：同上

特殊的运算

一些特殊的运算，需要借助一些工具使用，例如幂运算：

Math.pow(3,2)

Math里边包含了所有数学运算，不需要导入外部包，可以直接使用。

赋值运算符

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
\| =	按位或赋值操作符	C \| = 2等价于C = C \| 2

关系运算符：

包括：>，<，>=，<=，==，!=，instanceof

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

比较两个数之间的关系，返回一个布尔值。

**instanceof运算符：**该运算符用于操作对象实例，判断该实例对象与某一个特定的类或者接口有关系，可以是一个类的实例化对象，也可以是某个类的子类的实例化对象。

instanceof运算符使用格式如下：

( Object reference variable ) instanceof  (class/interface type)

例子

public class Demo04 {
    public static void main(String[] args) {
        String name = "James";
        boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真
        System.out.println(result);
    }
}

逻辑运算符

与、或、非

操作符	描述	例子
&&	称为逻辑与运算符，当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
\| \|	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A \| \| B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

短路逻辑运算符

当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

位运算符

包括：按位与 &，按位或 |，按位取反 ~，按位异或 ^，左移<<（相当于乘以2），右移>>（相当于除以2），按位右移补零操作 >>>

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
\|	如果相对应位都是 0，则结果为 0，否则为 1	（A \| B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符，左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符，左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

左移相当于乘2，右移相当于除以2

条件运算符

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值，该运算符的主要是决定哪个值应该赋值给变量，格式如下：

x= a ? b:c

如果表达式a为真，则x=b，否则x-c。

例子

public class Demo04 {
    public static void main(String[] args) {
        /*
        x?y:z
        如果x为真则结果等于y，否则等于z
         */
        int score=50;
        String type=score<60?"不及格":"及格";
        System.out.println(type);
    }
}

运算符的优先级

由上到下运算符的优先级降低

类别	操作符	关联性
后缀	() [] . (点操作符)	左到右
一元	expr++ expr–	从左到右
一元	++expr --expr + - ～！	从右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>> <<	左到右
关系	> >= < <=	左到右
相等	== !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或	\|	左到右
逻辑与	&&	左到右
逻辑或	\| \|	左到右
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ = \| =	从右到左
逗号	，	左到右