抽象类Abstract
抽象类
形状类：三角形 圆形 矩形
父类的方法必须要存在,因为我们多态的必要条件是必须存在方法重写
方法的实现毫无意义
提供一个方法的声明即可,不需要实现,就是抽象方法
抽象类的特点:
1.抽象方法和抽象类使用 abstract 修饰
2.有一个抽象方法的类必须是抽象类
3.抽象类中一定有抽象方法吗? --> 不一定
4.没有抽象方法的抽象类有意义吗? --> 有意义,防止外界创建对象
防止外界实例的方式:
a.构造方法私有
b.抽象类
c.接口
d.内部类
5.抽象类不能够实例化 – 利用多态
6.抽象类的子类的特点:
a.如果子类想要继承抽象类,就必须实现抽象类中所有的抽象方法
b.如果子类不想实现父类的抽象方法,那么子类必须升级为抽象类
7.抽象类和普通类的区别
抽象类中可以有成员变量,成员方法,构造方法,静态方法,常量? 有的话又有什么意义呢?
成员变量 --> 给子类使用
成员方法 --> 给子类使用
构造方法 --> 帮助子类初始化父类继承下来的成员
静态方法 --> 直接通过类名访问,防止创建对象的不建议访问方式
常量 --> 可以,方便访问
抽象类和普通类没有区别,只不过是抽象类多了抽象方法而已
抽象类的抽象方法强制子类重写
非抽象方法直接给子类使用
构造方法和成员变量直接给子类使用
抽象类是一个彻头彻尾的服务类,服务于所有的子类
8.抽象类的成员一般使用 public 或者 protected
9.private final static native 可以用来修饰抽象方法吗?
private修饰的方法不能够被子类继承,更不可能被重写,abstract修饰的方法强制子类重写,二者冲突
final修饰的方法不能够被子类继承,更不可能被重写,abstract修饰的方法强制子类重写,二者冲突
static修饰的方法一般方便调用,一般都是用来实现功能的,抽象方法没有方法体,二者没有意义
native修饰的方法不是Java实现的,有方法体,抽象方法没有方法体,二者没有意义
举例1代码如下所示：
public class AbstractDemo01 {
public static void main(String[] args) {
// Shape s2 = new Shape();
Shape s = new Triangle(2, 3, 4);
System.out.println(s.getPerimeter());
s = new Circle(1);
System.out.println(s.getPerimeter());
Shape.staticMethod();
System.out.println(Shape.NUM);
}
}
abstract class Shape {
public static int NUM = 100;
String name;
public Shape() {}
public Shape(String name) {
this.name = name;
}
public abstract double getPerimeter();
public abstract double getArea() ;
public void setName(String name) {
this.name = name;
}
public static void staticMethod() {
System.out.println("Shape.staticMethod()");
}
}
abstract class Square extends Shape {
}
class Rectangle extends Shape {
double width;
double length;
public Rectangle() {
super();
}
public Rectangle(String name, double width, double length) {
super(name);
this.width = width;
this.length = length;
}
@Override
public double getPerimeter() {
return (width + length) * 2;
}
@Override
public double getArea() {
// TODO Auto-generated method stub
return width * length;
}
}
class Triangle extends Shape {
double a;
double b;
double c;
public Triangle() {
super();
}
public Triangle(double a, double b, double c) {
super();
this.a = a;
this.b = b;
this.c = c;
}
public double getPerimeter() {
return a + b + c;
}
@Override
public double getArea() {
// TODO Auto-generated method stub
return 0;
}
}
class Circle extends Shape {
double r;
public Circle() {
super();
}
public Circle(double r) {
super();
this.r = r;
}
public double getPerimeter() {
return 2 * Math.PI * r;
}
@Override
public double getArea() {
// TODO Auto-generated method stub
return 0;
}
}
举例2代码如下所示：
/*
* 1、编写交通工具类，具有前进run()功能，子类有自行车、小轿车、地铁，重写父类方法，
* 主人有属性name,age属性，方法回家goHome(交通工具)，需要使用交通工具，使用抽象类优化程序。
*/
public class AbstractDemo02 {
public static void main(String[] args) {
Hoster hoster = new Hoster("隔壁老孙", 30);
Vehicle v = new Bike();
hoster.goHome(v);
hoster.goHome(new Car());
new Hoster("隔壁老邓", 31).goHome(new Subway());
}
}
class Hoster {
private String name;
private int age;
public Hoster() {
super();
}
public Hoster(String name, int age) {
super();
this.name = name;
this.age = age;
}
public void goHome(Vehicle v) {
// Vehicle v = new Car();
v.run(this);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
abstract class Vehicle {
public abstract void run();
public abstract void run(Hoster hoster);
}
class Bike extends Vehicle {
@Override
public void run() {
System.out.println("自行车在跑");
}
@Override
public void run(Hoster hoster) {
System.out.println(hoster.getName() + "骑着自行车回家");
}
}
class Car extends Vehicle {
@Override
public void run() {
System.out.println("小轿车在跑");
}
@Override
public void run(Hoster hoster) {
System.out.println(hoster.getName() + "开着小轿车回家");
}
}
class Subway extends Vehicle {
@Override
public void run() {
System.out.println("地铁在跑");
}
@Override
public void run(Hoster hoster) {
System.out.println(hoster.getName() + "坐着地铁回家");
}
}
static、final、abstract比较
