Java基础知识小结(持续更新)

电玩女神 2023-10-11 21:11 47阅读 0赞

**目录**

一丶Java开发环境

环境变量配置

二丶标识符、关键字、数据类型

1.注释

2.分隔符、代码块

3.标识符

4.关键字

5.基本数据类型

6.常量、变量

7.类型转换

8.方法

三丶运算符、表达式、选择结构

1.运算符

2.表达式

3.选择结构

四丶控制语句

1.while循环

2. do while循环结构

3.while 和do while的区别

4.for循环

5.break和continue

五丶数组

1.概念

2.数组声明

3.数组创建及初始化

4.数组的操作

5.数组排序

6.二维数组

六丶类和对象

1.基本概念

2.类与对象的定义和使用

3.方法

4.方法的调用

5.构造器(构造方法)

6.方法重载

七丶面向对象-封装

1.基本概念

2.private关键字

3.访问控制符

4.this关键字

5.static关键字

八丶面向对象-继承

1.基本概念

2.语法

3.继承的特点

4.对象的转型

5.super关键字

6.object类

7.final

九丶面向对象—多态

1.基本概念

2.多态的前提

3.方法重写与方法重载的区别

4.内部类

十丶面向对象—接口

1.基本概念

2.接口的格式

3.接口中的属性和方法

4.接口的实现

5.接口的实现

6.抽象方法与抽象类

7.抽象类与接口的区别

十一丶常用类

1.包装类的分类

2.使用原因

3.自动装箱与自动拆箱

4.String类

5. StringBuffer和StringBuilder

6.Date类

十二丶集合

1.基本概念

2.集合接口

3.Collection接口

4.List接口

5.Set接口

6.Arraylist类

7.LinkedList类

8.ArrayList与LinkedList的区别

9.HashSet

10.Set与List的区别

11. Vector类

十三丶集合的遍历

1.Iterable接口

2.Iterator接口

3.ListIterator接口

4.迭代器的使用

5.增强for循环

6.迭代器与增强的for循环之间的区别

7.Collections工具类

十四丶Map集合

1.基本概念

2.Map集合的获取功能

3.Map遍历演示

4.Hashtable与HashMap的区别

十五丶异常Exception

1.异常产生的原因

2.异常的处理

十六丶反射

1.基本概念

2.Class对象

3.使用反射生成并操作对象

--------------------

### **一丶Java开发环境** ###

#### **环境变量配置** ####

Windows系统下配置JDK环境变量

(1)安装JDK，我们可以自定义安装目录

(2)右击此电脑，选择属性

(3)点击高级系统设置，选择环境变量

(4)在系统变量中，设置3项属性，JAVA\_HOME PATH CLASSPATH

如果已存在则点击编辑，不存在则点击新建

(5)JAVA\_HOME选择JDK安装路径，例如E:\\Java\\JDK

(6)PATH设置为%JAVA\_HOME%/bin;

(7)创建CLASSPATH变量，设置为 .;%JAVA\_HOME%/lib；

(8)cmd输入命令javac，java，java -version这几个命令，出现东西，说明环境变量配置成功

### **二丶标识符、关键字、数据类型** ###

#### 1.注释 ####

注释有三种形式：单行注释，多行注释以及文档注释

单行注释：//

多行注释 ：/\*

文档注释：以/\*\*开始，以\*/结束

#### 2.分隔符、代码块 ####

以;作为代码结束语句

\{\}里面的代码叫代码块

#### 3.标识符 ####

在Java中类名，方法名以及变量名称为标识符

标识符命名要求

（1）必须以字母、数字、\_或$组成

（2）不能以数字作为开头

（3）不能使用java的关键字和保留字

驼峰命名：第一个单词的首字母如果是大写则是大驼峰命名法,若是小写,则是小驼峰命名法

#### 4.关键字 ####

Java语言中有一些特殊的用途的词称为关键字，关键字不能用作变量名、方法名、类名、包名和参数。

![9e080bce182946948ebd10db527b5cad.png][]

#### 5.基本数据类型 ####

![a277f0a926cc4ee6afbbafa2e50bbf32.png][]

**类型的范围**

**![b725ed9500764bc9920e5d4f2b364a84.jpeg][]**

#### **6.常量、变量** ####

**6.1变量**

变量是Java程序中的基本存储单元，它的定义主要包括变量名、变量类型和变量的作用域三个部分。

变量的声明： 数据类型 变量名称。例如：int i;

变量的值可以声明时赋值，也可以声明后赋值。

在声明时赋值 int i = 20; 在声明后赋值 i = 20；

**全局变量**

在类的\{\}内直接定义的变量，称为全局变量。

全局变量在整个类中都可以使用。

全局变量在创建对象时会自动初始化，并有初始值(默认值)

**局部变量**

在方法体内部定义的变量，称为成员变量。

成员变量只能在方法体内部使用。

成员变量不会自动初始化，没有默认值，使用之前必须要初始化。

**6.2常量**

在Java语言中，主要是利用final关键字(在Java类中灵活使用Static关键字)来进行Java常量定义。

一般情况下我们把static与final结合起来声明一个常量，例如：static final int i= 123;

当常量被设定后，一般情况下就不允许再进行更改。

#### 7.类型转换 ####

Java中类型转换分自动类型转换和强制类型转换。

