java如何运行curl java如何运行多个类

Java中多态的基本使用:

学习多态基础语法之前，我们需要普及两个概念：

第一个：向上转型
子类（多） --> 父类（少） （自动型）

第二个：向下转型
父类（少） --> 子类（多） （强制型，需要加强制类型转换符）

注意：Java中允许向上转型，也允许向下转型。
无论是向上转型，还是向下转型，两种类型之间必须有继承关系。

---

下面设计几个类：

//父类，动物类
class Animal {
	protected void run() { 
		System.out.println("动物在移动!!!");
	}
}


//子类，猫类
class Cat extends Animal {
//重写run()方法
	public void run() {
		System.out.println("猫在走猫步!!!");
	}
//子类应该会有自己特有的方法，比如猫会抓老鼠
	public void catchMouse() {
		System.out.println("猫正在抓老鼠!!!");
}
}
//子类，鸟儿类
class Bird extends Animal {
	//重写移动方法
	public void run() {
		System.out.println("鸟儿在飞翔!!!");
	}
}

我们来看一下“向上转型”，也就是“父类型的引用指向子类型的对象”（自动型，直接转）

Animal a2 = new Cat();
a2.run();  //输出：猫在走猫步!!!

分析一下执行过程：a2.run()

java程序分为编译阶段和运行阶段。

编译阶段：在编译时，编译器只知道a2的类型是Animal，编译阶段并没有进行实例化对象，也就没有进行new对象，所以在编译检查a2.run()的语法时，会去a2对象的Animal.class字节码中找run()方法，成功找到，绑定上run()方法，编译通过，静态绑定成功（编译阶段属于静态绑定）。

运行阶段：运行代码时，实际上在堆内存中创建的对象是一个Cat对象，也就是在栈内存当中的a2变量引用指向堆内存中的那只Cat对象，执行a2.run()时动态执行的是a2指向的Cat对象内部的run()方法，故输出“猫在走猫步！！！”。这一阶段属于运行绑定（运行绑定属于动态绑定）。

---

再来理解一下多态的定义：
多态指的是，父类型的引用指向子类型的对象。
在编译中一种形态，运行时另一种形态。

包括编译阶段和运行阶段。
编译阶段：静态绑定父类的方法。
运行阶段：动态绑定子类型对象的方法。

多种形态，编译时一种形态，运行时另一种形态，故称为多态。

我们来分析一下下面一行的代码能否执行？

//Animal a2 = new Cat();
//a2.catchMouse();

显然不行，因为在编译时会静态的去a2类字节码中找catchMouse()方法，没找到，静态绑定失败，编译不通过。

---

什么时候使用“向下转型”？

注意：不要随便做强制类型转换。当你需要访问子类对象中“特有”的方法，此时必须进行向下强制转型。

Animal a2 = new Cat();
//a2是一个Animal型引用变量，把它强制向下转成猫类型
Cat xCat = (Cat)a2;
//catchMouse()是子类中特有的方法，需向下转型
xCat.catchMouse(); //输出：猫正在抓老鼠!!!

//我们思考一个问题：向下转型有风险吗？分析以下代码

Animal a3 = new Bird();
Cat yCat = (Cat)a3;
yCat.catchMouse();

//编译阶段：Animal a3，a3型与Cat存在继承关系，故Animal a3能强制转为Cat型，yCat对象字节码内存在catchMouse()方法，静态绑定成功，编译通过。

//运行阶段：实例化的对象实际是一只“鸟儿”，拿着Bird强转为Cat，最后运行动态绑定的是鸟儿对象的catchMouse()方法，动态绑定失败，运行报错java.lang.ClassCastException（类型转换异常）。

---

如何避免类型转换异常的发生？

用运算符：instanceof
语法：(x instanceof ClassA)
作用：在运行阶段动态判断“引用变量指向的堆内存对象是否属于ClassA”。

返回值：
真：表示“引用变量x指向的堆内存对象属于ClassA”；
假：表示“引用变量x指向的堆内存对象不属于ClassA”。

程序员以后在向下转型的时候，应该养成好习惯，对所有的向下转型的变量先进行instanceof类型判断，再进行是否强制转换。

例如解决上面转型失败的问题：

Animal a3 = new Bird();
if (a3 instanceof Cat) {// 如果a3是一只Cat,显然a3指向的是Bird，条件不成立
	Cat yCat = (Cat)a3;
	yCat.catchMouse(); //无输出
}

---

多态语法测试代码如下：

public class MyTest {

