Java跨平台机制与关键字详解-CSDN博客

本文链接：https://blog.csdn.net/weixin_50166145/article/details/109267990

一、 Java 概

1、Java

Java是sun在1995年推出的，前身是OAK，Java之父詹姆斯·高斯林（James Gosling)、2009被甲骨文收购——->：https://www.oracle.com

2、Java跨平台原理

Java程序运行在jvm（Java虚拟机）上，Java编译器将Java源程序编译成字节码文件（class文件），然后由jvm对字节码文件解释执行，所以在不同的操作系统上，只需安装不同的java虚拟机即可实现跨平台
平台：操作系统
跨平台：就是idea可以在不同的操作系统程序上运行，只需这些系统安装相应版本的jvm即可

3、JRE 和 JDK

JVM：Java虚拟机
JRE：java运行环境，包括了JVM和Java的核心类库（API）
JDK：Java开发工具，包含了JRE和开发工具

4、关键字

有特殊作用
字母全部小写
一般都会高亮显示

关键字：

4.1 访问控制修饰符----关键字

所有类成员的默认访问范围都是 package 访问

到达 44 中访问修饰符详解

private 私有的：访问控制修饰符，在类的外部或者对于子类而言，它们是不可见的。
protected 受保护的：自身、子类及同一个包中的类可以访问
public 公共的：可以被所有类访问

4.2 类、方法和变量修饰符

抽象-----重写接口------实现

class类：来声明新的Java类
extendes: 继承、扩展：是用在 class、interface 声明中，是表示后面的是前面的子类。只能继承一个，单继承。
final 最终、不可改变：final可以应用于类、方法、变量，final不能于abstract在一起，abstract 意味：抽象类扩展类（增加子类），abstract必须重写抽象方法，但是final 定义的是最终的类、方法不可改变

到达 45、 final 关键字，详解
abstract 声明抽象：定义为抽象类、方法，方法不在声明的类中实现，而在其子类中重写
- 如果abstract类的子类没有实现其超类的所有abstract方法，该子类也是abstract类。
- abstract关键字不能应用于static、private或final方法，因为这些方法不能被重写，因此，不能在子类中实现。
- final类的方法都不能是abstract，因为final类不能有子类
interface 接口：实现Java的接口，接口是方法的集合，任何类都可声明并实现一个或多个接口，实现接口也就是实现了接口中所定义的方法，实现了接口的任何类都必须提供在该接口中的所有方法的实现。
implements 实现：在class声明中使用，指定所class声明的类要 implements(实现) 接口类
native 本地：关键字可以应用于方法，以指示该方法是用 Java 以外的语言实现的。
new 创建：用于创建类的实例。
static静态：

46、 static 关键字
- 方便与在没有创建对象的情况下进行调用（方法/变量），不需要对象就能使用/访问
- this 和 static 关键字不能同时出现在一个类中，this关键字是对对象引用
- 修饰成员变量，成员方法、代码块等，即被 饰的成员属于类（类变量、类方法），可以直接调用。
- static 字段（类的成员变量）在类的所有实例中只存在一次。
1. static 方法
- static 方法一般称为静态方法，不需要对象就能调用，所以一般是没有this的，并且因为这个特性-------->**在静态方法中不能访问类的非静态成员变量和非静态成员方法，**因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。但是：非静态方法/变量都可以调用静态方法/变量
- 如果说想在不创建对象的情况下调用某个方法，就可以将这个方法设置为static。
- 我们最常见的static方法就是main方法，**为什么main方法必须是static的，因为程序在执行main方法的时候没有创建任何对象，因此只有通过类名来访问。 **
- 静态方法中不能使用 this、super 关键字（因为 this 和 super 都是表示的是一个对象，而 static 修饰的属于类
1. static 变量
- static 修饰的变量称为静态变量，静态变量被所有的对象使用，在内存中只有一个副本，只会在类初次加载时，才会初始化。 而非静态变量：是对象所拥有，在创建对象时初始化，有多个副本，但副本之间互相不影响
- 初始化顺序就是定义的顺序
1. static 代码块
- static代码块可以置于**类中的任何地方，**一个类可以有多个static代码块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次，优先于执行 static 代码块，即使static代码块在main() 之后。
- static 特性:只会在类加载的时候执行一次。所以可以用来优化性能。
- 很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。如：赋值初始化
1. static
- static是不允许用来修饰局部变量
局部变量：
- 函数内部的变量称为局部变量（Local Variable），它的作用域仅限于函数内部， 离开该函数后就是无效的，再使用就会报错。
**strictfp 严格、精准：**精确浮点
synchronized 线程同步：
- 可应用于方法或者语句块，一次给一个线程执行的关键代码段执行保护
- 线程安全、同步：防止关键代码段一次被多个线程执行
- 如果应用于静态方法、实例方法、对象或者数组：该方法一次由一个类执行，整个类、实例、对象或数组将被锁定
volatile 易失：**用于表示可以被多个线程异步修改的成员变量

