JAVA的基础语法整理

最新推荐文章于 2024-09-14 18:46:05 发布

置顶 chenjialin1475

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量252

点赞数

分类专栏： java 基础文章标签： java 基础语法

本文链接：https://blog.csdn.net/chenjialin1475/article/details/85126671

版权

java 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

基础

2 篇文章 0 订阅

订阅专栏

JAVA语言特点

JAVA基础语言
- 类
  - 内部类
- 接口
- 枚举
- Lambda
- 变量
- 方法
- 构造器
JAVA语言中的变量
JAVA语言中的分支结构

类

Java是面向对象的语言，Java程序的最小程序单元是类。

定义类的最简单的语法：

[修饰符] class 类名 {
  
}

类的作用：

定义变量 = 类，是引用类型的一种。
访问static修饰的成员变量 = 类变量（静态变量）。
调用static修饰的方法 = 类方法（静态方法）。
创建对象。创建对象需要使用new关键字。
派生子类。

对象的作用：

访问没有static修饰的成员变量 = 实例变量（非静态变量）。
调用没有static修饰的方法 = 实例方法（非静态方法）。

对象的初始值：

创对象时，Java会自动为所有的实例变量分配内存空间，并自动指定初始值。所有数值型，初始值为0；所有boolean型，初始值为false；所有引用型，初始值为null。

this引用：

在方法中出现时，this代表该方法的调用者。谁调用方法，this就代表谁。
在构造器中出现时，this代表构造器正在初始化的对象（即通过构造器得到的对象）。

关于 修饰符 ，只能是 public、final | abstract
关于 类命名 ，只能是字母、数字、下划线、$组成，且数字不能开头。不能是关键字。建议：由1个或多个单词连缀而成，而且每个单词的首字母大写（驼峰写法）。
关于 类的成员 ，最多只能出现5种成员（成员变量、方法、构造器、内部类|接口|枚举、初始化块）。赋值、输出、流程控制等可执行性语句绝对不能直接放在类中，只能放在方法、构造器、初始化块中。
关于 对象和变量的关系 ，一个引用变量，最多只能指向一个对象。但一个对象，可被多个引用变量所指向。

内部类：

内部类的最简单的语法：

new 接口|父类构造器() {
  // 匿名内部类，必须、而且只能实现一个接口，或者继承一个父类。
  // 定义匿名内部类时，会立即创建匿名内部类的实例——因此匿名内部类不能是抽象类。
}

内部类与类的区别：

内部类比外部类多了private、protected、static这3个修饰符。
非静态内部类，不可拥有静态成员。
静态内部类，完全可以拥有静态成员。
静态内部类，不能直接访问外部类的实例成员（static成员，不能访问非static成员）。
内部类的class文件名为：类$内部类.class

内部类的优点：

提供了更好的封装。
内部类成员可以直接访问外部类的private数据，因为内部类被当成其他外部类成员。
但外部类不能直接访问内部类的private成员。
如果在没有变量名冲突的前提下，内部可以直接访问外部类private成员变量。
如果在变量名冲突的前提下，内部应该用语法 “ 外部类.this.外部类成员名 ”

内部类的应用场景：

定义变量。
访问类变量、调用类方法。
创建对象。
派生子类。

在方法中定义的内部类，它的修饰符只能是final|abstract。其他private、protected、public、static都不允许。
局部内部类不能拥有静态成员。
局部内部类,只能在当前方法中使用。
局部内部类的class文件名为：外部类$N内部类.class

类的外面使用内部类：

使用静态内部类（类内部类、static修饰的内部类）:

对于静态内部类而言，外部类相当于静态内部类的包。
定义变量：外部类.内部类变量名;
调用类成员：外部类.内部类.类成员
创建对象：new 外部类.内部类构造器();
派生子类：extends 外部类.内部类的类名
类内部类的对象、必须寄生在外部类的类本身中。

使用非静态内部类（实例内部类、无static修饰的内部类）:

定义变量：外部类.内部类变量名;
创建对象：外部类实例.new 内部类构造器();
派生子类：extends 外部类.内部类的类名
必须为子类定义构造器，而且在子类构造器的第一行，必须显式使用如下语句：
外部类实例.super(参数);
非静态内部类的实例、必须寄生在外部类的实例中。

类与类之间的继承关系：

Java的继承，通过extends来完成，而且只能继承一个（不过规范的来说，最多两个，因为一切类都是Object的子类）。
[修饰符] + class + 类名 + extends + 父类

接口

相当于一个彻底抽象的类。

定义接口的最简单的语法：

修饰符 interface 接口名 extends 父接口1, 父接口2... {
  // public、final static成员变量
	// public abstract修饰的抽象方法
	// public static内部类
	// public default修饰的默认方法，实例方法。
	// public static修饰的类方法。
}

