自学Java开发小白学习文档，4、常量4.1、常量

2023年Java自学小白文档 

1、类的定义

1.1、类定义的格式：

1 public class 类名{}

1.2、main方法的格式：

1 public static void main(String[] args){}

 　　1.3、输出语句的格式：　　

1 System.out.println("HelloWorld!!!");

2、注释

　　2.1、注释分类：

1）单行注释：格式：//注释信息

2）多行注释：格式：/*注释信息*/

3）文档注释：格式：/**注释信息*/

3、关键字

3.1、关键字特点：

1）关键字的字母全部小写；

2）常用的代码编辑器，针对关键字有特殊的颜色进行标记。

4、常量

4.1、常量的概念：

1）常量：在程序代码运行过程中，其值不可以发生改变的量。

4.2、常量的分类：

1）字符串常量：用双引号括起来的内容；

2）整数常量：不带小数的数字；

3）小数常量：带小数的数字；

4）字符常量：用单引号括起来的内容；

5）布尔常量：布尔值，表示真假（true/false）；

6）空常量：一个特殊的值，空值（null：空常量不能直接输出的）。

5、数据类型

5.1、基本数据类型：

1）数据型：

数据类型	关键字	内存占用	取值范围
整数	byte	1	-128~127
	short	2	-32768~32767
	int	4	-2的31次方到2的31次方-1
	long	8	-2的63次方到2的63次方-1
浮点数	float	4	负数：-3.402823E+38到-1.401298E-45 正数：1.401298E-45到3.402823E+38
	double	8	负数：-1.797693E+308到-4.9000000E-324 正数：4.9000000E-324到1.797693E+308
字符	char	2	0-65535
布尔	boolean	1	true,false

2）非数值型：ASCII 码*

 

6、变量

6.1、变量概述：

1）变量：在程序运行过程中，其值可以发生改变的量。

6.2、变量定义：

1）格    式：数据类型 变量名=变量值;

1 代码格式： int a=1;

 

6.3、变量使用注意事项：

1）变量名使用过程中不能重复；

2）变量未赋值不可使用；

3）long类型赋值后需在后面加L;(格式：long a =1000000L;)

4）float类型赋值后需在后面加F;(格式：float a =13.22F;)

 

7、标识符

7.1、标识符概述：

1）标识符：就是给类、方法、变量等起名字的符号;

7.2、标识符定义规则：

1）由数字、字母、下划线（_）和美元符（$）组成;

2）不能以数字开头；

3）不能是关键字；

4）区分大小写。

7.3、常见命名约定：小、大驼峰命名法

1）小驼峰命名法：方法、变量

• 约定1：标识符是一个单词的时候，首字母小写；（格式：two）
• 约定2：标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写；（格式：twoOneName）

2）大驼峰命名法：类

• 约定1：标识符是一个单词的时候，首字母大写；（格式：Two）
• 约定2：标识符由多个单词组成的时候，每个单词首字母大写；（格式：TwoOneName）

8、类型转换

8.1、类型转换分类：

1）自动类型转换：

• 把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量;
• 由小范围到大范围转换;数据类型要兼容。

格    式：float 变量名=char；

2）强制类型转换：

• 把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量;

格    式：目标数据类型 变量名=（目标数据类型）值或变量；

1 代码格式： int k=（int）88.88;

• 缺    点：数据丢失；

自动类型转换示意图

 

9、算术运算符

9.1、运算符和表达式：

1）运算符：对常量或者变量进行操作的符号；

符号	作用	说明
+	加
-	减
*	乘
/	除
%	取余	余数指整数除法中被除数未被除尽部分（这里以正数为例），且余数的取值范围为0到除数之间（不包括除数）的整数。

注意事项：

• /和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
• 整数操作只能取得整数，要想得到小数，必须有浮点数参与运算。

2）表达式：

• 用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
• 不同运算符连接的表达式体现的是不同类型的表达式。

9.2、字符的“+”操作：

1）char数据类型中‘A’、‘a’、‘0’计算机底层数值：ASCII 码值

• ‘A’    65    A-Z是连续数值
• ‘a’    97    a-z是连续数值
• ‘0’    48    0-9是连续数值
• ‘CR’    13    Enter键
• ‘NUL (NULL)’     0     多用于字符串结束标志

2）算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升

3）自动进行提升规则：

