Java 基础：多态

 

目录

什么是多态：

多态在编程中的形式

        1.父类类型做形参

         2.父类类型做属性

        3.父类类型做返回值

多态中的成员

---

什么是多态：

                1.面对对象的三大特征：封装、继承、多态。从一定角度来看，封装和继承都是为了多态而服务的

                2.多态的定义：允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（就拿打印机来说，有黑白打印机，有彩色打印机。他们都有打印的功能，但它们打印出来的结果不一样，黑白打印机打印出来的黑白的，彩色打印机打印出来的是彩色的，他们就形成了一种多态，  发送消息就是函数的调用）

                3.同一种类型的对象（同一种父类引用），执行的相同的方法，结果不同

        多态存在的三个必要条件：

• 要有继承；
• 要有重写；
• 父类引用指向子类（向上转型）

                执行过程中，引用对象会根据具体的子类类型来决定执行哪一个方法

代码如下：

        定义一个打印机类（父类）拥有打印功能

public class Printer {
	public void print() {
		System.out.println("打印----------------");
	}
}

        定义一个彩色打印机（子类）拥有彩色打印共功能（重写了父类的打印功能）

public class ColoredPrinter extends Printer {
	@Override
	public void print() {
//		super.print();
		System.out.println("彩色打印------");
	}
}

        上述程序中，第四行super.print()的意思是调用 父类的print()方法，如果父类的方法重写前的方法对你有用的话，可以加这句代码。

        定义一个黑白打印机（子类）拥有黑白打印功能（重写了父类的打印功能）

public class NomalPrinter extends Printer{
	@Override
	public void print() {
//		super.print();
		System.out.println("黑白打印");
		}
}

        定义一个测试类，输出黑白打印机和彩色打印机的打印功能

public class Text {

	public static void main(String[] args) {
		Printer p1 = new NomalPrinter();
		p1.print();
		
		Printer p2 = new ColoredPrinter();
		p2.print();

	}

}

执行结果：

多态在编程中的形式

        1.父类类型做形参

                模拟员工回家的：

    代码如下

        创建一个交通工具类，并定义一个回家的抽象方法

public abstract class Vehicle {
    //创建一个抽象类，并且定义一个抽象方法
	public abstract void run();
}

        抽象类里可以有抽象性方法，也可以没有，但是普通类里是不能写抽象方法的。抽象方法没有方法体，以分号结束，抽象方法的意义是让子类重写。

        创建一个自行车的类，并继承Vehicle类和重写Vehicle类中的方法

public class Bike extends Vehicle{

	@Override
	public void run() {
        //重写抽象类的抽象方法
		System.out.println("自行车行驶中。。。");
		
	}

}

  创建一个公共汽车车的类，并继承Vehicle类和重写Vehicle类中的方法

public class Bus extends Vehicle{

	@Override
	public void run() {
        //重写抽象类的抽象方法
		System.out.println("公交车行驶中。。。");
	}

	
}

        创建一个Employee类

public class Employee {
	
	public void goHome(Vehicle v) {
		v.run();
	}
}

        创建一个测试类

public class Text {

	public static void main(String[] args) {
		Employee e = new Employee();
		e.goHome(new Bus());
		
		System.out.println("==========");
		
		e.goHome(new Bike());

	}

}

执行结果为：

         2.父类类型做属性

                  修改Employee类

public class Employee {
	Vehicle v;
	
	public Employee() {
		
	}

	public Vehicle getV() {
		return v;
	}

	public void setV(Vehicle v) {
		this.v = v;
	}
	
	
	
}

测试

public class Textt {

	public static void main(String[] args) {
		Employee e = new Employee();
		e.setV(new Bus());
		e.getV().run();

	}

}

        3.父类类型做返回值

                  修改Employee类

public class Employee {
	
	public Vehicle choose(int num) {
		Vehicle v = null;
		if(num==1) {
			v = new Bike();
		}else {
			v = new Bus();
		}
		return v;
	}
	
}

测试：
 

public class Textt {

	public static void main(String[] args) {
		Employee e = new Employee();
		e.choose(1).run();;
		System.out.println("======");
		e.choose(2).run();;

	}

}

多态中的成员

        方法：
             普通方法：父类类型    引用=new 子类类型();
             静态方法：不会覆盖

public class Test {
	public static void main(String[] args) {
		Fu fu=new Zi();
		fu.f();
    }
}


class Fu{
	int a=12;
	public static void f() {
		System.out.println("fu static-----------");
	}
}

class Zi extends Fu{
	int a=35;
	public static void f() {
		System.out.println("zi static ---------");
	}
}

执行：

         属性不会被覆盖；

 多态：
         狭义：继承-重写-向上转型----动态的多态
         广义：通过重载来实现----静态的多态