接口的作用：

定义变量。
访问类变量、调用类方法。
被实现。（规范：类实现接口，就相当于遵守该接口的规范）

关于 类实现接口 ，要求必须实现接口中所有的抽象方法。否则该实现类也是抽象类

枚举

枚举也是一种特殊的类。枚举是一个不允许自由创建对象的类——它的对象在定义时已经固定下来了。

[修饰符] enum 枚举名
{
	// 必须在第一行列出所有的枚举实例
}

修饰符:public final| abstract , 对于枚举而言，final与abstract必定出现其中之一。如果枚举包含抽象方法，系统自动在enum前添加abstract；否则自动添加final。

枚举的作用：

定义枚举之后，枚举自动具有如下方法：
- static values()：返回该枚举的所有实例。
- static valueOf(String)：根据枚举名返回对应的枚举对象。
- name（来自Enum类），获取枚举对象的枚举名。
- ordinal（来自Enum类），获取枚举对象的顺序号。
枚举的构造器
枚举可以有构造器，但枚举的构造器只能使用private修饰，在枚举外部不能创建枚举对象。如果枚举中只包含有参数的构造器，枚举的第一行列出实例时，必须根据构造器传入相应的参数。

枚举与类的区别：

枚举默认继承java.lang.Enum类，因此枚举不能继承其他父类。
枚举要么自动添加final修饰、要么自动添加abstract修饰。因此枚举不派生子类。
构造器必须用private修饰——你写还是不写，构造器都是private的。
枚举必须在第一行列出所有实例。

抽象枚举：

需要在第一行使用匿名内部类列出所有枚举实例。

实现接口的枚举：

枚举不能显式继承其他父类，但枚举完全可以实现接口。枚举实现接口之后，分2种情况：
- 如果枚举实现了接口中所有抽象方法，那它就是普通的final修饰的枚举。
- 如果枚举没有实现了接口中所有抽象方法，那它就是抽象枚举。
抽象枚举，需要在第一行使用匿名内部类列出所有枚举实例。

Lambda

说到底就是匿名内部类的简化写法

Lambda表示式的语法

Lambda表示式由3个部分组成：形参列表组成。——即要实现的抽象方法的形参列表。

形参列表可以省略形参类型，而且大部分时候我们都省略。
如果形参列表只有一个形参，连圆括号都可以省略。
如果形参列表没有形参、或者有多个形参，圆括号不能省略。

被重写的方法体。
- 如果方法体只有一条语句，可以省略花括号。
- 如果被重写的方法需要返回值，而且方法体内仅有一条语句，可以省略return关键字（必须也省略花括号）。
Lambda表示式只能用于创建“函数式接口”的实例 —— Lambda表示式无需明确指定重写哪个方法。
Lambda表示式必须对应一个明确的“函数式接口”，该函数式接口就叫 Lambda表示式的【目标类型】
可通过如下方式来指定 Lambda表示式的【目标类型】
定义变量时类型指定【目标类型】。
也可【目标类型】进行强制转换。
调用方法时根据方法所需参数来确定【目标类型】。

Lambda表示式中的方法引用和构造器引用

引用类方法

类名::类方法 等同于如下形式：
(a,b,…) + -> + 类名.类方法(a,b, …)

函数式接口中被实现方法的全部参数传给该类方法作为参数。

引用特定对象的实例方法

特定对象::实例方法 等同于如下形式:
(a,b, …) -> 特定对象.实例方法(a,b, …)
(a,b,…) + 特定对象.实例方法(a,b, …)

函数式接口中被实现方法的全部参数传给该实例方法作为参数。

引用某类对象的实例方法

类名::实例方法 等同于如下形式:
(a,b,…) + a.实例方法(b, …)

在这种情况下，类名必须是被重写方法中第一个形参的类型。
函数式接口中被实现方法的第一个参数作为调用者，后面的参数全部传给该方法作为参数。

引用构造器

类名::new 等同于如下形式:
(a,b,…) + new 类的构造器(a,b, …)

函数式接口中被实现方法的全部参数传给该构造器作为参数。

变量

定义变量的最简单的语法：

[修饰符] + <类型> + <变量名> + [ = 默认值];

修饰符：public|protected|private、final、static|transient（序列化）。
类型：可以是任何有效的类型。包括基本类型和引用类型。
变量名：从语法角度来江讲：只要是一个合法的标识符即可。
- 从程序可读性角度来看，必须由一个或多个有意义的单词连缀而成，
- 单词与单词无需任何分隔符，除了第一个单词之外，后面的每个单词首字母大写——驼峰写法（camelize）
- 成员变量：用于描述该类的对象的状态。成员变量名尽量用名词。
Java是强类型的语言，因此什么类型的变量，只能指定对应类型的值。

