Java基础知识笔记整理

Java三大版本

• JavaSE：标准版（桌面程序，控制台开发）
• JavaME：嵌入式开发（手机，小家电）
• JavaEE：E企业级开发（Web端，服务器开发）

JDK、JRE、JVM

JDK简介

• JDK是Java Development Kit的缩写，是Java的开发工具包。

• JDK : Java Development ToolKit(Java开发工具包)。JDK是整个JAVA的核心，包括了Java运行环境（JRE），Java工具（javac/java/jdb等）和Java基础的类库（即Java API ）。

JRE简介

• JRE是Java运行环境，并不是一个开发环境，所以没有包含任何开发工具（如编译器和调试器），只是针对于使用Java程序的用户。

• JRE（Java Runtime Environment，Java运行环境），包含JVM标准实现及Java核心类库。 JRE中包含了Java virtual machine（JVM），runtime class libraries和Java application launcher，这些是运行Java程序的必要组件。通过它，Java的开发者才得以将自己开发的程序发布到用户手中，让用户使用。

JVM简介

• JVM是Java Virtual Machine（Java虚拟机）的缩写，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

• JVM(Java Virtual Mechinal)，Java虚拟机，是JRE的一部分。它是整个java实现跨平台的最核心的部分，负责解释执行字节码文件，是可运行java字节码文件的虚拟计算机。所有平台的上的JVM向编译器提供相同的接口，而编译器只需要面向虚拟机，生成虚拟机能识别的代码，然后由虚拟机来解释执行。

• 当使用Java编译器编译Java程序时，生成的是与平台无关的字节码，这些字节码只面向JVM。不同平台的JVM都是不同的，但它们都提供了相同的接口。JVM是Java程序跨平台的关键部分，只要为不同平台实现了相应的虚拟机，编译后的Java字节码就可以在该平台上运行。

三者联系以及区别

三者联系

• JVM不能单独搞定class的执行，解释class的时候JVM需要调用解释所需要的类库lib。在JDK下面的的jre目录里面有两个文件夹bin和lib,在这里可以认为bin里的就是jvm，lib中则是jvm工作所需要的类库，而jvm和 lib和起来就称为jre。JVM+Lib=JRE。总体来说就是，我们利用JDK（调用JAVA API）开发了属于我们自己的JAVA程序后，通过JDK中的编译程序（javac）将我们的文本java文件编译成JAVA字节码，在JRE上运行这些JAVA字节码，JVM解析这些字节码，映射到CPU指令集或OS的系统调用。

三者区别

• JDK和JRE区别：在bin文件夹下会发现，JDK有javac.exe而JRE里面没有，javac指令是用来将java文件编译成class文件的，这是开发者需要的，而用户（只需要运行的人）是不需要的。JDK还有jar.exe, javadoc.exe等等用于开发的可执行指令文件。这也证实了一个是开发环境，一个是运行环境。
• JRE和JVM区别：JVM并不代表就可以执行class了，JVM执行.class还需要JRE下的lib类库的支持，尤其是rt.jar。

Java基础语法

• 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 类：类是一个模板，它描述一类对象的行为和状态。
• 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
• 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

类别	关键字	说明
访问控制	private	私有的
protected	受保护的
public	公共的
default	默认
类、方法和变量修饰符	abstract	声明抽象
class	类
extends	扩充,继承
final	最终值,不可改变的
implements	实现（接口）
interface	接口
native	本地，原生方法（非 Java 实现）
new	新,创建
static	静态
strictfp	严格,精准
synchronized	线程,同步
transient	短暂
volatile	易失
程序控制语句	break	跳出循环
case	定义一个值以供 switch 选择
continue	继续
do	运行
else	否则
for	循环
if	如果
instanceof	实例
return	返回
switch	根据值选择执行
while	循环
错误处理	assert	断言表达式是否为真
catch	捕捉异常
finally	有没有异常都执行
throw	抛出一个异常对象
throws	声明一个异常可能被抛出
try	捕获异常
包相关	import	引入
package	包
基本类型	boolean	布尔型
byte	字节型
char	字符型
double	双精度浮点
float	单精度浮点
int	整型
long	长整型
short	短整型
变量引用	super	父类,超类
this	本类
void	无返回值
保留关键字	goto	是关键字，但不能使用
const	是关键字，但不能使用

注释、标识符、关键字

• 注释
  • 书写注释是一个非常好的习惯
  • 单行注释
  • 多行注释
  • 文档注释
• 标识符
  • 关键字 public，void，else等
  • Java所有的组成部分都需要名字。类名、变量名以及方法名都被成为标识符
  • 不能使用关键字作为变量名或方法名，标识符大小写敏感

数据类型

• 强类型语言：要求变量使用要求严格,所有变量须先定义后使用
• 基本类型

整数	浮点数	字符	布尔值
int	float	char	boolean
byte	double(要在数字后面加F)
short
long(要在数字后面加L)

类型转换

• 因为是强类型语言，所以进行有些运算的时候，需要用到类型转换
• 强制转换：高—>低
• 自动转换：低—>高
• 不能对布尔值进行转换

变量和常量

• 变量是程序中最基本的存储单元，要素包括变量名，变量类型和作用于
• 每个变量都有类型，可以是基本类型也可以是引用类型
• 变量，方法、类名：见名知意
• 类成员变量：首字母小写和驼峰原则，如lastName
• 类名：首字母大写和驼峰原则

运算符

算术运算符	+ , - , * , / ,% , ++ , —
赋值运算符	=
关系运算符	> , < , >= , <= , == , !=instanceof
逻辑运算符	&& , \	\	, !
位运算符	& , \	, ^ , ~ , >> , << , >>>
条件运算符	?: (x?y:z 若x为真则结果为y,否则结果为z)
扩展赋值运算符	+= , -= , *= , /=

包机制

标签	描述	示例
@author	标识一个类的作者，一般用于类注释	@author description
@deprecated	指名一个过期的类或成员，表明该类或方法不建议使用	@deprecated description
{@docRoot}	指明当前文档根目录的路径	Directory Path
@exception	可能抛出异常的说明，一般用于方法注释	@exception exception-name explanation
{@inheritDoc}	从直接父类继承的注释	Inherits a comment from the immediate surperclass.
{@link}	插入一个到另一个主题的链接	{@link name text}
{@linkplain}	插入一个到另一个主题的链接，但是该链接显示纯文本字体	Inserts an in-line link to another topic.
@param	说明一个方法的参数，一般用于方法注释	@param parameter-name explanation
@return	说明返回值类型，一般用于方法注释，不能出现再构造方法中	@return explanation
@see	指定一个到另一个主题的链接	@see anchor
@serial	说明一个序列化属性	@serial description
@serialData	说明通过 writeObject() 和 writeExternal() 方法写的数据	@serialData description
@serialField	说明一个 ObjectStreamField 组件	@serialField name type description
@since	说明从哪个版本起开始有了这个函数	@since release
@throws	和 @exception 标签一样.	The @throws tag has the same meaning as the @exception tag.
{@value}	显示常量的值，该常量必须是 static 属性。	Displays the value of a constant, which must be a static field.
@version	指定类的版本，一般用于类注释	@version info

