1、抽象类(abstract class)
abstract class指的是用关键字abstract修饰的类,叫做抽象类,是不允许实例化的类,不能直接创建对象,必须要通过子类创建才能使用abstract类的方法。
abstract不能修饰属性。
抽象类是不允许实例化的类,因此一般它需要被进行扩展继承。
在类声明中使用abstract修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。
总结:
1、抽象类是不能被实例化的,实例化的工作应该交由它的子实现类来完成,它只需要有一个引用即可(抽象类就是为了被继承而存在的)。
2、一个类中如果有抽象方法,则这个类必须定义成抽象类(有抽象方法的类必定是抽象类,抽象类不一定要有抽象方法)。
3、抽象类中可以包含具体的实现方法。
4、抽象类可以继承抽象类,子抽象类可以不用重写父抽象类抽象方法。但可以实现父抽象类的抽象方法
5、子实现类继承了抽象类,必须实现抽象类中定义的所有抽象方法。
6、如果子实现类/子抽象类重写父抽象类具体实现方法,将覆盖父方法实现。
(abstract不能与final并列修饰同一个类。abstract不能与private、static、final或native并列修饰同一个方法)、、
动物抽象类
package com.ershuai.stu.other.abstractClass;
public abstract class Animal {
private String name;
private String color;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public abstract void intro();
public abstract void bite();
}
宠物抽象类
package com.ershuai.stu.other.abstractClass;
public abstract class Pet extends Animal {
public double sellPrice;
public double getSellPrice() {
return sellPrice;
}
public void setSellPrice(double sellPrice) {
this.sellPrice = sellPrice;
}
public void suggest() {
System.out.println("如果你考虑养只宠物,建议领养哦…");
}
@Override
public void bite() {
System.out.println(this.getName() + " pet: 我是宠物,我不咬人…");
}
public abstract void hair(String hair);
}
狗狗实现类
package com.ershuai.stu.other.abstractClass;
public class Dog extends Pet {
@Override
public void intro() {
System.out.println("我是一只" + this.getColor() + this.getName());
System.out.println("¥" + this.getSellPrice());
super.bite();
this.suggest();
}
@Override
public void hair(String hair) {
System.out.println(this.getName() + ":" + hair);
}
}
猫猫实现类
package com.ershuai.stu.other.abstractClass;
public class Cat extends Pet {
public Cat() {}
public Cat(String name, String color, double sellPrice) {
this.setName(name);
this.setColor(color);
this.setSellPrice(sellPrice);
}
@Override
public void intro() {
System.out.println("我是一只" + this.getColor() + this.getName());
System.out.println("¥" + this.getSellPrice());
bite();
this.suggest();
}
@Override
public void bite() {
System.out.println(this.getName() + " cat: 我是宠物,我不咬人…");
}
@Override
public void hair(String hair) {
System.out.println(this.getName() + ":" + hair);
}
}
测试方法
package com.ershuai.stu.other.abstractClass;
/**
*
* @author ershuai
* @date 2017年6月14日 下午4:45:21
*/
public class Test0 {
public static void main(String[] args) {
Pet dog = new Dog();
dog.setName("狗狗");
dog.setColor("黑");
dog.setSellPrice(3000.00);
dog.intro();
dog.hair("我是长毛,我要脱毛…");
System.out.println("\r**************************\r");
Pet cat = new Cat();
cat.setName("猫猫");
cat.setColor("黑白");
cat.setSellPrice(2500.00);
cat.intro();
cat.hair("我是短毛,我要脱毛…");
}
}
打印结果
我是一只黑狗狗
¥3000.0
狗狗 pet: 我是宠物,我不咬人…
如果你考虑养只宠物,建议领养哦…
狗狗:我是长毛,我要脱毛…
**************************
我是一只黑白猫猫
¥2500.0
猫猫 cat: 我是宠物,我不咬人…
如果你考虑养只宠物,建议领养哦…
猫猫:我是短毛,我要脱毛…
如果抽象类只有仅仅上面的好处,那感觉和普通的类没有什么大的区别,我们完全可以定义普通类实现,那么抽象类的意义何在呢?
Pet a1 = new Dog();
Pet a2 = new Cat();
为了多态!
2、多态
面向对象编程有三大特性:封装、继承、多态。
多态:多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。
多态是面向对象的重要特性,简单点说:“一个接口,多种实现”,就是同一种事物表现出的多种形态。
现实中,关于多态的例子不胜枚举:比方说按下 F1 键这个动作,如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档;如果当前在 Word 下弹出的就是 Word 帮助;在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。
Java实现多态有三个必要条件:继承、重写、向上转型。
继承:在多态中必须存在有继承关系的子类和父类。
重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。
向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法。
只有满足了上述三个条件,我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象,从而达到执行不同的行为。
对于Java而言,它多态的实现机制遵循一个原则:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。
多态经典实例
public class A {
public String show(D obj) {
return ("A and D");
}
public String show(A obj) {
return ("A and A");
}
}
public class B extends A{
public String show(B obj){
return ("B and B");
}
public String show(A obj){
return ("B and A");
}
}
public class C extends B{
}
public class D extends B{
}
public class Test {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println("1--" + a1.show(b));
System.out.println("2--" + a1.show(c));
System.out.println("3--" + a1.show(d));
System.out.println("4--" + a2.show(b));
System.out.println("5--" + a2.show(c));
System.out.println("6--" + a2.show(d));
System.out.println("7--" + b.show(b));
System.out.println("8--" + b.show(c));
System.out.println("9--" + b.show(d));
}
}
输出
1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D
谢老师
http://www.cnblogs.com/chenssy/p/3376708.html
http://www.cnblogs.com/chenssy/p/3372798.html