	public static void main(String[] args) {
		//方法的覆盖
		Animal a1 = new Animal();
		a1.run();  //输出：动物在移动!!!
		Cat c1 = new Cat();
		c1.run();  //输出：猫在走猫步!!!
		Bird b1 = new Bird(); 
		b1.run();  //输出：鸟儿在飞翔!!!
				
		//父类型的引用指向子类型的对象，也就是向上转型（自动型）
		Animal a2 = new Cat();
		a2.run();  //输出：猫在走猫步!!!
		
		//Dog类没有继承Animal，转型失败，编译报错
		//Animal a3 = new Dog();
		//Dog d1 = new Animal();
		
		//分析一下下面一行的代码能否执行？
		//a2.catchMouse();
		//显然不行，因为在编译时会静态的去a2类字节码中找catchMouse()方法，没找到，静态绑定失败，编译不通过。
		
		//如果我写到这里，暴脾气上来了，就要用a2.catchMouse()去抓老鼠，那该怎么办？ 行，那就引出向下转型
		//a2是一个Animal型引用变量，把它强制向下转成猫类型
		Cat xCat = (Cat)a2;
		xCat.catchMouse(); //输出：猫正在抓老鼠!!!
		
		//我们思考一个问题：向下转型有风险吗？分析以下代码
		/*Animal a3 = new Bird();
		Cat yCat = (Cat)a3;
		yCat.catchMouse();*/
		//编译阶段：Animal a3，a3型与Cat存在继承关系，故Animal a3能强制转为Cat型，yCat对象字节码内存在catchMouse()方法，静态绑定成功，编译通过。
		//运行阶段：实例化的对象实际是一只“鸟儿”，拿着Bird强转为Cat，最后运行动态绑定的是鸟儿对象的catchMouse()方法，动态绑定失败，运行报错。
		//为避免向下转型出现ClassCastException（类型转换异常），我们使用instanceof判断。
		Animal a3 = new Bird();
		if (a3 instanceof Cat) {// 如果a3是一只Cat,显然a3指向的是Bird，条件不成立
			Cat yCat = (Cat)a3;
			yCat.catchMouse(); //无输出
		}
		
	}
}

//父类，动物类
class Animal {
	// 移动方法，访问权限为protected，比public低
	public void run() { 
		System.out.println("动物在移动!!!");
	}
}

//子类，猫类
class Cat extends Animal {
	//改方法的访问权限不能比原继承方法的访问权限低，可以更高
	public void run() {
		System.out.println("猫在走猫步!!!");
		// 这里不能抛出异常，因为抛出异常数=1 > 继承方法的抛出异常数=0
	}
	
	//子类应该会有自己特有的方法，比如猫会抓老鼠
	public void catchMouse() {
		System.out.println("猫正在抓老鼠!!!");
	}
}

//子类，鸟儿类
class Bird extends Animal {
	//重写移动方法
	public void run() {
		System.out.println("鸟儿在飞翔!!!");
	}
}

//狗类，这个类没有继承Animal类
class Dog {
	
}

---

下面给道例题理解一下多态在开发中的作用:

/*
 * 编写程序模拟主人喂养宠物的场景：
 * 	提示一：
 * 		主人类：Master
 * 		宠物类：Pet
 * 		宠物子类：Dog，Cat，Bird
 * 	提示二：
 * 		主人应该有喂养方法：feed()
 * 		宠物应该有吃的方法：eat()
 * 		只要主人喂养，宠物就吃。
 * 
 * 要求：主人类中只提供一个喂养方法feed()，要求达到可以喂养各种类型的宠物。
 * 	编写测试程序：创建主人对象
 * 			创建各种宠物对象
 * 			调用主人的喂养方法feed()，喂养不同的宠物，观察执行结果。
 * 	通过改案例，理解多态在开发中的作用。
 * 	重要提示：feed()方法是否需要一个参数，参数选什么类型？？？ 
 */

public class MyTest{
	public static void main(String[] args) {
		//实例化主人类
		Master pipi = new Master();
		//实例化三种宠物类
		Dog d1 = new Dog();
		Cat c1 = new Cat();
		Bird b1 = new Bird();
		//主人调用自己的喂养方法feed()来实现不同宠物的吃方法eat()
		pipi.feed(d1);
		pipi.feed(c1);
		pipi.feed(b1);
	}
}

//主人类
class Master {
	//feed()方法
	public void feed(Pet pet) {
		pet.eat();
	}
}

//宠物类
class Pet {
	//eat()方法
	public void eat() {
		System.out.println("宠物" + "在吃东西！！！");
	}
}

//宠物子类，Dog类
class Dog extends Pet {
	//重写eat()方法
	public void eat() {
		System.out.println("狗狗" + "喜欢啃骨头！！！");
	}
}

//宠物子类，Cat类
class Cat extends Pet {
	//重写eat()方法
	public void eat() {
		System.out.println("猫儿" + "喜欢吃鱼！！！");
	}
}

//宠物子类，Bird类
class Bird extends Pet {
	//重写eat()方法
	public void eat() {
		System.out.println("鸟儿" + "喜欢吃虫子！！！");
	}
}

---