方法

定义方法的最简单的语法：

[修饰符] <返回值类型> <方法名>(形参列表)
{

}

修饰符：public|protected|private、final|abstract、static、synchronized（线程同步）

方法中的修饰符：

private（彻底隐藏）：被private修饰的东西，将会被彻底隐藏在类的里面，只要离开该类，private成员就不能被访问。
不修饰（部分隐藏）：不使用修饰符修饰的东西，将会被彻底隐藏在类、以及与该类相同包的里面。不使用修饰符修饰的东西，可以在当前类的里面，以及与当前类相同的其他包的类里面被访问。
protected（部分暴露）：使用protected修饰的东西，可以在当前类的里面，以及与当前类相同的包的其他类里面、当前类的子类中被访问。
public（彻底暴露）：使用public修饰的东西，可以在任何地方被访问。
final：修饰变量：该变量被赋值之后，不能被再次赋值（是本人最喜欢的，开发中有许多玩法，以后有空单独写一篇介绍）。
abstract：只有方法签名，没有方法体。（抽象方法希望被子类重写）
static：类方法，可直接被类访问。
synchronized：每个对象和每个类都有锁，而且是互斥锁，也就是说只能有一方占有，另一方只能等到对方释放后才能再占有锁。synchronized关键字就是基于java的对象和类的锁的。（一个线程访问static的synchronized方法时，其他的线程还可以访问不是static却被synchronized修饰的方法）

方法中的返回值：

返回值类型：

可以是任何有效的类型。包括基本类型和引用类型。
该类型指定了调用该方法时会得到一个怎样类型的值。
在有些时候，调用一个方法后不会得到任何值，应该使用void来生命该方法没有返回值。

方法中的方法名：

请参考阿里规范。

方法中的形参列表：

形参列表，可指定0〜N个形参。
每个形参定义由形参类型形参名组成；多个形参之间以逗号隔开。
形参的作用：指定调用该方法时必须传入相应数量、相应类型的参数值。
– 形参个数可变：
在形参类型后面添加…，表明调用该方法时，可传入多个参数。（本质就是数组）

方法中的方法体：

可以放赋值、输出、分支、循环等各种语句。
如果方法声明了有返回值类型，该方法中必须包含一条有效的return语句，用于指定方法的返回值。

方法重载：

同一个类、出现多个方法名相同；但形参列表（只考虑形参类型、数量）不同，这就叫方法重载。两同一不同。

如果方法的修饰符不同，不算重载
如果方法的返回值类型不同，不算重载

构造器

定义构造器的最简单的语法：

// 构造器名必须与类名相同，形参列表与方法的形参列表一样
[修饰符] <构造器名>(形参列表)
{
	// 赋值、输出、分支、循环等各种语句。但一定不能出现return语句。
}

构造器的作用：

Java用new 构造器()来创建Java对象。

构造器的修饰符：

public|protected|private

JAVA语言中的变量

所有变量，必须先声明（定义）、再使用。什么类型的变量，只能赋值对应类型的值。

基本类型

整型：
- byte （1个字节Byte、 8bit），总共支持256个数，取值范围：-128〜127
- short（2个字节、16位），总共支持65536个数，取值范围：-32768〜32767
- int （4个字节、32位），总共支持4G个数，取值范围：-2的31次方〜2的31次方-1
- long （8个字节、64位），总共支持2的64次方个数，取值范围：-2的63次方〜2的63次方-1
浮点型：
- float （4个字节、32位）
- double（8个字节、64位）
字符型：
- char (2个字节、16位)，最多支持65536个字符，可支持全世界各种语言的所有字符。
boolean型：
- boolean 类型的值只能是true和false。

引用类型

数组：
- 静态初始化：new 类型[]{元素1 , 元素2 , 元素3 ⋯⋯}; Java可以自动识别数组的长度。
- 动态初始化：new 类型[长度]; 只指定长度，由Java自动为每个元素分配默认的初始值（阿里规范是推荐这个）。
  - 注：数组对象必须用new才能创建数组对象。数组、对象一旦创建出来，它占的内存是静态的，位置、大小不会发生改变。因此，数组对象被创建出来之后，其长度不会发生改变。

数据类型的转换

byte → short → int → long → float → double

赋值运算符

左边=右边的表达式、常量、直接量、变量的值，赋值=左边的变量。

位运算符