程序控制语句

break 跳出、中断：用于提前退出 for、while、do循环，或在 switch 语句结束 case 块，退出的是总的本次循环，即使还有条件没执行，也会退出这个循环，继续执行循环外的语句。
continue 继续：用来暂停本次小的循环，即本次小循环的结果并不会输出，会继续执行总循环的其它条件，总循环的所有条件都执行完毕后，才会退出本次循环，但continue的条件结果，并不会输出
return 返回：会使方法返回到调用它的方法，从而传递与返回方法的返回类型匹配的值，返回值两侧的括号使可选的 void代表的使无返回值类型。
**if 如果：**if表示有条件的执行语句，if里面的条件结果必须是布尔类型的，if语句可以有可选的else子句，也可没有，包含 boolean 操作数的表达式只能包含 boolean 操作数。
else 否则：在于和if 结合使用，组成 if…else…
- if…else… : if 的执行结果为false时运行else的
switch 观察（循环）：switch…case…
- switch 语句中变量必须是：byte、short、int 、char、String、enum
- 一个switch可以拥有多个case，每一个case后面跟一个要比较的值和冒号
- 遇上break;时语句停止，如果没有则会继续执行下一条case语句
**case 返回观察里的结果：**case 用来标记switch语句中的默认分支，case没有隐式结束点，如句末没有break; 执行流将进入所有后面的case/default 块里
default 默认：用来标记switch语句中的默认分支，没有隐式结束点（在最后最好加一个break;），一般在末尾，方便完成时退出switch语句如果没有default语句，其参数与任何case块都不匹配时，switch语句则不起操作
while 循环：只要判断条件（while括号里）是正确，就会执行。
do while循环：do里面放执行语句（do{} ）while里放判断条件（while（））；无论判断条件是否正确，do里面的语句都会执行一遍
for循环：在进入for语句时，将执行一次赋值语句，每次执行循环体之前都将计算判断条件的结果，如果时true则执行循环体，在进入循环体之后，在计算下一个迭代的判断条件时，先执行自加或自减语句
instanceof 实例 ：确定对象所属的类

错误（异常）处理

try 捕获异常：try 关键字包含可能引发异常的语句块，每一个 try块都至少有一个 catch或finally 子句
- 每一个 try块都必须至少有一个 catch或finally子句
- 如果某个特定异常类未被任何 catch 子句处理，该异常将沿着调用栈递归地传播到下一个封闭 try 块。如果任何封闭 try 块都未捕获到异常，Java 解释器将退出，并显示错误消息和堆栈跟踪信息
catch 处理异常：catch关键字用来在 try–catch 或 try–catch–finally 语句中定义异常处理块
- 开始和结束的 { } 也是catch子句的一部分
throw 抛出一个异常对象： throw用于引发异常，throw是语句抛出一个异常，一般在代码块的内部，throw 出现在函数体，执行throw抛出了异常，执行throw 一定是抛出了某种异常对象
throws 声明一个异常可能被抛出：throws 关键字可以应用于方法，指出方法引发了特定类型的异常

包相关

import 引入：import 关键字使一个包中的一个或所有类在当前 Java 源文件中可见。可以不使用完全限定的类名来引用导入的类。
package 包：package 关键字指定在 Java 源文件中声明的类所驻留的 Java 包。

package 语句（如果出现）必须是 Java 源文件中的第一个非注释性文本。

基本类型

