Java面向对象_多态

最新推荐文章于 2023-08-11 16:03:22 发布

and-android

最新推荐文章于 2023-08-11 16:03:22 发布

阅读量489

点赞数

分类专栏： Java学习

本文链接：https://blog.csdn.net/u010773245/article/details/8969330

版权

Java学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

多态定义：不同的对象收到同一个消息产生不同的效果；

作用：增加操作的透明性，可理解性和扩展性，增加了软件的灵活性和重用性

效果：用户发送一个信息，而实现的细节有接收对象自行决定

继承中多态必须满足的三个条件：1>有继承关系

2>子类重写父类的方法

3>父类引用指向子类的对象

接口中多态满足的三个条件：

1>有实现关系，指的是有接口，还有类去实现接口；

2>实现类实现了接口中定义的方法

3>接口的引用指向实现对象

多态中成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用方法，如果有编译通过，没有则编译失败；

在运行时期：参阅对象所属的类中是否有调用的方法；

例：Animal a = new Cat() 【父类 Animal 子类 Cat】

引用a 在编译时期参阅父类 new Cat参阅子类；

多态中成员变量的特点：无论编译还是运行都按左边；例： Fu f = new Fu(); Zi z = new Zi();

多态中静态函数的特点：编译和运行都看左边；即父类走父类、子类走子类同上例；

final：关键字可以修饰类，方法，变量

final修饰的类不能被继承，不能在被派生，也就算是最终类

final修饰的方法不能被覆盖

final修饰的变量不能再被改变

abstract：用abstract修饰一个类时，该类则称为抽象类

抽象方法必须被重写，抽象方法只有声明，不能有实现

interface ：用于定义接口， class用于定义类；接口中的成员都是public

接口是一种特殊的抽象类

接口的特点：接口是对外暴露的；

接口是程序的扩展功能

接口可以用来多实现

接口与接口之间可以有继承关系

定义接口时的格式特点：有固定的修饰符

定义常量：public static final

定义方法: public abstract

举例接口的应用：

<span style="font-size:18px;"><strong>public interface USB {
  
  public abstract String transData();  //USB的方法
  public abstract String transElectric();
 
}
 
public class Upan implements USB,Player{
 
 public String transData() {
    
  return "给U盘传输数据";
  }
 
 
  public String transElectric() {
   
   return "给U盘传输电流";
  } 

public class DigitCamera implements USB{
 
 public String transData() {
   
   return "给相机传数据";
  }
 
 public String transElectric() {
   
   return "给相机传电流";
  }
 }
 
}
 
public class Computer {
                  
 public void chuandianliu(USB usb){
   System.out.println("电脑"+usb.transElectric());
  }
  public void chuanshuju(USB usb){
   System.out.println("电脑"+usb.transData());
  }
 }
 
public class Text {
  public static void main(String[] args) {
   
   Upan upan=new Upan();
   DigitCamera  camera=new DigitCamera();
   
   Computer c=new Computer();
   c.chuandianliu(upan);
   c.chuanshuju(upan);
   
   c.chuandianliu(camera);
   c.chuanshuju(camera); 
     
  }
 
}
 
</strong></span>

继承中多态的体现

<span style="font-size:18px;"><strong>public abstract class Animal {
	
	public abstract void eat();
	public  void run(){
		System.out.println("走步");
	}
	public static void speak(){//静态方法
		System.out.println("叫");
	}
}
public class Cat extends Animal{

	public void eat(){//重写父类的方法
		System.out.println("猫吃鱼");
	}
	public void catchMouth(){//子类自己的方法
		System.out.println("猫捉老鼠");
	}
}
public class Dog extends Animal{

	public void eat(){//重写父类的方法
		System.out.println("狗啃骨头");
		
	}
	public void run(){//子类自己的方法
		System.out.println("狗走步");
	}
	public static void speak(){//重写父类静态方法
		System.out.println("狗叫");
	}
}
public class AnimalDemo {

	public static void main(String[] args) {
		
		Animal a = new Cat();
		a.eat();
		a.run();
		//a.catchMouth编译失败父类中没有此方法
		
		
		Animal a1 = new Dog();
		a1.speak();	//调用静态方法，编译和运行都看左边
		Dog d = new Dog();
		d.run();//调用静态方法，编译和运行都看左边
     }
}</strong></span>

接口中多态的体现

<span style="font-size:18px;"><strong>public interface Opertion{
	
	public  void add();
	public  void delet();
	public  void update();
	public  void select();
}
public class JDBC implements Opertion{

	public void add() {
		System.out.println("添加操作");
		
	}
	public void delet() {
		System.out.println("删除操作");
	}

	public void select() {
		System.out.println("修改操作");
	}

	public void update() {
		System.out.println("查询操作");
	}
}
public class Demo {
	
	public static void main(String[] args) {
		Opertion o = new JDBC();//多态的体现
		o.add();
		o.delet();
		o.update();
		o.select();
		
	}

}
</strong></span>