• byte类型、short类型和char类型（同时进行算术）将被提升到int类型；
• 整个表达式的类型自动提升到表达式中最高等级操作数同样的类型；
• 等级顺序：byte、short、char→int→long→float→double。

9.3、字符串的“+”操作：

1）当“+”操作中出现字符串时，这个“+”是字符串连接符，而不是算术运算；

• 代码格式：“字符串”+666；   执行结果：“字符串666”

2）当“+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。；

• 代码格式：1+99+“字符串”；   执行结果：“100字符串”

10、赋值运算符

10.1、赋值运算符：扩展的赋值运算符隐含了强制类型转换

符号	作用	说明
=	赋值	a=10,将10赋值给变量a。
+=	加后赋值	a+=b,将a+b的值给a。
-=	减后赋值	a-=b,将a-b的值给a。
*=	乘后赋值	a*=b,将a*b的值给a。
/=	除后赋值	a/=b,将a/b的商给a。
%=	取余后赋值	a%=b,将a%b的余数给a。

11、自增自减运算符

11.1、自增自减运算符

1）++：自增，变量的值加1

2）--：自减，变量的值减1

11.2、注意事项

1）++和--既可以放在变量前边，也可以放在变量后边；

2）单独使用的时候，++和--无论是放在变量的前边还是后边，结果都一样。

3）参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者--。

4）参与操作的时候，如果放在变量的前边，先拿变量做++或者--，后拿变量参与操作。

12、关系运算符

12.1、关系运算符：结果都是boolean值类型，true、false

符号	作用	说明
>	大于	A>B,判断A是否大于B,成立true,不成立false
<	小于	A<B,判断A是否小于B,成立true,不成立false
>=	大于等于	A>=B,判断A是否大于等于B,成立true,不成立false
<=	小于等于	A<=B,判断A是否小于等于B,成立true,不成立false
==	等于	A==B,判断A是否等于B,成立true,不成立false
!=	非等于	A!=B,判断A是否不相等B,成立true,不成立false

 

13、逻辑运算符

13.1、逻辑运算符：

符号	作用	说明
&	逻辑与	a&b,a和b都是true，结果为true,否则为false
|	逻辑或	a|b,a和b都是false，结果为false,否则为true
^	逻辑异或	a^b,a和b不同为true，相同未false
!	逻辑非	!b,结果和b的结果正好相反

13.1、短路逻辑运算符：

符号	作用	说明
&&	短路与	作用和&相同，但是有短路效果
||	短路或	作用和||相同，但是有短路效果

1）注意事项：

• 逻辑与&：无论左边真假，右边都要执行。
• 短路与&&：如果左边为真，右边都要执行，如果左边为假，右边都不执行。
• 逻辑或|：无论左边真假，右边都要执行。
• 短路或||：如果左边为真，右边都不执行，如果左边为假，右边都要执行。

14、三元运算符

14.1、三元运算符：

格式：关系表达式？表达式1：表达式2；

1 代码： a > b ? a : b;

14.2、计算规则：

首先计算关系表达式的值，如果值为true，表达式1的值就是运算结果，如果值false,表达式2的值就是运算结果。

15、数据输入

15.1、Scanner使用的基本步骤：

1）导包：import java.util.Scanner;

2）创建对象：Scanner sc=new Scanner(System.in);

3）接收数据：

• int i=sc.nextInt();int基本类型
• String s=sc.nextLine();字符串类型

16、条件语句

16.1、if(){}语句：

1 if(关系表达式){
2 
3     语句体;
4 
5 }

16.2、if(){}else{}语句：

1 if(关系表达式){
2 
3     语句体1;
4 
5 }else{
6 
7     语句体2;
8 
9 }

16.3、if(){}else if(){}else{}语句：

 1 if(关系表达式1){
 2 
 3     语句体1;
 4 
 5 }else if(关系表达式2){
 6 
 7     语句体2;
 8 
 9 }else{
10 
11     语句体3;
12 
13 }

16.4、switch语句：

1）格式说明：

• 表达式：取值为byte、short、int、char，JDK5以后支持枚举，JDK7后可以使用String;
• case:后面跟的是要和表达式进行比较的值；
• case:具有穿透性如case 1:case 2:case3:break;
• break:表示中断，结束的意思，用来结束switch语句；
• default:表示所以情况都不匹配时，就执行该处内容，和if语句的else相似；

