面向对象常用关键字的使用
1：this：表示当前对象
（1）this.属性/this.方法
- 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式
- 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，
- 在某个方法中把this作为返回值，则可以多次连续调用同一个方法，从而使代码更加简洁。
（2）this调用构造器
- 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
- 构造器中不能通过"this(形参列表)"方式调用自己
- 规定："this(形参列表)"必须声明在当前构造器的首行
- 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器
2：super：表示父类的引用
（1）super.属性/super.方法
我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
- 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
- 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
（2）构造器：super()或super(实参列表）
super调用构造器：
1：我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
2："super(形参列表)"的使用，必须声明在子类构造器的首行！
3： 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)“只能二一，不能同时出现
4：在构造器的首行，没显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()
5：在类的多个构造器中，至少一个类的构造器中使用了"super(形参列表)”，调用父类中的构造器
3： static：静态的
- static相当于一个标志，有static修饰的成员属于类本身，没有static修饰的属于该类的实例
- 修饰属性、方法、代码块、内部类
4： final：最终的
5：instanceof：
- 表示某个对象是否是本类或本类的子类的对象
6：extends：表示继承
7： abstract：抽象
abstract class 几何图形类{
public abstract double getArea();
}
class 圆 extends 几何图形类{
private double 半径;
public double getArea(){
return Math.PI * 半径 * 半径;
}
}
class 矩形 extends 几何图形类{
private double 长;
private double 宽;
public double getArea(){
return 长 * 宽;
}
}
原因：
（1）从逻辑角度
几何图形类中，应该包含所有几何图形共同的特征
那么所有几何图形，就应该包含 “获取面积”的功能
（2）语法角度
通过“几何图形”类对圆对象，矩形对象等的多态引用，
应该是可以调用“获取面积”的方法，如果父类中没有声明该方法，
就无法调用，无法实现多态引用
（1）抽象类
在父类中明确子类应该包含某些方法，但是在父类中又不能给出具体的实现，父类中只能把这个方法声明为抽象方法
格式【修饰符】 abstract class 抽象类的名称{
类的成员列表
}
abstract class A {
abstract void m1();
public void m2() {
System.out.println("A类中定义的m2方法");
}
}
class B extends A {
void m1() {
System.out.println("B类中定义的m1方法");
}
}
public class RecursionTest {
public static void main(String args[]) {
A a = new B();
a.m1();
a.m2();
}
}
编译结果：
B类中定义的m1方法
A类中定义的m2方法
（2）抽象方法
【修饰符】 abstract 返回值类型 方法名（形参列表）;
- 声明一个方法但不提供实现，该方法的实现由子类提供
- 抽象方法只有方法的声明，没方法体
- 若子类重写了父类中的所的抽象方法后，此子类方可实例化
- 若子类没重写父类中的所的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
（3）抽象类的应用
模板设计模式：在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式
abstract class Template{
//计算某段代码执行所需要花费的时间
public void spendTime(){
long start = System.currentTimeMillis();//开始时间
this.code();//不确定的部分、易变的部分
long end = System.currentTimeMillis();//结束时间
System.out.println("花费的时间为：" + (end - start));
}
public abstract void code();
}
class SubTemplate extends Template{
@Override
public void code() {
for(int i = 2;i <= 1000;i++){
boolean isFlag = true;
for(int j = 2;j <= Math.sqrt(i);j++){
if(i % j == 0){
isFlag = false;
break;
}
}
if(isFlag){
System.out.println(i);
}
}
}
}
