Java 两大利器 多态和反射

多态： 静态多态性和动态多态性

静态多态性：有两个函数，名称一样，但是系统可以接受，这叫函数重载，（静态多态性）
一个函数呈现多种状态，系统能够根据参数来决定调用谁
三种情况：参数个数不同；参数个数相同，类型不同；个数类型相同，出现的顺序不同
静态是指：虽然函数名只有一个，但是代码要写多个

动态多态性：一般在继承时使用， 不多说，直接上代码：

动态多态性；
例1

package  duotail
//动态多台性一般在继承时使用
abstract class Person{
public abstract void printInfo();
}

class Student extends Person{
public void printInfo(){
System.out.println("学生打印");
}
}
class Teacher extends Person{
public void printInfo(){
System.out.println("老师打印")
}
}

public class StudentTest{
public static void print(Person p){
p.printInfo();
}
public static void main(String[] args){
print(new student());
}

}

 

例2
package duotai;

//模块1调用一个对话框，让对话框显示出来
class Module1{
private Dialog dialog;
public Module1(Dialog dialog){
this.dialog = dialog;
}
public void callDialog(){
dialog.show();
}
}

abstract class Dialog{
public abstract void show();
}
class Dialog1 extends Dialog{
public void show(){
System.out.println("对话框1显示");
}
}

//客户对Dialog不满意，想要自己开发一个Dialog2,被Module1调用，不能改变Module1源代码
class Dialog2 extends Dialog{
public void show(){
System.out.println("对话框2显示")；
}
}

public class DialogTest{
public static void main(String[] args){
Dialog dialog = new Dialog();
Module1 module1 = new Module1(dialog);
module1.callDialog();
}

 

反射：反射机制主要方便配置文件的读入

不多说，直接上代码（有注释）

例1

package fanshe;

class Customer{
private String account;
private String password;
public Customer(){
System.out.println("构造函数1")；
}

public Customer(String account, String password){
System.out.println("构造函数2")；
this.account = account;
this.password = password;
}

public void printInfo(){
System.out.println("账号："+account+"密码："+password);
}

}

public class Test1{
public static void main(String[] args) throws Exception{
String className = "fanshe.Customer";
/*className cus = "fanshe.Customer";
//得到类的信息
calss c = class.forName(className);
//得到里面的构造函数，就可以生成对象
Constructor[] cons = c.getConstructors();
for(int i=0; i<cons.length;i++){
System.out.println("名字"+cons[i].getName());
Class params = cons[i].getParameterTypes();//得到参数类型
for(int j=0;j<params.length;j++){
System.out.println(Params[j].getName());
}
}
//得到里面的成员函数 （包括继承过来的） 就可以调用成员函数
Method mets= c.getMethods();
for(int i=0;i<mets.length;i++){
System.out.println("名字："+mets[i].getName());
Class[] params= mets[i].getParameterTypes();//得到参数类型
for(int j=0;j<params.length;j++){
System.out.println(params[j].getName());
}
}
}
}

例2
package fanshe;

public class Test2{
public static void main(String[] args)throws Exception{
String className = "fanshe.Customer";
Class c = Class.forName(className);
//c.newInstance();//表示调用不带参数的构造函数
//生成一个对象：用构造函数
Constructor con1 = c.getConstructor(new Class[]{});
//若要传入参数，则如下：
Constructor con1 = c.getConstructor(new Class[]{Class.forName("java.lang.String"),Class.forName("java.lang.String")});
//生成对象
Object obj = con1.newInstance(new Object[]{});
//new Object[]表示不传入参数
//若要传入参数，则如下：
Object obj = con1.newInstance(new Object[]{"1111","2222"});
Method met = c.getMethod("printInfo",new Class[]{});
met.invoke(obj,new Object[]{});//调用

//上述所有与代码相当于：
Customer cus = new Customer("1111","2222");
cus.printInfo();
}
}