反射专题

87 阅读15分钟

一、反射快速入门

根据配置文件 re.properties 指定信息,创建 Cat 对象并调用 eat() 方法。

classfullpath=reflection.Cat
method=eat
public class Cat {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
package reflection;
​
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
​
public class ReflectionQuestion {
    public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\re.properties"));
        String classfullpath = properties.get("classfullpath").toString();
        String methodName = properties.get("method").toString();
        System.out.println("classfullPath=" + classfullpath);
        System.out.println("method = " + methodName);
​
        // 2. 创建对象,传统的方法行不通 -》 反射机制
        // new classfullpath();
​
        // 3.使用反射机制解决
        // (1) 加载类,返回Class类型的对象
        Class aClass = Class.forName(classfullpath);
        // (2) 通过 class 得到你加载的类 反射.Cat 的对象实例
        Object o = aClass.newInstance();
        System.out.println("o的运行类似=" + o.getClass());           //运行类型
        // (3) 通过 aClass 得到你加载的类 反射.Cat 的 methodName 的方法对象
        //     即:在反射中,可以把方法视为对象
        Method method = aClass.getMethod(methodName);
        // (4) 通过 method 调用方法,即通过方法对象来实现调用方法
        // 传统方法是 对象.方法(),反射机制是 方法.invoke(对象)
        method.invoke(o);
    }
}

二、反射原理

(1)反射机制允许程序在执行期借助于 Reflection API 取得任何类的内部信息(比如成员变量,构造器,成员方法等等),并能操作对象的属性及方法。反射在设计模式和框架底层都会用到。

(2)加载完类之后,在堆中就产生了一个 Class 类型的对象(一个类只有一个 Class 对象),这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个 Class 对象就像一面镜子,透过这个镜子看到类的结构,所以,形象的称之为:反射。

三、反射相关类

Java 反射机制可以完成

  1. 在运行时判断任意一个对象所属的类
  2. 在运行时构造任意一个类的对象
  3. 在运行时得到任意一个类所具有的成员变量的方法
  4. 在运行是调用任意一个对象的成员变量和方法
  5. 生成动态代理

反射相关的主要类

  1. java.lang.Class:代表一个类,Class 对象表示某个类加载后在堆中的对象
  2. java.lang.reflect.Method :代表类的方法,Method 对象表示某个类的方法
  3. java.lang.reflect.Field:代表类的成员变量,Field 对象表示某个类的成员变量
  4. java.lang.reflect.Constructor:代表类的构造方法,Constructor 对象表示构造器

这些类在 java.lang.reflection

Cat

public class Cat {
    public String age = "10";
​
    public Cat(String age) {
        this.age = age;
    }
​
    public Cat() {
​
    }
​
    public void eat() {
        System.out.println("猫吃鱼");
    }
​
    public void giao() {
        System.out.println("giao");
    }
}

使用反射获取 Cat 类属性、调用方法、获取构造方法

public class Reflection01 {
    public static void main(String[] args) throws IOException, IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        // 使用 properties 读取配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\re.properties"));
        String classfullpath = properties.get("classfullpath").toString();
        String methodName = properties.get("method").toString();
​
        // 3.使用反射机制解决
        // (1) 加载类,返回Class类型的对象
        Class aClass = Class.forName(classfullpath);
        // (2) 通过 class 得到你加载的类 反射.Cat 的对象实例
        Object o = aClass.newInstance();
        System.out.println("o的运行类似=" + o.getClass());           //运行类型
        // (3) 通过 aClass 得到你加载的类 反射.Cat 的 methodName 的方法对象
        //     即:在反射中,可以把方法视为对象
        Method method = aClass.getMethod(methodName);
        // (4) 通过 method 调用方法,即通过方法对象来实现调用方法
        // 传统方法是 对象.方法(),反射机制是 方法.invoke(对象)
        method.invoke(o);
​
        // java.lang.reflect.Field:代表类的成员变量,Field 对象表示某个类的成员变量
        // 得到 name 字段,getField 不能达到私有的属性
        // 传统写法:对象.成员变量,反射:成员变量对象.get(对象)
        Field nameField = aClass.getField("age");
        System.out.println(nameField.get(o));
​
        // java.lang.reflect.Constructor:代表类的构造方法,Constructor 对象表示构造器
        // () 中可以指定构造器参数类型,返回无参构造器这里
        Constructor constructor = aClass.getConstructor();
        System.out.println(constructor);
        // 获取有参构造器,这里传入的 String.class 就是 String 类的 Class 对象
        Constructor constructor1 = aClass.getConstructor(String.class);
        System.out.println(constructor1);
    }
}

