黑马程序员——java基础--多态

标签：黑马程序员   java基础   多态   

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

模板方法设计模式：
解决的办法：当功能内部一部分是现实确定，一部分是现实不确定的，这时间不可把不确定的部分暴漏出去，让子类实现。
实例：统计一个程序的的运行时间
思路：程序的结束时间减去程序的开始时间

abstract class Gettime{
	public final void getTime(){//这段功能用final限制
		long start = System.currentTimeMillis();
		runtime();//这部分功能不确定，提取出来，通过抽象方法实现
		long end = System.currentTimeMillis();
		System.out.println("te time:"+(end-start));
	}
	public abstract void runtime();//抽象不确定的功能，让子类复写实现
}
class Demo extends Gettime{
	public void runtime(){//子类复写功能方法
		for(int i=0; i<1000; i++){
			System.out.println(i);
		}
	}
}

class A{
	void show(){
		System.out.println("a");
	}
}
class B{
	int num = 3;
	void print(){
		System.out.println(num);
	}
}
class C extends A,B{//这样是错误的，类不能多继承，之前提到过
	}
但是可以通过接口的多实现来体现：
abstract class A{
	public abstract void show(){
		System.out.println("a");
	}
}
abstract class B{
	public static final int num = 3;
	public abstract void print(){
		System.out.println(num);
	}
}
class C implements A,B{//这样正确的
	}
6.一个类在继承类一个类的同时，还可以实现多个接口，所以接口的出现避免了单继承的局限性，还可以将类进行功能的扩展。
 class A{
	public void show(){
		System.out.println("a");
	}
}
ieterface class B{
	public static final int num = 3;
	public abstract void print(){
		System.out.println(num);
	}
}

class person{
	 void sleep(){
		System.out.println("在床上睡");
	}//这是共性
}
interface class inter{
	abstract void smoking()；//这是特性
	abstract void drink()；//这是特性，这也可以独立成一个接口
}
class smallstudent extends person{
}
class bigstudent extends person inplememts{
	 smoking(){
		System.out.println("smooking");
	}
	drink(){
		System.out.println("drinking");
	}
}
	
public class interDemo{
	public static void main(String args[]){
		smoking s = new smoking();
		System.out.println(s);
	}
}

abstract class Animal{
	abstract void sleep();//共性功能
}
class Cat extends Animal{
	sleep(){
		System.out.println("morning sleep");
	}
	public void catchMouse(){//单独属性
		System.out.println("catchMouse");	
	}
}
class Dog extends Animal{
	sleep(){
		System.out.println("night sleep");
	}
	public void yaoren(){
		System.out.println("yaoren");
	}
}
public class duotaiDemo{
	public static void main(String agrs[]){
		Cat c = new Cat();
		c.sleep();
		c.catchMouse();
		Dog d = new Dog();
		d.sleep();
		d.yaoren();
	}//这样是ok的，但是扩展性比较差，因为猫和狗都是动物，他们有共性的属性，		//在创建对象的时候可以使用Animal创建,并且如果有新的动物加进来的话操作更加麻烦
	public static void function(Cat c){
		c.sleep();
	}
	public static void function(Dog d){
		d.sleep();
	}
}
我们可以这样考虑，
	public static void function(Cat c){
		c.sleep();
	}
	public static void function(Dog d){
		d.sleep();
	}
将这段代码简化：
 	public static void function(Animal A){//这里的Animal A = new Cat()/Dog()
		A.sleep();
	}
main函数可以这样写：
public class duotaiDemo{
	public static void main(String agrs[]){
		function(new Cat);
		A.sleep();
		A.catchMouse();
		function(new Dog);
		A.sleep();
		A.yaoren();
	}
}
实例二：
class A{
	void learn(){
		System.out.println("learn chinese");
	}
	void habit(){
		System.out.println("play pingpang");
	}
}
class B extends A{
	void learn(){
		System.out.println("learn english");
	}
	void write(){
		System.out.println(" write code");
	}
}
class Demo{
	public static void main(String args[]){
		A a = new B();//向上转型
		a.learn();
		a.write();//这是错的，父类没有子类的功能
	
		//如果想要调用猫的特有方法时，如何操作？
		//强制将父类的引用。转成子类类型。向下转型。
		B b = (B)a;//向下转型
		b.write();
		//千万不要出现这样的操作，就是将父类对象转成子类类型。
		//我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。
		//多态自始至终都是子类对象在做着变化。
	}
}

package code;
class fu{
	int num = 4;
	void show(){
		System.out.println("fu");
	}
	void print(){
		System.out.println("num:"+num);
	}
	public static void method(){
		System.out.println("fu.method");
	}
}
class zi extends fu{
	int num = 5;
	void show(){
		System.out.println("zi");
	}
	public static void method(){
		System.out.println("zi.method");
	}
}
public class duotaiDemo {
	public static void main(String args[]){
		fu a = new zi();
		a.show();//zi
		a.print();//num:4
		a.method();//fu.method
	}
}

class mainboard(){
	mainopen(){
		System.out.println("mainopen");
	}
	mainclose(){
		system.out.println("mainclose");
	}
	mainusepci(pci p){
		if(pci != null){
		p.open();
		p.close();
	}
}
interface pci{
	public abstract void open();
	public abstract void close();
}
class netcard implements pci{
	public void open(){
		System.out.println("netcard open");
	}
	public void close(){
		System.out.println("netcard close");
	}
}
class soundcard implements pci{
	public void open(){
		System.out.println("soundcar open");
	}
	public void close(){
		System.out.println("soundcar close");
	}
}
public class mainboardDemo{
	public static void main(String args[]){
		mainboard m = new mainboard();
		m.open();
		m.mainusepci(new netcard());
		m.mainusepci(new soundcard());
	}
}

Object:是所有对象的直接后者间接父类帝。
该类中定义的肯定是所有对象都具备的功能。
Object类中已经提供了对对象是否相同的比较方法。
如果自定义类中也有比较相同的功能，没有必要重新定义。
只要沿袭父类中的功能，建立自己特有比较内容即可,这就是覆盖.

涉及知识点：
	1.equals
	2.instanceof
	3.tostring()
	4.object类
比较两个对象：
class Demo{
	void show(){
		System.out.println("Demo");
	}
}
class objectDemo{
	public static vodi main(String args[]){
	Demo d1 = new Demo();
	Demo d2 = new Demo();
	System.out.println(d1.equals(d2));//输出false，因为d1和d2地址不一样
	//equals用法：d1.equals(d2)
	}
}
比较两个成员变量：
class Demo{
	private int  num = 4;
	Demo(int num){
		this.num = num;
		}
	public boolean equals(object obj){
		Demo d = (Demo)obj;
		return this.num == d.num;
		}
}
class objectDemo{
	public static vodi main(String args[]){
		Demo d = new Demo();
		
	}
}

黑马程序员——java基础--多态

标签：黑马程序员   java基础   多态   

原文地址：http://blog.csdn.net/orangeisnotapple/article/details/41557933