boolean 布尔类型：是Java的原始类型，值为：true、false，不能进行类型转换，包含boolean类型的表达式只能含有boolean 类型。
byte 字节类型：是Java的原始类型，存储范围在[-128，127]范围内。
short 短整型：原始类型，short可存储16位带符号的整数，占用2个内存
int 整型：原始，可存储32位整数值。
long 长整型：原始，存储64位带符号整数，一般定义long类型，在值后面添加 L/l
float 浮点：原始，存储单精度浮点数，定义float类型，在值后面添加 F/f
double 双精度：原始，存储双精度
- 由于浮点数据是实际数据的近似值，所以一般不进行是否相等的比较
char 字符型：原始，存储一个 Unicode 的字符，char值没有符号，可以与int类型进行强转得到符号的阿斯克码值和阿斯克码值的符合
null 空：null是Java的保留字，表示无值，将null赋值给非原始变量（基本数据类型八种）相当于释放变量先前所引用的对象 不能将null赋值给基本数据类型
true 真：boolean值得一个
false 假：boolean值得一个

变量引用

super 父类、超类、基类：只能出现在继承关系的子类中作用：对当前类父类的对象的引用
- 第一种用法： super.属性名、super.方法名（参数列表）
- 第二周用法：super(参数列表) 的形式出现在子类构造方法的第一句代码时，就明确指明了通过参数列表来匹配父类的构造方法，来创建父类对象
this 本类：this关键字只能用在没有被【static关键字】修饰的方法中
- 作用：表示对当前对象的引用
- 第一种用法：区分成员、局部变量
- 第二种用法：以this(参数列表)的形似出现在第一句代码是，代表应用其它类中的构造方法
void 无返回值：表示null类型，用作方法中，代表该方法无返回值

保留字

保留字是为java预留的关键字
goto 跳转：保留关键字，java不允许goto跳转
const 静态：类型修饰符，声明的对象不能更新
native 本地：Java无法直接访问到操作系统底层（如系统硬件等)，为此Java使用native方法来扩展Java程序的功能。

5、常量

常量：在程序运行的过程中，其值不可以发生改变的
除空常量外，其它常量均可使用输出语句直接输出
----->例： System.out.println(10)

6、数据类型

计算机存储最小的单元信息是“位(bit)”，比特位用“b”表示。
计算机最基本的存储单元是字节（byte），通常用“B”表示，字节是连续8个位组成
Java数据类型分基本数据类型、引用数据类型

7、变量

在程序运行的过程中，其值是可以发生变化的
从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。
定义格式：数据类型变量名 = 初始化值

注意事项：

变量名不能重复
必须要初始化
long类型后面加 L/l，整型默认为int
float类型后面加 F/f，浮点型默认为double

8、标识符

标识符是编程时使用的名字，用于给类、方法、变量、常量等命名

标识符规则：

由字母、下划线、数字、美元符号组成，第一个字符不能是数字。
不能使用Java的关键字
区分大小写、长度无限制
最好见明知意

9、类型转换

1、自动类型转换：

数据范围小的------>数据范围大的
- double dou01 = 10; System.out.print(dou01) //10.0

2、强制转换类型：

数据范围大的----->数据范围小的需要强转
- 强转格式：目标数据类型变量名 = （目标数据类型）值或者变量
- long lo01 = (long)23.8F； System.out.print(lo01) //23

3、转换注意：

数据范围从小到大：

byte —> short/char —> int —> long —> float —> double
char 转 int类型是按照阿斯克码值表的转换
整数默认是 int 类型，byte、short、char 类型参与运算会自动转换成int类型
boolean类型不能与其他基本数据类型相互转换。

10、算术运算符

1、运算符：

对常量或者变量进行操作的符号
+、-、*、/、%

2、表达式：

用运算符将常量和变量连接起来符合Java语法的式子，表达式的结果就是表达式的数据类型
/ 和 % 的区别：两个数据做除法，/取结果的商，%取结果的余数。
整数操作只能得到整数，要想得到小数，必须有浮点数参与运算
“+” ：连接符、相加

3、基本阿斯克码值：

’a’ – 97 a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加
’A’ – 65 A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加
’0’ – 48 0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加

4、 ++ – 运算符：

