多态与抽象

原创 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指向的不是男性对象");
  }
  
 
 }

}

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

抽象类多态接口

  • 2008-07-19 17:03
  • 1.70MB
  • 下载

抽象类、接口、多态特性

1. 抽象类本身不能被实例化,可以没有抽象方法 2. 父类与接口有相同的方法时,不会产生冲突,因为只会有一份方法的实现 package com.yjq.cn.interface public abs...

多态,抽象类,接口

多态 定义:某一类事物的多种存在形态,也可以理解为事物存在的多种体现形态。 体现:父类引用或者接口的引用指向了自己的子类对象。例如:Animal a = new Cat();动物是猫具体事...

C#第06类,抽象类,多态

  • 2009-03-15 10:53
  • 350KB
  • 下载

使用抽象方法实现多态

  • 2009-04-22 17:02
  • 66KB
  • 下载

final关键字、多态、抽象类、接口的特点及其使用

1:final关键字 (1)是最终的意思,可以修饰类,方法,变量。 (2)特点: A:它修饰的类,不能被继承。 B:它修饰的方法,不能被重写。 ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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