2）代码格式： 

 1 switch(表达式){
 2 
 3     case 值1：
 4 
 5         语句体1；
 6 
 7         break;
 8 
 9     case 值2：
10 
11         语句体2；
12 
13         break;
14     ...
15 
16     default:
17 
18         语句体N+1;(默认带break)
19 
20 }

 17、循环语句

17.1、for循环语句：

1 for(初始化语句；条件判断语句；条件控制语句){
2 
3     循环体语句；
4 
5 }

17.2、while循环语句：

1 int i=0;说明：初始化语句
2 
3 while(条件判断语句){
4 
5     条件控制语句;
6 
7     循环体语句；
8 
9 }

17.3、do...while循环语句：

1 int i=0;说明：初始化语句
2 
3 do{
4 
5     条件控制语句;
6 
7     循环体语句；
8 
9 }while(条件判断语句);

17.4、for、while、do...while循环语句区别：

1)三种循环的区别：

• do...while循环至少循环一次，然后判断条件是否成立，是否继续执行循环体（先执行后判断）；
• for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）；

2)for和while的区别：

• 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了；
• 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用。

18、跳转控制语句

18.1、跳转控制语句概述：

1）continue用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行；

2）break用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环。

19、Random

19.1、Random的作用和使用步骤：

1）作用：用于产生一个随机数

2）步骤：

• 导包：improt java.util.Random;
• 创建对象：Random r=new Random();
• 获取随机数：int number=r.nextInt(10);
• 获取数据的范围：[0,10]包括0，但不包括10；

20、数组

20.1、数组定义格式：

1）格式：数据类型 [] 数组名；

int [] arr;

20.2、数组动态初始化：

1）格式：数据类型 [] 数组名=new 数据类型[数组元素]；

int [] arr=new int[3];

20.3、数组静态初始化：

1）格式：数据类型 [] 数组名=new 数据类型[]{数组元素值}；

int [] arr=new int[]{1,2,3,3};

20.4、数组两个常见问题：

1）索引越界异常：.ArrayIndexOutOfBoundsException

1）空指针异常：.NullPointerException

21、遍历

21.1、数组循环遍历：

1）获取数组元素长度：数组名.length

1）获取数组最大值：数组名.length

22、方法

22.1、方法概述：

1）方法(method)是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集；

2）方法必须先创建才可以使用，该过程称为方法定义；

3）方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用

22.2、定义方法：

1）创建方法格式：方法先定义，后调用

public static void 方法名称(){

方法体；

}

22.3、带参数定义方法：

1）创建方法格式：方法先定义，后调用

public static void 方法名称(数据类型 变量名称){

方法体；

}

22.3、带参数方法调用：

1）格式：方法名（参数）；

22.4、形参和实参：

1）形参:方法定义中的参数等同于变量定义格式

2）实参:方法调用中的参数

22.5、方法注意事项：

1）方法不能嵌套定义

1）void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

22.6、方法重载概述：

1）方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载：

多个方法在同一个类中

多个方法具有相同的方法名

多个方法的参数不相同，类型不同或者数量不同

22.7、方法重载特点：

1）重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式

2）重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

22.8、方法参数传递(基本类型)：

对于基本数据类型的参数，形式参数的改变，不影响实际参数的值

22.9、方法参数传递(引用类型)：堆内存中数组地址值相同

对于引用类型的参数，形式参数的改变，影响实际参数的值

23、类和对象

23.1、类的定义：

类：类是一个模板，它描述一类对象的行为和状态。

 

23.2、对象的定义：

对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。

24、String字符串类型

24.1、String构造方法:

1）public string():创建一个空白字符串对象，不含有任何内容;

2）public string(char[] chs):根据字符数组的内容，来创建字符串对;

3）public string(byte[] bys)，根据字节数组的内容，来创建字符串对象String s =“abc”;直接赋值的方式创建字符串对象，内容就是abc。

24.2、String对象的特点:

1）通过new 创建的字符审对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同；

2）以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次JVM 都只会建立一个String 对象，并在字符串池中维护。

24.3、字符串比较:

1）方法格式：常量1.equals(常量2)；返回boolean布尔值

24.4、指定字符串索引位置:

1）方法格式：常量.charAt(索引)；索引必须是int类型

24.5、字符串长度获取:

1）方法格式：常量.length()；

24.6、拼接字符串-append():