四、反射调用优化

1.反射优缺点

优点:可以动态的创建和使用对象(也是框架底层核心),使用灵活,没有反射机制,框架技术就失去底层支撑。

缺点:使用反射基本是解释执行,对执行速度有影响。

2.优化-关闭访问检查

  1. MethodFieldConstructor 对象都有 setAccessible() 方法。
  2. setAccessible 作用是启动和禁用访问安全检查的开关。
  3. 参数值为 true 表示反射的对象在使用时取消访问检查,提高反射的效率。参数值为 false 则表示反射的对象执行访问检查。

五、Class 类分析

1.特性

  1. Class也是类,因此也继承Object 类;
  2. Class类对象不是 new 出来的,而是系统创建的;
  3. 对于某个类的 Class 类对象,在内存中只有一份,因为类只加载一次;
  4. 每个类的实例都会记得自己是由哪个 Class实例所生成;
  5. 通过 Class 可以完整地得到一个类的完整结构,通过一系列 API
  6. Class 对象是存放在堆的
  7. 类的字节码二进制数据,是放在方法区的,有的地方称为类的元数据(包括 方法代码,变量名,方法名,访问权限等等)。

2.Class 类的常用方法

方法名功能说明
static Class forName(String name)返回指定类名 nameClass对象
Object newInstance()调用缺省构造函数,返回该Class对象的一个实例
getName()返回此Class对象所表示的实体(类、接口、数组类、基本类型等)名称
Class getSuperClass()返回当前 Class 对象的父类的 Class对象
Class [] getInterfaces()获取当前 Class 对象的接口
ClassLoader getClassLoader()返回该类的类加载器
Class getSuperclass()返回表示此 Class 所表示的实体的超类的 Class
Constructor[] getConstructors()返回一个包含某些 Constructor 对象的数组
Field[] getDeclaredFields()返回 Field 对象的一个数组
Method getMethod(String name, Class ... paramTypes)返回一个 Method 对象,此对象的形参类型为 paramType

3.应用实例