/**
 * @author ja
 * @version 1.0
 * @since 1.8
*/

#Java流程控制

##用户交互Scanner

• 基本语法：Scanner s=new Scanner(System.in);
• 通过Scanner类的next()与nextLine()方法获取输入的字符串

在读取之前一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据

next()	nextLine()
1.一定要读取到有效字符后才可以结束输入	1.以Enter为结束符也就是说该方法返回的是输入回车之前的所有字符
2.对输入有效字符之前遇到的空白，会自动去掉	2.可以获得空白
3.只有输入有效字符之后才将其后面输入的空白作为分隔符或者结束符
4.next()不能得到带有空格的字符串

##顺序结构

• 基本结构就是顺序结构，是最简单的算法结构
• 语句与语句之间，框与框之间是按从上到下顺序进行，是任何一个算法都离不开的一种基本算法结构

##选择结构

• if 单选择结构

  if(布尔表达式){
      //如果布尔表达式为true将执行的语句
  }
  

• if 双选择结构

  if(布尔表达式){
      //如果布尔表达式为true
  }else{
      //如果布尔表达式为false
  }
  

• if 多选择结构

  if(布尔表达式1){
      //如果布尔表达式1的值为true执行代码
  }else if(布尔表达式2){
      //如果布尔表达式2的值为true执行代码
  }else if(布尔表达式3){
      //如果布尔表达式3的值为true执行代码
  }else{
      //如果以上布尔表达式都不为true执行代码
  }
  

• 嵌套的if结构

  if(布尔表达式1){
      //如果布尔表达式1的值为true执行代码
      if(布尔表达式2){
          //如果布尔表达式2的值为true执行代码
      }
  }
  

• switch多选择结构，类型可以为byte，short，int或者char

  从javase7开始，switch支持字符串String类型

  switch(expression){
      case value:
          //语句
          break;//可选
      case value:
          //语句
          break;//可选
      //数量任意
      default://可选
          //语句
  }
  

##循环结构

• while循环

  while(布尔表达式){
      //循环内容
  }
  

  只要布尔表达式为true，循环一直执行

  大多数是会让循环停止下来的，需要用一个表达式失效来结束；少部分需要循环一直执行，比如服务器请求响应监听等

• do…while循环

  对while而言，不满足条件则不能进入循环，而do…while与此相似但至少会循环一次

  do{
      //代码语句
  }while(布尔表达式);
  

  **区别：**while先判断后执行，dowhile先执行后判断，dowhile总是保证循环体会被至少执行一次。

• for循环

  for(初始化；布尔表达式；更新){
      //代码语句
  }
  

  增强for循环

  for(声明语句：表达式)
  {
      //代码句子
  }
  

##break & continue

• break在任何循环语句的主体部分，均可使用break控制循环流程，break用于强行退出循环，不执行循环中剩余的语句（break语句在switch语句中使用）
• continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行执行循环的判定。

##练习

打印三角形

for (int i = 1; i <= 5; i++) {
    for(int j=5;j>=i;j--){
        System.out.print(" ");
    }
    for(int j=1;j<=i;j++){
        System.out.print("*");
    }
    for(int j=1;j<i;j++){
        System.out.print("*");
    }
    System.out.println();
}

Java方法

##什么是方法

Java方法是语句的集合，它们在一起执行一个功能。

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用

##方法的优点

• 使程序变得更简短而清晰。
• 有利于程序维护。
• 可以提高程序开发的效率。
• 提高了代码的重用性。

##方法的命名规则

• 方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。

##方法的定义

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

• **修饰符：**修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
• 返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
• **方法名：**是方法的实际名称。方法名和参数表共同构成方法签名。
• **参数类型：**参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
• **方法体：**方法体包含具体的语句，定义该方法的功能。

##方法的调用

当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger = max(30, 40);

如果方法返回值是void，方法调用一定是一条语句

System.out.println("欢迎访问菜鸟教程！");

##方法的重载

• 创建另一个有相同名字但参数不同的方法

Java数组

声明数组变量

dataType[] arrayRefVar;   // 首选的方法
 
或
 
dataType arrayRefVar[];  // 效果相同，但不是首选方法

创建数组

Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：

• 一、使用 dataType[arraySize] 创建了一个数组。
• 二、把新创建的数组的引用赋值给变量 arrayRefVar。

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] array = new dataType[arraySize];

另外，你还可以使用如下的方式创建数组。

dataType[] array = {value0, value1, ..., valuek};

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。

处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 For-Each 循环。

示例

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

运行结果

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

---

For-Each 循环

JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

语法格式如下：

for(type element: array)
{
    System.out.println(element);
}

示例

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

运行结果

1.9
2.9
3.4
3.5

---

数组作为函数的参数

数组可以作为参数传递给方法。

例如，下面的例子就是一个打印 int 数组中元素的方法:

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}

---

数组作为函数的返回值

public static int[] reverse(int[] list) {
  int[] result = new int[list.length];
 
  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}

---

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：

String[][] str = new String[3][4];

多维数组的动态初始化

• 直接为每一维分配空间，格式如下：

type[][] typeName = new type[typeLength1][typeLength2];

type 可以为基本数据类型和复合数据类型，typeLength1 和 typeLength2 必须为正整数，typeLength1 为行数，typeLength2 为列数。

int[][] a = new int[2][3];

• 从最高维开始，分别为每一维分配空间，例如：

String[][] s = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

解析：s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间，也就是为最高维限制其能保存数据的最长的长度，然后再为其每个数组元素单独分配空间 s0=new String(“Good”) 等操作。

---

Arrays 类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

• 给数组赋值：通过 fill 方法。

• 对数组排序：通过 sort 方法,按升序。

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

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

具体说明请查看下表：

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

Java面向对象编程（OOP)

初识面向对象

面向过程&面向对象