1）方法格式：StringBuilder()方法，内容是可变的；

2）构造方法：

StringBuilder（）；StringBuilder(String str);

3）添加数据方法（可链式编程）：StringBuilder对象.append(任意类型)；

4）字符串反转序列方法：StringBuilder对象.reverse();

5）StringBuilder转换为String：方法toString();

5）String转换为StringBuilder：方法StringBuilder();

25、集合基础

25.1、集合概述:

1）集合类的特点:提供一种存储空间可变的存储模型，存储的数据容量可以发生改变集合类有很多，目前我们先学习一个: ArrayList

2）ArrayList<E> 可调整大小的数组实现，<E>:是一种特殊的数据类型，泛型

3）代码格式：ArrayList<String>;ArrayList<Student>;

4）ArrayList添加方法：集合对象.add(数据信息)，

5）ArrayList添加方法：指定位置添加元素：集合对象.add(元素位置，数据信息);

25.2、ArrayList集合常用方法:

方法名	说明
public boolean remove(Object o)	制除指定的元素，返回删除是否成功
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size0	返回集合中的元素的个数

 

25.3、Collection 集合概述和使用

1）Collection集合概述

·是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素

· JDK 不提供此接口的任何直接实现，它提供更具体的子接口(如Set和List)实现

2）创建Collection集合的对象

·多态的方式

·具体的实现类ArrayList

25.3、Collection 集合常用方法

 

25.4、Collection 集合的遍历

1）lterator:迭代器，集合的专用遍历方式

·lterator<E> iterator0: 返回此集合中元素的迭代器，通过集合的iterator0方法得到

·迭代器是通过集合的iterator0方法得到的，所以我们说它是依赖于集合而存在的

2）lterator中的常用方法

·E next0:返回选代中的下一个元素

·boolean hasNext0: 如果迭代具有更多元素，则返回 true

25.5、List集合概述和特点-继承lterator类

1）List集合概述

·有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素并搜索列表中的元素

·与Set集合不同，列表通常允许重复的元素

2）List集合特点

·有序:存储和取出的元素顺序一致

·可重复:存储的元素可以重复

 

25.6、List 集合常用方法

 

25.7、List并发修改异常

1）并发修改异常：ConcurrentModificationException（）

2）产生原因：

·迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致

3）解决方案

·用for循环遍历，然后用集合对象做对应的操作即可

25.8、Listlterator列表迭代器

1）列表迭代器：

·通过List集合的listlterator0方法得到，所以说它是List集合特有的迭代器

·用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

2）Listlterator中的常用方法

·E next0:返回选代中的下一个素

·boolean hasNext0: 如果迭代具有更多元素，则返回true

·E previous0:返回列表中的上一个元素

·boolean hasPrevious0: 如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回truevoid add(Ee)将指定的元素插入列表

25.9、增强for循环

1）增强for:简化数组和Collection集合的遍历

·实现Iterable接口的类允许其对象成为增强型for语句的目标

·它是JDK5之后出现的，其内部原理是一个Iterator选代器

1）代码格式：

for(元素数据类型变量名:数组或者Collection集合){

//在此处使用变量即可，该变量就是元素

}

25.10、数据结构

1）数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率

2）常见数据结构之栈：

·数据进入栈模型的过程称为:压/进栈

·数据离开栈模型的过程称为:弹/出栈

3）常见数据结构之队列：

·数据从后端进入队列模型的过程称为:入队列

·数据从前端离开队列模型的过程称为:出队列

·注意：队列是一种数据先进先出的模型

4）数组数据和链表数据区别：

·数组是一种增删慢的模型（对比链表）

·数组是一种查询快的模型（对比链表）

·链表是一种增删快的模型(对比数组)

·链表是一种查询慢的模型(对比数组)

5）List集合子类特点：ArrayList，LinkedList

·ArrayList: 底层数据结构是数组，查询快，增删慢

·LinkedList:底层数据结构是链表，查询慢，增删快

25.11、LinkedList集合

1）LinkedList集合的特有功能：

 

25.12、Set集合

1）Set集合特点

·不包含重复元素的集合

·没有带索引的方法，所以不能使用普通for循环遍历

2）哈希值：

·哈希值:是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

·获取哈希值：hashCode()

3）对象的哈希值特点：

·同一个对象多次调用hashCode()方法返回的哈希值是相同的

·默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

