多态与抽象

原创 2015年07月09日 17:30:12


多态与抽象(被abstract这样的可选关键字修饰)
多态:相同的行为,不同的实现(重载、重写,动态绑定),针对的是动作,方法。

给私有属性添加get set方法的好处:
1.隐藏真实属性的存储方式;
2.给外界提供只读或只写方法;
3.在get/set中还可以提供数据校验。

java编程四个时期:编辑,编译(.java->.class),加载(类加载、字节校验),运行(解释器把.class解释给操作系统)

多态是面向对象编程的精髓所在。
多态分为:静态多态(包括重载、重写,指在编译期即决定要执行的效果),动态多态(在编译期不知道多态的效果,要运行起来后根据绑定

对象的不同,得到不同效果的多态)

动态多态的实现:使用动态绑定和重写实现
动态技术包含的技术基础:转型(等号两边数据类型不一致),instanceof关键字。

不是所有的数据类型都可以转换,像类这样的引用数据类型要强转,必须要有继承关系,Object最大,父类(大类型)大于子类(小类型)

基本数据类型转化成引用数据类型,使用Java包装类的工具类Integer
规则:向上转,是自动的;向下转,是强转的。
例如Persion类分为Man类、Woman类,Persion p=new Man()是自动类型转换,父类引用可以指向子类对象,此时P只能访问Persion中的属性

和方法,而看不到子类特有的部分。
再例如,Man man=(Man)(new Persion()),这是强转的,编译期会通过,但运行失败。
而换成:Persion p=new Man();Man man=(Man)p;就不会出现编译错误,这个时候man确实指向Man类一个Mna对象。

结论:强转不一定成功,只有运行起来后确实指向该子类的一个实例才行。父类的引用指向子类的对象,子类的引用不能指向父类对象,本

类对象指向本类对象。

解决:使用instanceof关键字先做判断。

多态的应用:方法的形参是个引用。

抽象类
被abstract关键字修饰,只用在修饰类和方法上,public abstract 与 abstract public 是一样的。
只要在方法声明中写了{ },就表明该方法被实现了;
抽象类不能实例化产生对象,抽象方法只要方法签名,而没有实现。
当一个类拥有类一个抽象方法时,这个类就不能产生对象,这个类就叫抽象类,需要被abstract关键字修饰。
抽象类只能做父类。可以强制要求子类重写抽象方法。
结论:
1.设计时候,有抽象方法的类才被设计成抽象类。但是,语法上,抽象类里面可以没有抽象方法,不过这样子没有意义。
public abctract claa Test{
abstract type method_name(method_array);
}
2.任何子类必须重写抽象方法,除非该子类也是抽象类。越往上层,抽象的等级越高。

抽象类:

package com.lovo.abs;

public abstract class A {
 
 private int aa;
 
 private String bb;
 
 public A(){
  
 }
 
 public abstract void a();
 
 public abstract void b();
 
 public void c(){
  System.out.println("已实现");
 }
 
}

package com.lovo.abs;

public abstract class B extends A{
 
 public void b(){
  
 }
 
}

package com.lovo.abs;

public class C extends B{
 
 public void a(){
  
 }
 
}
多态之动态绑定

package com.lovo.game;

public class Role {
 
 public void attack(Weapon weapon){
  System.out.println("老子弄你!!!");
  weapon.harmEffect();
  if(weapon instanceof Sword){
   Sword sw = (Sword)weapon;
   sw.effectOver();
  }
 }
}

package com.lovo.game;

public class Spear extends Weapon {
 
 @Override
 public void harmEffect() {
  // TODO Auto-generated method stub
  System.out.println("金枪不倒!!");
 }
 
}

package com.lovo.game;

public class Sword extends Weapon{
 
 @Override
 public void harmEffect() {
  // TODO Auto-generated method stub
  System.out.println("一剑封喉!");
 }
 
 public void effectOver(){
  System.out.println("收剑入鞘!");
 }
}


public class GameTest {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Role r = new Role();
  Spear s = new Spear();
  Sword sw = new Sword();
  r.attack(sw);
 }

}


类型转换(继承关系的引用类型)

父类:
public class PersonBean {
 private String name;

 private int age;

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }

 public void hello() {
  System.out.println("同志,你好!");
 }
}

子类A:

package com.lovo.bean;

public class MaleBean extends PersonBean {

 private int height;

 public int getHeight() {
  return height;
 }

 public void setHeight(int height) {
  this.height = height;
 }
 
 public void dance(){
  System.out.println("我们爱跳钢管舞!");
 }

