java编程思想 -- 多态

一: 向上转型和向下转型

面向对象中的转型只会发生在有继承关系的子类和父类中（接口的实现也包括在这里）。
父类：人    子类：男人
向上转型： Person p = new Man() ; //向上转型不需要强制类型转化
向下转型： Man man = (Man)new Person() ; //必须强制类型转化

 

向上转型  子类创建对象时,可以使用向上转型的形式操作,方法程序的后期维护,  List队列也是使用的向上转型

 

 

package com.wj.interfaceDemo;

/**
 *向上转型
 */
 class People{ //定义一个基类:三个属性和打印属性的方法
	String name ="java",sex="android";//名字和性别
	int age=15;//年龄
	//打印输出
	public void getAll(){
		System.out.println("name:"+name+"  sex:"+sex+"  age:"+age);
	}
	
}

 //子类继承基类
 public class Man extends People{
	 //主方法
	public static void main(String[] args) {
		//向上转型  
		Man p = new Man();
		//调用父类的方法
		p.getAll();
	}
}

 

 

运行结果:

 name:java  sex:android  age:15

 

<!--[if !supportLists]-->2)<!--[endif]-->,向下转型

子类必须强制的转型为父类的数据类型

   向下转型： Man man = (Man)new Person() ; //必须强制类型转化

向上转型子类不需要强制转型为父类的数据类型

 

向下转型不要使用 一下的方式

 

 

A demo =(A) new ManDemo();

demo.getName();

 

/**
 * 向下转型
 */


class ManDemo {
	String name = "android";

	public void getName() {
		System.out.println(name);
	}
}

//A类继承ManDemo
class A extends ManDemo {

}

public class PeopleDemo {
	public static void main(String[] args) {
		// 向下转型
		// cannot convert from ManDemo to PeopleDemo
		// 必须要向上转型,ManDemo不可以转为PeopleDemo
		// PeopleDemo p=new ManDemo();
		// 向下转型必须要是子类才可以转型
		ManDemo demo = new A();
		// 将父类转为子类
		A a = (A) demo;
		// 调用父类的方法
		a.getName();

		// *************第二种转型
		ManDemo demos = new A();
		//使用instanceof控制类型,防止类型不一样的情况
		if(demos instanceof A){
			//转为A
		A aa = (A) demos;
        aa.getName();
		}
	}
}

 运行结果;

     android

   android

 

 

二:多态:允许不同类的对象对同一消息做出处理

package com.wj.interfaceDemo;

//*多态

public class Shape {
	public static void main(String[] args) {
		// 创建对象时使用的是多态
		ShapeMain s = new ShapeMain();
		s = new Circle();
		// 此时的s.draw()调用的是父类还是子类的方法
		s.draw();
	}

}

// 基类
class ShapeMain {
	// 基类定义方法
	public void draw() {
		System.out.println("ShapeMain");
	};
}

// Circle继承基类
class Circle extends ShapeMain {
	@Override
	// 重写基类基类的方法
	public void draw() {
		System.out.println("Circle");
	};
}

 运行结果:

  Circle

 

三;多态的缺陷缺陷 

 

<!--[if !supportLists]-->1)<!--[endif]-->.不能“覆盖” 私有方法 

package com.wj.interfaceDemo;

//覆盖私有的方法

public class PrivateOverride {

	private void f() {
		System.out.println("private f()");
	}

	public static void main(String[] args) {   创建
		PrivateOverride p = new Derived();
		p.f();//调用f()方法
	}
}

class Derived extends PrivateOverride {
	public void f() {
		System.out.println("public f()");
	}
}

 运行结果:

   Private f()

 

   从前面写的程序中一眼就看出执行的结果是:public f(),  但是多态中是不能够覆盖私有方法 如果存在私有的方法就睡直接在前面加上final  执行结果为private f()  ,只有非private的方法才可以被覆盖  这是多态的缺陷之一

 

 

 

<!--[if !supportLists]-->2)<!--[endif]-->缺陷 :不能覆盖域与静态方法

   

   What is a field in java?

 

A field is an attribute. A field may be a class's variable, an object's variable, an object's method's variable, or a parameter of a function.

package com.wj.interfaceDemo;

class Super{
	public int field=0;
	public int getField(){
		return field;	
	}
}


class Sub extends Super{
	public int field=1;
	public int getField(){
		return field;	
	}
	
	public int getSuperField(){
		//调用父类的Field
		return super.field;
		
	}
}

public class FieldAccess {

	public static void main(String[] args) {
		//创建对象	
		Super sup=new Sub();
		System.out.println("sup.field ="+sup.field+"  sup.getField()="+sup.getField());
	   //创建对象
		Sub sub = new Sub();
	   System.out.println("sub.field ="+sub.field+"  sub.getField()="+sub.getField()+" sub.getSuperField() ="+sub.getSuperField());

	}
}

 sup.field =0  sup.getField()=1

sub.field =1  sub.getField()=1 sub.getSuperField() =0

 

3),不能覆盖静态属性和方法

package com.wj.interfaceDemo;
/*
 * 多态性不能覆盖静态方法
 */

class StaticSuper{
	//静态属性
	public static String getName(){
		return "java";
	}
	
	public String getSex(){
		return "男";
	}
	//静态方法
	static int age=10;
}

class StaticSub extends StaticSuper{
	//静态方法
	public static String getName(){
		return "android";
	}
	
	public String getSex(){
		return "女";
	}
	//静态属性
	static int age=7;
}

public class StaticField {

	public static void main(String[] args) {
		//静态属性在多态性中是不能被覆盖的
		StaticSuper s=new StaticSub();
		System.out.println(s.getName());
		System.out.println(s.getSex());
		System.out.println(s.age);
	}
}

 运行结果:

java

女

10

 

四:构造器的执行顺序

   构造器是不同于其它种类的方法,涉及到多态时也是如此,构造器是不具有多态性的,通过static方法,static为隐式的

package com.wj.interfaceDemo;

/*构造器的调用顺序
 */

class Construct1 {
	public Construct1() {
		print();
	}

	private int print() {
		System.out.println("Construct1");
		return 1;
	}
}

class Construct2 extends Construct1 {
	public Construct2() {
		print();
	}

	private int print() {
		System.out.println("Construct2");
		return 2;

	}
}

class Construct3 extends Construct2 {
	public Construct3() {
		print();
	}

	private int print() {
		System.out.println("Construct3");
		return 3;
	}
}

public class Construct {
	public static void main(String[] args) {
	Construct1 c = new Construct3();
	}

}

运行结果:

 Construct1

Construct2

Construct3

 

五:用继承进行设计

package com.wj.interfaceDemo;

/**
 * 用继承设计
 */

class Actor {
	public void act() {
	}
}

class HappyActor extends Actor {
	public void act() {
		System.out.println("HappyActor");
	}
}

class SadActor extends Actor {
	public void act() {
		System.out.println("SadActor");
	}
}

class Stage {
	private Actor actor = new HappyActor();

	public void change() {
		actor = new SadActor();
	}

	public void performplay() {
		actor.act();
	}
}

public class ExtendsDesign {
	public static void main(String[] args) {
		Stage stage = new Stage();
		stage.performplay();
		stage.change();
		stage.performplay();
	}
}

 实现没有搞清楚用继承设计到底讲的什么,求大神指教