3.3HashSet集合概述和特点

25.13、HashSet集合

1)底层数据结构是哈希表特点:

·对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致

·没有带索引的方法，所以不能使用普通for循环遍历

·由于是Set集合，所以是不包含重复元素的集合

25.13、LinkedHashSet集合

1）LinkedHashSet集合特点：

·哈希表和链表实现的Set接口，具有可预测的迭代次序

·由链表保证元素有序，也就是说元素的存储和取出顺序是一致的

·由哈希表保证元素唯一，也就是说没有重复的元素

 

26、继承

26.1、继承概述:

1）概述：继承是面向对象三大特征之一。可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法

2）代码格式：extends    

public class 子类名 extends 父类名{}

Public class Zu extends Fu{}

注意：Fu:是父类，也被称为基类、超类Zi:是子类，也被称为派生类

3)继承中子类的特点:

子类可以有父类的内容;

子类还可以有自己特有的内容。

26.2、继承的好处和弊端:

1)继承的好处:

提高了代码的复用性(多个类相同的成员可以放到同一个类中)；

提高了代码的维护性(如果方法的代码需要修改，修改一处即可)。

2)继承的弊端:

继承让类与类之间产生了关系，类的糊合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性。

26.3、继承中变量的访问特点:

1）在子类方法中访问一个变量：

先到子类局部范围找；

再到子类成员范围找；

最后到父类成员范围找；

如果都没有就报错(不考虑父亲的父亲...)。

26.4、继承中访问父类中的变量关键字:

1）关键字：super(代表父类存储空间的标识(可以理解为父类对象引用)

26.5、继承中构造方法的访问特点:

1)子类中所有的构造方法默认都会访问父类中无参的构造方法

因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化每一个子类构造方法的第一条语句默认都是: super0

2)如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢?

通过使用super关键字去显示的调用父类的带参构造方法

建议在父类中自己提供一个无参构造方法

推荐:自己给出无参构造方法

26.6、继承中成员方法的访问特点:

1)通过子类对象访问一个方法:

先到子类局部范围找；

再到子类成员范围找；

最后到父类成员范围找；

如果都没有就报错(不考虑父亲的父亲...)。

26.7、方法重写:

1）方法重写概述

子类中出现了和父类中一模一样的方法声明

2）方法重写的应用

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

4）@Override：是一个注解，可以帮助我们检查重写方法的方法声明的正确性。

26.8、方法重写注意事项:

1）注意事项：

私有方法不能被重写(父类私有成员子类是不能继承的)；

子类方法访问权限不能更低(public>默认>私有)

26.9、Java中继承的注意事项:

1）Java中类只支持单继承，不支持多继承；

2）Java中类支持多层继承

27、修饰符

 

27.1、 final

1）final 关键字是最终的意思，可以修饰成员方法，成员变量，类；

2）final 修饰的特点：

修饰方法:表明该方法是最终方法，不能被重写

修饰变量: 表明该变量是常量，不能再次被赋值

修饰类:表明该类是最终类，不能被继承

27.2、 final修饰局部变量

1）变量是基本类型:final 修饰指的是基本类型的数据值不能发生改变

2）变量是引用类型:final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

27.3、 static

1）static 关键字是静态的意思，可以修饰成员方法，成员变量

2）static 修饰的特点：

被类的所有对象共享：这也是我们判断是否使用静态关键字的条件

可以通过类名调用，当然，也可以通过对象名调用，推荐使用类名调用

 

 

3）static访问特点：

非静态的成员方法：

能访问静态的成员变量

能访问非静态的成员变量

能访问静态的成员方法

能访问非静态的成员方法

静态的成员方法：

能访问静态的成员变量能访问静态的成员方法

总结成一句话就是：静态成员方法只能访问静态成员

28、多态

28.1、多态概述:

1）同一个对象，在不同时刻表现出来的不同形态

28.2、多态的前提和体现有:

1）继承/实现关系

2）有方法重写

3）有父类引用指向子类对象

28.3、多态中成员访问特点:

1）成员变量编译看左边，执行看左边

2）编译看左边，执行看右边成员方法

3）为什么成员变量和成员方法的访问不一样呢?因为成员方法有重写，而成员变量没有

28.4、多态的好处和弊端:

1）多态的好处:提高了程序的扩展性；

2）具体体现:定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作

3）多态的弊端:不能使用子类的特有功能

