本帖最后由 小江哥 于 2018-12-21 12:34 编辑
抽象类介绍
1. 用abstract关键字来修饰一个类时,这个类叫做抽象类;用abstract来修饰一个方法时,改方法叫做抽象方法
2. 含有抽象方法的类必须被声明抽象类,继承抽象类的非抽象子类的抽象方法必须被重写
3. 抽象类不能被实例化
4. 抽象方法只需声明,而不需要实现示例代码:
[Java] 纯文本查看 复制代码 public abstract class Animal {
private String name;
Animal(String name) {
this.name = name;
}
public abstract void enjoy();
}
class Cat extends Animal {
private String eyesColor;
Cat(String n, String c) {
super(n);
eyesColor = c;
}
public void enjoy() {
System.out.println("猫叫:喵喵喵...");
}
}
分析以上代码深入理解抽象类
1. 在子类中实现enjoy方法,这里不需要再写了,因为enjoy方法迟早都要被继承的子类重写,所以没必要在写enjoy
方法的实现,谢了也是白写,写了也不会用它去实现.
2. 在父类里面定义的enjoy方法,可作为父类Animal来说,它并不知道它的子类对象高兴的时候是怎么叫的,而且父类
Animal这个enjoy方法都是要被继承它的子类重写的,既然都是要被重写了,那在父类里面写这个enjoy方法的实现
就没有必要了,所以这个enjoy方法在父类里面只需要声明,不需要实现,即不需要写方法体.
注意:这个enjoy方法的定义是必须要有的,不然继承Animal类的子类就没法重写这个enjoy方法的实现了,没有了
重写那么多态就不能实现了. 所以这个方法只需要去定义,不需要去实现,即这个方法是靠继承Animal类的子类去
实现的,Animal类实现不了这个方法,因为不知道怎么去实现.
分析结论
因此在类Animal里面只需要定义这个enjoy()方法就可以了，使用abstract关键字把enjoy()方法定义成一个抽象方法，定义如下：public abstract void enjoy(); 从某种意义上来说，抽象方法就是被用来重写的，所以在父类声明的抽象方法一定要在子类里面重写。如果真的不想在子类里面重写这个方法，那么可以再在子类里面把这个方法再定义为抽象方法，因为子类觉得我去实现也不合适，应该让继承我的子类去实现比较合适，因此也可以在继承这个子类的下一个子类里面重写在父类里面声明的抽象方法，这是可以的。 这里有一个规则：既然父类里面的方法是抽象的，那么对于整个类来说，它就有一个没有实现的方法，这个方法不知道怎么去实现，那么这个类是就是残缺不全的，因此这个类应该被定义为一个抽象类。所以前面这样声明的声明的class Animal应该要在class的前面加上abstract，即声明成这样：abstract class Animal，这样Animal类就成了一个抽象类了。Animal类的最终定义代码如下： [Java] 纯文本查看 复制代码 /**
* 父类Animal
* 在class的前面加上abstract，即声明成这样：abstract class Animal
* 这样Animal类就成了一个抽象类了
*/
abstract class Animal {
public String name;
public Animal(String name) {
this.name = name;
}
/**
* 抽象方法
* 这里只有方法的定义，没有方法的实现。
*/
public abstract void enjoy();
} Java语言规定，当一个类里面有抽象方法的时候，这个类必须被声明为抽象类。 子类继承父类时，如果这个父类里面有抽象方法，并且子类觉得可以去实现父类的所有抽象方法，那么子类必须去实现父类的所有抽象方法，如： [Java] 纯文本查看 复制代码 /**
* 子类Dog继承抽象类Animal，并且实现了抽象方法enjoy
* @author gacl
*
*/
class Dog extends Animal {
/**
* Dog类添加自己特有的属性
*/
public String furColor;
public Dog(String n, String c) {
super(n);//调用父类Animal的构造方法
this.furColor = c;
}
@Override
public void enjoy() {
System.out.println("狗叫....");
}
} 这个父类里面的抽象方法，子类如果觉得实现不了，那么把就子类也声明成一个抽象类，如： [Java] 纯文本查看 复制代码 /**
* 这里的子类Cat从抽象类Animal继承下来，自然也继承了Animal类里面声明的抽象方法enjoy()，
* 但子类Cat觉得自己去实现这个enjoy()方法也不合适，因此它把它自己也声明成一个抽象的类，
* 那么，谁去实现这个抽象的enjoy方法，谁继承了子类，那谁就去实现这个抽象方法enjoy()。
* @author gacl
*
*/
abstract class Cat extends Animal {
/**
* Cat添加自己独有的属性
*/
public String eyeColor;
public Cat(String n, String c) {
super(n);//调用父类Animal的构造方法
this.eyeColor = c;
}
} 这里的子类Cat从抽象类Animal继承下来，自然也继承了Animal类里面声明的抽象方法enjoy()，但子类Cat觉得自己去实现这个enjoy()方法也不合适，因此它把它自己也声明成一个抽象的类，那么，谁去实现这个抽象的enjoy方法，谁继承了子类，那谁就去实现这个抽象方法enjoy()。如： [Java] 纯文本查看 复制代码 /**
* 子类BlueCat继承抽象类Cat，并且实现了从父类Cat继承下来的抽象方法enjoy
* @author gacl
*
*/
class BlueCat extends Cat {
public BlueCat(String n, String c) {
super(n, c);
}
/**
* 实现了抽象方法enjoy
*/
@Override
public void enjoy() {
System.out.println("蓝猫叫...");
}
}完整的测试代码如下： [Java] 纯文本查看 复制代码 package javastudy.summary;
/**
* 父类Animal
* 在class的前面加上abstract，即声明成这样：abstract class Animal
* 这样Animal类就成了一个抽象类了
*/
abstract class Animal {
public String name;
public Animal(String name) {
this.name = name;
}
/**
* 抽象方法
* 这里只有方法的定义，没有方法的实现。
*/
public abstract void enjoy();
}
/**
* 这里的子类Cat从抽象类Animal继承下来，自然也继承了Animal类里面声明的抽象方法enjoy()，
* 但子类Cat觉得自己去实现这个enjoy()方法也不合适，因此它把它自己也声明成一个抽象的类，
* 那么，谁去实现这个抽象的enjoy方法，谁继承了子类，那谁就去实现这个抽象方法enjoy()。
* @author gacl
*
*/
abstract class Cat extends Animal {
/**
* Cat添加自己独有的属性
*/
public String eyeColor;
public Cat(String n, String c) {
super(n);//调用父类Animal的构造方法
this.eyeColor = c;
}
}
/**
* 子类BlueCat继承抽象类Cat，并且实现了从父类Cat继承下来的抽象方法enjoy
* @author gacl
*
*/
class BlueCat extends Cat {
public BlueCat(String n, String c) {
super(n, c);
}
/**
* 实现了抽象方法enjoy
*/
@Override
public void enjoy() {
System.out.println("蓝猫叫...");
}
}
/**
* 子类Dog继承抽象类Animal，并且实现了抽象方法enjoy
* @author gacl
*
*/
class Dog extends Animal {
/**
* Dog类添加自己特有的属性
*/
public String furColor;
public Dog(String n, String c) {
super(n);//调用父类Animal的构造方法
this.furColor = c;
}
@Override
public void enjoy() {
System.out.println("狗叫....");
}
}
public class TestAbstract {
/**
* @param args
*/
public static void main(String[] args) {
/**
* 把Cat类声明成一个抽象类以后，就不能再对Cat类进行实例化了，
* 因为抽象类是残缺不全的，缺胳膊少腿的，因此抽象类不能被实例化。
*/
//Cat c = new Cat("Catname","blue");
Dog d = new Dog("dogname","black");
d.enjoy();//调用自己实现了的enjoy方法
BlueCat c = new BlueCat("BlueCatname","blue");
c.enjoy();//调用自己实现了的enjoy方法
}
}
| 
收藏
淘帖
踩