package reflection;
​
public class Car {
    public String brand = "宝马";
    public int price = 500000;
    public String color = "白色";
​
    public String toString() {
        return "Cat{" +
                "brand='" + brand + ''' +
                ", price='" + price + ''' +
                ", color='" + color + ''' +
                '}';
    }
}
public class Class01 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        String classAllPath = "reflection.Car";
        // 1. 获取到 Car 类对应的 Class 对象
        // <?> 表示不确定的 Java 类型
        Class<?> cls = Class.forName(classAllPath);
        
        // 2. 输出 cls
        System.out.println(cls);              // 显示cls对象,是哪个类的Class对象
        System.out.println(cls.getClass());         // 输出 cls 运行类型 java.lang.Class
        
        // 3. 得到包名
        System.out.println(cls.getPackage().getName());
        
        // 4. 得到类名
        System.out.println(cls.getName());
        
        // 5. 通过cls创建对象实例
        Car car = (Car)cls.newInstance();
        System.out.println(car);
        
        // 6. 通过反射获取属性 brand,此方法不能获取私有属性
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));             // 宝马
        
        // 7. 通过反射给属性赋值
        brand.set(car, "奔驰");
        System.out.println(brand.get(car));             // 奔驰
        
        // 8. 获取所有的属性
        Field[] fields = cls.getFields();
        for (Field f : fields) {
            System.out.println(f.getName());
        }
    }
}

4.获取 Class 对象的6种方法

1.Class.forName()

前提:已知一个类的全类名,且该类在类路径下,可通过 Class 类的静态方法 forName() 获取,可能抛出 ClassNotFoundException,实例:Class cls1 = Class.forName("java.lang.Cat")

应用场景:多用于配置文件,读取类全路径,加载类。

2.类名.class

前提:若已知具体的类,可通过类的 class 获取,该方式最为安全可靠,程序性能最高实例:Class cls2 = Cat.class;

应用场景:多用于参数传递,比如通过反射得到对应构造器对象。

3.对象.getClass()

前提:已知某个类的实例,调用该实例的 getClass() 方法获取 Class 对象,实例:Class clazz = 对象.getClass();

应用场景:通过创建好的对象,获取 Class 对象。

4.通过类加载器获取

// 通过类加载器来获取类的 Class 对象
// (1)先得到类加载器 car
ClassLoader cl = 对象.getClass().getClassLoader();
// (2)通过类加载器得到 class 对象
Class clazz4 = cl.loadClass("类的全类名");

5.基本数据的 Class类对象

基本数据 (int, char, boolean, float, double, byte, long, short),按如下方式得到 Class类对象:

Class<对应包装类> cls = 基本数据类型.class;
// Class<Integer> integrClass = int.class;

6.包装类的 Class类对象

基本数据类型对应的包装类,可以通过 .type 得到 Class 类对象:

Class cls = 包装类.TYPE;
// Class<Integer> type = Integer.TYPE;

5.哪些类型有 Class 对象

  1. 外部类,成员内部类,静态内部类,局部内部类,匿名内部类
  2. interface:接口
  3. 数组
  4. enum:枚举
  5. annotation :注解
  6. 基本数据类型
  7. void
public static void main(String[] args) {
    Class<String> cls1 = String.class;                  // 外部类
    Class<Serializable> cls2 = Serializable.class;      // 接口
    Class<Integer[]> cls3 = Integer[].class;            // 数组
    Class<float[][]> cls4 = float[][].class;            // 二维数组
    Class<Deprecated> cls5 = Deprecated.class;          // 注解
​
    // 枚举
    Class<Thread.State> cls6 = Thread.State.class;
    Class<Long> cls7 = long.class;
    Class<Void> cls8 = void.class;
    Class<Class> cls9 = Class.class;
​
    System.out.println(cls1);
    System.out.println(cls2);
    System.out.println(cls3);
    System.out.println(cls4);
    System.out.println(cls5);
    System.out.println(cls6);
    System.out.println(cls7);
    System.out.println(cls8);
    System.out.println(cls9);
}
​
// 输出
class java.lang.String
interface java.io.Serializable
class [Ljava.lang.Integer;
class [[F
interface java.lang.Deprecated
class java.lang.Thread$State
long
void
class java.lang.Class

六、类加载

1.概念

反射机制是 Java 实现动态语言的关键,也就是通过反射实现类动态加载。

静态加载:编译时加载相关的类,如果没有则报错,依赖性太强。

动态加载:运行时加载需要的类,如果运行时不用该类,则不报错,即使不存在该类,也不报错,降低了依赖性。

2.类加载时机

  • 当创建对象时(new);(静态加载)
  • 当子类被加载时,父类也加载;(静态加载)
  • 调用类中的静态成员时;(静态加载)
  • 通过反射。(动态加载)

3.类加载过程

加载 -> 验证 -> 准备 -> 解析 -> 初始化

1.加载

JVm 在该阶段的主要目的是将字节码从不同的数据源(可能是 class 文件、也可能是 jar 包,甚至网络)转化为二进制字节流加载到内存中,并生成一个代表该类的 java.lang.Class 对象。

2.连接阶段-验证

目的是为了确保Class 文件的字节流中包含的信息符合当前虚拟机的要求,并且不会危害虚拟机自身的安全。

包括:文件格式验证、元数据验证、字节码验证和符号引用验证。

可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施,缩短虚拟机类加载的时间。

3.连接阶段-准备

JVM 会在该阶段对静态变量,分配内存并默认初始化(对应数据类型的默认初始值,如 00Lnullflase 等)。这些变量锁使用的内存都将在方法区中进行分配。

4.连接阶段-解析

虚拟机将常量池内的符号引用替换为直接引用的过程。

5.初始化

1.到初始化阶段,才真正开始执行类中定义的 Java 程序代码,此阶段是执行 <clinit>()方法的过程

2.<clinit>() 方法是由编译器按语句在源文件中出现的顺序,依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句,并进行合并。

3.虚拟机会保证一个类的 <clinit>() 方法在多线程环境中被正确地加锁、同步,如果多个线程同时去初始化一个类,那么只会有一个线程去执行这个类的 <clinit>() 方法,其他线程都需要阻塞等待,直到活动线程执行 <clinit>() 方法完毕。

七、获取类结构信息

1.java.lang.Class

getName:获取全类名
    
getSimpleName:获取简单类名
    
getFields:获取所有 public 修饰的属性,包含本类以及父类的
    
getDeclaredFields:获取本类中所有属性
    
getMethods:获取所有 public 修饰的方法,包含本类以及父类的
    
getDeclaredFields:获取本类中所有属性,不包括父类的
    
getConstructors:获取本类所有 public 修饰的构造器
    
getDeclaredConstructors:获取本类中所有的构造器
    
getPackage:以 Package 形式返回 包信息
    
getSuperClass:以 Class 形式返回父类信息
    
getInterfaces:以 Class[] 形式返回接口信息
    
getAnnotations:以 Annotation[] 形式返回注解信息

示例

class A {
    public String hobby;
    public void a() {}
}
​
interface IA {
}
​
interface IB {
}
​
@Deprecated
class Person extends A implements IA, IB{
    // 属性
    public String name;
    protected int age;
    String job;
    private double sal;
​
    // 方法
    public void m1() {}
    protected void m2() {}
​
    void m3() {}
​
    private void m4() {}
​
    public Person() {}
​
    public Person(String name) {}
​
    private Person(String name, int age) {}
}
@Test
public void api_01() throws ClassNotFoundException {
    // 1.得到 Class 对象
    Class<?> personCls = Class.forName("reflection.Person");
    // 2.获得全类名
    System.out.println(personCls.getName());
    // 3.获得简单类名
    System.out.println(personCls.getSimpleName());
    // 4.获取所有 public 修饰的属性,包含本类以及父类的
    Field[] fields = personCls.getFields();
    for (Field field : fields) {
        System.out.println("本类以及父类的 public 属性=" + field.getName());
    }
    // 5.获取本类中所有属性,不包括父类的
    Field[] fields1 = personCls.getDeclaredFields();
    for (Field field : fields1) {
        System.out.println("本类中的所有属性=" + field.getName());
    }
    // 6.获取所有 public 修饰的构造器,包含本类以及父类的
    Method[] methods = personCls.getMethods();
    for (Method method : methods) {
        System.out.println("本类以及父类的方法="+method.getName());
    }
    // 7.获取本类中的所有方法
    Method[] declaredMethods = personCls.getDeclaredMethods();
    for (Method declaredMethod : declaredMethods) {
        System.out.println("本类中所有方法=" + declaredMethod.getName());
    }
    // 8.获取所有 public 修饰的构造器,包含本类的构造器
    Constructor<?>[] constructors = personCls.getConstructors();
    for (Constructor<?> constructor : constructors) {
        System.out.println("本类public的构造器" + constructor.getName());
    }
    // 9.获取本类中的所有构造器
    Constructor<?>[] declaredConstructor = personCls.getDeclaredConstructors();
    for (Constructor<?> constructor : declaredConstructor) {
        System.out.println("本类中所有的构造器=" + constructor.getName());
    }
    // 10.以Package形式返回包信息
    System.out.println(personCls.getPackage());
    // 11.以Class形式返回父类信息
    Class<?> superclass = personCls.getSuperclass();
    System.out.println("父类的class对象=" + superclass);
    // 12.返回接口信息
    Class<?>[] interfaces = personCls.getInterfaces();
    for (Class<?> anInterface : interfaces) {
        System.out.println("接口信息=" + anInterface);
    }
    // 13.以Annotation[] 形式返回注解信息
    Annotation[] annotations = personCls.getAnnotations();
    for (Annotation annotation : annotations) {
        System.out.println("注解信息=" + annotation);
    }
}

2.java.lang.reflect.Field

  1. getModifiers:以 int 形式返回修饰符(说明:默认修饰符是0,public 是1,private是2,protected是4,static是8,final是16)。
  2. getType:以 Class形式返回类型。
  3. getName:返回属性名。
  4. getParameterTypes:以 Class[] 返回参数类型数组。
@Test
public void api_02() throws ClassNotFoundException {
    // 得到 Class 对象
    Class<?> personCls = Class.forName("反射.Person");
    // 获取本类中所有方法,不包括父类的
    Field[] fields1 = personCls.getDeclaredFields();
    for (Field field : fields1) {
        System.out.println("本类中的所有属性=" + field.getName()
            + " 该属性的修饰符值=" + field.getModifiers()
            + " 该属性的类型=" + field.getType());
        System.out.println();
    }
}

3.java.lang.reflect.Method

  1. getModifiers:以 int形式返回修饰符(说明:默认修饰符是0,public是1,private是2,protected是4,static是8,final是16)。
  2. getReturnType:以Class形式获取返回类型。
  3. getName:返回方法名
  4. getParameterTypes:以Class[] 返回参数类型数组。
@Test
public void api_03() throws ClassNotFoundException {
    // 得到 Class 对象
    Class<?> personCls = Class.forName("reflection.Person");
    // 获取本类中的所有方法
    Method[] declaredMethods = personCls.getDeclaredMethods();
    for (Method declaredMethod : declaredMethods) {
        System.out.println("本类中所有方法=" + declaredMethod.getName()
            + " 该方法的访问修饰符值=" + declaredMethod.getModifiers()
            + " 该方法返回类型=" + declaredMethod.getReturnType());
​
        // 输出当前这个方法的形参数组情况
        Class<?>[] parameterType = declaredMethod.getParameterTypes();
        for (Class<?> aClass : parameterType) {
            System.out.println("该方法的形参类型=" +aClass);
        }
        System.out.println();
    }
}

4.java.lang.reflect.Constructor

  1. getModifiers:以 int 形式返回修饰符。
  2. getName:返回构造器名(全类名)。
  3. getParameterTypes:以 Class[] 返回参数类型数组。
@Test
public void api_04() throws ClassNotFoundException {
    // 得到 Class 对象
    Class<?> personCls = Class.forName("reflection.Person");
    // 获取本类中所有的构造器
    Constructor<?>[] declaredConstructor = personCls.getDeclaredConstructors();
    for (Constructor<?> constructor : declaredConstructor) {
        System.out.println("本类中所有的构造器=" + constructor.getName());
        Class<?>[] parameterTypes = constructor.getParameterTypes();
        for (Class<?> parameterType : parameterTypes) {
            System.out.println("该构造器的形参类型=" + parameterType);
        }
        System.out.println();
    }
}

八、通过反射创建对象

概念

(1)方式一:调用类中的 public 修饰的无参构造器。

(2)方式二:调用类中的指定构造器。

Class类相关方法

  • newInstance:调用类中的无参构造器,获取对应类的对象;
  • getConstructor(Class... clazz):根据参数列表,获取对应的 public 构造器对象;
  • getDecalaredConstructor(Class... clazz):根据参数列表,获取对应的构造器对象;

Constructor类相关方法

  • setAccessible:暴力破解
  • newInstance(Object... obj):调用构造器

案例

  • 通过反射创建某类的对象,要求该类中必须有 public 的无参构造方法。
  • 通过调用某个特定构造器的方式,实现创建某类的对象。
public class ReflectCreateInstance {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        // 1. 先获取到 User 类的 Class 对象
        Class<?> userClass = Class.forName("reflection.User");
        // 2. 通过 public 的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);
        // 3. 通过 public 的有参构造器创建实例,并传入实参
        Constructor<?> constructor = userClass.getConstructor(String.class);
        Object o1 = constructor.newInstance("小帅哥");
        System.out.println(o1);
        // 4. 通过非 public 的有参构造器创建实例,需要修改 accessible 为 true 暴力破解
        Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
        constructor1.setAccessible(true);
        Object o2 = constructor1.newInstance(20, "大帅哥");
        System.out.println(o2);
    }
}
​
​
class User {
    private int age = 10;
    private String name = "帅哥";
​
    public User() {
​
    }
​
    public User(String name) {
        this.name =name;
    }
​
    private User(int age, String name) {
        this.age = age;
        this.name = name;
    }
​
    public String toString() {
        return "User [age=" + age + ", name=" + name + "]";
    }
}

九、通过反射操作属性

概念

1.根据属性名获取 Field 对象

Field f = clazz对象.getDeclaredField(属性名);

2.暴力破解

f.setAccessible(true);               // f 是 Field

3.访问

f.set(o, 值);                        // o 表示对象
System.out.println(f.get(o));       // o 表示对象
注意:如果是静态属性,则 setget 中的参数 o,可以写成 null

实例

public class ReflecAccessProperty {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        // 1. 得到 Student 类对应的 Class 对象
        Class<?> stuClass = Class.forName("reflection.Student");
        // 2. 创建对象
        Object o = stuClass.newInstance();
        System.out.println(o.getClass());
        // 3. 使用反射得到 age 属性对象
        Field age = stuClass.getField("age");
        age.set(o, 60);                               // 通过反射来操作属性
        System.out.println(o);
        System.out.println(age.get(o));
        // 4. 使用反射操作 name 属性(私有、静态),暴力破解
        Field name = stuClass.getDeclaredField("name");
        name.setAccessible(true);
        // 静态变量才可以用 null
        name.set(null, "帅哥");
        System.out.println(name.get(null));
    }
}
​
class Student {
    public int age;
    private static String name;
​
    public Student() {
​
    }
​
    public String toString() {
        return "age=" + age + ", name=" + name + "]";
    }
}
​

十、通过反射访问方法

概念

  1. 根据方法名和参数列表获取 Method 方法对象:clazz.getDeclaredMethod(方法名, XX.class);
  2. 获取对象:Object o = clazz.newInstance();
  3. 暴力破解:m.setAccessible(true);
  4. 访问:Object returnValue = m.invoke(o, 实参列表);(在反射中,方法返回都是 Object 类型)

注意:如果是静态方法,则 invoke 的参数 o,可以写成 null

实例

public class ReflecAccessMethod {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        // 1. 得到 Boss 类对应的 Class 对象
        Class<?> aClass = Class.forName("reflection.Boss");
        // 2. 创建对象
        Object o = aClass.newInstance();
        // 3. 获取 public 的方法
        Method hi = aClass.getMethod("hi", String.class);
        // 可获取所有的方法
        //Method hi = aClass.getDeclaredMethod("hi", String.class);
        // 4. 调用
        hi.invoke(o, "帅哥");
​
        // 5. 调用 private static 方法
        Method say = aClass.getDeclaredMethod("say", int.class, String.class, char.class);
        // 因为 say 方法是private,所以需要暴力破解
        say.setAccessible(true);
        System.out.println(say.invoke(o, 100, "张三", '男'));
        // 因为 say 方法是static的,还可以这样调用
        System.out.println(say.invoke(null, 200, "李四", '男'));
        
        // 6. 在反射中,如果方法有返回值,统一返回Object,但是他运行类型和方法定义的返回类型一致
        Object reVal = say.invoke(null, 300, "王五", '男');
        System.out.println("reVal 的运行类型=" + reVal.getClass());      // String
    }
}
​
class Boss {
    public int age;
    private static String name;
​
    public Boss() {
​
    }
​
    private static String say(int n, String s, char c) {
        return n + " " + s + " " + c;
    }
​
    public void hi(String s) {
        System.out.println("hi " + s);
    }
}

\