28.5、多态中的转型:

1）向上转型：从子到父-父类引用指向子类对象；

1）向下转型：从父到子-父类引用转为子类对象

 

29、抽象

29.1、抽象类概述:

1）抽象类和抽象方法必须使用关键字修饰：abstract

2)在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

29.2、抽象类概述:

1)抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

2)抽象类不能实例化

抽象类如何实例化呢?参照多态的方式，通过子类对象实例化，这叫抽象类多态

3)抽象类的子类

要么重写抽象类中的所有抽象方法

要么是抽象类

29.3、抽象类的成员特点:

1)成员变量:可以是变量,也可以是常量;

2)构造方法:

有构造方法，但是不能实例化;

那么，构造方法的作用是什么呢?用于子类访问父类数据的初始化

2)成员方法:

可以有抽象方法:限定子类必须完成某些动作

也可以有非抽象方法:提高代码复用性

30、接口

30.1、接口概述:

1）接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用Java中的接口更多的体现在对行为的抽象

30.2、接口的特点:

1）接口用关键字interface修饰

Public interface 接口名

2）类实现接口用implements表示

Public class 类名implements 接口名0

3）接口不能实例化

接口如何实例化呢：参照多态的方式，通过实现类对象实例化，这叫接口多态

4）多态的形式:具体类多态，抽象类多态，接口多态

5）多态的前提: 有继承或者实现关系，有方法重写;有父(类/接口)引用指向(子/实现)类对象接口的实现类

6）要么重写接口中的所有抽象方法，要么是抽象类

30.3、接口的成员特点:

1）成员变量：只能是常量

默认修饰符:public static final

2）构造方法

接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在一个类如果没有父类，默认继承自Object类

2）成员方法：只能是抽象方法

默认修饰符: public abstract

30.4、类和接口的关系:

1）类和类的关系：

继承关系，只能单继承，但是可以多层继承

2）类和接口的关系：

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

3）接口和接口的关系

继承关系，可以单继承，也可以多继承

30.5、抽象类和接口的区别:

1）成员区别

抽象类：变量常量;有构造方法;有抽象方法也有非抽象方法

接口常量;抽象方法

 

2）关系区别

类与类：继承，单继承

类与接口：实现，可以单实现，也可以多实现

接口与接口：继承，单继承，多继承

3）设计理念区别

抽象类：对类抽象，包括属性、行为

接口：对行为抽象，主要是行为

30.6、抽象类名作为形参和返回值:

1）方法的形参是抽象类名，其实需要的是该抽象类的子类对象。

2）方法的返回值是抽象类名，其实返回的是该抽象类的了类对象。

30.7、接口名作为形参和返回值:

1）方法的形参是接口名，其实需要的是该接口的实现类对象

2）方法的返回值是接口名，其实返回的是该接口的实现类对象

31、内部类

31.1、内部类概述:

1）内部类:就是在一个类中定义一个类。

2）举例:在一个类A的内部定义一个炎B，类B就被称为内部类

3）内部类访问特点：内部类可以直接访问外部类的成员。包括私有外部类要访间内部类的成员，必须创建对象。

31.2、成员内部类:

1）按照内部类在类中定义的位置不同，可以分为如下两种形式： 在类的成员位置:成员内部类

在类的局部位置:局部内部类

2）成员内部类，外界如何创建对象使用呢：

格式:外部类名.内部类名 对象名=new 外部类对象.内部类对象

31.3、局部内部类:

1）局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用该类，可以直接访问外部类的成员，也可以访问方法内的局部变量。

31.4、匿名内部类:相当于创建对象，只不过没有对象名字

1）前提: 存在一个类或者接口，这里的类可以是具体类也可以是抽象类

2）代码格式：new 类名/接口名(){方法体}；

2）本质：是一个继承了该类或者实现了该接口的子类匿名对象

3）多次调用匿名内部类中方法的方法格式：

类名/接口名 对象名= new 类名/接口名(){方法体}；

对象名.方法体()；

32、常用API

32.1、Math类:

1）Math类概述:Math 包含执行基本数字运算的方法

2）Math类常用方法：

 

32.2、System类:

1）System类概述:Math 包含执行基本数字运算的方法

2）System类常用方法：

 

32.3、Object类:

1）Object类概述:Object是类层次结构的根，每个类都可以将 Object作为超类。所有类都直接或者间接的继承自该类。

 

