**一、**abstract[抽象的]
1. abstract可以修饰类：
(1) 被 abstract 修饰的类称为抽象类
(2) 语法：
abstract class 类名 {}
(3) 特点：抽象类只能声明引用，不能创建对象
(4) 抽象类中可以定义属性和成员方法、构造方法
2. asbtract可以修饰方法：
(1) 被 asbtract 修饰的方法称为抽象方法
(2) 语法：
访问修饰符 abstract 返回值类型 方法名(形参 );
注意：访问修饰符和abstract 没有先后顺序
(3) 特点：抽象方法只有声明部分，没有方法的实现
(4) 注意：抽象方法只能定义在抽象类中
3. 抽象可以定义子类：
(1) 语法： class 类名 extends 抽象类类名 {}
(2) 特点：子类不想成为抽象类，则必须覆盖父类中所有的抽象方法
**二、**static[静态的]
1. 可以修饰属性：
(1) 被 static 修饰的属性称为静态属性、静态变量、类变量
(2) 语法： static 数据类型 变量名 ;
static 数据类型 变量名 = 值 ;
(3) 特点：静态变量基于类存在，被所有对象共享，和创建对象的多少无关
(4) 使用：
a. 可以通过 对象 . 静态属性名
b. 可以直接通过 类名 . 静态属性名 -> 建议
2.
3. 可以修饰方法：
(1) 被 static 修饰的方法称为静态方法
(2) 语法：
访问修饰符 static 返回值类型 方法名 ( 形参){}
(3) 使用：直接通过 类名 . 静态方法名 ( 实参 );
(4) 注意：静态方法中只能访问本类的静态成员，不能直接访问本类的非静态成员
(5) 静态方法中不能使用 this 和 super 关键字
4. 可以代码块 ：
(1) 被 static 修饰的代码称为静态代码块
(2) 位置：定义在类以内，方法以外，被 static修饰的{}
(3) 语法：
class 类名 {
static{}
}
(4) 作用：在类加载的时候，静态代码块按照和属性定义的先后顺序完成对静态属性的初始化工作
(5) 类加载：当 jvm 第一次使用一个类的时候，通过classpath 找到类对应的 .class 文件，对文件进行读取, 读取该类的包名、类名、父类、属性、构造方法等信息，并将读取的信息保存到jvm 内存中，一个类进行一次类加载。
(6) jvm 类加载的时机 ( 什么叫第一次使用一个类) ：
a. 第一次访问该类的静态成员
b. 第一次创建该类对象：
先进行类加载，再完成对象的创建
c. 子类类加载，先导致其父类类加载
**三、**final[最终的、最后的]
1. final可以修饰变量：
(1) 被 final 修饰的变量作用范围内的常量
(2) final 数据类型 变量名 ;
(3) 特点：只允许一次赋值，不允许修改
(4) 注意：引用一旦被 final 修饰，代表引用中存储的对象不能更换
2. final可以修饰方法：
允许子类继承，但是不允许覆盖
3. final可以修饰类：
被final 修饰的类不允许被继承，没有子类，例如：System 、 Math
思考：System.out.println(); 实现原理？
System -> 类
out -> 静态 属性 - 》对象类型
println() -> 方法
附：练习
1.
编程：定义一个交通工具类(Vehicles)，该类的属性为：商标(brand)、颜色(color);功能方法为：run方法(行驶功能，控制台输出"车已经启动")、showInfo(显示信息，控制台输出商标和颜色)
(1) 编写一个小汽车类(Car)继承于Vehicles类，添加属性座位(seats)；成员方法showCar(显示小汽车的所有信息)
(2) 编写一个卡车类(Truck)继承于Vehicles类，添加属性载重(load)；)成员方法showTruck(显示卡车的所有信息)
(3)定义测试类，分别创建Car对象和Truck对象，控制台打印输出的信息如下：
商标：奔驰，颜色：白色，座位：5
商标：福田，颜色：红色，载重：6.5吨
java
package demo;
public class zuoye7c6{
public static void main(String args[]){
//The Third Demand
Car a = new Car();
Truck b = new Truck();
a.setBrand("奔驰");
a.setColor("白色");
a.setSeats(5);
b.setBrand("福田");
b.setColor("红色");
b.setLoad(6.5);
a.showCar(a.getBrand(),a.getColor(),a.getSeats());
b.showTruck(b.getBrand(),b.getColor(),b.getLoad());
}
}
//父类
class Vehicles{
//1.属性
private String brand;//商标
private String color;//颜色
//封装
public void setBrand(String brand){
this.brand = brand;
}
public String getBrand(){
return brand;
}
public void setColor(String color){
this.color = color;
}
public String getColor(){
return color;
}
//3.功能方法（成员方法）
public void run(){
System.out.println("车已经启动");
}//行驶功能
public void showInfo(String brand,String color){
this.brand = brand;
this.color = color;
System.out.print("商标："+brand+"，颜色："+color);
}//显示信息
}
//子类1
//The First Demand
class Car extends Vehicles{
//1.属性
private int seats;//座位
//封装
public void setSeats(int seats){
this.seats = seats;
}
public int getSeats(){
return seats;
}
//3.功能方法（成员方法）
public void showCar(String brand,String color,int seats){
super.showInfo(brand,color);
this.seats = seats;
System.out.println(",座位："+seats);
}
}
//子类2
//The Second Demand
class Truck extends Vehicles{
//1.属性
double load;//载重
//封装
public void setLoad(double load){
this.load = load;
}
public double getLoad(){
return load;
}
//3.功能方法（成员方法）
public void showTruck(String brand,String color,double load){
super.showInfo(brand,color);
this.load = load;
System.out.println(",载重："+load+"吨");
}
}++至此第九章结束++