1.final关键字

1.1final关键字基本介绍

（1）用来修饰类，在JDK中，被设计为final类的有String、System等。

当用final修改类时，该类成为最终类，无法被继承。简称为“断子绝孙类”。

（2）用来修饰一个方法

当使用final修饰方法时，这个方法将成为最终方法，无法被子类重写。但是，该方法仍然可以被继承。

（3）final修饰变量，

①如果是基本数据类型的变量，则其数值一旦在初始化之后便不能改变；

②如果是对象类型的变量，只能保证它的引用不变，但对象的内容是可以改变的

例如：

class Fu{
      int x = 10;
 }
 public class DemoTest {
     public static void main(String[] args) {
         // 定义引用类型为 final
         final Fu f= new Fu();
         System.out.println(f.x); //输出10      
         //可以为 final的引用类型的值进行改变，实际上只是该对象所对应的地址值不能被改变
         f.x = 100;
         System.out.println(f.x); //输出100
         //但不能对该 final 类型的引用对象的地址值进行改变，下面的就会报错
         f = new Fu();
     }
 }

1.2 使用细节

（1）final修饰的属性又叫常量，一般用XX_XX_XX 来命名

（2）final修饰的属性在定义时，必须赋初值，并且以后不能再修改了

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

//方法体

}

2.abstract关键字

2.1 定义

（1）抽象方法：没有方法体的方法。

（2）抽象类：包含抽象方法的类。

2.2 abstract使用格式

（1）抽象方法

使用 abstract 关键字修饰方法，该方法就成为了抽象方法，抽象方法只包含一个方法名，而没有方法体。

①定义格式：修饰符 abstract 返回值类型 方法名 (参数列表)；

②代码举例：public abstract void run()；

（2）抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。

①定义格式：

abstract class 类名字 {
}

②代码举例：

public abstract class Animal {
  public abstract void run()；
}

2.3 注意事项

（1）抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

（2）抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

（3）抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

（4）抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

3.instanceof关键字

3.1 如何才能知道一个父类引用的对象，本来是什么子类？

格式：对象 instanceof 类名称

这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例

3.2实例

public static void main(String[] args){
  Animal animal = new Dog();//本来是一只狗
  giveMeAPet(new Dog());
}
public static void giveMeAPet(Animal animal){
// 如果希望调用子类特有方法，需要向下转型
// 判断一下父类引用animal本来是不是Dog
if(animal instanceof Dog) {
  Dog dog = (Dog) animal;
  dog.watchHOuse();
}
// 判断一下animal本来是不是Cat
if(animal instanceof Cat){
  Cat cat = (Cat)animal;
  cat.catchMouse();
  }
}

4.static关键字

4.1 概述

关于 static 关键字的使用，它可以用来修饰成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

4.2 定义和使用格式

（1）类变量(静态变量)

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

①类变量：使用 static关键字修饰的成员变量。

②定义格式：static 数据类型 变量名；

③举例：static int numberID；

（2）静态方法

当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单

①类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。

②定义格式：

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

// 执行语句

}

③举例：

public static void showNum() {

System.out.println(“哈哈哈” );

}

静态方法调用的注意事项：

①静态方法可以直接访问类变量和静态方法。

②静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。

③静态方法中，不能使用this关键字。

（3）调用格式

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

// 访问类变量
类名.类变量名；
// 调用静态方法
类名.静态方法名(参数)

4.3 静态代码块

（1）静态代码块：定义在成员位置，使用static修饰的代码块{ }。

（2）位置：类中方法外。

（3）执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

（4）格式

public class ClassName{
static {
// 执行语句
  }
}