**自动类型转换**

类型兼容、小类型转换为大类型

byte-->int short--->int int--->long

long--->float float--->double

String--->Object （子类--->父类）

**强制类型转换**

大类型转换为小类型

int-->byte int--->short long--->int

float--->long double--->float

Object--->String （父类--->子类）

#### 8.方法 ####

package com.xszx;
    /**
     * @Author 杨 滢
     * @CreateDate 2023-03-15 15:30
     **/
    public class type {
        public static void main(String[] args) {
            byte b = 15;
            short s = 30;
            int i = 126;
            long l = 222L;
    
            System.out.println(b);
            System.out.println(s);
            System.out.println(i);
            System.out.println(l);
        }
    }

### 三丶运算符、表达式、选择结构 ###

#### 1.运算符 ####

*  **按操作个数分类：**

单目运算符：只需一个操作数参与运算。

双目运算符：需要两个操作数参与运算。

三目运算符：需要三个操作数参与运算

*  **按运算符功能分类：**

算数运算符 ：+ - \* / % ++ – –

关系运算符：> < >= <= == !=

逻辑运算符： ! && || & |

位运算符 ：>> << >>> & | ^ ~

赋值运算符：= += -= \*= /=

条件运算符 ：? ：

其他：instanceof

**（1）算术运算符**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="text-align:center;"><strong>运算符</strong></td> 
   <td style="text-align:center;"><strong>运&nbsp; 算</strong></td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">+</td> 
   <td style="text-align:center;">加</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">-</td> 
   <td style="text-align:center;">减</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">*</td> 
   <td style="text-align:center;">乘</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">/</td> 
   <td style="text-align:center;">除</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">%</td> 
   <td style="text-align:center;">取余</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">+=</td> 
   <td style="text-align:center;"> <p style="margin-left:.0001pt;text-align:center;">加并赋值</p> </td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">-=</td> 
   <td style="text-align:center;"> <p style="margin-left:.0001pt;text-align:center;">减并赋值</p> </td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">*=</td> 
   <td style="text-align:center;"> <p style="margin-left:.0001pt;text-align:center;">乘并赋值</p> </td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">/=</td> 
   <td style="text-align:center;"> <p style="margin-left:.0001pt;text-align:center;">除并赋值</p> </td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">%=</td> 
   <td style="text-align:center;"> <p style="margin-left:.0001pt;text-align:center;">取余并赋值</p> </td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">++</td> 
   <td style="text-align:center;">自增</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">--</td> 
   <td style="text-align:center;">自减</td> 
  </tr> 
 </tbody> 
</table>

**n++ 被使用之后再进行值加1 ++n 值先加1再进行使用**

**n-- 被使用之后再进行值减1 --n 值先减1再进行使用**

**（2）关系运算符**

关系运算符是两个操作数之间的比较运算

关系运算的结果为布尔类型值，如果关系成立为true，否则为false

关系运算符最常用于if语句和各种循环语句中的控制表达式

**（3）逻辑运算符**

逻辑运算符是对布尔类型操作数进行的与，或，非，异或等运算，运算结果仍然是布尔类型值

<table style="width:600px;"> 
 <tbody> 
  <tr> 
   <td style="text-align:center;"><strong>运算符</strong></td> 
   <td style="text-align:center;"><strong>运算</strong></td> 
   <td style="text-align:center;"><strong>结果</strong></td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">&amp;</td> 
   <td style="text-align:center;">与</td> 
   <td style="text-align:center;">左右两边都为true,结果为true，否则为false</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">|</td> 
   <td style="text-align:center;">或</td> 
   <td style="text-align:center;">左右两边只要有一个为true,结果为true，否则为false</td> 
  </tr> 
  <tr> 
   <td> <p style="margin-left:.0001pt;text-align:center;">^</p> </td> 
   <td style="text-align:center;">异或</td> 
   <td style="text-align:center;">左右两边不同，结果为true，否则为false</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">！</td> 
   <td style="text-align:center;">非</td> 
   <td style="text-align:center;">取反</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">&amp;&amp;</td> 
   <td style="text-align:center;">逻辑与</td> 
   <td style="text-align:center;">左右两边都为true,结果为true，否则为false</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">||</td> 
   <td style="text-align:center;">逻辑或</td> 
   <td style="text-align:center;">左右两边只要有一个为true,结果为true，否则为false</td> 
  </tr> 
 </tbody> 
</table>

**（4）位运算符**

位运算符是对操作数以二进制为单位进行的操作和运算，位运算数的运算对象只能是整型和字符型，结果为整型

**（5）赋值运算符**

赋值运算符的次序是从右向左的，即先计算表达式的值，再将表达式的赋值给变量。

**（6）条件运算符**

表达式为：表达式1？表达式2：表达式3 例如： int m =(a>b)?a:b

运算符按照优先级别的高低排序分别是：自加 / 减运算符、 算术运算符、关系运算符、逻辑运算符、赋值运算符。

#### **2.表达式** ####

*  表达式由操作数与运算符组成
 *  操作数可以是常量、变量，也可以是方法
 *  运算符就是数学中的运算符号比如+、-、\*、/、%等

#### 3.选择结构 ####

**单分支if语句**

语法格式：  
if(条件)\{  
语句  
\}

注意事项：

