Java笔记

第一周

  提示：**在单一的语句后有“;”，在一对括号“{}“之外无“;”。方法调用名和紧跟在其后的左括号

“(”无空格，该左括号和其后的标识符之间无空格。多个参数之间的逗号和前一个参数紧靠，与后一个

  参数空一格。

 命名规则：

     Java类的命名规则：类名首字母大写，如果由多个单词组合，则每个单词首字母大写（大驼峰命名法）

     如：HelloWorld,Demo

     注意：Java严格区分大小，如：name和Name意思不一样

关键字：

     public 表示访问说明符，表明该类是一个公共类，可以控制其他对象对类成员的访问。

     关键字 class 用于声明一个类，其后所跟的字符串是类的名称。

     关键字 static 表示该方法是一个静态方法，允许调用 main() 方法，无须创建类的实例。

     关键字 void 表示 main() 方法没有返回值。

     main() 方法是所有程序的入口，最先开始执行。

Java注释

    多行注释：包含在“`/*`”和“`*/`”之间，能注释很多行的内容。

    单行注释：以双斜杠“//”标识，只能注释一行内容，用在注释信息内容少的地方。 （快捷键 ctrl + /）

    文档注释：   包含在“`/**`”和“`*/`”之间，也能注释多行内容，一般用在类、方法和变量上面，用来描述其作用。

    注：保存的文件名中不能出现空格，类似“Hello Java.java”的文件名在编译时会出现找不到文件的错误。

变量：

    声明变量：在 java 中用户可以通过指定数据类型和标识符来声明变量  如：DataType identifier;

    变量标识符的命名规范如下：

​    首字符必须是字母、下划线（―）、美元符号（$）或者人民币符号（¥）。

​    标识符由数字（0~9）、大写字母（A~Z）、小写字母（a~z）、下划线（―）、美元符号（$）、人民币符号（¥）以及所有

    在十六进制 0xc0 前的 ASCII 码组成。

    不能把关键字、保留字作为标识符。

​    标识符的长度没有限制。

​    标识符区分大小写。

Java变量的作用域：

    根据作用域不同来划分成成员变量和局部变量。

    成员变量有两种，分别是全局变量和静态变量（类变量）， 定义在方法体和语句块之外，不属于任何一个方法，作用域是整个类。

    局部变量：是指在方法或者方法代码块中定义的变量，其作用域是其所在的代码块。

    可分为以下三种：

​       方法参数变量（形参）：在整个方法内有效。

​       方法局部变量（方法内定义）：从定义这个变量开始到方法结束这一段时间内有效。

​       代码块局部变量（代码块内定义）：从定义这个变量开始到代码块结束这一段时间内有效

常量：

   常量一旦被定义赋值，则不可以再被修改

   成员常量和静态常量再定义同时必须初始化

   常量命名规则：

   1、常量名字应该全部大写

   2、当常量命由多个单词组成时用下划线分割

   Java 的整型常量值主要有如下 3 种形式。

​     十进制数形式：**如 54、-67、0。

​     八进制数形式：**Java 中的八进制常数的表示以 0 开头，如 0125 表示十进制数 85，-013 表示十进制数 -11。

​     十六进制数形式：**Java 中的十六进制常数的表示以 0x 或 0X 开头，如 0x100 表示十进制数 256，-0x16 表示十进制数 -22。

Java的数据类型：

   1、基本数据类型

     byte（字节型 1字节  取值范围 -128~127）、short（短整型 2字节取值范围 -32768~32767）

     int（整型 4字节）、long （长整型 8字节）、float（单，4）double（双精度 8）、char、boolean（布尔型）

   2、引用数据类型（就是对一个对象是引用）

   除了基本数据类型，其他全部是引用数据类型 如String、数组等

   注：长整型，需要在其末尾添加L或者l

         单精度浮点型末尾需要加F或者f（有效小数点位6~7位   精度丢失   如pi=3.141593）

         字符型需单引号引起来，数字不用

       布尔型，Java中布尔值类型只有true和false

第二周：

数据类型转换：

 基本数据类型大小排行

   byte  1字节

   short 2字节

   char   2字节

   int     4字节

   long  8字节

   float  4字节

   double 8字节

小类 型数据转换为大类型（自动转换）

大类型转换为小类 型数据时需要强制转换（类型强转）

转换模式：小类 型 变量名 = 小类 型 大类型

  注意：大类数据转为小类数据时可能会造成数据进度丢失和溢出

short类型和char类型互相转化需要强制转换

**注意：两种数据类型需要彼此兼容时才可以互相转换，否则不可以转换

**基本类型和引用类型不可以互相转换

java逻辑运算符：

 *与、或、非

 && （短路与）：如a&&b，全为true时才为true，否则为false

 | |    （短路或）：如a&&b，有一个为true或者都为true时才为true，否则为false

 !        （非）     ：结果相反

 * && 和 &区别：如果a为false，则不计算b（因为不论b为何值，结果都为false）

 * | | 和 |  区别   ：如果a为true ，则不计算b（因为不论b为何值，结果都为true）

关系运算符：

 * == 、 ！= 、 > 、 < 、 <= 、 >=

 ** 注意：关系运算符的结果为布尔值类型。

 *equals（obj）方法和==的区别：

     equals方法比较的是两个对象的内容是否相等

   “==”比较的是两个对象在内存存放的地址是否为同一

Scanner ：java扫描器，用户从控制台输入数据，后台java程序接收

/**

   *next（）和nextLine（）方法的区别：

   *当遇到空格或者回车的时候next（）方法停止读取

   *当遇到回车的时候nextLine（）方法停止读取，读取整行数据

第三周：

If语句：

If（表达句）{为true执行代码块}else（）{//条件为false执行}

多分支语句：

If（）{}else if（）{}else if（）{}…{}else{

//else语句可要也可不要

}

While语句：

 语法：

  While（循环条件）{循环体}

Do while语句：

 语法：

  do{循环体}while（循环条件）

while 与do while循环的区别：

1. while是先判断后执行，do while 是先执行再判断
2. do while 循环必须执行一次

while和do while的特点：都是循环的执行某一语句 ，循环次数不固定。

For循环：语法：

 for（; 表达式1 ; 表达式2；表达式3）{循环体}

 特点：循环次数固定

如何定义一个int类型的数组：

 如Int [] arr = {…}

访问数组元素：通过访问数组下标来访问元素：如arr【i】表示 arr 下标为 I 的元素

Foreach语法：

 for（迭代变量类型 变量名 ： 需要变量（迭代）的对象）{

   语句块

}

如： int【】array = {12,13,14 }

for（int num ： array）{

system .out .print (num   }

break语句：

结束当前循环。

定义方法的语法： 修饰符 返回值 类型 方法名（参数1，参数2）{ 方法体…}

  方法（函数）的类型;

1. 无参 无返回值： 修饰符 返回值类型 方法名（）{方法体}
2. 无参有返回值: ：修饰符 返回值类型 方法名（）{方法体 return；}
3. 有参无返回值：修饰符 void 方法名（参数1，参数2，…）{方法体}
4. 有参有返回值： 修饰符 返回值类型 方法名（参数1， 参数 2，…）{方法体}

方法调用：

1. 通过 对象名.方法名（参数）
2. 类名 方法名（参数）
3. 方法（参数）

调用非static关键字修饰的方法：

 语法 ： 对象 方法（参数）

如： int max = d4.max（3,5）；

调用被static修饰的方法：

 语法：类名.方法（参数）

如：String grade = Demo04.grade（56）；

方法重载:

 重载就是在一个类中，有相同的函数名，但参数列表不相同的方法

注意：方法重载只与方法名字和参数列表有关，与方法返回值类型无关

 方法签名： 方法名字 +参数列表

程序 = 算法 + 数据结构

固定参数和可变参数的区别：

如固定参数： public void  fun1（int num， double d）{}

 可变参数的定义，可变参数最终会被封装成一个数组

如：public int fun2（int…num）

{for（int I ： num）{sout（i）}}

// 可变参数必须位于参数列表的最后一个

数组：

 数组定义：用来存放相同类型的一组数据数组下标从0开始，对数组元素进行操作是通过数组的下标（索引）数组一旦被创建，则数组的长度不可被修改

语法：静态创建数组数据类型[] 数组名 = {值1，值2....}据类型 数组名[] = {值1，值2....} 

动态创建数组 数据类型[] 数组名 = new 数据类型[数组长度]
      类型 数组名[] = new 数据类型[数组长度]
      静态创建数组，特点：创建数组的同时给数组元素赋值

 int arr[] = {1, 2, 4, 8, 9};

 动态创建数组，特点创建数组时指定数组的长度
long[] arr1 = new long[5];

数组元素赋值：语法，数组名[索引] = 值
 

使用数组元素
System .out. println (dArr[0] + 2);// 打印数组的第一个元素
 数组元素必须是相同类型的，不允许出现混合类型。
dArr[2] = "hello array"; 数组元素类型与数组类型不匹配，语法报错
定义引用数据类型数组

       String[] str = new String[5];

       创建demo01对象数组
Demo01[] d1 = new Demo01[10];
Date date[] = new Date[3];
// 数组的长度获取方式，array.length
// 获取数组d1的长度
int len = d1.length;

      System.out.println("数组demo01的长度为：" + len);

第四周：

数组：**数组的四个基本特点：**

1、 数组一旦被创建，它的大小将不可以在被改变。

2、 数组元素必须是相同类型的，不允许出现混合类型。

3、 数组中的元素可以是任何类型，包括基本类型与引用类型。

4、 数组属于引用类型，数组可以看成是一个对象，数组中的每一个元素相当于该对象的成员变量，因为数组本身就是对象，Java中对象是存放在堆中的，因此数组无论保存原始类型还是其他类型，数组对象本身都是在堆中。

二维数组：

 java中使用 `[][]` 来定义二维数组，定义数组时也可同时初始化。

  格式1、动态初始化

  数据类型 数组名[][] = new 数据类型[m][n]

数据类型[][]  数组名 = new 数据类型[m][n]

数据类型[]   数组名[] = new 数据类型[m][n]

格式2、 静态初始化

数据类型[][]  数组名 = {{元素1,元素2....},{元素1,元素2....},{元素1,元素2....}.....};

Arrays类：

**给数组赋值：**通过调用fill方法。

**对数组进行排序：**通过sort方法。

**比较数组：**通过equals方法比较数组中元素的值是否相等。

**查找数组元素：**通过binarySearch方法能对排序好的数组进行二分查找法操作。

**将数组转为字符串输出：**通过toString方法实现。

1、System.arraycopy（浅拷贝）

如：System.arraycopy(src, 1, dest, 0, 6);

1. Arrays.copyOf（浅拷贝）

dest = Arrays.copyOf(src, 2); // Arrays.copyOf  src为原数组，2为复制的位数

1. Arrays.copyOfRange

dest = Arrays.copyOfRange(src, 1, 3);

稀疏数组介绍：当一个数组中大部分元素为0时，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组定义：

稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是值无效数据量远大于有效数据量的数组。

面向对象-oop

 抽象的数据类型：

所谓抽象数据类型可以理解为：将不同类型的数据的集合组成一个整体，用来描述一种新的事务。如：对象类型数据

类中可以包含:

所有对象所共有的属性/特征------------成员变量

所有对象所共有的行为-----------------方法

一个类可以创建多个对象：

同一类型所创建的对象，结构相同，数据不同

类是对象的模板，对象是类的具体的实例

面向对象的三大特征：

封装、继承、多态

定义一个类：

1、类的定义包括“成员变量”的定义和“方法”的定义，其中“成员变量”用于描述对象  共同的数据结构，“方法”则是所有对象共同的     行为。

2、Java语言中，类的成员变量的定义可以使用如下的语法：

修饰符 class  类名 {

      成员变量类型   变量名;

      ………

}

1. 对象创建后，其成员变量可以按照默认的方式初始化，初始化对象成员变量时，其默认值的规则如下表所示：

| **成员变量类型**                                  | **默认初始值** |

| ------------------------------------------------- | -------------- |

| 数值类型（byte、short、int、long、float、double） | 0              |

| boolean类型                                       | false          |

| char类型                                          | /u0000         |

| 引用类型                                          | null           |

定义类的方法：

class  类名 {

    修饰符  返回值类型   方法名(参数列表){

         方法体………

    }

    ……………

}

类定义完成之后，可以使用new关键字创建对象，创建对象的过程通常称为实例化对象，new的运算语法为：

new   类名();

如：new  JFrame(); //可以创建一个窗体对象

创建对象语法：

数据类型   引用类型变量   指向  new关键字        对象

Student       zs        =    new           Student();

引用类型变量的赋值：1、引用类型变量存储的是对象的地址信息，相同类型的引用类型变量之间也可以互相赋值。2、引用类型变量之间的赋值不会创建新的对象，但有可能会使两个以上的引用指向同一个对象。例如：

Emp  e1  =  new  Emp();

Emp  e2  =  e1; // 将e1的值（对象地址信息）赋给e2，此时e1和e2指向相同对象

null和NullPointerException：

1. 对于引用类型变量。可以对其赋值为null，null的含义为“空”，表示还没有指向任何对象，例如：

Emp  emp  =  null; //emp为的值null，没有指向任何对象

emp  =  new  Emp(); //emp指向了一个Emp对象

1. 当一个引用变量的值为null的时候，如果通过引用访问对象成员变量或者调用方法不符合逻辑时，会产生NullPointerException，例如：

int[] arr = null;

arr.length;

第五周：

构造方法的定义原则：

​    1、构造方法的方法名字必须与类名完全相同（包括大小写必须相同），

​    2 构造方法没有返回值，连void关键字有没有

默认的构造方法：

1.任何一个类都必须含有构造方法

2.当定义了构造方法之后，Java编译器不再添加默认的无参构造器

构造方法的重载：

​    可以对一个类定义多个构造方法，这些构造方法都有相同的名称，但是方法的参数列表不同，

一个构造方法可以通过this关键字调用另外一个重载的构造方法

this关键字的使用:

this关键字用在方法体中，用于指向调用该方法的当前对象,

构造方法的语法：

             修饰符   类名(参数){

                  方法体....

               }

        构造方法的作用：用于创建类的对象（实例化对象），还可以初始化成员比啊量的初始值

       注意：当我们手动添加构造器（构造方法）之后，编译器将不在为我们添加默认的无参构造器

堆、栈、方法区：

堆: new出来的对象(包括实例变量)

栈: 局部变量(包括方法的参数)

方法区:.class字节码文件(包括方法、静态变量)

静态域：存放静态成员（static定义的

常量池：存放字符串常量和基本类型常量（public static final）

对于成员变量和局部变量：

成员变量就是方法外部，类的内部定义的变量；

局部变量就是方法或语句块内部定义的变量。局部变量必须初始化。

局部变量的数据存在于栈内存中

成员变量存储在堆中的对象里面

数组是对象：

​        1、在Java中，数组属于引用数据类型。

​        2、数组对象存储在堆中，数组变量属于引用类型，存储数组对象的地址信息，指向数组对象。

​        3、数组的元素可以看成数组对象的成员变量（只不过类型全部相同）

引用类型数组的声明：

​        数组的元素可以是任意类型，当然也包括引用类型。

private:私有的

        特点：凡是被private关键字修饰的属性和方法，只能在本类当中访问

                  在其他类当中访问则没有权限

public:关键字

    特点：任何地方都可以被访问

引用类型数组的初始化：

​     1）引用类型数组的默认初始值是null。

​     2）如果希望每一个元素都指向具体的对象，需要针对每一个数组元素进行new运算。

protected和默认访问控制：

​ 1：用protected修饰的成员变量和方法可以被子类及同一个包中的类使用。

​     2：默认的访问控制即不书写任何访问修饰符，默认访问控制的成员变量和方法可以被同一个包中的类调用。

向上造型：能访问的内容看引用类型

引用类型   引用变量 = 对象

Animal      an      = new Haha ();

封 装：

我们在设计程序是要追求“高内聚，低耦合”，其中，高内聚指的是类的内部数据操作细节由自己完成，不允许外部干涉。低耦合指的是仅暴露少量的方法给外部调用（使用get/set方法）。

封装的意义：

​ 1、对外提供可调用的，稳定的功能。

​ 2、封装容易变化的，具体的细节，外界不可访问，这样封装的意义在于：

​   a. 降低代码出错的可能性，便于维护。

​ b. 当内部的实现细节改变时，只要保证对外的功能定义不变，其他的模块就不会因此而受到牵连。

封装的核心：属性私有化，行为（方法）公开化

继  承:

extends关键字:

​    1、通过extends关键字可以实现类的继承。

​     2、子类可以继承父类的成员变量及成员方法，同时也可以定义自己的成员变量和成员方法。

​     3、Java语言不支持多重继承，一个类只能继承一个父类，但是一个父类可以有多个子类。

继承中的构造方法:

1、子类的构造方法中必须通过super关键字调用父类的构造方法，这样可以妥善的初始化继承自父类的成员变量。

​2、如果子类的构造方法中没有调用父类的构造方法，Java编译器会自动的加入对父类的无参构造方法的调用（如果父类没有无参构造方法，则会有编译错误）。

super关键字:

关于super 与 this 关键字的对比（区别）：

1. super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）。

​2. this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）。

3. super:　它引用当前对象的直接父类中的成员

4. this：它代表当前对象名.

5.this()和super()都指的是对象，所以均不可以在static环境中使用。

6.从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

方法重写:

​    1、发生在父子类中，方法名称相同，参数列表相同，方法体不同

​    2、重写方法被调用时，看对象的类型

​    3、遵循"两同两小一大"原则:------------了解

​      3.1、两同:

​            3.1.1、方法名称相同

​            3.1.2、参数列表相同

​        3.2、两小:

​            3.2.1、派生类方法的返回值类型小于或等于超类方法的

​                a、void时，必须相同

​                b、基本数据类型时，必须相同

​                c、引用数据类型时，小于或等于

​        3.2.2、派生类方法抛出的异常小于或等于超类方法的

​            3.3、一大:

​                 3.3.1、派生类方法的访问权限大于或等于超类方法的

重写与重载的区别:

​1、重写(Override):

​    1、发生在父子类中，方法名相同，参数列表相同，方法体不同

​    1.2、"运行期绑定"，看对象的类型绑定方法

​2、重载(Overload):

​    2.1、发生在一个类中，方法名相同，参数列表不同，方法体不同

​    2.2、"编译期绑定"，看参数/引用的类型绑定方法

多  态:

    多态指的是同一方法可以根据发送对象的不同而采用多种不同的行为方式。

​多态存在的条件：

​                1、 有继承关系

​                2、 子类重写父类的方法

​                3、 父类引用指向子类对象

多态的意义:

​        1、行为的多态(所有抽象方法都是多态的)

​        2、对象的多态(所有对象都是多态的)

多态的表现形式

​        1、重写:根据对象的不同来表现多态

​        2、重载:根据参数的不同来表现多态

注：多态是方法的多态性，属性没有多态性。

向上造型：

​        1.超类型的引用指向派生类的对象

​        2.能点出来什么，看引用的类型

向下造型：（容易出现类型转换异常）

​        1.派生类的引用指向超类对象

​        2.向下造型需要进行强转

第六周：

  设计模式的六大原则：（需背诵）

1. 开闭原则
2. 里氏代换原则
3. 依赖倒转原则
4. 接口隔离原则
5. 迪米特原则
6. 合成复用原则

Instanceof:java中的一个二元运算符、保留关键字

向上造型：超类型的引用指向派生类的对象

向下造型：派生类的引用指向超类对象（向下造型需要进行强转）

static和final关键字：

 1、static修饰成员变量

1、用static修饰的成员变量不属于对象的数据结构，属于类的数据结构。

2、static变量是属于类的变量，通常可以通过类名来引用static成员。

3、static成员变量和类的信息一起存储在方法区，而不是在堆中，一个类的static变量只有一份，无论这个类创建了多少个对象。

2、static修饰方法

1、通常的方法都会涉及到对具体对象的操作，这些方法在调用时需要隐式传递对象的引用（this）。

2、static修饰的方法则不需要针对某些对象进行操作，其运行结果仅仅与输入的参数有关，调用时直接用类名引用。

3、static在调用时没有具体的对象，因此在static方法中不能对非static成员进行访问，static方法的作用在于提供一些“工具方法”和“工厂方法”等。

3、static静态块

4、final修饰变量

1、final关键字修饰成员变量，表示变量不可被改变。

2、final修饰成员变量的两种方式初始化：

a. 声明的同时初始化

b. 构造函数中初始化

3、final关键字也可以修饰局部变量，使用之前初始化即可

5、final修饰方法

1、final关键字修饰的方法不可被重写。

2、使一个方法不能被重写的意义在于：防止子类在定义新方法使造成“不间意”重写。

6、final修饰类

1、final关键字修饰的类不可被继承。

2、 JDK中的一些基础类库被定义为final的，例如：String、Math、Integer、Double等。

3、使一个类不能继承的意义在于：可以保护类不被继承修改，可以控制滥用继承对系统造成的危害。

7、static final常量

1、static final修饰的成员变量称为常量，必须声明同时初始化，不可被改变。

2、static final常量会在编译期被替换，例如：

抽象类（abstract）

抽象类描述：（在Java语言中使用abstract class来定义抽象类）

 定义：如果一个类 没有足够的信息来描绘一个具体的对象，这样的类就是抽象类。

在Java中抽象类 表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

抽象方法:

1、由abstract修饰

2、只有方法的定义，没有具体的实现(连{ }都没有)

注：如果一个方法使用 abstract 来修饰，则说明该方法是抽象方法，抽象方法只有声明没有实现。需要注意的是 abstract 关键字只能用于普通方法，不能用于 static 方法或者构造方法中。

抽象方法的 3个特征如下：

1）抽象方法没有方法体

2）抽象方法必须存在于抽象类中

3）子类重写父类时，必须重写 父 类所有的抽象方法

**注意：**在使用 abstract 关键字修饰抽象方法时不能使用 private 修饰，因为抽象方法必须被子类重写，而如果使用了 private 声明，则子类是无法重写的。

抽象类:

1、由abstract修饰

2、包含抽象方法的类必须是抽象类

不包含抽象方法的类也可以声明为抽象类------我乐意

3、抽象类不能被实例化

4、抽象类是需要被继承的，派生类:

4.1、重写所有抽象方法--------常用

4.2、也声明为抽象类----------一般不这么做

5、抽象类的意义:

5.1、封装派生类所共有的属性和行为---------代码复用

5.2、给所有派生类提供统一的类型-----------向上造型

5.3、可以包含抽象方法，为所有派生类提供统一的入口

派生类的具体行为不同，但入口是一致的

接口（Interface）：

**接口（英文：Interface）**，在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过实现（implements）接口的方式，从而来实现接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非 实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类相似点：

        1）一个接口可以有多个方法。

        2）接口文件保存在 .java 结尾的文件中，文件名使用接口名。

        3）接口的字节码文件保存在 .class 结尾的文件中。

        4）接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

        1）接口不能用于实例化对象。

        2）接口没有构造方法。

        3）接口中所有的方法必须是抽象方法。

        4）接口不能包含成员变量，除了 static 和 final 变量。

        5）接口不是被 类继承了，而是要被 类实现。

        6）接口支持多继承（接口不能继承类，接口只能继承接口）。

接口特性：

​        1）接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

​        2）接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

​        3）接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别：

​        1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

​        2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

​        3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

​        4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

注：JDK 1.8 以后，接口里可以有静态方法和方法体了。

内部类：

java内部类的几种类型：**成员内部类，静态内部类，方法内部类，匿名内部类。

成员内部类：成员内部类是类 内部的非静态类。成员内部类不能定义静态方法和变量（final修饰的除外）。这是因为成员内部类是非静态的，类初始化的时候先初始化静态成员，如果允许成员内部类定义静态变量，那么成员内部类的静态变量初始化顺序是有歧义的。

成员内部类的使用方法：

        1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等

        2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

        3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

静态内部类：

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问。

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与          内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员。

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

方法内部类（局部内部类）：

方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

需要注意：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

匿名内部类：

匿名类是不能有名称的类，所以没办法引用他们。必须在创建时，作为new语句的一部分来声明他们。但使用匿名内部类还有个前提条件：必须继承一个父 类或实现一个接口。

        这种形式的new语句声明一个 新的匿名类，他对一个给定的类进行扩展，或实现一个给定的接口。他还创建那个类的一个新实例，并把他作为语句的结果而返回。要扩展的类和要实现的接口是 new语句的操作数，后跟匿名类的主体。

        注意匿名类的声明是在编译时进行的，实例化在运行时进行。这意味着 for循环中的一个new语句会创建相同匿名类的几个实例，而不是创建几个不同匿名类的一个实例。

        从技术上说，匿名类可被视为非静态的内 部类，所以他们具备和方法内部声明的非静态内部类相同的权限和限制。

        假如要执行的任务需要一个对象，但却不值得创建全新的对象（原因可能 是所需的类过于简单，或是由于他只在一个方法内部使用），匿名类就显得很有用。匿名类尤其适合在Swing应用程式中快速创建事件处理程式。

枚举:

枚举是一个被命名的整型常数的集合，用于声明一组带标识符的常数。

1、声明枚举:

声明枚举时必须使用 enum 关键字，然后定义枚举的名称、可访问性、基础类型和成员等。

任意两个枚举成员不能具有相同的名称，且它的常数值必须在该枚举的基础类型的范围之内，多个枚举成员之间使用逗号分隔。

提示：如果没有显式地声明基础类型的枚举，那么意味着它所对应的基础类型是 int。

正在上传…重新上传取消

之后便可以通过枚举类型名直接引用常量，如 SexEnum.male、Color.RED。

使用枚举还可以使 switch 语句的可读性更强，例如以下示例代码：

正在上传…重新上传取消

2、枚举类

Java 中的每一个枚举都继承自 java.lang.Enum 类。当定义一个枚举类型时，每一个枚举类型成员都可以看作是 Enum 类的实例，这些枚举成员默认都被 final、public, static 修饰，当使用枚举类型成员时，直接使用枚举名称调用成员即可。

所有枚举实例都可以调用 Enum 类的方法，常用方法如表 1 所示。

下表Enum类的常用方法

正在上传…重新上传取消

例 2：通过调用枚举类型实例的 values() 方法可以将枚举的所有成员以数组形式返回，也可以通过该方法获取枚举类型的成员。

下面的示例创建一个包含 3 个成员的枚举类型 Signal，然后调用 values() 方法输出这些成员。

正在上传…重新上传取消

3、为枚举添加方法

       Java 为枚举类型提供了一些内置的方法，同时枚举常量也可以有自己的方法。此时要注意必须在枚举实例的最后一个成员后添加分号，而且必须先定义枚举实例。

正在上传…重新上传取消

第九周：

八、分割字符串（spilt()）​ String 类的 split() 方法可以按指定的分割符对目标字符串进行分割，分割后的内容存放在字符串数组中。

九、字符串的替换 1、replace() 方法​ replace() 方法用于将目标字符串中的指定字符（串）替换成新的字符（串），其语法格式如下：```java字符串.replace(String oldChar, String newChar)```​ 其中，oldChar 表示被替换的字符串；newChar 表示用于替换的字符串。replace() 方法会将字符串中所有 oldChar 替换成 newChar

十、字符串比较​ 字符串比较是常见的操作，包括比较相等、比较大小、比较前缀和后缀串等。在 Java 中，比较字符串的常用方法有 3 个：equals() 方法、equalsIgnoreCase() 方法、 compareTo() 方法。## 1、equals() 方法​ equals() 方法将逐个地比较两个字符串的每个字符是否相同。如果两个字符串具有相同的字符和长度，它返回 true，否则返回 false。

十一、1、equalsIgnoreCase() 方法​ equalsIgnoreCase() 方法的作用和语法与 equals() 方法完全相同，唯一不同的是 equalsIgnoreCase() 比较时不区分大小写。当比较两个字符串时，它会认为 A-Z 和 a-z 是一样的。

2、equals()与==的比较​ 理解 equals() 方法和`==`运算符执行的是两个不同的操作是重要的。如同刚才解释的那样，equals() 方法比较字符串对象中的字符。而`==`运算符比较两个对象引用看它们是否引用相同的实例

1. 4、compareTo() 方法​ 通常，仅仅知道两个字符串是否相同是不够的。对于排序应用来说，必须知道一个字符串是大于、等于还是小于另一个。一个字符串小于另一个指的是它在字典中先出现。而一个字符串大于另一个指的是它在字典中后出现。字符串（String）的 compareTo() 方法实现了这种功能。​ compareTo() 方法用于按字典顺序比较两个字符串的大小，该比较是基于字符串各个字符的 Unicode 值。
2. **提示：**如果两个字符串调用 equals() 方法返回 true，那么调用 compareTo() 方法会返回 0。

• 字符串查找​

 在给定的字符串中查找字符或字符串是比较常见的操作。字符串查找分为两种形式：一种是在字符串中获取匹配字符（串）的索引值，另一种是在字符串中获取指定索引位置的字符。## 1、根据字符查找​ String 类的 indexOf() 方法和 lastlndexOf() 方法用于在字符串中获取匹配字符（串）的索引值。

• 1. indexOf() 方法​ indexOf() 方法用于返回字符（串）在指定字符串中首次出现的索引位置，如果能找到，则返回索引值，否则返回 -1。
  2. fromIndex 表示查找时的起始索引，如果不指定 fromIndex，则默认从指定字符串中的开始位置（即 fromIndex 默认为 0）开始查找。
  3. lastlndexOf() 方法​ lastIndexOf() 方法用于返回字符（串）在指定字符串中最后一次出现的索引位置，如果能找到则返回索引值，否则返回 -1。
• StringBuffer 类是可变字符串类，创建 StringBuffer 类的对象后可以随意修改字符串的内容。每个 StringBuffer 类的对象都能够存储指定容量的字符串，如果字符串的长度超过了 StringBuffer 类对象的容量，则该对象的容量会自动扩大
• 删除字符串​ StringBuffer 类提供了 deleteCharAt() 和 delete() 两个删除字符串的方法，下面详细介绍。**1、deleteCharAt() 方法**​ deleteCharAt() 方法用于移除序列中指定位置的字符，该方法的语法格式如下：```javaStringBuffer 对象.deleteCharAt(int index);```​ deleteCharAt() 方法的作用是删除指定位置的字符，然后将剩余的内容形成一个新的字符串
• StringBuilder 和 StringBuffer 功能基本相似，方法也差不多。不同的是，StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。因此在通常情况下，如果需要创建一个内容可变的字符串对象，则应该优先考虑使用 StringBuilder 类。

1、静态常量​ Math 类中包含 E 和 PI 两个静态常量，正如它们名字所暗示的，它们的值分别等于 e（自然对数）和 π（圆周率）。

2、生成随机数（random()和Random类）​ 在 Java 中要生成一个指定范围之内的随机数字有两种方法：一种是调用 Math 类的 random() 方法，一种是使用 Random 类。​ Random 类提供了丰富的随机数生成方法，可以产生 boolean、int、long、float、byte 数组以及 double 类型的随机数，这是它与 random() 方法最大的不同之处。random() 方法只能产生 double 类型的 0~1 的随机数。​ Random 类位于 java.util 包中，该类常用的有如下两个构造方法。​ **Random()：**该构造方法使用一个和当前系统时间对应的数字作为种子数，然后使用这个种子数构造 Random 对象。​ **Random(long seed)：**使用单个 long 类型的参数创建一个新的随机数生成器。​

Random 类提供的所有方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的概率是均等的，在表 1 中列出了 Random 类中常用的方法

3、Math 类的 random() 方法没有参数，它默认会返回大于等于 0.0、小于 1.0 的 double 类型随机数，即 0<=随机数<1.0。对 random() 方法返回的数字稍加处理，即可实现产生任意范围随机数的功能。

4、BigInteger 类型的数字范围较 Integer 类型的数字范围要大得多。BigInteger 支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值。​ 除了基本的加、减、乘、除操作之外，BigInteger 类还封装了很多操作，像求绝对值、相反数、最大公约数以及判断是否为质数等。​ 要使用 BigInteger 类，首先要创建一个 BigInteger 对象。BigInteger 类提供了很多种构造方法，其中最直接的一种是参数以字符串形式代表要处理的数字。

5、igDecimal 类​ BigInteger 和 BigDecimal 都能实现大数字的运算，不同的是 BigDecimal 加入了小数的概念。一般的 float 和 double 类型数据只能用来做科学计算或工程计算，但由于在商业计算中要求数字精度比较高，所以要用到 BigDecimal 类。BigDecimal 类支持任何精度的浮点数，可以用来精确计算货币值。​ BigDecimal 常用的构造方法如下。​ 1、BigDecimal(double val)：实例化时将双精度型转换为 BigDecimal 类型。​ 2、BigDecimal(String val)：实例化时将字符串形式转换为 BigDecimal 类型。​ BigDecimal 类的方法可以用来做超大浮点数的运算，像加、减、乘和除等。在所有运算中，除法运算是最复杂的，因为在除不尽的情况下，末位小数的处理方式是需要考虑的。

6、Java时间日期的处理​ 在 Java 中获取当前时间，可以使用 java.util.Date 类和 java.util.Calendar 类完成。其中，Date 类主要封装了系统的日期和时间的信息，Calendar 类则会根据系统的日历来解释 Date 对象。下面详细介绍这两个类的具体使用。## 1、Date 类​ Date 类表示系统特定的时间戳，可以精确到毫秒。Date 对象表示时间的默认顺序是星期、月、日、小时、分、秒、年。#### 1.1、构造方法​ Date 类有如下两个构造方法。​ 1、Date()：此种形式表示分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒），使用该构造方法创建的对象可 以获取本地的当前时间。​ 2、Date(long date)：此种形式表示从 GMT 时间（格林尼治时间）1970 年 1 月 1 日 0 时 0 分 0 秒开始经过参数 date 指定的毫 秒数。

7、Calendar 类​ Calendar 类是一个抽象类，它为特定瞬间与 YEAR、MONTH、DAY_OF—MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（如获得下星期的日期） 提供了一些方法。​ 创建 Calendar 对象不能使用 new 关键字，因为 Calendar 类是一个抽象类，但是它提供了一个 getInstance() 方法来获得 Calendar类的对象。getInstance() 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化

十七、

1.  实现 int 和 Integer 的相互转换**​ 可以通过 Integer 类的构造方法将 int 装箱，通过 Integer 类的 intValue 方法将 Integer 拆箱。
   2、 将字符串转换为数值类型**​ 在 Integer 和 Float 类中分别提供了以下两种方法：​ ① Integer 类（String 转 int 型）```javaint parseInt(String s);```​ s 为要转换的字符串。​ ② Float 类（String 转 float 型）```javafloat parseFloat(String s)```​ **注意：**使用以上两种方法时，字符串中的数据必须由数字组成，否则转换时会出现程序错误。
   3、将整数转换为字符串**​ Integer 类有一个静态的 toString() 方法，可以将整数转换为字符串
   4、Object类​ Object 是 Java 类库中的一个特殊类，也是所有类的父类。也就是说，Java 允许把任何类型的对象赋给 Object 类型的变量。当一个类被定义后，如果没有指定继承的父类，那么默认父类就是 Object 类。因此，以下两个类表示的含义是一样的。
   5、toString() 方法​ toString() 方法返回该对象的字符串，当程序输出一个对象或者把某个对象和字符串进行连接运算时，系统会自动调用该对象的 toString() 方法返回该对象的字符串表示。​ Object 类的 toString() 方法返回“运行时类名@十六进制哈希码”格式的字符串，但很多类都重写了 Object 类的 toString() 方法，用于返回可以表述该对象信息的字符串。
   6、equals() 方法​ 在前面学习字符串比较时，曾经介绍过两种比较方法，分别是`==`运算符和 equals() 方法，`==`运算符是比较两个引用变量是否指向同一个实例，equals() 方法是比较两个对象的内容是否相等，通常字符串的比较只是关心内容是否相等。
   7、getClass() 方法​ getClass() 方法返回对象所属的类，是一个 Class 对象。通过 Class 对象可以获取该类的各种信息，包括类名、父类以及它所实现接口的名字等。
   8、Integer类​ Integer 类在对象中包装了一个基本类型 int 的值。Integer 类对象包含一个 int 类型的字段。此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。## 1、Integer 类的构造方法​ Integer 类中的构造方法有以下两个：​ **Integer(int value)：**构造一个新分配的 Integer 对象，它表示指定的 int 值。​ **Integer(String s)：**构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。

1. Integer 类的常量​ Integer 类包含以下 4 个常量。​ **MAX_VALUE：**值为 231-1 的常量，它表示 int 类型能够表示的最大值。​ **MIN_VALUE：**值为 -231 的常量，它表示 int 类型能够表示的最小值。​ **SIZE：**用来以二进制补码形式表示 int 值的比特位数。​ **TYPE：**表示基本类型 int 的 Class 实例。
   10、Float 类的构造方法​ Float 类中的构造方法有以下 3 个。​ **Float(double value)：**构造一个新分配的 Float 对象，它表示转换为 float 类型的参数。​ **Float(float value)：**构造一个新分配的 Float 对象，它表示基本的 float 参数。​ **Float(String s)：**构造一个新分配的 Float 对象，它表示 String 参数所指示的 float 值。
   11、Float 类的常用常量​ 在 Float 类中包含了很多常量，其中较为常用的常量如下。​ **MAX_VALUE：**值为 1.4E38 的常量，它表示 float 类型能够表示的最大值。​ **MIN_VALUE：**值为 3.4E-45 的常量，它表示 float 类型能够表示的最小值。​ **MAX_EXPONENT: **有限 float 变量可能具有的最大指数。​ **MIN_EXPONENT：**标准化 float 变量可能具有的最小指数。​ **MIN_NORMAL：**保存 float 类型数值的最小标准值的常量，即 2-126。​ **NaN：**保存 float 类型的非数字值的常量。​ **SIZE：**用来以二进制补码形式表示 float 值的比特位数。​ **TYPE：**表示基本类型 float 的 Class 实例。
   12、Double类​ Double 类在对象中包装了一个基本类型 double 的值。Double 类对象包含一个 double 类型的字段。此外，该类还提供了多个方法，可以将 double 类型与 String 类型相互转换，同时 还提供了处理 double 类型时比较常用的常量和方法。## 1、Double 类的构造方法​ Double 类中的构造方法有如下两个。​ **Double(double value)：**构造一个新分配的 Double 对象，它表示转换为 double 类型的参数。​ **Double(String s)：**构造一个新分配的 Double 对象，它表示 String 参数所指示的 double 值。
   13、Number类​ Number 是一个抽象类，也是一个超类（即父类）。Number 类属于 java.lang 包，所有的包装类（如 Double、Float、Byte、Short、Integer 以及 Long）都是抽象类 Number 的子类。
   14、在 validateUser() 方法中，使用 for 循环遍历用户输入的用户名、密码和年龄，对其每个字符进行验证，判断其是否符合要求。在验证的过程中，分别使用了 Character 类的 isLetter() 方法、isLetterOrDigit() 方法和 isDigit() 方法。
   15、Byte 类的构造方法​ Byte 类提供了两个构造方法来创建 Byte 对象。

第十周

Error和Exception

Error(错误)我们不可以解决

Exception（异常）我们可以解决

它们讲个都是java.lang.Throwable类的子类，只有继承了Throwble类的实例才能被throw（抛）和catch（捕获）

Try catch语句

Try catch finally语句

异常的声明和抛出

Throws

集合简介

List集合

List是一个有序的（存放和取出是有序的），可重复的集合（元素可重复）

List实现了collection接口，它主要有两个常用的实现类，ArrayList类和LinkedList

ArrayList类实现了可变数组的大小，存储在内的数据称为元素

ArrayList特点

优点:查询效率极快，基于数组实现的

缺点：添加元素慢（增，删，改）

LinkedList类

Set集合

HashSet类

它是set接口的典型实现，用到set接口的时候一般用该类来实现，

HashSet的特点：

1. 不能保证元素的排列顺序，顺序可能与添加的顺序不同，可能改变
2. HashSet不是同步的，如果有多分个线程来访问或修改一个HashSet，必须通过代码来保证其同步，

3.集合元素可以为Null

TreeSet类

List集合与Set集合的区别：List（有序），Set（无序）

{存放的顺序与取出的顺序}

Map集合