• 面向过程思想
  • 步骤清晰简单，第一步做什么，第二步做什么….
  • 面对过程适合处理一些较为简单的问题
• 面向对象思想
  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题!
• 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作,仍然需要面向过程的思路去处理。

什么是面向对象

• 面向对象编程(Object-Oriented Programming, OOP)
• 面向对象编程的本质就是:以类的方式组织代码，以对象的形式封装数据。
• 抽象：编程思想!持续的学习，茅塞顿开!多实践,多测试大脑中的想法!实践出真知~
• 三大特性:
  • 封装
  • 继承
  • 多态
• 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
• 从代码运行角度考虑是先有类后有对象。类是对象的模板。

方法回顾和加深

• 方法的定义

  • 修饰符

  • 返回类型

  • break（跳出switch，结束循环）和return的区别

  • 方法名：注意规范就0K，见名知意

  • 参数列表：(参数类型，参数名) ….

  • 异常抛出：throws

    //main方法
    public static void main(String[] args) {
    }
    

     /*
    修饰符 返回值类型 方法名 (...) {
        //方法体
        return返回值;
    }
    */
    //return结束方法，返回一个结果!    void表示没有返回值
    public String sayHello(){
        return "Hello,Word";
    }
    public void print(){
        return;
    }
    public int max(int a,int b){
        return a>b ? a : b; //三元运算符!
    }
    public void readFile(String file) throws IOException {
    }
}
```

• 方法的调用

  • 静态方法

  • 非静态方法

    public class Demo02 {
        //静态方法  static
        //非静态方法
        public static void main(String[] args) {
            //调用Student类的say1，因为say1是静态方法
            Student.say1();
            //如果要调用Student类的say2，就必须实例化Student类 new
            //对象类型 对象名=对象值;
            Student student = new Student();
            student.say2();
        }
        //和类一起加载的
        public static void a () {
            // b();
        }
        //类实例化之后才存在
        public void b () {
        }
    }
    

  //学生类
  public class Student {
      //静态方法
      public static void say1(){
          System.out.println("say1:学生说话了！");
      }
      //非静态方法
      public void say2(){
          System.out.println("say2:学生说话了！");
      }
  }

• 形参和实参

  public class Demo03 {
      public static void main(String[] args) {
          //注意：实际参数和形式参数的类型要对应!
          //调用的第一种，如果方法是非静态的，就去new对象
  //        Demo03 demo03 = new Demo03();
  //        int add = demo03.add(1, 2);
  //        System.out.println(add);
          //调用的第二种，将add方法添加static静态修饰符即可
          //类.方法名()
          int add1 = Demo03.add(2, 3);
          System.out.println(add1);
          //方法名()
  //        int add2 = add(3, 4);
  //        System.out.println(add2);
      }
      //定义两个形式参数a和b
      public static int add(int a,int b){
          return a+b;
      }
  }
  

• 值传递和引用传递

  public static void main(String[] args) {
      Person person = new Person();
      System.out.println(person.name);
      Demo05.change(person);
      System.out.println(person.name);
  }
  public static void change(Person person){
      //person是一个对象:指向的---> Person person = new Person(); 这是一个具体的人，可以改变属性!
      person.name="张三丰";
  }
  

//定义了一个Person类, 有一个属性:name
class Person{
    String name;//默认值为null
}

• this关键字

对象的创建分析

类与对象的关系

• 类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物.
  • 动物、植物、手机、电脑….
  • Person类、Pet类、 Car类等, 这些类都是用来描述/定义某一类具体的事物应该具备的特
    点和行为
• 对象是抽象概念的具体实例
  • 张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。
  • 能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念.

我们可以将这些思想转换为代码实现!

创建与初始化对象

• 使用new关键字创建对象
• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
  • 1.必须和类的名字相同
  • 2.必须没有返回类型,也不能写void
• 构造器必须要掌握

//学生类
public class Student {
    //属性:字段
    String name;//没有赋值，默认为null
    int age;//没有赋值，默认为0
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

构造器

• 构造器:
  • 和类名相同
  • 没有返回值
• 作用：
  • new本质在调用构造方法
  • 初始化对象的值
• 注意点:
  定义有参构造之后，如果想使用无参构造，需要显示的定义一个无参的构造

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    public Person(){
//        this.name = "张三丰";
    }
    //有参构造:一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }
}

面向对象三大特性

1、封装

• 该露的露，该藏的藏
  • 我们程序设计要追求**“高内聚，低耦合”**。
    • 高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉;
    • 低耦合：仅暴露少量的方法给外部使用。
• 封装(数据的隐藏)
  • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
• 记住这句话就够了:属性私有，get/set

封装的优点

1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了

Student类

//类     private:私有
public class Student {
    //属性私有
    private String name;//名字
    private int age;//年龄
    private int idCard;//学号
    private char sex;//性别
    //提供一些可以操作这个属性的方法!
    //提供一些public 的get、set方法
    //get获得这个数据
    public String getName() {
        return name;
    }
    //set给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age>120||age<0){ //不合法
            this.age = 3;
        }else{
            this.age = age;
        }
    }
    public int getIdCard() {
        return idCard;
    }
    public void setIdCard(int idCard) {
        this.idCard = idCard;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    //学习（）
    //睡觉（）
}

Application类

package com.oop.demo04;
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("青龙");
        System.out.println(s1.getName());
        s1.setAge(99);
        System.out.println(s1.getAge());
    }
}

2、继承

• 继承的本质是对某一 批类的抽象,从而实现对现实世界更好的建模。

• extends的意思是“扩展”。子类是父类的扩展。

• 当当前类被final修饰时，当前类不能被继承

• JAVA中类只有单继承，没有多继承!

• 继承是类和类之间的一种关系。除此之外类和类之间的关系还有依赖、组合、聚合等。

• 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。 子类继承父类,使用关键字extends来表示。

• 子类和父类之间,从意义上讲应该具有”is a”的关系.

• object类

• super

• 方法重写

• super注意点:

  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super必须只能出现在子类的方法或者构造方法中!
  3. super和 this不能同时调用构造方法!

• Vs this:

  • 代表的对象不同:
    • this:本身调用者这个对象
    • super:代表 父类对象的应用
  • 前提
    • this:没有继承也可以使用
    • super:只能在继承条件才可以使用
  • 构造方法
    • this() ; 本类的构造
    • super():父类的构造

重写

• 重写:需要有继承关系，子类重写父类的方法!
  1.方法名必须相同
  2.参数列表列表必须相同
  3.修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
  4.抛出的异常:范围，可以被缩小，但不能扩大;ClassNotFoundException —>Exception(大)
• 重写，子类的方法和父类必要一致;方法体不同!
• 为什么需要重写:
  1. 父类的功能，子类不一定需要，或者不一定满足!

父类（这里的案例是B类）

//重写都是方法的重写，和属性无关
public class B {
    public  void test(){
        System.out.println("B==>test()");
    }
}

子类（A类）

public class A extends B{
    //Override重写
    @Override //注解:有功能的注释!
    public  void test(){
        System.out.println("A==>test()");
    }
}

Application

public class Application {
    public static void main(String[] args) {
        //静态的方法和非静态的方法区别很大!
        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();
        //父类的引用指向了子类
        B b = new A();
        b.test();
        /*
        输出结果:
            A==>test()
            A==>test()
        */
    }
}

• 父类中不能被重写的方法有：

  1.带static修饰的方法（static方法属于类，不属于实例）

  2.带final修饰的方法（final常量修饰符）

  3.带private修饰的类，私有类不能重写

3、多态

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
• 多态存在的条件
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象
• 注意:多态是方法的多态，属性没有多态性。
• instanceof (类型转换)引用类型

Person类

public class Person {
    public void run(){
        System.out.println("run");
    }
}

Student类

public class Student extends Person{
    @Override
    public void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

Application类

package com.oop.demo07;
public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();
        //可以指向的引用类型就不确定了:父类的引用指向子类
        //Student能调用的方法都是自己的或者继承父类的!
        Student s1 = new Student();
        //Person父类型，可以指向子类，但是不能调用子类独有的方法(只能将父类强制转换成子类对象
            才能调用)
        //父类引用指向子类对象，
        //在父类new子类，调用时是调用父类，要是子类重写了父类，则调用子类方法
        Person s2 = new Student();
        Object s3 = new Student();
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!
        s2.run();//子类重写了父类的方法，执行子类的方法
        ((Student) s2).eat();
        s1.run();
    }
}

• 多态注意事项:

  • 1.多态是方法的多态，属性没有多态
  • 2.父类和子类，有联系 类型转换异常! ClassCastException!
  • 3.存在条件: 继承关系，方法需要重写，父类引用指向子类对象! Father f1 = new Son();

• static方法，属于类，它不属于实例

• final 常量;

• private 方法;

  父类方法中有static，final，private这三种修饰符，子类不能重写（没办法重写）

多态的总结(核心：抽象面对的一个思想)

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型;
3. 把父类转换为子类，向下转型; 强制转换
4. 方便方法的调用，减少重复的代码!简洁
   封装、组承、多态! 抽象类，接口

简单介绍static

//static
public class Student {
    public static  int age;//静态变量   大多只会出现在多线程
    private double score;//非静态变量
    //下面这个是非静态方法
    public void run(){
        System.out.println("run");
        //go();//非静态方法里可以调用静态方法
    }
    //下面这个是静态方法
    public static void go(){
        System.out.println("go");
    }
    public static void main(String[] args) {
        Student s1 = new Student();
        //静态变量对于类，所有对象（实例）所共享，当直接使用类名去调用变量名，说明这个变量名是static（静态）的
        System.out.println(Student.age);
        //System.out.println(Student.score);会报错，提示score是非静态变量，无法用类名调用。
        System.out.println(s1.age);
        System.out.println(s1.score);
        System.out.println("========================");
        /*
        s1.run();(想使用run()方法，就必须new一个Student，即new一个对象,调用的写法只能是 对象名称.方法名)
        go();(即使没有new一个Student，也可以直接调用go()方法，)
        Student.go();(也可以在go()方法前面加类名，也可以像上面一样不加类名,(不加类名的前提是必须在同一个类下面))
        */
    }
}

匿名代码块/静态代码块

//当下面public class Person写成public final class Person时，表示当前类不能被继承
//final有最终的意思
public class Person {
    //第二个执行，每new一次对象就会执行一次(可以用来赋初始值)
    {
        System.out.println("匿名代码块");
    }
    //第一个执行，并且只执行一次
    static {
        System.out.println("静态代码块");
    }
    //第三个执行，每new一次对象就会执行一次
    public Person() {
        System.out.println("无参构造方法");
    }
    public static void main(String[] args) {
        Person person = new Person();
        /*
        输出结果：
                静态代码块
                匿名代码块
                无参构造方法
         */
    }
}

静态导入包

//静态导入包~
import static java.lang.Math.random;
public class Test {
    public static void main(String[] args) {
        //System.out.println(Math.random());//静态导入包的方法之后，连类名都可以不写了
        System.out.println(random());
        System.out.println(Math.PI);//这里没导入包的方法，所以要写Math
    }
}

抽象类和接口

Java中，类只能单继承，接口可以多继承

抽象类

• abstract修饰符可以用来修饰方法也可以修饰类,
  • 如果修饰方法,那么该方法就是抽象方法;
  • 如果修饰类,那么该类就是抽象类。
• 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
• 抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
• 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
• 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。
• 抽象类中存在无参构造方法

抽象类Action

//abstract  抽象类
public abstract class Action {
    //约束~有人帮我们实现~
    //abstract，抽象方法，只有方法名字，没有方法的实现!
    public abstract void doSomething();
    //1.不能new这个抽象类，只能靠子类去实现它;约束!
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
    public void run(){
        System.out.println("run");
    }
}

普通类A继承抽象类Action

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法~（重写父类的方法），除非把这个类也设置为抽象类
public class A extends Action {
    @Override
    public void doSomething() {
    }
}

接口

• 普通类: 只有具体实现
• 抽象类: 具体实现和规范(抽象方法)都有!
• 接口: 只有规范! 自己无法写方法~专业的约束! 约束和实现分离: 面向接口编程~
• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你…则必须能…的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。
• 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
• OO的精髓，是对对象的抽象，最能体现这一点的就是接口。 为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++. java、 c#等) ，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

注意：

声明类的关键字是class  声明接口的关键字是interface

接口UserService

//interface 定义的关键字  接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的public abstract
    //返回值类型+参数名+(参数有就写，没有就不写)
    /*
    void shout();
    void run(String name);
    */
    //常量~ public static final
    int AGE = 99;
    //接口中的所有定义的方法其实都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

接口TimeService

public interface TimeService {
    void timer();
}

普通类UserServiceImpl实现（也叫继承）UserService,TimeService

//抽象类   extends 只能单继承
//类可以实现接口   implements 接口名  （implement可以多实现，也叫多继承）
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void query(String name) {
    }
    @Override
    public void timer() {
    }
}

接口的作用

1.约束

2.定义一些方法，让不同的人实现~ 10—- >1

3.public abstract  成员方法

4.public static final  成员变量

5.接口不能被实例化，接口中没有构造方法

6.implements可以实现多个接口

7.必须要重写接口中的方法~

面试题

1：

• abstract 不能和哪些关键字共存?
  • private 冲突 — 对子类隐藏,而 abstract 必须让子类重写
  • final 冲突 — 不能被重写,矛盾
  • static 无意义— 类名调用,没有方法体,无意义
• 可以组合的关键字
  • public static
  • public static final

方法前面 public

属性前面 private

2：

• 一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
  • 可以，这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成

总结：类和接口

一、面向对象(接口的概述及其特点)

• A:接口概述
  • 从狭义的角度讲就是指java中的interface
  • 从广义的角度讲对外提供规则的都是接口
• B:接口特点
  • a:接口用关键字interface表示
    • interface 接口名 {}
  • b:类实现接口用implements表示
    • class 类名 implements 接口名 {}
• c:接口不能实例化，那么，接口如何实例化呢?
  • 按照多态的方式来实例化。
• d:接口的子类
  • a:可以是抽象类。但是意义不大。
  • b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

二、面向对象(接口的成员特点)

• 接口成员特点
  • 成员变量；只能是常量，并且是静态的并公共的。 默认修饰符：public static final 建议：自己手动给出。
  • 构造方法：接口没有构造方法。
  • 成员方法：只能是抽象方法。 默认修饰符：public abstract 建议：自己手动给出。

三、面向对象(类与类,类与接口,接口与接口的关系)

• 类与类,类与接口,接口与接口的关系
  • a:类与类：
    • 继承关系,只能单继承,可以多层继承。
  • b:类与接口：
    • 实现关系,可以单实现,也可以多实现。并且还可以在继承一个类的同时实现多个接口。
  • c:接口与接口：
    • 继承关系,可以单继承,也可以多继承。

四、面向对象(抽象类和接口的区别)

• A:成员区别
  • 抽象类：
    • 成员变量：可以变量，也可以常量
    • 构造方法：有
    • 成员方法：可以抽象，也可以非抽象
  • 接口：
    • 成员变量：只可以常量
    • 构造方法：没有
    • 成员方法：只可以抽象
• B:关系区别
  • 类与类
    • 继承，单继承
  • 类与接口
    • 实现，单实现，多实现
  • 接口与接口
    • 继承，单继承，多继承
• C:设计理念区别
  • 抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
  • 接口被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

内部类及OOP实战

• 内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
  • 1.成员内部类
  • 2.静态内部类
  • 3.局部内部类
  • 4.匿名内部类

• 内部类的作用 将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。
• 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
• 当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。

成员内部类

• 把一个类定义在另外一个类当中作为他的成员，与实例变量（也叫属性）实例方法同级别的类

public class Outer {
    private int id = 10;
    public void out(){
        System. out. println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性~
        public void getID(){
            System.out.println(id);
        }
    }
}

Application

public class Application {
    public static void main(String[] args) {
        //new
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

静态内部类

• 把一个类定义在外部类里以static来修饰，目的是为了降低包的深度，方便类的使用，说简单点就是不依靠外部类对象，可直接通过类名来访问，可声明静态成员

public class Outer {
    private int id = 10;
    public void out(){
        System. out. println("这是外部类的方法");
    }
    public static class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
    }
}

Application

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
    }
}

局部内部类

• 把一个类定义在一个方法内，与局部变量类似，局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，也只能在当前方法块中实例化,但是他不能包含任何访问修饰符

public class Outer {
    //局部内部类(方法里面写一个类)
    public void method( ){
        class Inner {
            public void in() {
            }
        }
    }
}
//一个java类中可以有多个class类， 但是只能有一个public class
/*class A{
    public static void main(String[] args) {
    }
}*/

匿名内部类

• 没有名字的内部类（一切特征与局部内部类相同），在使用接口和抽象类的时候使用的比较多，所以匿名内部类只能使用一次，它通常用来简化代码编写 但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

public class Test {
    public static void main(String[] args) {
        /*
        正常情况下我们想调用Apple类中eat方法，我们会先new一个对象，然后初始化类
        Apple apple = new Apple();
        然后用对象名调用eat
        apple.eat();
        但是这里我们不需要去初始化，直接new
        */
        //没有名字初始化类,不用将实例保存到变量中
        new Apple().eat();
        //下面的也叫匿名内部类
        //new UserService()其实是长这样， UserService userService =  new UserService()
        new UserService(){
            @Override
            public void hello() {
            }
        };
    }
}
class Apple {
    public void eat() {
        System.out.println("1");
    }
}
interface UserService{
    void hello();
}

Java异常处理

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；如果你用System.out.println(10/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。

异常发生的原因有很多，通常包含以下几大类：

• 用户输入了非法数据。
• 要打开的文件不存在。
• 网络通信时连接中断，或者JVM内存溢出。

这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。-

要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：

• **检查性异常：**最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
• 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
• 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

Exception 类的层次

所有的异常类是从 java.lang.Exception 类继承的子类。

Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。

Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。

Error 用来指示运行时环境发生的错误。

例如，JVM 内存溢出。一般地，程序不会从错误中恢复。

异常类有两个主要的子类：IOException 类和 RuntimeException 类。

Java 内置异常类

Java 语言定义了一些异常类在 java.lang 标准包中。

标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的，所以大部分从运行时异常类继承而来的异常都可以直接使用。

Java 根据各个类库也定义了一些其他的异常，下面的表中列出了 Java 的非检查性异常。

异常	描述
ArithmeticException	当出现异常的运算条件时，抛出此异常。例如，一个整数"除以零"时，抛出此类的一个实例。
ArrayIndexOutOfBoundsException	用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。
ArrayStoreException	试图将错误类型的对象存储到一个对象数组时抛出的异常。
ClassCastException	当试图将对象强制转换为不是实例的子类时，抛出该异常。
IllegalArgumentException	抛出的异常表明向方法传递了一个不合法或不正确的参数。
IllegalMonitorStateException	抛出的异常表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
IllegalStateException	在非法或不适当的时间调用方法时产生的信号。换句话说，即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。
IllegalThreadStateException	线程没有处于请求操作所要求的适当状态时抛出的异常。
IndexOutOfBoundsException	指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。
NegativeArraySizeException	如果应用程序试图创建大小为负的数组，则抛出该异常。
NullPointerException	当应用程序试图在需要对象的地方使用 null 时，抛出该异常
NumberFormatException	当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
SecurityException	由安全管理器抛出的异常，指示存在安全侵犯。
StringIndexOutOfBoundsException	此异常由 String 方法抛出，指示索引或者为负，或者超出字符串的大小。
UnsupportedOperationException	当不支持请求的操作时，抛出该异常。

下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类。

异常	描述
ClassNotFoundException	应用程序试图加载类时，找不到相应的类，抛出该异常。
CloneNotSupportedException	当调用 Object 类中的 clone 方法克隆对象，但该对象的类无法实现 Cloneable 接口时，抛出该异常。
IllegalAccessException	拒绝访问一个类的时候，抛出该异常。
InstantiationException	当试图使用 Class 类中的 newInstance 方法创建一个类的实例，而指定的类对象因为是一个接口或是一个抽象类而无法实例化时，抛出该异常。
InterruptedException	一个线程被另一个线程中断，抛出该异常。
NoSuchFieldException	请求的变量不存在
NoSuchMethodException	请求的方法不存在

---

异常方法

下面的列表是 Throwable 类的主要方法:

序号	方法及说明
1	public String getMessage() 返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。
2	public Throwable getCause() 返回一个 Throwable 对象代表异常原因。
3	public String toString() 返回此 Throwable 的简短描述。
4	public void printStackTrace() 将此 Throwable 及其回溯打印到标准错误流。。
5	public StackTraceElement [] getStackTrace() 返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。
6	public Throwable fillInStackTrace() 用当前的调用栈层次填充Throwable 对象栈层次，添加到栈层次任何先前信息中。

---

捕获异常

使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。

try/catch代码块中的代码称为保护代码，使用 try/catch 的语法如下：

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。

如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。

下面的例子中声明有两个元素的一个数组，当代码试图访问数组的第四个元素的时候就会抛出一个异常。

import java.io.*;
public class ExcepTest{
 
   public static void main(String args[]){
      try{
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

以上代码编译运行输出结果如下：

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

---

多重捕获块

一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获。

多重捕获块的语法如下所示：

try{
   // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}catch(异常类型3 异常的变量名3){
  // 程序代码
}

上面的代码段包含了 3 个 catch块。

可以在 try 语句后面添加任意数量的 catch 块。

如果保护代码中发生异常，异常被抛给第一个 catch 块。

如果抛出异常的数据类型与 ExceptionType1 匹配，它在这里就会被捕获。

如果不匹配，它会被传递给第二个 catch 块。

如此，直到异常被捕获或者通过所有的 catch 块。

该实例展示了怎么使用多重 try/catch。

try {
    file = new FileInputStream(fileName);
    x = (byte) file.read();
} catch(FileNotFoundException f) { // Not valid!
    f.printStackTrace();
    return -1;
} catch(IOException i) {
    i.printStackTrace();
    return -1;
}

##throws/throw 关键字

如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。

也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。

下面方法的声明抛出一个 RemoteException 异常：

import java.io.*;
public class className
{
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
}

一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。

例如，下面的方法声明抛出 RemoteException 和 InsufficientFundsException：

import java.io.*;
public class className
{
   public void withdraw(double amount) throws RemoteException,
                              InsufficientFundsException
   {
       // Method implementation
   }
   //Remainder of class definition
}

finally关键字

finally 关键字用来创建在 try 代码块后面执行的代码块。

无论是否发生异常，finally 代码块中的代码总会被执行。

在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。

finally 代码块出现在 catch 代码块最后，语法如下：

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}

public class ExcepTest{
  public static void main(String args[]){
    int a[] = new int[2];
    try{
       System.out.println("Access element three :" + a[3]);
    }catch(ArrayIndexOutOfBoundsException e){
       System.out.println("Exception thrown  :" + e);
    }
    finally{
       a[0] = 6;
       System.out.println("First element value: " +a[0]);
       System.out.println("The finally statement is executed");
    }
  }
}

以上实例编译运行结果如下：

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed

注意下面事项：

• catch 不能独立于 try 存在。
• 在 try/catch 后面添加 finally 块并非强制性要求的。
• try 代码后不能既没 catch 块也没 finally 块。
• try, catch, finally 块之间不能添加任何代码。

---

try-with-resources

JDK7 之后，Java 新增的 try-with-resource 语法糖来打开资源，并且可以在语句执行完毕后确保每个资源都被自动关闭 。

JDK7 之前所有被打开的系统资源，比如流、文件或者 Socket 连接等，都需要被开发者手动关闭，否则将会造成资源泄露。

try (resource declaration) {
  // 使用的资源
} catch (ExceptionType e1) {
  // 异常块
}

以上的语法中 try 用于声明和实例化资源，catch 用于处理关闭资源时可能引发的所有异常。

**注意：**try-with-resources 语句关闭所有实现 AutoCloseable 接口的资源。

import java.io.*;

public class RunoobTest {

    public static void main(String[] args) {
    String line;
        try(BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            while ((line = br.readLine()) != null) {
                System.out.println("Line =>"+line);
            }
        } catch (IOException e) {
            System.out.println("IOException in try block =>" + e.getMessage());
        }
    }
}

以上实例输出结果为：

IOException in try block =>test.txt (No such file or directory)

以上实例中，我们实例一个 BufferedReader对象从 test.txt 文件中读取数据。

在 try-with-resources 语句中声明和实例化 BufferedReader 可确语句执行完毕后实例资源，不需要考虑 try 语句是正常执行还是抛出异常。

如果发生异常，可以使用 catch 来处理异常。

再看下不使用 try-with-resources 而改成 finally 来关闭资源，整体代码量多了很多，而且更复杂繁琐了：

import java.io.*;

class RunoobTest {
    public static void main(String[] args) {
        BufferedReader br = null;
        String line;

        try {
            System.out.println("Entering try block");
            br = new BufferedReader(new FileReader("test.txt"));
            while ((line = br.readLine()) != null) {
            System.out.println("Line =>"+line);
            }
        } catch (IOException e) {
            System.out.println("IOException in try block =>" + e.getMessage());
        } finally {
            System.out.println("Entering finally block");
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                System.out.println("IOException in finally block =>"+e.getMessage());
            }
        }
    }
}

以上实例输出结果为：

Entering try block
IOException in try block =>test.txt (No such file or directory)
Entering finally block

try-with-resources 处理多个资源

try-with-resources 语句中可以声明多个资源，方法是使用分号 ; 分隔各个资源：

import java.io.*;
import java.util.*;
class RunoobTest {
    public static void main(String[] args) throws IOException{
        try (Scanner scanner = new Scanner(new File("testRead.txt"));
            PrintWriter writer = new PrintWriter(new File("testWrite.txt"))) {
            while (scanner.hasNext()) {
                writer.print(scanner.nextLine());
            }
        }
    }
}

以上实例使用 Scanner 对象从 testRead.txt 文件中读取一行并将其写入新的 testWrite.txt 文件中。

多个声明资源时，try-with-resources 语句以相反的顺序关闭这些资源。 在本例中，PrintWriter 对象先关闭，然后 Scanner 对象关闭。

---

声明自定义异常

在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。

• 所有异常都必须是 Throwable 的子类。
• 如果希望写一个检查性异常类，则需要继承 Exception 类。
• 如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。

可以像下面这样定义自己的异常类：

class MyException extends Exception{ }

只继承Exception 类来创建的异常类是检查性异常类。

下面的 InsufficientFundsException 类是用户定义的异常类，它继承自 Exception。

一个异常类和其它任何类一样，包含有变量和方法。

以下实例是一个银行账户的模拟，通过银行卡的号码完成识别，可以进行存钱和取钱的操作。

// 文件名InsufficientFundsException.java
import java.io.*;
 
//自定义异常类，继承Exception类
public class InsufficientFundsException extends Exception
{
  //此处的amount用来储存当出现异常（取出钱多于余额时）所缺乏的钱
  private double amount;
  public InsufficientFundsException(double amount)
  {
    this.amount = amount;
  } 
  public double getAmount()
  {
    return amount;
  }
}

// 文件名称 CheckingAccount.java
import java.io.*;
 
//此类模拟银行账户
public class CheckingAccount
{
  //balance为余额，number为卡号
   private double balance;
   private int number;
   public CheckingAccount(int number)
   {
      this.number = number;
   }
  //方法：存钱
   public void deposit(double amount)
   {
      balance += amount;
   }
  //方法：取钱
   public void withdraw(double amount) throws
                              InsufficientFundsException
   {
      if(amount <= balance)
      {
         balance -= amount;
      }
      else
      {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
  //方法：返回余额
   public double getBalance()
   {
      return balance;
   }
  //方法：返回卡号
   public int getNumber()
   {
      return number;
   }
}

//文件名称 BankDemo.java
public class BankDemo
{
   public static void main(String [] args)
   {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500...");
      c.deposit(500.00);
      try
      {
         System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600...");
         c.withdraw(600.00);
      }catch(InsufficientFundsException e)
      {
         System.out.println("Sorry, but you are short $"
                                  + e.getAmount());
         e.printStackTrace();
      }
    }
}

编译上面三个文件，并运行程序 BankDemo，得到结果如下所示：

Depositing $500...

Withdrawing $100...

Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException
        at CheckingAccount.withdraw(CheckingAccount.java:25)
        at BankDemo.main(BankDemo.java:13)

---

通用异常

在Java中定义了两种类型的异常和错误。

• **JVM(Java虚拟机)异常：**由 JVM 抛出的异常或错误。例如：NullPointerException 类，ArrayIndexOutOfBoundsException 类，ClassCastException 类。
• **程序级异常：**由程序或者API程序抛出的异常。例如 IllegalArgumentException 类，IllegalStateException 类。

Java常用类

Object类

• 所有类的父类（超类）位于继承类的最高层.
• 任何类，如果没有书写extends显示继承某个类，都默认继承Object类，否则为间接继承。
• Object类中定义的方法，是所有对象都具备的方法
• Object类型可以存储任何对象（作为参数，可以接受任何对象。作为返回值，可以返回任何对象）

getClass()方法

• 返回引用中存储的实际对象类型
• 应用：通常用于判断两个引用中实际存储对象类型是否一致

public static void main(String[] args){
    Person person1 = new Person("姜老师","20");
    Person person2 = new Person("傲老师","22");
    Class c1 = person1.getClass();
    Class c2 = person2.getClass();
    if(c1==c2){
        System.out.println("相同");
    }else{
        System.out.println("不相同");
    }
}
//结果是不同
//原因：两个new开辟了不同的地址

###hashCode()方法

• 返回对象的哈希码值
• hashCode()返回对象的内存地址（10进制）
• 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
• 一般情况相同对象返回相同的哈希码

public int hashCode(){}

public static void main(String[] args){
    Person person1 = new Person("姜老师","20");
    Person person2 = new Person("傲老师","22");
    Class c1 = person1.getClass();
    Class c2 = person2.getClass();
    if(c1==c2){
        System.out.println("相同");
    }else{
        System.out.println("不相同");
    }
    System.out.println(person1.hashCode());
    System.out.println(person2.hashCode());
}
//hashCode不同
//在内存中开辟了两个对象的地址

toString()方法

• 返回该对象的字符串表示（表现形式）
• 可以根据程序需求覆盖该方法，例如：展示对象各个属性的值

public String toString(){}

equals()方法

• 默认实现为（this == obj ) , 比较两个对象地址是否相同
• 可进行覆盖，比较两个对象的内容是否相同
• 如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址

public boolean equals(Object obj){}

• equals()和==的区别

  • 对象类型不同

    • equals()是Object中的方法， == 是操作符

  • 比较的对象不同

    • equals()：用来检测两个对象是否相等，即两个对象的内容是否相等。

    • ==：用于比较引用和比较基本数据类型时具有不同的功能，具体如下：

    （1）、基础数据类型：比较的是他们的值是否相等，比如两个int类型的变量，比较的是变量的值是否一样。

    （2）、引用数据类型：比较的是引用的地址是否相同，比如说新建了两个User对象，比较的是两个User的地址是否一样。

  • 运行速度不同

    • equals()：没有==运行速度快
    • ==运行速度快，因为只是比较引用。

包装类

• 基本数据类型所对应的的引用数据类型
• Object 可统一所有数据，包装类的默认值是null

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

装箱拆箱

• 基本数据类型的数据都存在栈空间里面
• 而引用类型是存在堆空间里面

装箱
基本类型int num = 666;
使用Integer类创建对象、
方法一Integer integer = new Integer(num);
num传过来成了引用类型了，从栈跑到堆里面了
方法二Integer integer2 = Integer.valueOf(num);

以上的装箱拆箱方法是jdk1.5之前的方法，一般不用，现在是自动装箱拆箱

其实原理还是上面那个int age = 666;
自动装箱Integer integer = age ;
自动拆箱int age2 = integer;

类型转换

• 8种包装类中提供了不同类型间的转换方式
• Number父类中提供的6个共性方法
• parseXXX()静态方法

基本类型转为字符串

int num = 914;   
String str = num + "";
String str = Integer.toString(num);

字符串转成基本类型

String str = "ja";
int num = Integer.parseInt(str);

boolean字符串形式转换为基本类型

String str = "true";
boolean b1 = Boolean.parseBoolean(str);
String str = "aaatrue";
boolean b1 = Boolean.parseBoolean(str);

Integer 缓冲区

• Java 预先创建了256个常用的整数包装类型对象
• 在实际应用当中，对已创建的对象进行复用

Integer integer1 = new Integer(10);    
Integer integer2 = new Integer(10);      
System.out.println(integer1==integer2);//比较的是内存地址返回的是false  

Integer integer3 = 100;    
Integer integer4 = 100;    
System.out.println(integer3==integer4);//100值在-127~128间为true
Integer integer5 = Integer.valueOf(127);    
Integer integer6 = 127;    
System.out.println(integer5==integer6);//-127~128之间为true,超过了则false   

String类

• 创建String常量的两种方式
  • 直接赋值 String name = “ja”；
  • String s = new String(“ja”) ; //这种方法产生两个对象，栈、堆各一个
• 字符串是常量，创建之后不可改变，不是值不可修改，是不能++—之类的

String 类常用方法

方法	解释
public int length():	返回字符串的长度，空格也算字符
public char charAt(int index)	根据下标从0开始下标获取某个位置的字符
public boolean contains(String str)	判断当前的字符串是否包含str
public char[] toCharArray()	将字符串转换成数组
public int indexOf(String str)	返回首次出现的下标，不存在返回-1
public int lastIndexOf(String str)	返回str在最后一次出现的下标，不存在返回
public int compareTo( ）	不相等，按照第一个字符的ASCII码顺序进行比较
public String toUpperCase()	将小写转成大写
public boolean endWith(String str)	判断字符串是否以str结尾
public boolean startWith(String str)	判断字符串是否以str开头
public String trim()	去掉字符串前后的空格，前面和后面不是中间
public String[] split(String str)	根据str拆分，返回值是数组,可为正则表达
public boolean equalsIgnoreCase()	忽略大小写比较
public String substring(int beginIndex)	截取，参数为开始下标（可加结束下标）

可变字符串

StringBuffer  
    //可变长字符串，jdk1.0提供，运行效率慢、线程安全（就是String的增强类）        
    //和String的区别，比String 效率高，节省内存    
    //掌握4个方法    
    /*    append();//追加在后面            
    StringBuffer sb = new StringBuffer("Java");        
    sb.append("牛！");        
    System.out.println(sb);    //结果 Java牛！           
    /*   
    insert() ; //添加            
    sb.insert(0, "学习");        
    System.out.println(sb);    //结果  学习Java牛！
    /*   
    replace(int start,int end,String str); //左闭右开      
    sb.replace(0, 2, "！");            
    System.out.println(sb);    //结果 ！Java牛！         
    /* 
    delete(start , end); 	   //左闭右开                  
    sb.delete(0, 1);       
    System.out.println(sb);    //结果Java牛！       
    */       
StringBuilder（）也是一样的，就是效率比较高
可变长字符串，jdk1.5提供，运行效率快，线程不安全

###三者区别

三者都可以操作字符串。

• String 是不可变字符串对象，每次修改字符串都会创建新对象
• StringBuilder、StringBuffer 是可变字符串序列（对象），StringBuilder 和 StringBuffer 在修改字符串时不会创建新对象
• 当需要对字符串频繁的修改时，推荐使用StringBuilder 或 StringBuffer
  StringBuffer是jkd 1.0 提供的。StringBuilder是jdk 1.5提供的，二者的常用方法名 和实现原理是一样的。区别在于StringBuffer是线程安全的，StringBuilder是线程不安全的。如果不涉及线程安全问题，推荐使用StringBuilder,因为它的效率会更高一些
  执行效率上： StringBuilder 快于 StringBuffer 快于 String

Date类

• Date来表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代（Date不够完美）
• 时间单位
• • 1秒 = 1000毫秒
  • 1毫秒 = 1000微秒
  • 1微秒 = 1000纳秒

Date d1 = new Date();  

方法	描述
boolean after(Date when)	判断此日期是否在指定日期之后
boolean before(Date when)	判断此日期是否在指定日期之前
int compareTo(Date anotherDate)	比较两个日期的顺序
boolean equals(Object obj)	比较两个日期的相等性
long getTime()	返回自 1970 年 1 月 1 日 00:00:00 GMT 以来，此 Date 对象表示的毫秒数
String toString()	Date 对象转换为 String: dow mon dd hh:mm:ss zzz yyyy

##Calendar类

• Calendar提供了获取或者设置各种日历字段的方法
• 构造方法
• • protected Calendar( ) : 由于修饰符是protected ，所以无法直接创建该对象
  • 其他方法

方法	解释
static Calendar getInstance()	使用默认时区或区域获取日历
void set(int year,int month,int date,int hourofday,int minute,int second)	设置日历的时分秒
int get(int filed)	返回给定日历字段的值，字段比如年，月，日等
void settime(Date date)	用给定Date设置此日历的时间，Date-Calendar
Date getTim()	返回一个Date表示日历的时间。Calendar-Date
void add(int file,int amount)	按照日历的规则，给指定字段添加或者减少时间
long getTimeMillies()	毫秒为单位，返回该日历的时间值。

SimpleDateFormat类

• 格式化时间

import java.text.SimpleDateFormat;
import java.util.Date;
 
public class Main{
    public static void main(String[] args){
        Date date = new Date();
        String strDateFormat = "yyyy-MM-dd HH:mm:ss";
        SimpleDateFormat sdf = new SimpleDateFormat(strDateFormat);
        System.out.println(sdf.format(date));
    }
}

System 类

• System 系统类，主要用于获取系统的属性数据和其它操作，构造方法私有的

方法名	说明
static void arrayCopy( … )	复制数组
static long currentTimeMillies( … )	获取当前系统时间毫秒数，返回的是毫秒值
static void gc( )	建议JVM赶快启动垃圾回收器回收垃圾
static void exit( int status)	退出jvm ， 如果参数是0表示正常退出jvm,非0表示异常退出jvm，退出程序

System.arrayCopy( )和Arrays.copyOf( )的关系:

Arrays.copyOf( )在底层用的就是System.arrayCopy( )