*  条件的结果只能是布尔类型的值

**双分支if语句**

语法格式：  
if(条件)\{  
语句1  
\}else\{  
语句2  
\}

注意事项：

else子句不能单独使用，它必须是if语句的一部分，与最近的if语句配对使用

**多分支if语句**

语法格式：  
if(条件1)\{  
语句1  
\}else if(条件2)\{  
语句2  
\}else if(条件3)\{  
语句3  
\}  
…  
\}else\{  
语句n  
\}

注意事项：

不论多分支if语句中有多少个条件，只会执行符合条件的一个，如果没有符合条件的，则执行else子句中的语句。

**多分支switch语句**

语法格式：  
switch(表达式)\{  
case 常量 1:  
语句;  
break;  
case 常量 2:  
语句;  
break;  
…  
default:  
语句;  
break;  
\}

注意事项：

*  如果case后没有break语句，程序将继续向下执行，直到switch语句结束或遇到break语句
 *  在同一个switch语句中，两个case常量不允许具有相同的值
    
     *  每个case语句中需要加上break;语句。如果遗漏了break，则会继续进入到下一个case。
     *  default语句通常放在末尾，可以放在开始，中间或者末尾位置

### 四丶控制语句 ###

#### **1.while循环** ####

语法结构：

while(条件)\{

执行的代码块;

注意事项：

条件是boolean类型的

当条件为true时则会重复执行其中的代码块。

如果条件为false的话则会停止运行。

#### **2. do while循环结构** ####

语法结构：

do \{  
语句块;  
\}while(条件表达式);

至少执行一次循环

#### 3.while 和do while的区别 ####

do while先执行 后判断 所以它至少执行一次

while先判断条件 再执行 有可能一次也不执行

所有的循环，都可能出现死循环

#### 4.for循环 ####

语法结构：

for(初始化表达式; 条件表达式; 更新表达式)\{  
循环体;  
java语句;  
java语句;  
....  
\}

循环是可以嵌套的，包括while和do-while循环

#### 5.break和continue ####

break：结束本层循环

continue：跳过本次循环，执行循环的下一次

### 五丶数组 ###

#### 1.概念 ####

数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。

#### 2.数组声明 ####

数据类型\[\] 数组名；

int\[\] a; //声明一个int类型的数组，名字为a

或 数据类型 数组名\[\]；

int a\[\];

#### 3.数组创建及初始化 ####

int\[\] a; //声明

数组名=new 数组类型\[数组长度\];

例如：a=new int\[5\]; //给数组对象开辟一个长度为5的空间

**数组创建的三种方式**

int\[\] nums = new int\[5\]; //初始化为默认值

int\[\] nums = \{1,2,3,4,5\}; //初始化为\{\}中指定的值

int\[\] nums = new int\[\] \{1,2,3,4,5\};//初始化为\{\}中指定的值

#### 4.数组的操作 ####

*  通过下标访问数组元素
 *  通过循环打印输出所有数组元素
 *  可以使用属性length获取数组的长度

#### 5.数组排序 ####

*  冒泡排序
 *  Arrays.sort()

#### 6.二维数组 ####

初始化：

Int\[\]\[\] 数组名称 = new int\[行数\]\[列数\]；

例如：Int\[\]\[\] arr = new int\[3\]\[5\];

遍历：

先遍历第一维，然后在内层循环遍历第二维

int[][] a = new int[3][5];
     
    for(int i = 0 ; i < a.length ; i++){
     
        for(int j = 0 ; j < a[i].length ; j++){
     
            System.out.println(a[i][j]);
     
        }
     
    }

### 六丶类和对象 ###

#### 1.基本概念 ####

**类：**有相同特征的事物的集合

**对象：**对象是类实例化出来的,对象中含有类的属性

#### 2.类与对象的定义和使用 ####

*  创建类的语法：

class 类名称 \{  
成员变量/ 实例变量；  
成员方法；  
\}

*  创建对象的语法：

类名称 引用名称 = new 类名称（）

Phone p = new Phone();

例如：

public class PhoneTest {
        public static void main(String[] args) {
            //创建一个实例化对象
            Phone p = new Phone();
            //通过对象来调用实例变量，成员方法
            p.setBrand("小米");
            p.setPrice(998);
            p.call();
            p.sendMessage();
            p.playGame();
    
        }
    }

#### 3.方法 ####

已经写好的代码块，可能会被重复利用多次，就可以把这段代码抽象成方法

*  创建方法的语法：

public static 方法返回值 方法名称（参数类型 形式参数列表） \{

方法体代码；

\[return 返回值\]；

*  **return**

（1）return语句用于明确地从一个方法返回。即，return语句导致程序的执行控制转移回到方法的调用者。

（2）如果return之后还有代码也不会执行。

（3）如果方法的返回类型为void，可以使用return跳出函数，但是不能使用return返回数据。

（4）可以返回对象。

#### 4.方法的调用 ####

*  调用相同类中的方法：可以直接调用。（本质上是使用this关键字调用）
 *  调用其他类中的方法：对象.方法名

#### 5.构造器(构造方法) ####

*  构造方法的作用：开辟内存空间、创建实例、初始化属性值
 *  构造方法的特点：

（1）方法名与类名相同

（2）不能声明返回类型

（3）不能使用return语句

（4）通常为public

#### 6.方法重载 ####

方法重载是指发生在同一个类中，定义了若干个方法名称相同，参数列表不同的(参数类型、参数个数不同)，且与返回值无关的一组方法，叫做方法重载

public class aa{
        //两个整型相乘的方法
        public static int add(int a, int b) {
            return a* b;
        }
     
        //两个整型相加的方法
        public static int add(int a, int b) {
            return a + b ;
        }
     
    }

**特点：**

1、方法名相同

2、形参列表不同：形参的类型/顺序、形参的个数

**注意的地方：**

1、返回值在区分重载方法时不起作用。修饰符也不起作用

2、当调用重载方法时，Java使用参数的类型和/或数量确定实际调用哪个版本。

### 七丶面向对象-封装 ###

#### **1.基本概念** ####

封装是面向对象的三大特征之一（封装 继承 多态）

所谓的封装就是把类的属性和方法使用private修饰，不允许类的调用者直接访问，而是通过该类所提供的方法来实现对内部信息的操作和访问

#### 2.private关键字 ####

是一个权限修饰符 ,可以用来修饰成员变量和成员方法.被私有化的成员只能在本类中访问

#### 3.访问控制符 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="width:95px;">修饰符</td> 
   <td style="width:90px;">同类&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</td> 
   <td style="width:116px;">同包</td> 
   <td style="width:105px;">子类</td> 
   <td style="width:93px;">所有包</td> 
  </tr> 
  <tr> 
   <td style="width:95px;">public</td> 
   <td style="width:90px;">是</td> 
   <td style="width:116px;">是</td> 
   <td style="width:105px;">是</td> 
   <td style="width:93px;">是</td> 
  </tr> 
  <tr> 
   <td style="width:95px;">protected</td> 
   <td style="width:90px;">是</td> 
   <td style="width:116px;">是</td> 
   <td style="width:105px;">是</td> 
   <td style="width:93px;"></td> 
  </tr> 
  <tr> 
   <td style="width:95px;">默认</td> 
   <td style="width:90px;">是</td> 
   <td style="width:116px;">是</td> 
   <td style="width:105px;"></td> 
   <td style="width:93px;"></td> 
  </tr> 
  <tr> 
   <td style="width:95px;">private</td> 
   <td style="width:90px;">是</td> 
   <td style="width:116px;"></td> 
   <td style="width:105px;"></td> 
   <td style="width:93px;"></td> 
  </tr> 
 </tbody> 
</table>

#### 4.this关键字 ####

this关键字指向的是当前对象的引用

用法：

*  this.属性名称

指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）。

*  this.方法名称

用来访问本类的成员方法。

*  this()

访问本类的构造方法。

()中可以有参数的 如果有参数 就是调用指定的有参构造。

**注意事项：**

*  this() 不能使用在普通方法中 只能写在构造方法中。
 *  必须是构造方法中的第一条语句。

#### 5.static关键字 ####

static可以是：

1.变量

如果将一个变量声明为`static`，就是静态变量了

2.Java静态方法

如果在任何方法上应用`static`关键字，此方法称为静态方法，静态方法属于类，而不属于类的对象，可以直接调用静态方法，而无需创建类的实例，静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

**静态方法的限制：**

1.静态方法不能直接使用非静态数据成员或调用非静态方法。

2.**this**和**super**两个关键字不能在静态上下文中使用。

3.Java静态块

Java中的静态块主要有两个作用：

*  用于初始化静态数据成员。
 *  在类加载时在main方法之前执行。

### 八丶面向对象-继承 ###

#### 1.基本概念 ####

*  继承就是java允许我们用extends关键字，让一个类和另一个类建立起一种父子关系。 提高代码复用性，减少代码冗余，增强类的功能扩展性。 继承的格式 子类 extends父类
 *  被继承的类称为父类，继承的类称为子类

#### 2.语法 ####

public class A extends SuperA\{

#### 3.继承的特点 ####

子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。 Java是单继承模式：一个类只能继承一个直接父类。 Java不支持多继承、但是支持多层继承。 Java中所有的类都是Object类的子类。

#### 4.对象的转型 ####

*  子类对象 赋给 父类引用 自动转换
 *  父类引用 赋给 子类引用 需要强转 ，前提：父类引用确实指向了正确的子类对象

#### 5.super关键字 ####

<table style="width:700px;"> 
 <tbody> 
  <tr> 
   <td style="width:48px;"><strong>关键字</strong></td> 
   <td style="width:212px;"><strong>访问成员变量</strong></td> 
   <td style="width:224px;"><strong>访问成员方法</strong></td> 
   <td style="width:207px;"><strong>访问构造方法</strong></td> 
  </tr> 
  <tr> 
   <td style="width:48px;"><strong>this</strong></td> 
   <td style="width:212px;">this.成员变量 访问本类成员变量</td> 
   <td style="width:224px;">this.成员方法(…) 访问本类成员方法</td> 
   <td style="width:207px;"><strong>this(…)</strong>&nbsp;<strong>访问本类构器</strong></td> 
  </tr> 
  <tr> 
   <td style="width:48px;"><strong>super</strong></td> 
   <td style="width:212px;">super.成员变量 访问父类成员变量</td> 
   <td style="width:224px;">super.成员方法(…) 访问父类成员方法</td> 
   <td style="width:207px;">super(…) 访问父类构造器</td> 
  </tr> 
 </tbody> 
</table>

#### 6.object类 ####

Object 是 Java 类库中的一个特殊类，也是所有类的父类

*  equals()方法

equals方法默认判断的是地址是否相等，等价于 ==，子类中往往重写该方法，用于判断内容是否相等

*  tostring()方法

直接打印对象时，默认调用对象的toString()方法

*  HashCode()方法

返回该对象的哈希码值

当我们重写equals()方法，判断两个对象相等时，最好也同时重写hascode()方法，让相同对象的哈希码值也相同

#### 7.final ####

*  如果final修饰变量，变量就是常量，常量不可修改，定义时必须初始化
 *  如果final修饰方法，方法就不能被子类重写
 *  如果final修饰类，类就不能再被扩展，不能再有子类。Java类库中的String、Math就是final类
 *  final修饰的对象引用不可变，内容可变

如果final修饰的常量是基本数据类型，不可以再修改。

如果final修饰的常量是引用类型，不能再将其他对象赋给该引用，但可以使用该引用改变对象内部的属性。

### 九丶面向对象—多态 ###

#### 1.基本概念 ####

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

#### 2.多态的前提 ####

*  要有继承或实现关系
 *  要有方法的重写
 *  要有父类引用指向子类对象

#### **3.方法重写与方法重载的区别** ####

只有当两个方法的名称和类型签名都相同时才会发生重写。如果不是都相同，那么这两个方法就只是简单的重载关系

重载是在同一个类中，两个方法的方法名相同，参数列表不同（参数类型、顺序、个数），与方法返回值无关

重写发生在父类和子类之间，子类继承父类方法（非构造、final、static修饰的方法）并重写父类方法。  
重写规则：

1.  重写方法参数列表、返回值类型必须和父类被重写的方法保持一致
2.  重写方法的访问权限不能低于父类被重写的方法

#### 4.内部类 ####

概念：把类定义在其他类的内部，这个类被称为内部类

分类:根据其所在位置及形式的不同,分为成员内部类、静态内部类、局部内部类、匿名内部类

成员内部类

class Outer {
     
    // 成员内部类
     
    class Inner {
     
    }
     
    }

访问成员内部类中的方法：

Outer.Inner inner = **new** Outer().**new** Inner();

静态内部类

class Outer {
     
    // 静态内部类
     
    static class Inner {
     
    }
     
    }

访问静态内部类中的方法：

Outer.Inner inner = **new** Outer.**new** Inner();

方法内部类

class Outer {
     
    // 成员方法
     
    public Object show() {
     
    // 方法内部类
     
    class Inner {
    
          }
      }
     
    }

访问静态内部类中的方法：

Outer outer= **new** Oute();

System.out.println(outer.showr());

匿名内部类

new Object(){
     3    void show(){
     4          System.out.println("HHHHHH");                
     5     }
     6 }.show();

### 十丶面向对象—接口 ###

#### 1.基本概念 ####

简单的说，接口就是一种被规范的标准，只要符合这个标准都可以通用

#### 2.接口的格式 ####

public interface 接口名

#### 3.接口中的属性和方法 ####

（1）接口中所有方法默认是公有的抽象方法

隐式地标识为public、abstract，并且接口中的方法也只允许使用这两个修饰符。

注意，在抽象类中必需使用abstract关键字明确指定方法为抽象方法。

（2）在接口中所有变量默认为公有的静态常量

被隐式地标识为public、static、final。这意味着实现接口的类不能修改它们。同时还必须初始化它们。

#### 4.**接口的实现** ####

一旦定义了一个接口，一个或多个类就可以实现该接口。为了实现接口，在类定义中需要包含implements子句，然后创建接口定义的方法

public class Aimplements B{
        }

注意：

（1）实现接口的类，必须实现接口的所有抽象方法，如果只实现了部分抽象方法，该类必须声明为抽象类

（2）一个类可以实现多个接口，实现的多个接口用,隔开

（3）实现接口的类可以同时继承一个父类，必须是先继承后实现

#### 5.接口的实现 ####

接口可以通过关键字extends继承另一个接口，其语法和类继承相同。如果类实现的接口继承自另外一个接口，则该类必需实现在接口继承链中定义的所有方法

#### 6.抽象方法与抽象类 ####

*  抽象方法

抽象方法是使用abstract修饰的方法。将一个方法声明为抽象方法，如果有继承关系要求子类必须重写该方法

注意：

1.  抽象方法没有方法实现，即没有方法体\{\}，只有定义
2.  类中如果有抽象方法，该类必须是抽象类，必须使用abstract
3.  对于抽象方法，abstract不能与private、static同时使用

*  抽象类

类定义中使用abstract修饰的类为抽象类

注意：

1.  从语法上讲，抽象类中可以没有抽象方法，但是没有实际意义
2.  有抽象方法的类必须是抽象类
3.  抽象类不能new对象

#### 7.抽象类与接口的区别 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="width:67px;"></td> 
   <td style="width:88px;"></td> 
   <td style="width:176px;">抽象类</td> 
   <td style="width:168px;">接口</td> 
  </tr> 
  <tr> 
   <td style="width:67px;"></td> 
   <td style="width:88px;"></td> 
   <td colspan="2" style="width:344px;">都可以有抽象方法，都不能实例化，但都可以声明，并能引用子类或实现类对象</td> 
  </tr> 
  <tr> 
   <td style="width:67px;"></td> 
   <td style="width:88px;">相同点</td> 
  </tr> 
  <tr> 
   <td colspan="1" style="width:67px;">不同点</td> 
   <td style="width:88px;">属性变量</td> 
   <td style="width:176px;">可以有变量</td> 
   <td style="width:168px;">只能是静态常量，数据成员必须初始化</td> 
  </tr> 
  <tr> 
   <td style="width:88px;">成员方法</td> 
   <td style="width:176px;">可以有具体方法，而且具体方法可以调用抽象方法</td> 
   <td style="width:168px;">如果有方法，全部是抽象方法</td> 
  </tr> 
  <tr> 
   <td style="width:88px;">构造方法</td> 
   <td style="width:176px;"> <p style="margin-left:.0001pt;text-align:justify;">有构造方法</p> </td> 
   <td style="width:168px;"> <p style="margin-left:.0001pt;text-align:justify;">没有构造方法</p> </td> 
  </tr> 
  <tr> 
   <td style="width:88px;">继承</td> 
   <td style="width:176px;"> <p style="margin-left:.0001pt;text-align:justify;">只能单继承</p> </td> 
   <td style="width:168px;"> <p style="margin-left:.0001pt;text-align:justify;">可以多重实现接口</p> </td> 
  </tr> 
  <tr> 
   <td style="width:88px;">扩张性</td> 
   <td style="width:176px;">弱</td> 
   <td style="width:168px;">强</td> 
  </tr> 
 </tbody> 
</table>

### 十一丶常用类 ###

#### 1.包装类的分类 ####

Java有八种基本数据类型：byte、short、int、long、float、double、char、boolean

提供了8种对应的包装类：Byte、Short、Integer、Long、Float、Double、Character、Boolean

#### 2.使用原因 ####

一方面出于性能方面的考虑，java为数值使用基本类型，而不是对象。基本类型不是对象层次的组成部分，它们不继承Object。

#### 3.自动装箱与自动拆箱 ####

*  **自动装箱**

自动装箱就是在需要的时候，基本数据类型会自动被装配成为对应的包装类

创建包装类对象有两种方式：new关键字、valueOf()方法

Integer n = new Integer(3);	            //基本数据类型转为包装类
    Integer integer = Integer.valueOf(8);   //基本数据类型转为包装类
    int m = n.intValue();		            //包装类型转为基本数据类型

*  **自动拆箱**

自动拆箱就是自动装箱的逆过程，在需要的时候，包装类会被自动转换为对应的基本数据类型

Integer  n = 20;		//自动装箱
    int m = n;		        //自动拆箱
    System.out.println(n);
    System.out.println(m);

#### 4.String类 ####

*  **基本概念**

在Java中字符串属于对象，，Java提供了String类来创建和操作字符串

String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。 如果需要对字符串做很多修改，那么应该选择使用StringBuffer类或StringBuilder类

*  **字符串长度**

可以使用length() 方法来返回string字符串的长度

*  **String类的构造方法**

String(); //创建不包含内容的字符串对象

String(char\[ \] *chars*) //通过使用平台的默认字符集解码指定的char数组，构造一个新的String

String(byte\[ \] *bytes*) //通过使用平台的默认字符集解码指定的byte数组，构造一个新的String

String(byte\[\] bytes,int offset,int length)

//通过使用平台的默认字符集解码指定的byte数组，构造一个新的String

还可以直接使用字符串字面创建String对象：String str = “abc”;

*  **字符串的比较**

String类重写了equals()方法，重写后的方法比较两个字符串对象的内容是否相同。

运算符“==”比较两个String引用是否指向同一个String对象

*  **其他比较方法**

boolean equalsIgnoreCase(String str) 将此String与另一个String比较，不考虑大小写。

boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。

boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始

*  **字符串的连接**

String str1 = “abc” ;

String str2 = “def”;

String str3 = “hij”;

(1) String str3 = str1 + str2;

(2)str1.concat(str2);

#### 5. StringBuffer和StringBuilder ####

**区别**

1.  StringBuffer类是线程安全的它的方法都有**`synchronized`** 关键字修饰，而StringBuilder则不是，即不保证其对象的同步性，在多线程环境中是不安全的
2.  StringBuilder在性能上要比StirngBuffer好一些。

**StringBuffer类的常用方法**

**append()**

append()方法将各种其他类型数据的字符串表示形式连接到调用StringBuffer对象的末尾该方法有多个重载版本，下面是其中的几个：

StringBuffer append(String str)

StringBuffer append(int num)

**insert ()**

在指定位置插入参数提供的内容，返回修改后的该StringBuffer对象引用。该方法有多个重载版本，下面是其中的几个：

StringBuffer insert(int index, String str)

StringBuffer insert(int index, char ch)

**StringBuffer deleteCharAt(int index)**

移除指定位置的字符，返回修改后的该StringBuffer对象引用

**StringBuffer reverse()**

将字符序列逆序，返回修改后的该StringBuffer对象引用

**int length()**

获取StringBuffer对象的当前长度

#### 6.Date类 ####

Date类封装了当前日期和时间。位于java.util包

**常用方法**

public Date() //使用当前日期和时间初始化对象

public Date(long date) //参数date为自从1970年1月1日子时经历的毫秒数

long getTime() //返回从1970年1月1日午夜开始已经流逝毫秒数

void setTime(long time) //将日期和时间设置为time所指定的值，time是是自从1970年1月1日午夜开始已经流逝的毫秒数

String toString() //将调用Date对象转换成字符串并返回结果

**SimpleDateFormat类**

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

SimpleDateFormat sf = **new** SimpleDateFormat(**"****yyyy****-MM-dd HH:mm:ss"**);

*1.**字符串转日期* *2008-07-10 19:20:00* *要把它转成日期，可以用*

sf.format(date )

*日期转字符串**假如把今天的日期转成字符串可用*

*String str = sdf.format(new Date());*

**jdk1.8日期类**

*  Instant：// 时间戳 瞬时时间。
 *  LocalDate： // 同时含有年月日时分秒的日期时间对象 本地日期，不包含具体时间, 格式 yyyy-MM-dd。
 *  LocalTime：// 只含有时分秒的时间对象 本地时间，不包含日期. 格式 yyyy-MM-dd HH:mm:ss.SSS 。
    
     *  ZonedDateTime：最完整的日期时间，包含时区和相对UTC或格林威治的时差
     *  LocalDateTime： // 同时含有年月日时分秒的日期时间对象

### 十二丶集合 ###

#### 1.基本概念 ####

（1）集合是存储其他对象的特殊对象。可以将集合当做一个容器。

（2）集合的相关接口和类位于java.util包中

（3）集合中的接口和类是一个整体、一个体系

#### 2.集合接口 ####

Collection 允许操作一组对象，它位于集合层次结构的顶部

List 扩展Collection，以处理序列(对象列表)

Set 扩展Collection，以处理组，组中的元素必须唯一

注意：

Set类型的集合（实现Set接口的类）称为集，其特点是组中的元素必须唯一

#### 3.Collection接口 ####

Collection接口是构建集合框架的基础，Collection是泛型接口，其声明如下：

interface Collection<E>，其中，E指定了集合将存储的对象类型

*  集合中只能存储对象，不能存基本类型
 *  使用泛型的优点是在编译时可以检查元素的类型，从而更加安全

#### 4.List接口 ####

List接口扩展了Collection，并且声明了存储一连串元素的集合的行为。索引从0开始，通过它们的位置插入或访问元素。列表可以包含重复的元素

声明：interface List<E>

#### 5.Set接口 ####

Set接口定义了组/集/集合(set)。它扩展了Collection接口，并声明了不允许重复元素的集合的行为。如果为集合添加重复的元素，add()方法会返回false

声明：interface Set<E>

#### 6.Arraylist类 ####

ArrayList实现了List接口。本质上是元素为对象引用的长度可变的数组

ArrayList长度取默认值 10

#### 7.LinkedList类 ####

LinkedList类实现了List、Deque以及Queue接口。它提供了（双向）链表数据结构

#### 8.ArrayList与LinkedList的区别 ####

（1）ArrayList是基于数组结构的集合，有容量的概念；LinkedList是基于链表结构的集合，没有容量的概念

（2）对于随机访问（get和set方法），ArrayList优于LinkedList，因为LinkedList要移动指针

（3）对于新增和删除操作（add和remove方法），LinkedList比较占优势，因为ArrayList要移动数据。但是如果只是在末尾追加元素，并且没有超出容量限制，则ArrayList的性能更好。

（4）LinkedList 还实现了Queue接口,该接口比List提供了更多的方法,包括 offer(),peek(),poll()等

#### 9.HashSet ####

HashSet类实现了Set接口。该类在内部使用哈希表存储元素

哈希法的优点是add()、contains()、remove()以及size()方法的执行时间保持不变，即使是对于比较大的集合也是如此

HashSet默认容量是16

#### 10.Set与List的区别 ####

（1）Set中的元素无序不能重复，List中的有序元素可以重复

（2）List有索引（下标）的概念，Set没有索引的概念

（3）对于Set表示的集合，通常是遍历操作，没有get()和set()方法

#### 11. Vector类 ####

Vector类实现了动态数组，与ArrayList类似，也实现List接口。但有如下区别：

Vector实现同步，线程安全。ArrayList没有实现线程安全

Vector性能比ArrayList低

Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间，而ArrayList每次对size增长50%

### 十三丶集合的遍历 ###

####  1.Iterable接口 ####

实现了Iterable接口的类是可以遍历的。因为Iterable接口是Collection接口的父接口

Iterable接口只定义了一个方法：

Iterator<T> iterator() //返回迭代器对象

#### 2.Iterator接口 ####

Iterator接口描述了迭代器的行为，所有迭代器类都必须实现该接口，该接口定义了以下方法：

boolean hasNext() 如果迭代还有更多的元素则返回true

T next() 返回下一个元素

void remove() 删除迭代器返回的元素

#### 3.ListIterator接口 ####

只有实现了List接口的集合类才提供了ListIterator迭代器

List接口提供以下两个方法用于获取列表集合的列表迭代器：

ListIterator<E> listIterator() 该迭代器从列表的开头开始

ListIterator<E> listIterator()(int index) 该迭代器从index所指定的位置开始

#### 4.迭代器的使用 ####

为了使用迭代器遍历集合的内容，需要以下步骤：

通过调用集合的Iterator()方法，获取指向集合开头的迭代器

建立一个hasNext()调用循环。只要hasNext()返回true，就循环迭代

在循环中，通过调用next()获取每个元素

#### 5.增强for循环 ####

如果不修改集合的内容，也不以反向获取元素，使用for-each版的for循环遍历集合通常比使用迭代器更方便

#### 6.迭代器与增强的for循环之间的区别 ####

使用迭代器遍历集合时，可以调用Iterator.remove()方法删除集合中元素，使用增强的for循环遍历集合时，不能删除集合中的元素

可以使用增强的for循环遍历数组，但是数组不支持迭代器

使用增强的for循环遍历基本类型的数组时，只能使用数组元素，而不能修改数组元素

#### 7.**Collections工具类** ####

Collections类里面包括动态、有序、可变大小的一维数组Vector与ArrayList

### 十四丶Map集合 ###

#### 1.基本概念 ####

*  Map是一个接口，我们不能直接创建对象，可以通过多态的形式创建对象
 *  Map中一个元素包含两个值（一个key，一个value）
 *  Map中的元素，key不允许重复，value可以重复

Map实现常用的一般有两种，一是HashMap，另一个是TreeMap

#### 2.Map集合的获取功能 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="text-align:center;">方法名</td> 
   <td style="text-align:center;">说明</td> 
  </tr> 
  <tr> 
   <td> <pre style="text-align:center;">get(Object key)</pre> </td> 
   <td style="text-align:center;">根据键获取值</td> 
  </tr> 
  <tr> 
   <td> <pre style="text-align:center;">keySet()</pre> </td> 
   <td style="text-align:center;">获取所有键的集合</td> 
  </tr> 
  <tr> 
   <td> <pre style="text-align:center;">values()</pre> </td> 
   <td style="text-align:center;">获取所有值的集合</td> 
  </tr> 
  <tr> 
   <td> <pre style="text-align:center;">entrySet()</pre> </td> 
   <td style="text-align:center;">获取所有键值对对象的集合</td> 
  </tr> 
 </tbody> 
</table>

#### 3.Map遍历演示 ####

//返回此映射中包含的映射关系的 Set 视图
            Set<Map.Entry<Integer, String>> entries = hashMap.entrySet();
            //遍历输出 hashmap 里面的数据
            System.out.println("获取hashmap中所有的数据");
            for (Map.Entry str :entries) {
                System.out.print(str.getKey()+"\t");
                System.out.print(str.getValue());
                System.out.println();
            }

#### 4.Hashtable与HashMap的区别 ####

*  HashMap不是线程安全的，HashTable中的方法是Synchronize的，所以是线程安全。
 *  HashMap允许空（null）的键和值（key），HashTable则不允许。
 *  HashMap性能优于Hashtable

### 十五丶异常Exception ###

#### 1.异常产生的原因 ####

程序错误分为三种：1.编译错误；2.运行时错误；3.逻辑错误  
（1）编译错误是因为程序没有遵循语法规则，编译程序能够自己发现并且提示我们错误的原因和位置  
（2）运行时错误是因为程序在执行时，运行环境发现了不能执行的操作  
（3）逻辑错误是因为程序没有按照预期的逻辑顺序执行

#### 2.异常的处理 ####

*  **抛出异常**

借助关键字throw，抛出一个指定的异常对象

*  **捕获异常**

try\{

\}catch(…)\{

finally\{

异常处理过程：

（1）当执行过程中遇到异常时，系统会抛出异常（对象）

（2）catch()块捕获异常并处理

（3）没有被捕获的异常最终都将由默认处理程序进行处理。默认处理程序会显示一个描述异常的字符串，输出异常发生点的跟踪栈，并终止程序

### 十六丶反射 ###

#### 1.基本概念 ####

反射是在运行时获取类或对象的信息的能力。具体的讲：可以通过类名或对象获取该类的相关信息，例如类的属性和方法、类实现接口或继承父类。甚至可以通过反射在运行过程中实例化对象，动态调用方法

#### 2.Class对象 ####

可以通过以下三种方式获取类的Class对象：

1.  类名.class //大部分时候使用这种方式
2.  对象.getClass()
3.  Class.forName(“类的全名”) //参数必须是类的全名

一旦获得了类的Class对象，就可以通过该Class对象获取类的相关信息了

#### 3.使用反射生成并操作对象 ####

获得了类的Class对象后，还可以通过Class对象调用newInstance()方法创建该类的对象。

Class<Student> c1 = Class.forName(“com.yy.day”);

Student s = c1.newInstance(); //这种情况要求Student类提供了无参构造方法

创建对象的另外一种方法：通过Constructor对象

[9e080bce182946948ebd10db527b5cad.png]: https://img-blog.csdnimg.cn/9e080bce182946948ebd10db527b5cad.png
[a277f0a926cc4ee6afbbafa2e50bbf32.png]: https://img-blog.csdnimg.cn/a277f0a926cc4ee6afbbafa2e50bbf32.png
[b725ed9500764bc9920e5d4f2b364a84.jpeg]: https://img-blog.csdnimg.cn/b725ed9500764bc9920e5d4f2b364a84.jpeg