&：与，当上、下两位都是1时结果才是1.
|：或，只要上、下两位有一个1，结果就是1.
~：非，单目运算符，所有的位（包括最高的符号后）都取反。
^：异或：只有当上、下两个位不同时，结果才是1.
<<：左移运算符。左移N位，相当于乘以2的N次方。
>>：右移运算符，空出来的高位是补符号位。右移N位，相当于除以2的N次方。
>>>：无符号右移，空出来的高位总是补0。
a+=b, 相当于 a = (a的类型)(a + b);
a-=b, 相当于 a = (a的类型)(a - b);
a*=b, 相当于 a = (a的类型)(a * b);
a>>=b, 相当于 a = (a的类型)(a >> b);

比较运算符

<、>、>=、<=、!=、==

逻辑运算符

&&（短路与）：当两个操作数都是true时，结果才是true——当程序需要保证2个条件都为真时，采用“与”运算符。当前一个操作数为false，该运算符直接返回false，该运算符不再计算后一个操作数。
& (不短路与）：总会同时计算2个操作数。
||（短路或）：只要一个操作数为true，结果就是true。——当程序只要任意1个条件都为真时，采用“或”运算符。当前一个操作数为true，该运算符直接返回true，不再计算后一个操作数。
| (不短路或）：总会同时计算2个操作数。
!（非）：原来true，变成false；原来是false，就变成true。
^（异或）：当两个操作数不同时，结果是true。当两个操作数相同时，结果是false。

三目运算符

条件 ? 值1 : 值2

包装类

Byte、Short、Integer、Long、Float、Double、Character、Boolean

自动装箱：把基本类型的值直接转换为包装类的实例。
自动拆箱：程序可以直接把包装类的实例当成基本类型的值使用。

JAVA语言中的分支结构

if语句：

if语句的最简单的语法：

有3种语法格式：
if(条件）
{

}

if(条件）
{

}else {

}

if(条件）
{

} else if(条件） // 可出现0〜N次
{

} else // 可出现0〜1次
{

}

注：如果条件执行体只有一行语句，Java允许省略条件执行体的花括号。当省略了花括号之后，if条件只控制到紧跟if条件的第一个分号。

switch语句：

switch语句的最简单的语法：

switch(表达式）  // 表达式可以是byte、short、int、char、枚举、String（Java 7才行）
{
	case 值1：
 		break;
	case 值2：
                 break;
	case 值3：
		break;
		...
	default: 
	//只有表达式值与所有case块都不相等时才执行
}

注：省略了case块后的break后，程序会从第一个匹配的case块开始执行，再遇到break之前，程序会直接执行case块，不会去判断条件。

循环结构：

while语句和do…while语句最简单的语法：

while(条件）
{

}

每次进入循环体之前，程序先判断while条件，如果while条件为true，程序执行循环体。
循环体执行完成后，程序再次去判断while条件，只要while条件为true，程序会重复执行循环体。
最后一次while条件为false，不再执行循环体，而是直接跳转到循环体的后一个花括号的后面。
while条件的执行次数 = 循环体的执行次数 + 1
如果循环条件开始就是false，程序就不会执行循环体。
while循环的注意点：如果循环体只有一行语句，Java允许省略循环体的花括号。
如果省略while循环的花括号，while条件仅控制到紧跟循环条件的第一个分号。

do
{

}while(条件);

开始先执行循环体，接下来程序判断while条件，如果while条件为true，程序再次执行循环体。
最后一次while条件为false，不再执行循环体，而是直接跳转到下面语句。
while条件的执行次数 = 循环体的执行次数
即使循环条件开始就是false，循环体也会执行一次。

for语句最简单的语法：

for([初始语句] ; [循环条件] ; [迭代语句] )
{

}

初始语句：
- 初始语句只执行一次。允许省略的。如果存在初始语句，在循环开始之前，会先执行初始语句一次。
- 初始语句，可声明多个变量，只要多个变量的类型相同即可。多个变量的声明之间用逗号隔开。
循环条件：
- 循环条件的执行次数 = 循环体的执行次数 + 1
- 允许省略的。如果省略循环条件，相当于循环条件永远为true。
- 如果存在循环条件，每次进入循环体之前，程序先判断循环条件，如果条件为true，程序执行循环体。
- 循环体执行完成后，程序再次去判断循环条件，只要循环条件为true，程序会重复执行循环体。
- 最后一次循环条件为false，不再执行循环体，而是直接跳转到循环体的后一个花括号的后面。
迭代语句：
- 迭代语句的执行次数 = 循环体的执行次数
- 允许省略的。每次循环体执行完之后，程序自动执行迭代语句。
- 迭代语句部分，可以放置多条任意语句，语句之间用逗号作为分隔符。
注：允许省略循环体的花括号。如果省略for循环的花括号，for条件仅控制到紧跟循环条件的第一个分号。