32.4、Arrays类:

1）Arrays类的概述和常用方法:Arrays类包含用于操作数组的各种方法。

 

2）工具类的设计思想:

构造方法用private

修饰成员用 public static修饰

32.5、日期类:

1）代码格式：Date date=new Date();创建日期对象

2）Date类的常用方法：

 

32.6、日期类-SimpleDateFormat 类:

1）SimpleDateFormat 类概述：

SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。我们重点学习日期格式化和解析

2）SimpleDateFormat 的构造方法

 

3）SimpleDateFormat 格式化和解析日期：

 

 

33、常用API-基本类型包装类

33.1、基本类型包装类概述:

1）将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据常用的操作之一:用于基本数据类型与字符串之间的转换

 

33.2、Integer 类的概述和使用:

1）Integer:包装一个对象中的原始类型int的值

 

33.3、int 和 String 的相互转换:

1）基本类型包装类的最常见操作就是：用于基本类型和字符串之间的相互转换

2）int 转换为 String：

public static String valueOf(int i): 返int 参数的字符串表示形式。该方法是String 类中的方法

3）String 转换为int：

Public static int parselnt(String s): 将字符串解析为int类型。该方法是Integer类中的方法

33.4、String类中split方法:

1）描述：把字符串中的数字数据存储到一个int类型的数组中,空格分割获取数字。

2）代码格式：public string [] split(String regex)

33.5、自动装箱和拆箱:

1）装箱:把基本数据类型转换为对应的包装类类型

2）拆箱:把包装类类型转换为对应的基本数据类型

3）注意:在使用包装类类型的时候，如果做操作，最好先判断是否为 null我们推荐的是，只要是对象，在使用前就必须进行不为 null 的判断

 

34、异常

34.1、异常的概述:

1）异常:就是程序出现了不正常的情况

2）Error:严重问题，不需要处理

3）Exception:称为异常类，它表示程序本身可以处理的问题：

·RuntimeException: 在编译期是不检查的，出现问题后，需要我们回来修改代码非

·RuntimeException: 编译期就必须处理的，否则程序不能通过编译，就更不能正常运行了

34.2、JVM的默认处理方案:

1）如果程序出现了问题，我们没有做任何处理，最终JVM 会做默认的处理：

·把异常的名称，异常原因及异常出现的位置等信息输出在了控制台

·程序停止执行

34.3、异常处理:

1）try...catch代码格式：try{可能出现代码异常的代码体}catch(异常类名 变量名){异常的处理代码}

2）try...catch执行流程:

·程序从try里面的代码开始执行

·出现异常，会自动生成一个异常类对象，该异常对象将被提交给Java运行时系统

·当Java运行时系统接收到异常对象时，会到catch中去找匹配的异常类，找到后进行异常的处理

·执行完毕之后，程序还可以继续往下执行

34.4、Throwable 的成员方法:

 

34.4、编译时异常和运行时异常的区别:

1）Java 中的异常被分为两大类: 编译时异常和运行时异常，也被称为受检异常和非受检异常所有的RuntimeException类及其子类被称为运行时异常，其他的异常都是编译时异常

·编译时异常:必须显示处理，否则程序就会发生错误，无法通过编译。

·运行时异常:无需显示处理，也可以和编译时异常一样处理。

34.5、异常处理之 throws:

1）虽然我们通过try...catch...可以对异常进行处理，但是并不是所有的情况我们都有权限进行异常的处理也就是说，有些时候可能出现的异常是我们处理不了的，可以使用Java提供了throws的处理方案

2）代码格式：throws 异常类名；

2）注意：这个格式是跟在方法的括号后面的；

·编译时异常必须要进行处理，两种处理方案: try..atch ..或者throws，如果采用throws 这种方案，将来谁调用谁处理

·运行时异常可以不处理，出现问题后，需要我们回来修改代码

34.6、自定义异常：

1）代码格式：

Public class 异常类名 extends Exception{无参构造，带参构造}

34.6、throws 和 throw 的区别：

1）throws

·用在方法声明后面，跟的是异常类名

·表示抛出异常，由该方法的调用者来处理

·表示出现异常的一种可能性，并不一定会发生这些异常

2）throw

·用在方法体内，跟的是异常对象名

·表示抛出异常，由方法体内的语句处理

·执行throw一定抛出某种异常