1.抽象类
1.1实例
描述：定义一个抽象类Shape，具有受保护类型的x和y属性，以及公有的抽象方法获得面积。
Rectangle类继承于Shape类，在构造方法中给父类属性x和y初始化，并重写父类中求面积的抽象方法。
Triangle类也继承于Shape类，在构造方法中给父类属性x和y初始化，并重写父类中求面积的抽象方法。
Cube类继承于Rectangle类，独有的属性是height，其构造方法需要调用父类的构造方法完成对x和y的初始化（立方体的底面长和宽），并对height初始化；独有的方法是求体积。
创建上转型对象，求矩形的面积和三角形面积。
创建对象，求立方体的体积。
代码：
Shape类
/**
* 父类Shape，抽象类
*/
public abstract class Shape {
//声明两个受保护类型的属性x、y
protected double x;
protected double y;
//无参构造器
public Shape() {
}
//全参构造器,只做声明， 具体属性初始化到子类中做
public Shape(double x, double y) {
}
//声明了一个抽象方法，抽象方法不能带方法体
public abstract double getArea();
}
Rectangle类
/**
* 矩形子类，继承Shape类，Java是单一继承，只能有一个父类
*/
public class Rectangle extends Shape {
public Rectangle() {
super();
}
public Rectangle(double x, double y) {
//在构造方法中给父类属性x和y初始化，通过super.x和super.y访问父类属性
super.x = x;
super.y = y;
}
//重写父类中的的抽象方法getArea()，求出具体形状的面积
@Override
public double getArea() {
//this.x和 this.y是访问当前对象的x和y属性，此处用super.x*super.y也可以
return this.x * this.y;
}
}
Triangle类
/**
* 三角形子类,继承Shape，实现方式同Rectangle
*/
public class Triangle extends Shape{
public Triangle() {
super();
}
public Triangle(double x, double y) {
super.x = x;
super.y = y;
}
@Override
public double getArea() {
return this.x * this.y * 0.5;
}
}
Cube类
/**
* 立方体子类，继承Rectangle类，为最终类,不再被继承
*/
public final class Cube extends Rectangle {
//声明一个私有属性，为立方体的高
private double height;
public Cube() {
}
public Cube(double x, double y, double height) {
//调用父类构造方法，完成对底面矩形的长、宽的初始化
super(x, y);
//通过this关键字，完成当前立方体对象的高的初始化
this.height = height;
}
//本类独有的成员方法，求体积
public double getVolumn(){
//调用父类的求面积方法，求出底面矩形面积，使用this.height访问当前立方体的高，最终求出立方体的体积
return super.getArea() * this.height;
}
}
主程序ShapeTest
/**
* 主程序，用来测试各种子类及方法
*/
public class ShapeTest {
public static void main(String[] args) {
//通过上转型对象创建一个三角形的对象
Shape shape = new Triangle(4.0, 3.0);
System.out.println("三角形面积是：" + shape.getArea());
//通过上转型对象创建一个矩形的对象
Shape shape1 = new Rectangle(4.0, 3.0);
System.out.println("矩形面积是：" + shape1.getArea());
//通过最终类创建一个立方体对象
Cube cube = new Cube(4.0, 3.0, 2.0);
System.out.println("立方体体积是：" + cube.getVolumn());
}
}
运行结果
运行结果
1.2 注意点
1.super关键字的三个作用
- 访问父类属性
- 调用父类构造方法
- 调用父类成员方法
2. 抽象类的说明
- 抽象类中可以有抽象方法和非抽象方法共存
- 如果一个类中含有抽象方法，则该类一定是抽象类
- 子类如果继承抽象类，必须强制重写父类中的抽象方法！
3.final关键字的说明
- final修饰的变量就是常量
- final修饰的类不能被继承
- final修饰的方法不能被子类重写
2.接口
和抽象类相似，但是更严格
接口中只能有抽象方法
接口中不能声明属性
一个类可以实现多个接口
实例：Fly接口、FlyObject抽象类、Plane类、Bird类、FlyTest类
2.1 新建Fly接口，做法是新建一个class的时候，选择一下Kind类型为interface，如图：
新建接口
Fly接口代码：
/**
* 飞行接口
* 接口中所有的方法都是公有的，抽象的
* 接口中不能定义属性
*/
public interface Fly {
/**
* 省略了public和abstract修饰符的fly方法，返回飞行信息字符串
* @return String
*/
String fly();
}
2.2 新建FlyObject抽象类，实现Fly接口
/**
* 飞行物抽象类，实现了Fly接口
* 抽象类中可以有属性变量
*/
public abstract class FlyObject implements Fly {
//飞行物名称
protected String name;
//飞行时速
protected double speed;
//构造方法，给飞行物的两个属性初始化
public FlyObject(String name, double speed) {
this.name = name;
this.speed = speed;
}
}
2.3 新建Plane类，继承FlyObject抽象类，重写fly()方法
/**
* 飞机类，继承FlyObject抽象类
*/
public class Plane extends FlyObject {
public Plane(String name, double speed) {
//通过super调用父类构造方法
super(name, speed);
}
@Override
public String fly() {
//重写fly抽象方法，返回飞机的飞行信息
return "飞机型号：" + this.name + ",飞行时速：" + this.speed + "km/h";
}
}
2.4 新建Bird类，继承FlyObject抽象类，重写fly()方法
/**
* 飞禽类，继承FlyObject抽象类
*/
public class Bird extends FlyObject {
public Bird(String name, double speed) {
//通过super调用父类构造方法
super(name, speed);
}
@Override
public String fly() {
//重写fly抽象方法，返回飞禽的飞行信息
return "飞禽名称：" + this.name + ",飞行时速：" + this.speed + "km/h";
}
}
2.5 新建FlyTest测试主类，通过接口回调，创建具体实例并输出飞行结果
public class FlyTest {
public static void main(String[] args) {
//通过接口回调，创建一个Plane的实例给接口变量
Fly fly1 = new Plane("波音747", 940.0);
//调用fly()方法，输出飞机的飞行信息
System.out.println(fly1.fly());
//通过接口回调，创建一个Bird的实例给接口变量
Fly fly2 = new Bird("老鹰", 80.8);
//调用fly()方法，输出飞禽的飞行信息
System.out.println(fly2.fly());
}
}
2.6 运行结果
运行结果
