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();
}
}
实现没有搞清楚用继承设计到底讲的什么,求大神指教