 public void hello() {
  System.out.println("Hi,baby!");
 }
 
 
 @Override
 public boolean equals(Object obj) {
  // TODO Auto-generated method stub
  if(obj instanceof MaleBean){
   MaleBean m = (MaleBean)obj;
   if(this.height == m.getHeight() &&
     this.getName().equals(m.getName()) &&
     this.getAge() == m.getAge()){
    return true;
   }else{
    return false;
   }
   
  }else{
   return false;
  }
 }

}

子类B:

package com.lovo.bean;

public class FemaleBean extends PersonBean {

}


测试:

package com.lovo.test;

import com.lovo.bean.FemaleBean;
import com.lovo.bean.MaleBean;
import com.lovo.bean.PersonBean;

public class TestMain {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  
  PersonBean p = new PersonBean();
  //父类引用指向子类对象,一定成功!
  p = new MaleBean();
//  p = new FemaleBean();
  
//  MaleBean m = (MaleBean)new PersonBean();
  
  if(p instanceof MaleBean){
   //强转不一定成功,必须运行起来以后确实指向该子类对象才能成功
   MaleBean m = (MaleBean)p;
   p.hello();
   m.hello();
  }else{
   System.out.println("p指向的不是男性对象");
  }
  
 
 }

}

对抽象,继承,多态的理解

抽象继承多态是java的核心部分。 抽象就是把事物归类便于管理----比如自然界也是有动物和植物这样分类的,动物下面也有细分,这就是大类小类。把相同点提出来就是抽象。 继承就是把提出来的共同点作为...
  • qq_28040477
  • qq_28040477
  • 2016年07月19日 12:27
  • 309

对封装、抽象、继承、多态的理解?(java四大特性)

封装是把过程和数据包围起来,对数据的访问只能通过自定义的接口,这个可以保护里面的数据和结构不被修改。继承是实现代码复用的重要手段,Java的继承具有单继承的特点,每一个子类只允许有一个父类。通过继承子...
  • u014316462
  • u014316462
  • 2016年07月23日 21:39
  • 2781

七:Java之封装、抽象、多态和继承

本文章介绍了关于Java中的面向对象封装、抽象、继承、多态特点 Java面向对象主要有四大特性:封装、抽象、继承和多态。...
  • u010893129
  • u010893129
  • 2014年06月28日 15:22
  • 3042

面向对象(多态,抽象类,接口的比较)

(一)面向对象(多态) 多态概述: 多态实质上是同一个对象相应不同消息的能力,你理解不了也可以把它理解为事物存在的多种形态. 当然了能够理解实质当然更好. 多态的前提: 要有继承关系, 要有方法重...
  • tongzhengtong
  • tongzhengtong
  • 2015年09月10日 23:32
  • 1556

对封装、继承、多态、抽象的理解

封装是面向对象的重要原则;继承是面向对象最显著的一个特性;多态指允许不同的对象对同一个消息做出相应;抽象表示对问题领域进行分析、设计中得出的抽象的概念。...
  • qq598535550
  • qq598535550
  • 2016年10月31日 17:25
  • 6284

JAVA的抽象、封装、继承、多态

面向对象的四种状态? 抽象:就是把现实生活中的某一类东西提取出来,用程序代码表示,我们通常叫做类或者接口。抽象包括两个方面:一个是数据抽象,一个是过程抽象。数据抽象也就是对象的属性。过程抽象是对象的...
  • xieqian923
  • xieqian923
  • 2012年11月14日 16:42
  • 4825

java中,什么是封装,继承,多态和抽象,好处与用法

Java的四大特性分别是封装,继承,多态与抽象。 1.封装 封装的概念:把对象的属性和方法结合成一个独立的整体,隐藏实现细节,并提供对外访问的接口。 封装的好处:...
  • hs2201056
  • hs2201056
  • 2017年03月11日 23:56
  • 1617

Java 多态的理解(使用抽象类)

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势,很好的解决了应用程序函数同名问题。 多态有两种表现形式:重载和覆盖...
  • u012289441
  • u012289441
  • 2014年09月19日 15:57
  • 902

java面向对象的四大特性-多态,继承,抽象,封装

1.多态 面向对象的四大特性:封装、继承、多态、抽象。从一定角度来看,封装和继承几乎都是为多态而准备的。是最重要的知识点。多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对...
  • basycia
  • basycia
  • 2016年07月07日 12:54
  • 4146

多态、抽象

多态:对象的多种形态; 多态的概念在很多面向对象的语言都存在; 在生物学中,多态指的是生物攒在的很多形态与阶段; OOP:一个对象又有多种形式,相同的行为不同表象形式; java多态分...
  • MR_FENGG
  • MR_FENGG
  • 2017年07月31日 15:06
  • 91
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:多态与抽象
举报原因:
原因补充:

(最多只允许输入30个字)