下载文档原格式
java中方法重载方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。
调用重载方法时，Java编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法。
方法重载通常用于创建完成一组任务相似但参数的类型或参数的个数不同的方法。
java中重载与重写的区别首先我们来讲讲：重载(Overloading)(1) 方法重载是让类以统一的方式处理不同类型数据的一种手段。
多个同名函数同时存在，具有不同的参数个数/类型。
重载Overloading是一个类中多态性的一种表现。
(2) Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。
(3) 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。
无法以返回型别作为重载函数的区分标准。
下面是重载的例子：package c04.answer;//这是包名//这是这个程序的第一种编程方法，在main方法中先创建一个Dog类实例，然后在Dog 类的构造方法中利用this关键字调用不同的bark方法。
不同的.重载方法bark是根据其参数类型的不同而区分的。
//注意：除构造器以外，编译器禁止在其他任何地方中调用构造器。
package c04.answer;public class Dog {Dog(){this.bark();}void bark()//bark()方法是重载方法{System.out.println(\ no barking!\this.bark(\ female\ , 3.4);}void bark(String m,double l)//注意：重载的方法的返回值都是一样的，{System.out.println(\ a barking dog!\this.bark(5, \ China\}void bark(int a,String n)//不能以返回值区分重载方法，而只能以参数类型和类名来区分{System.out.println(\ a howling dog\}public static void main(String[] args){Dog dog = new Dog();//dog.bark(); [Page]//dog.bark(\ male\ , \ yellow\//dog.bark(5, \ China\然后我们再来谈谈重写(Overriding)(1) 父类与子类之间的多态性，对父类的函数进行重新定义。
⽅法重写与⽅法重载的区别⼀、⽅法重写(0veriding)在Java程序中，类的继承关系可以产⽣⼀个⼦类，⼦类继承⽗类，它具备了⽗类所有的特征，继承了⽗类所有的⽅法和变量。
⼦类可以定义新的特征，当⼦类需要修改⽗类的⼀些⽅法进⾏扩展，增⼤功能，程序设计者常常把这样的⼀种操作⽅法称为重写，也叫称为覆写或覆盖。
重写体现了Java优越性，重写是建⽴在继承关系上，它使语⾔结构更加丰富。
在Java中的继承中，⼦类既可以隐藏和访问⽗类的⽅法，也可以覆盖继承⽗类的⽅法。
在Java中覆盖继承⽗类的⽅法就是通过⽅法的重写来实现的。
所谓⽅法的重写是指⼦类中的⽅法与⽗类中继承的⽅法有完全相同的返回值类型、⽅法名、参数个数以及参数类型。
这样，就可以实现对⽗类⽅法的覆盖。
如果⼦类将⽗类中的⽅法重写了，调⽤的时候肯定是调⽤被重写过的⽅法，那么如果现在⼀定要调⽤⽗类中的⽅法该怎么办呢?此时，通过使⽤super关键就可以实现这个功能，super关键字可以从⼦类访问⽗类中的内容，如果要访问被重写过的⽅法，使⽤“super.⽅法名(参数列表)”的形式调⽤。
如果要使⽤super关键字不⼀定⾮要在⽅法重写之后使⽤，也可以明确地表⽰某个⽅法是从⽗类中继承⽽来的。
使⽤super只是更加明确的说，要从⽗类中查找，就不在⼦类查找了。
⼆、重写规则在重写⽅法时，需要遵循以下的规则：(⼀) ⽗类⽅法的参数列表必须完全与被⼦类重写的⽅法的参数列表相同，否则不能称其为重写⽽是重载。
(⼆) ⽗类的返回类型必须与被⼦类重写的⽅法返回类型相同，否则不能称其为重写⽽是重载。
..(三) Java中规定，被⼦类重写的⽅法不能拥有⽐⽗类⽅法更加严格的访问权限。
编写过Java程序的⼈就知道，⽗类中的⽅法并不是在任何情况下都可以重写的，当⽗类中⽅法的访问权限修饰符为private时，该⽅法只能被⾃⼰的类访问，不能被外部的类访问，在⼦类是不能被重写的。
如果定义⽗类的⽅法为public，在⼦类定义为private，程序运⾏时就会报错。
Java中的⽅法覆盖（Overriding）和⽅法重载（Overloading）是什么意思？ ⽅法覆盖也称为重写，重写即⼦类重新定义了⽗类的⽅法。
重写： 1、重写的⽅法必须与原⽅法有相同的⽅法名、参数列表和返回值类型（Java SE5之后返回值类型可以是其类型的⼦类型） 2、被重写的⽅法不能是final类型，因为final类型⽆法重写 3、被重写的⽅法不能是private，因为private⽆法继承，⽽继承是重写的前提 4、被重写的⽅法不能为static，如果⽗类中的⽅法为静态，⽽⼦类的⽅法不是静态的，但是两个⽅法除了这⼀点其他都满⾜重写条件，那么会发⽣编译错误，反之亦然。
如果⼦类和⽗类中的⽅法都是静态的，并且满⾜重写条件，但仍然不会发⽣重写，因为静态⽅法是在编译时把静态⽅法和类的引⽤进⾏匹配。
5、重写的⽅法的访问权限不能⼩于原⽅法 6、重写抛出的异常的范围不能⼤于原⽅法 7、重写是在运⾏是发⽣的，JVM会在代码运⾏时作出决定。
⽅法重载简称重载，重载即同⼀个类中两个或多个⽅法名相同但参数不同的情况重载： 1、⽅法名必须相同 2、参数列表必须不同（参数的个数，类型，顺序不同） 3、⽅法的返回类型可以相同也可以不同 4、仅仅返回值类型不同不⾜以成为⽅法的重载 5、重载是发⽣在编译时的，因为编译器可以根据参数类型来选择使⽤哪个⽅法重写和重载的区别： 1、重写只能⽤于⼦类重写⽗类的⽅法，⽽重载⽤于同⼀类中的所有⽅法 2、重写的参数列表必须相同，重载的参数列表必须不同 3、重写要求返回值类型必须⼀致或是其⼦类，重载没有要求 4、重写对⽅法的访问权限和抛出异常有特殊的要求，⽽⽅法的重载没有这⽅⾯的限制 5、⽗类的⽅法只能被同⼀⼦类重写⼀次，⽽⼀个⽅法可以在所有类中被重载很多次 6、重写是运⾏时的多态，重载是编译时的多态。
C#中override和overload的区别1.override: 父类：public virtual string ToString(){return "a";}子类：public override string ToString(){return "b";}2.overload: 同一类中或父子关系类中皆可.public string ToString(){return "a";}public string ToString(int id){return id.ToString();}override是用于重写基类的虚方法,这样在派生类中提供一个新的方法；重载是提供了一种机制, 相同函数名通过不同的返回值类型以及参数来表来区分的机制================================================很本质的区别就是看函数特征：覆写（Override）的两个函数的函数特征相同，重载（Overload）的两个函数的函数名虽然相同，但函数特征不同。
函数特征包括函数名，参数的类型和个数。
Override 是在继承的时候，如果你写的函数与要继承的函数函数特征相同，那么，加上这个关键字，在使用这个子类的这个函数的时候就看不见父类（或超类）的函数了，它被覆盖掉了。
比如：Derived继承了Base，Base里面有void A(int a) ，那么如果你Derived里面觉得A写得不好或不适合这个类，你想重新再写一遍A里的代码，那么就写override void A(int a)这样，原来的那个函数就被你新写的这个覆盖掉了。
Overload 是重载，就是说函数名相同，函数特征不同，系统会根据你提供的参数来调相应的函数。
比如：void A(int a)和void A(int a,int b)如果你用的是A(1)那么调的是第一个，如果是A(1,1)那么调的是第二个。
⽅法的重载与重写区别（1）⽅法重载是让类以统⼀的⽅式处理不同类型数据的⼀种⼿段。
多个同名函数同时存在，具有不同的参数个数/类型。
重载Overloading是⼀个类中多态性的⼀种表现。
（2）的⽅法重载，就是在类中可以创建多个⽅法，它们具有相同的名字，但具有不同的参数和不同的定义。
调⽤⽅法时通过传递给它们的不同参数个数和参数类型来决定具体使⽤哪个⽅法, 这就是多态性。
（3）重载的时候，⽅法名要⼀样，但是参数类型和个数不⼀样，返回值类型可以相同也可以不相同。
⽆法以返回型别作为重载函数的区分标准。
下⾯是重载的例⼦：package c04.answer;//这是包名//这是这个程序的第⼀种编程⽅法，在main⽅法中先创建⼀个Dog类实例，然后在Dog类的构造⽅法中利⽤this关键字调⽤不同的bark⽅法。
不同的重载⽅法bark是根据其参数类型的不同⽽区分的。
//注意：除构造器以外，编译器禁⽌在其他任何地⽅中调⽤构造器。
package c04.answer;public class Dog {Dog(){this.bark();}void bark()//bark()⽅法是重载⽅法{System.out.println(\"no barking!\");this.bark(\"female\", 3.4);}void bark(String m,double l)//注意：重载的⽅法的返回值都是⼀样的，{System.out.println(\"a barking dog!\");this.bark(5, \"China\");}void bark(int a,String n)//不能以返回值区分重载⽅法，⽽只能以“参数类型”和“类名”来区分{System.out.println(\"a howling dog\");}public static void main(String[] args){Dog dog = new Dog();//dog.bark(); [Page]//dog.bark(\"male\", \"yellow\");//dog.bark(5, \"China\"); 然后我们再来谈谈重写（Overriding）（1）⽗类与⼦类之间的多态性，对⽗类的函数进⾏重新定义。
Java⽅法重载（Overload）与⽅法覆盖（重写Override）Java ⽅法重载（Overload）与⽅法覆盖（重写Override）
1、⽅法重载（Overload）
对于类的⽅法（包括从⽗类中继承的⽅法），如果有两个⽅法的⽅法名相同，但是参数不⼀致，那么可以说，⼀个⽅法是另⼀个⽅法的重载⽅法。
在⼀个类中不允许定义两个⽅法名相同，并且参数类型也相同的⽅法。
重载⽅法必须满⾜以下条件：
1. ⽅法名相同。
2. ⽅法的参数类型、个数、顺序⾄少有⼀个不同。
3. ⽅法的返回类型、修饰符可以不相同。
2、⽅法覆盖（Override）
如果在⼦类中定义的⼀个⽅法，其⽅法名称、返回类型及参数签名正好和⽗类中的某个⽅法的名称、返回类型以及参数签名⼀致，那么可以说，⼦类的⽅法覆盖了⽗类的⽅法。
覆盖⽅法必须满⾜多种约束：
1. ⼦类⽅法的⽅法名称、参数签名和返回类型必须⽗类的⽅法的名称、参数签名和返回类型⼀致。
2. ⼦类不能缩⼩⽗类的访问权限。
3. ⼦类不能抛出⽐⽗类更多的异常。
4. ⽅法覆盖只存在于⼦类和⽗类之间（包括直接⽗类和间接⽗类）。
5. ⼦类可以定义和⽗类⼀样的静态⽅法。
以便在⼦类中隐藏⽗类的静态⽅法。
⼦类隐藏⽗类的静态⽅法和⼦类覆盖
⽗类的实例⽅法，这两者的区别在于：运⾏时， java虚拟机把静态⽅法和所属的类绑定，⽽把实例和所属的实例绑定。
6. ⽗类的⾮静态⽅法不能被⼦类覆盖为静态⽅法。
7. ⽗类的私有⽅法不能被⼦类覆盖。
8. ⽗类的抽象⽅法可以被⼦类通过两种⽅法覆盖：⼀是⼦类实现⽗类的抽象⽅法；⼆是⼦类重新申明⽗类的抽象
⽅法。
ts的函数重载1、什么是函数重载在JavaScript中，函数重载是指在一个函数中存在多个同名函数，但是他们的参数类型或个数不同。
因为JavaScript的函数是动态类型，所以函数重载对其实现是相对严格的。
2、为什么需要函数重载函数重载有两个主要的优点：（1）代码更易读：函数重载可以减少代码重复，使代码更易读。
（2）更高效的代码：使用函数重载可以减少代码长度，提高执行效率，更高效的处理程序。
3、函数重载的实现方法JavaScript不支持函数重载，但是可以使用以下方法实现：（1）使用if语句进行参数判断；（2）利用arguments和typeof实现多态。
简单来说，就是可以在函数内部判断输入参数的类型或者个数，根据不同的类型或者数量来执行不同的逻辑。
4、函数重载的注意事项在使用函数重载时，需要注意以下的几个细节：（1）只能根据参数类型或者参数个数进行函数重载，不能根据返回值类型进行函数重载；（2）不能在同一个作用域中定义两个相同签名的函数；（3）避免使用过多的重载，不仅会增加客户端的代码量，还会降低可读性和可维护性。
5、函数重载的应用场景（1）Math类中的min()和max()方法就是函数重载的经典应用场景。
这两个方法accept any number of arguments，但是它们的实现却各不相同。
（2）JQuery中的val()方法也是函数重载的典型例子。
val()方法可以接受一个参数，也可以不接受参数，在接受参数时可以传入一个函数作为参数，不同的参数类型会调用不同的函数。
6、函数重载的缺点函数重载虽然有着很多优点，但是也存在着一些缺点：（1）JavaScript的函数是动态类型，函数重载的实现方法相对较为严格。
（2）过多的重载会降低代码的可读性和维护性。
7、结语函数重载是JavaScript编程语言中非常重要的特性之一。
函数重载使得代码更加简洁，逻辑更加清晰。
但是，我们需要了解到函数重载的实现方法，以及注意事项和优缺点。
java方法重载和重写方法重载：就是在同一个类中，方法的名字相同，但参数个数、参数的类型或返回值类型不同!方法重写：它是指子类和父类的关系，子类重写了父类的方法，但方法名、参数类型、参数个数必须相同!Java方法的重写与重载一、方法的重写。
1、重写只能出现在继承关系之中。
当一个类继承它的父类方法时，都有机会重写该父类的方法。
一个特例是父类的方法被标识为final。
重写的主要优点是能够定义某个子类型特有的行为。
class Animal {public void eat(){System.out.println ( Animal is eating.}}class Horse extends Animal{public void eat(){System.out.println ( Horse is eating.}}2、对于从父类继承来的抽象方法，要么在子类用重写的方式设计该方法，要么把子类也标识为抽象的。
所以抽象方法可以说是必须要被重写的方法。
3、重写的意义。
重写方法可以实现多态，用父类的引用来操纵子类对象，但是在实际运行中对象将运行其自己特有的方法。
public class Test {public static void main (String[] args) {Animal h = new Horse();h.eat();}}class Animal {public void eat(){System.out.println ( Animal is eating.}}class Horse extends Animal{public void eat(){System.out.println ( Horse is eating.}public void buck(){}}一个原则是：使用了什么引用，编译器就会只调用引用类所拥有的方法。
如果调用子类特有的方法，如上例的h.buck(); 编译器会抱怨的。
java方法的重载的规则Java方法的重载是指在一个类中，可以定义多个方法名相同但参数类型或参数个数不同的方法。
通过重载，可以根据不同的参数类型和个数来调用不同的方法，从而提高代码的灵活性和可复用性。
重载方法的规则主要包括以下几点：1. 方法名必须相同：在同一个类中，只有方法名相同才能构成重载关系，否则会被视为重复定义的错误。
2. 参数类型或参数个数必须不同：重载的方法必须拥有不同的参数类型或参数个数，否则编译器无法区分它们，会报错。
3. 与返回值类型无关：重载方法与返回值类型无关，即便返回值类型不同也可以构成重载关系。
4. 可以有不同的访问修饰符：重载方法可以具有不同的访问修饰符，如public、private、protected等。
5. 可以抛出不同的异常：重载方法可以抛出不同的异常，但是需要遵循Java异常处理的规则。
6. 重载方法的调用是根据参数类型和参数个数来确定的：在调用重载方法时，编译器会根据传入的参数类型和参数个数来匹配对应的方法，选择最匹配的方法进行调用。
重载方法的好处在于提高了程序的可读性和可维护性。
通过重载，我们可以用相同的方法名来表示各种不同的功能，而不必使用不同的方法名。
这样一来，我们在调用方法时就能够更加直观地理解其功能，同时也方便了代码的管理和维护。
下面通过一些示例来展示重载方法的规则和应用。
1. 重载方法的参数类型不同：```javapublic class Calculator {public int add(int a, int b) {return a + b;}public double add(double a, double b) {return a + b;}}```在上面的例子中，我们定义了两个add方法，一个接收两个int类型的参数，另一个接收两个double类型的参数。
通过重载，我们可以根据传入的参数类型来选择不同的方法进行调用。
2. 重载方法的参数个数不同：```javapublic class StringUtil {public String concat(String str1, String str2) {return str1 + str2;}public String concat(String str1, String str2, String str3) {return str1 + str2 + str3;}}```在上面的例子中，我们定义了两个concat方法，一个接收两个String类型的参数，另一个接收三个String类型的参数。
函数的重载和重写在编写程序时，函数是重要的组成部分之一。
函数可以让代码更具有可读性和可维护性，同时也可以提高代码的复用性。
函数的重载和重写是函数的两种常见形式，本文将对这两种形式进行详细介绍。
函数的重载（Function Overloading）函数的重载是指在同一个作用域内，定义多个同名函数，但是这些函数的参数类型、参数个数或者参数顺序不同。
编译器会根据函数调用时传入的参数类型、个数和顺序来自动选择正确的函数。
函数的重载可以让我们在不改变函数名的前提下，提供更多的函数功能。
例如，我们可以定义一个add函数来实现两个整数相加的功能，同时也可以定义一个add函数来实现两个浮点数相加的功能，这就是函数的重载。
下面是一个简单的add函数的重载示例：```int add(int a, int b) {return a + b;}float add(float a, float b) {return a + b;}```在上面的例子中，我们定义了两个同名的add函数，一个是用于整数相加，一个是用于浮点数相加。
当我们调用add函数时，编译器会自动选择正确的函数来执行。
函数的重写（Function Overriding）函数的重写是指在派生类中重新定义基类中已经定义的函数。
在派生类中重新定义的函数和基类中的函数具有相同的名称和参数列表，但是派生类中的函数实现可以与基类中的函数实现不同。
函数的重写是面向对象编程中的重要概念之一。
通过函数的重写，我们可以实现多态性，即在运行时根据对象的实际类型来调用相应的函数。
下面是一个简单的函数重写的示例：```class Animal {public:virtual void move() {cout << "Animal is moving" << endl;}};class Dog : public Animal {public:void move() {cout << "Dog is running" << endl;}};int main() {Animal* animal = new Dog();animal->move();return 0;}```在上面的例子中，我们定义了一个Animal类和一个Dog类，Dog 类是从Animal类派生而来的。
论述函数重载的定义
函数重载是指在一个作用域内，定义两个或多个函数名称相同，但参数不同，数据类型可相同也可不同的函数，以便在程序中可以根据调用函数时传递的参数类型和参数个数，调用不同的函数。
通常，函数重载是指定义一个函数需要接受多种不同类型和参数个数的重
复使用一个函数名称的技术。
在编程语言中，函数重载是一种常用的编程行为，可以使得代码看起来更加简洁，避免定义多个不同名称的函数实现相同的功能，减少代码重复的书写。
- 1 -。
简述方法的重写和重载在面向对象的程序设计中，方法的重写和重载是两个很重要的概念。
虽然它们都涉及到方法的定义，但它们的意义和用法是不同的。
本文将详细介绍这两个概念的含义和使用方法。
一、方法的重写方法的重写（Override）是指在继承关系中，子类中定义一个与父类中同名、同参数的方法，但是方法体的实现不同。
这样的方法就覆盖了父类中的方法，从而使得在子类中调用该方法时，执行的是子类中的实现。
重写的方法和被重写的方法具有相同的方法名、方法参数列表和返回值类型。
重写方法的实现要符合“里氏替换原则”，即子类对象必须能够替换掉父类对象，而系统的行为不发生变化。
因此，重写方法的访问修饰符不能比被重写方法的访问修饰符更严格。
如果被重写方法是public，那么重写方法也必须是public；如果被重写方法是protected，那么重写方法可以是protected或public；如果被重写方法是default，那么重写方法可以是default、protected或public。
而且，重写方法的返回值类型必须与被重写方法的返回值类型相同，或者是其子类。
重写方法的使用场景很多，比如在实现多态时，子类可以根据自己的需要来重写父类的方法，从而实现不同的行为。
此外，在框架设计中，重写方法也是常用的技术手段。
二、方法的重载方法的重载（Overload）是指在同一个类中，定义多个方法，它们具有相同的方法名，但是参数列表不同。
重载方法的返回值类型可以相同也可以不同，但是不能仅仅是参数名不同或者是返回值类型不同。
重载方法的使用场景也很多，比如在Java中的print和println方法就是一个很好的例子。
print方法被重载了多次，以便于接受不同类型的参数。
此外，在处理数据类型转换时也经常会用到方法的重载。
需要注意的是，方法的重载和方法的重写是不同的概念，虽然它们都涉及到方法的定义。
重载方法是在同一个类中定义多个方法，而重写方法是在子类中覆盖父类的方法。
JAVA重写和重载方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
Overloaded的方法是可以改变返回值的类型。
也就是说，重载的返回值类型可以相同也可以不同。
1、重载(Overloading)a、方法重载是让类以统一的方式处理不同类型数据的一种手段。
多个同名函数同时存在，具有不同的参数个数/类型。
重载Overloading是一个类中多态性的一种表现。
b、Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。
c 、重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。
无法以返回型别作为重载函数的区分标准。
2、重写（Overriding）a、父类与子类之间的多态性，对父类的函数进行重新定义。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。
在Java中子类可继承父类中的方法，而不需要重新编写相同的方法。
但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。
方法重写又称方法覆盖。
b、若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。
如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
this指示当前。
c、子类函数的访问修饰权限不能少于父类的；重写是子类的方法覆盖父类的方法，要求方法名和参数都相同重载是在同一个类中的两个或两个以上的方法，拥有相同的方法名，但是参数却不相同，方法体也不相同，最常见的重载的例子就是类的构造函数，可以参考API帮助文档看看类的构造方法.构造方法和普通方法都能重载吗？2.构造方法和普通方法都能重写吗？3.重写的话是子类中的方法覆盖同名父类方法？重载的话覆盖是怎样的呢？（多同名方法情况下哪个覆盖哪个？）1 能2 能3 重写是方法名相同，参数也相同，重载是方法名相同，参数不同首先我们来讲讲：重载(Overloading)（1）方法重载是让类以统一的方式处理不同类型数据的一种手段。
重载和覆盖的区别都有哪些重载和覆盖是多态性的两大主要表现，学习代码的朋友对此可能会有所了解，但是可能理解不深，下面是小编带来的关于重载和覆盖的区别的内容，欢迎大家阅读!重载和覆盖的区别在同一个类中方法成员的名称相同，但参数的类型和个数不同，这称为重载。
在存在继承关系的两个话，子类与父类的方法成员名称相同、参数的类型和个数相同的话，子类的方法覆盖父类的方法，这称为覆盖。
下面举个例子说明一下。
例如：class Shape {void draw() {}void erase() {}}class Circle extends Shape {void draw() {System.out.println("Circle.draw()");}void erase() {System.out.println("Circle.erase()"); }}class Square extends Shape {void draw() {System.out.println("Square.draw()");}void erase() {System.out.println("Square.erase()");}}class Triangle extends Shape {void draw() {System.out.println("Triangle.draw()"); }void erase() {System.out.println("Triangle.erase()"); }}public class Test {public static Shape randShape() { switch((int)(Math.random() * 3)) { default:case 0: return new Circle();case 1: return new Square();case 2: return new Triangle();} }public static void main(String[] args) { Shape[] s = new Shape[9];for(int i = 0; i < s.length; i++)s[i] = randShape();for(int i = 0; i < s.length; i++)s[i].draw();}}输出结果Triangle.draw()Circle.draw()Triangle.draw()Triangle.draw()Triangle.draw()Square.draw() Triangle.draw()Circle.draw()Triangle.erase()Circle.erase()Triangle.erase() Triangle.erase() Triangle.erase() Square.erase() Square.erase() Triangle.erase()Circle.erase()Press any key to continue... 又一次执行Triangle.draw() Triangle.draw()Circle.draw()Circle.draw()Circle.draw()Triangle.draw() Triangle.draw() Square.draw()Circle.draw()Triangle.erase() Triangle.erase()Circle.erase()Circle.erase()Circle.erase()Triangle.erase()Square.erase()Circle.erase()Press any key to continue...两次执行结果不同的原因是其中的Math.random()这个类导致的,math.random()得到的数是0-1之间的随机数。