++ 和 – 单独使用的时候，无论放在前还是后，结果都是一样的
++/-- 自增/自减：放在变量的前面，先+/-1在操作（输出）
++/-- 自增/自减：放在变量的后面，**先操作（输出）**在+/-1

11、算术表达式

一般含有算术运算符的式子都是算术表达式
算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。

提升规则：

byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。
整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型
等级顺序：byte,short,char --> int --> long --> ﬂoat --> double

12、关系运算符

关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。
关系运算符的结果都是boolean类型，要么是true，要么是false。
== 是判断是否相等，判断地址

13、逻辑运算符

判断结果是 true/false
&、|、^ 、!
a^b，a和b结果不同为true，相同为false

短路逻辑运算符，规律

&&、||
相比较于关系运算符：提高了效率、节约了时间
逻辑与& ：无论左边真假，右边都要执行
短路与&& ：如果左边为假，右边不执行（左边为真，右边也要执行）
逻辑 | ：无论左边真假，右边都要执行
短路逻辑或 ||：如果左边为真，右边不执行（左边为假，右边执行）

14、三元运算符

格式：
- 关系表达式？结果正确执行的语句：结果错误执行的语句
- 关系表达式是判断条件，判断结果为boolean类型

15、Scanner数据输入

在 java.util 包下的 Scanner类
使用步骤：
- 需要导包 import java.util.Scanner;
- 创建Scanner 对象 Scanner sc(自定义的变量名)= new Scanner(System.in)；
- 接受数据数据类型变量名 = sc.next数据类型（）；next数据类型---->数据类型首字母大写

16、流程控制语句

在 4、关键字 —> 程序控制语句 中也有介绍

流程控制语句分为：

1、顺序结构

按照先后顺序进行执行（程序中最简基本的流程控制语句）

2、分支结构（if,swich）

if(关系表达式1){ 语句体1; }
if(关系表达式1){ 语句体1；}else{ 语句体2; }
if(关系表达式1){ 语句体1；}else if(关系表达式2){ 语句体2; }…else{ 语句体; }
switch(表达式){ case 值1：语句体1；break； case 值2：语句体2；break；

… default: 语句体; break; } // 表达式的值只能是：byte\char\short\int\enum\String，case的值为数字、char类型。

3、循环结构（for,while,do…while）

for(初始化语句；条件表达式；条件控制语句){ 循环语句体; }
while(条件判断语句){ 循环体语句; 条件控制语句; }
do{ 循环体语句; 条件控制语句; }while(条件判断语句);

三种循环的区别：

for循环和while循环：都是先判断后执行
do…while：无论条件是否成立都会执行一次语句体，先执行后判断
for循环和while的区别：
- for 循环结束后，不能访问其条件控制语句：归宿于for循环语句中，结束后就消失了
- 但对于while来讲条件控制语句不归属其语法结构中，所以在该循环结束后还能继续使用

死循环：

for( ; ; ){}
while(true){}
do{}while(true);

16、跳转控制语句

break：跳出循环，结束循环
continue：跳过本次循环，继续下次循环
continue只能在循环中进行使用！

17、循环嵌套

循环嵌套概述：在循环中，继续定义循环
（整个内循环，就是外循环的一个循环体，内部循环体没有执行完毕，外循环是不会继续向下执行的）
外循环执行一次，内循环执行一圈

18、数组

-----> 一维数组

概述：

数组：就是存储一组相同类型数据的数据结构
数组元素可以是基本数据类型，也可是引用数据类型【引用数据类型：数组、类、接口】

定义：

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度]
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,…}
数据类型[] 数组名 = {元素1,元素2,元素3,元素4…}

