抽象类、多态

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

在这里看结果1、2、3还好理解，从4开始就开始糊涂了，对于4来说为什么输出不是“B and B”呢？      

首先我们先看一句话：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。这句话对多态进行了一个概括。其实在继承链中对象方法的调用存在一个优先级： this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。      

分析：     

从上面的程序中我们可以看出A、B、C、D存在如下关系。

       首先我们分析5，a2.show(c)，a2是A类型的引用变量，所以this就代表了A，a2.show(c),它在A类中找发现没有找到，于是到A的超类中找(super)，由于A没有超类（Object除外），所以跳到第三级，也就是this.show((super)O)，C的超类有B、A，所以(super)O为B、A，this同样是A，这里在A中找到了show(A obj)，同时由于a2是B类的一个引用且B类重写了show(A obj)，因此最终会调用子类B类的show(A obj)方法，结果也就是B and A。      

按照同样的方法我也可以确认其他的答案。      

方法已经找到了但是我们这里还是存在一点疑问，我们还是来看这句话：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。这我们用一个例子来说明这句话所代表的含义：a2.show(b)；      

这里a2是引用变量，为A类型，它引用的是B对象，因此按照上面那句话的意思是说有B来决定调用谁的方法,所以a2.show(b)应该要调用B中的show(B obj)，产生的结果应该是“B and B”，但是为什么会与前面的运行结果产生差异呢？这里我们忽略了后面那句话“但是这儿被调用的方法必须是在超类中定义过的”，那么show(B obj)在A类中存在吗？根本就不存在！所以这句话在这里不适用？那么难道是这句话错误了？非也！其实这句话还隐含这这句话：它仍然要按照继承链中调用方法的优先级来确认。所以它才会在A类中找到show(A obj)，同时由于B重写了该方法所以才会调用B类中的方法，否则就会调用A类中的方法。      

所以多态机制遵循的原则概括为：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法，但是它仍然要根据继承链中方法调用的优先级来确认方法，该优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。 

谢老师

http://www.cnblogs.com/chenssy/p/3376708.html

http://www.cnblogs.com/chenssy/p/3372798.html