-------> 二维数组
声明:数据类型【】【】数组名; 数据类型数组名[][];
数组名=new 【数据类型】【表示二维数组的长度][表示每个一维数组有几个元素】;

19、数组的访问

索引：每一个存储到数组的元素，都会有一个整数编号，从0开始
语法：数组名[索引]
数组的长度是固定的 --------> 获取数组长度：数组名.length
- 数组最大索引值：数组名.length-1
索引访问数组的元素：
- 数组名[索引] = 数值为数组的元素赋值
- 数组名[索引] 获取数组中的元素

1、数组越界：

  报出异常：ArrayIndexOutOfBoundsException数组索引越界异常

2、数组空指针：

报出异常：NullPointerException空指针异常。

20、数组的遍历

一般有三种方法：

1、for循环遍历：

遍历一维数组：一般单层for循环，遍历二维数组时：使用双重for循环

2、Arrays 工具类：

to String 静态方法遍历：可以将一维数组转化成字符串形式并输出

3、foreach循环：也就是增强for循环：

使用foreach循环时，并不能改变数组元素的值，所以不要对foreach的循环遍历赋值

数组常用方法

反转：利用一个变量
复制：System.arraycopy(arg[]1,index1, arg[]2,index2, arr[].length)
- arg[]1 : 源数组
- index1：表示源数组从哪个索引位置开始复制
- arg[]2 : 目标数组
- index2：表示目标数组从那个位置开始存储数据
- arr[].length：表示要复制的个数
【如果目标数组是空数组，但存储位置（下标）不是0，则会报数组索引越界异常】
升降序：
- 升序：Arrays.sort(数组名称);
- 降序：
  
  //降序排列for(int i=0;i<nums.length-1;i++){//外层循环控制的循环的次数 //里层循环控制，外层循环每执行一次，需要对比的次数for(int j=0;j<nums.length-1-i;j++){//if(nums[j]<nums[j+1]){int temp=nums[j+1];nums[j+1]=nums[j];nums[j]=temp;}}}

21、增强for循环

增强for循环，也叫foreach循环。

语法：

for ( 数据类型变量名：数组名或集合名) { }
内部原理为：Iterator 迭代器，所以在遍历过程中，无法对元素中其它元素进行操作

【弊端：无法获取元素的索引值只适合对数组中的元素进行遍历操作】

可变参数

定义一个方法接收多个参数，并且类型一致
- 修饰符返回值类型方法名(参数类型… 参数名){ }
- 修饰符返回值类型方法名(参数类型[] 数组名){ }

22、数组内存分析

1、内存概述：

内存是计算机中，临时数据存储区域，作用是运行程序
我们写的程序是存放在硬盘中，只有放在内存中才会运行，运行完毕后会清空内存。

2、Jvm内存划分

方法区：存储可运行的class文件
堆内存：存储对象或者数组，new 来创建的，都存储在堆内存中
方法栈：方法运行时使用的内存，比如main 方法运行，进入方法栈中

23、数组在内存中的存储

日后填坑

24、方法

方法概念：具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

方法必须先创建才能使用，该过程称为方法定义
方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用

1、方法的定义（无参）：

public static void 方法名( ){ //方法体 }

2、方法的调用（无参）：

方法名( );

【方法必须先定义，后调用，否则会报错】

方法调用过程：

【总结：每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失】

3、方法的定义（带参数）：

public static void 方法名( 参数1 ){ 方法体 }
public static void 方法名( 参数1,参数2,参数3,… ){ 方法体 }

4、方法的调用（带参数）：

方法名(参数)；
方法名(参数1,参数2,参数3…)

【方法定义时：参数中的数据类型和变量名都不能缺少，多个参数用逗号分隔】

【方法调用时：参数的数量和类型必须与方法定义中的设置相匹配】

25、形参和实参

49、参数传递

形参于实参对应两种类型：

值类型（八种基本数据类型）与引用类型 （类、接口、数组）

1、形参：

不是实际存在变量，又称虚拟变量
形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。
是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数.在调用函数时，实参将赋值给形参。
形参的个数一定要与实参一一对应，并却实参要有一定的值

2、实参：

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参**。所以要给它们予设值。**

3、注意：

在值的传递过程中，只能 实参—>形参，不能形参传递实参。
在值传递调用过程中，只能把实参传递给形参，而不能把形参的值反向作用到实参上。

4、参数传递：

基本数据类型：形式参数的改变，不影响实际参数的值
依据：每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失
引用类型：形参的改变，影响世界参数的值
依据：引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果
传值时：为值类型时，形参方法内的参数值改变，并不会影响到实参的值
传值时：为引用类型时，形参方法内的参数值改变时，会影响到实参的值。注意是地址所指向的堆中的值，如果形参的地址改变了，那么这个改变不会影响到实参。

26、带返回值的方法

1、定义

public static 数据类型方法名 ( 参数 ){ return 数据; }

【方法定义时 return 后面的返回值与方法定义上的数据类型要匹配】

2、调用：

方法名( 参数 )；

数据类型变量名 = 方法名(参数)；

【方法的返回值通常会使用变量接收，否则该返回值将无意义】

方法注意事项：

方法不能嵌套定义
void 表示无返回值，可以省略 return，也可以单独的书写 return，后面不加数据

27、方法通用格式

格式：

public static 返回值类型方法名(参数){ 方法体； return 数据; }

注意：

定义方法时：要明确是否有返回值
明确参数，有无

28、方法重载

概念：

在一个类中，有多个方法名一致，但是参数列表不同
不能通过返回值来判断两个方法是否重载

【返回值一样不一样都可，但方法重载必须是参数列不同方法名相同】

【参数列表不一样】

public class Demo {

    //一个普通得方法，不带参数，无返回值
    public void add(){
        //method body
    }

    //重载上面的方法，并且带了一个整形参数，无返回值
    public void add(int a){
        //method body
    }

    //重载上面的方法，并且带了两个整型参数，返回值为int型
    public int add(int a,int b){
        //method body
        return 0;
    }

}

29、Debug

F8：单步调试，不进入函数内部
F7：单步调试，不进入函数内部

30、面向对象

特征：三大：（封装、继承、多态）（四大：封装、抽象、继承、多态）

1、对象：

没有相同的对象，对象唯一

2、抽象：

就是把同一类事物中共有的特征（属性）和行为（方法）进行抽取，归纳，总结

接口(interface) 抽象(abstract) 实现接口类

接口中的所有方法均为抽象方法
abstract class Es{ public static void a(){}; abstract void aa(); }
class Sa extends Es{@Override void aa() {} }

3、抽象方法的特点

只有方法头没有方法体的方法称之为抽象方法。（即只有方法的声明，没有方法的实现）
抽象方法用abstract关键字来修饰。
抽象方法代表一种不确定的操作或行为。（由子类去具体实现）
抽象方法不能被调用。

4、抽象类的特点

定义中含有抽象方法的类叫做抽象类。
抽象类用abstract关键字来修饰。
抽象类代表一种抽象的对象类型。
抽象类不能实例化。
抽象类中可以有具体方法，可以没有抽象方法。（也就是说一个类中只要有一个方法是抽象方法那么这个类一定是抽象类，反过来，一个抽象类中可以没有抽象方法，可以带有具体实现的方法）
一旦一个类中有抽象方法，那么这个类必须也要用abstract来修饰，代表这个类是抽象类，它是不能被实例化的

5、封装：

封装：就是包装，对抽象出来的数据进行包装，为了数据的安全性，
包括：属性和方法的封装，不是绝对的封装，可以通过指定的入口
抽象和封装这两个特征，在程序中的具体体现形式就是【类】 属性和方法的封装两者是相辅相成密不可分的。

31、类

1、定义：

public class 类名{ //成员变量 //成员方法 }

变量的分类：

数据类型：
- 基本数据类型变量
- 应用数据类型变量
位置划分：
- 局部变量：定义在方法内部或某个语句块的内部，只限于本方法或者本语句块内使用
- 全局变量：定义在类的内部，任何方法的外部，范围是整个类
- 局部变量：只有初始化才能使用

2、类和对象：

类是对对象的抽象
对象是类的实例化

32、创建对象

格式：类名对象名 = new 类名();
对象的使用：
- 对象名.成员属性(变量)
- 对象名.方法名(参数列表)
成员属性都有默认值，所以在声明成员属性时，可以不用初始化，就能使用默认值跟数据类型有关系

33、成员方法的应用

语法：访问修饰符返回值类型方法名称(参数列表){ }

成员方法之间调用，直接写方法名(参数列表)杰克

代码都是从 main方法开始到main结束

34、构造方法

对象是通过构造方法创建出来的

public 类名称（参数类型参数名称）{ 方法体 }

构造方法定义：

1、定义语句：

访问修饰符类名(参数列表){ }

2、构造方法规则：

方法名必须和类名一致
方法中没有return 也没有返回值和void
构造方法不能被 static 等关键字修饰
也可以重载，构造方法之间的参数列表(个数、类型、顺序的不同)不同即可

3、作用：

创建对象
可以对成员变量进行初始化

构造方法分类：

无参数（默认）构造方法：
- 显示无参数的构造方法
- 隐私无参数的构造方法
  - 当一个类中没有任何构造方法时，jvm就会默认创建一个
  - 有了后 jvm创建的就会自动消失
- 有参的构造方法

35、 this关键字

1、前提条件：

只能在没有被 static 关键字修饰的方法中

2、作用：

表示对当前类某个对象的引用

3、用法：

区分成员、局部变量
以this(参数列表) 的形似出现在第一句代码是，代表应用其它类中的构造方法

36、 JavaBean

凡是符合JavaBean的定义规范都统称为JavaBean，但是JavaBean也是一个类

JavaBean定义规范：

成员属性使用private关键字来修饰语法：private 数据类型属性名；
提供一个公共无参的构造方法
为所有的私有属性，提供set/get方法
- set是无返回值有参数，目的是给成员属性赋值
- get是有返回值无参数，目的是获取私有属性的值

37、 private 访问修饰符

private 表示私有的，修饰的属性，只能在当前类中使用，私有的

【类和类之间的方法或属性可以相互被调用，只需要创建一个目标类的对象即可】

38、package 创建包

包名可以是多级目录层次，层次之间用英文的点分割
包一定是位于源代码的第一句
- 带包的类编译语法： javac –d . 类名.java 点的意思表示当前类生成的带包的字节码文件位于当前目录
- 运行带包的字节码文件： java 包名.类名包名.类名又称为类的全限定名
导包的语法：
- import 包名.类名; 或者 import 包名.*; *表示包下所有的类。
- 【import 导包一定要位于 package 的下面】
一个Java源文件中存在多个类

【一个 Java 源文件中，可以存在多个类，但是只能有一个类带 public 访问修饰符，而且 main 方法就要位于该类中，而且 java 源文件的名称还要和带 public 修饰的类类名相同，其它类都要位于每个类结束大括号的外面，而且不需要添加 public 访问修饰符。】

39、Random 随机数类

1、此类用于产生伪随机数

方法：

Random 变量名r = new Random(); 数据类型变量名 = 变量名r.next数据类型();

Random 变量名r = new Random(); 数据类型变量名 = 变量名r.next数据类型(10/10L);

40、包装类

-----> 51、包装类

Java中的基本数据类型没有方法和属性，而包装类就是为了让这些拥有方法和属性，实现对象化交互。

八种基本数据类除int、char外其余的首字母大写
- int ----> Integer
- char —> Character
为了方便基本数据类型和包装类之间的相互转换，从 JDK5.0 开始，提供了装箱和拆箱。
- 装箱：就是把基本数据类型可以直接赋值给所对应的包装类对象
- 拆箱：可以把一个包装类对象直接赋值给所对应的基本数据类型
【装箱和拆箱是自动完成的】

Java中除了float和double的其他基本数据类型，都有常量池
所有整型包装类对象之间值的比较，全部使用equals方法比较。
- 说明：对于Integer var = ? 在-128至127 范围内的赋值，Integer 对象是在 IntegerCache.cache 产生，会复用已有对象，这个区间内的 Integer 值可以直接使用==进行判断，但是这个区间之外的所有数据，都会在堆上产生，并不会复用已有对象，这是一个大坑，推荐使用 equals方法进行判断
【强制】浮点数之间的等值判断，基本数据类型不能用==来比较，包装数据类型不能用 equals来判断

41、 String 类

java.lang.String

只要是用双引号引起来的内容，就是一个String字符串内容

特点：

字符串是一个不可变的类，也就是字符串的值在创建后不可改变
- 不可变指的是值本身不可变，但是重新给字符串对象赋值会改变字符串对象原本指向的内存地址
- 字符串池的原理来实现以上的过程：字符串池是一个专门用来存储字符串值得空间，所有创建的字符串对象在赋值时，都需要和字符串池中已有的内容进行对比，如果内容已经存在，直接引用已存在的值得内存地址；如果不存在，才会把新的内容放到字符串池中