目录
 
1、调用本类属性
 
2、调用本类方法
 
3、表示当前对象
 

this是一个非常灵活的关键字，不会明确表示一个固定概念，比如int，它就是表示一个整型。
 
1、调用本类属性
 
类中有许多成员，大部分情况下类中直接进行成员调用，但是为了清楚的描述调用是本类属性，会用this.属性表示。
 
    class Person{
        String name;
        int age;
        public Person(){}
        public Person(String name, int age) {
            name = name;
            age = age;
        }
    }
 
如上定义的类，构造方法按上述写法，对象中不会保存我们定义的内容，而是默认值，因为程序以{}为界定范围，如果在此范围内有指定的变量名称，则会直接调用，若没有，则会调用类中的相应属性。
 
当参数与属性名称相同时，则会出现混淆，则需要用户自己手动明确调用的是属性还是方法中的参数，若是属性，则需要加this.属性，标准程序开发中都会以此方式进行：
 
    class Person{
        String name;
        int age;
        public Person(){}
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
 
2、调用本类方法
 
一个类中存在普通方法和构造方法，this调用本类方法时，对应的语法不同：
 
1）调用本类中的其他方法：this.方法()
 
一个类中可能存在很多方法，这些方法之间可以直接进行调用，但是不够标准，应用this.方法()调用，标准化风格。
 
2）调用本类其他构造方法：this()
 
一个类中可以有多个方法，且可以重载，并且构造方法在实例化对象时只能被调用一次。
 
若现在需求：Person类中中有三个构造方法，无论调用哪个构造方法，都要求执行语句"**********"。
 
【举例】：原始实现方式
 
    class Person{
        String name;
        int age;
        public Person(){
            System.out.println("********");
        }
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
            System.out.println("********");
        }
    }
 
程序设计的一个重要原则，避免重复代码。按照这个原则，以上的代码并不符合开发要求，这时可以使用this()形式实现，调用本类无参构造。
 
class Person{
        String name;
        int age;
        public Person(){
            System.out.println("********");
        }
        public Person(String name) {
            this();
            this.name = name;
        }
        public Person(String name, int age) {
            this(name);
            this.name = name;
            this.age = age;
        }
    }
 
需要注意的是，this()形式只能放在构造方法的首行。在使用this()调用本类其他构造方法时，应该避免循环调用。
 
下面通过实例说明构造方法互调的意义所在。
 
【举例】：写一个雇员的信息类，类中提供如下四个属性：姓名、职位、部门、工资，还有4个构造方法：
 
无参构造：姓名未知、职位待定、部门后勤、工资为0；
单参构造（姓名）：职位主管、部门技术部、工资10；
双参构造（姓名、部门）：职位工程师、工资5；
四参构造。
针对以上要求可以有两种代码实现方法：
 
第一种：传统实现
 
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Emp emp = new Emp();
        System.out.println(emp.getInfo());

    }


    class Emp{
        private String name;
        private String job;
        private String dept;
        private double sal;

        public Emp(){
            this.name ="未知";
            this.job = "待定";
            this.dept = "后勤";
            this.sal = 0.0;
        }
        public Emp(String name){
            this.name =name;
            this.job = "主管";
            this.dept = "技术部";
            this.sal = 10.0;
        }
        public Emp(String name,String dept){
            this.name =name;
            this.job = "工程师";
            this.dept = dept;
            this.sal = 5.0;
        }

        public Emp(String name,String job, String dept, double sal){
            this.name =name;
            this.job =job;
            this.dept = dept;
            this.sal = sal;


        }
        public String getInfo(){
            return "姓名："+this.name+"职位："+this.job+"部门："+this.dept+"工资："+this.sal;
        }
    }
 
以上程序重复的代码太多，过于冗余。
 
第二种：使用this改进
 
 protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Emp emp = new Emp();
        System.out.println(emp.getInfo());

    }


    class Emp{
        private String name;
        private String job;
        private String dept;
        private double sal;

        public Emp(){
            this("未知","待定","后勤",0.0);
        }
        public Emp(String name){
            this(name,"主管","技术部",10.0);
        }
        public Emp(String name,String dept){
            this(name,"工程师",dept,5.0);
        }

        public Emp(String name,String job, String dept, double sal){
            this.name =name;
            this.job =job;
            this.dept = dept;
            this.sal = sal;
        }
        public String getInfo(){
            return "姓名："+this.name+"职位："+this.job+"部门："+this.dept+"工资："+this.sal;
        }
    }
 
以上代码消除了很多重复代码，实际开发中应用较多。
 
3、表示当前对象
 
一个类，可以生成若干个对象，每个对象都可调用类中的方法，类中实际上很难描述某一个具体的对象，为了能区分出当前正在操作类中的方法是哪一个，可以使用this完成。
 
【举例】：观察
 
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Person perA = new Person();
        Person perB = new Person();

        System.out.println("MainActivity类中对象输出："+perA);
        System.out.println("MainActivity类中对象输出："+perB);

    }

    class Person{
    }
 
 
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Person perA = new Person();
        Person perB = new Person();

        System.out.println("MainActivity类中对象输出："+perA);
        perA.print();
        System.out.println("--------------------------------");
        System.out.println("MainActivity类中对象输出："+perB);
        perB.print();

    }

    class Person{

        void print(){
            System.out.println("Person类中的输出，this="+this);
        }
    }
 
 
由以上可知，由perA调用print()方法时，this=perA,由perB调用print()方法时，this=perB, 所以，this的对象引用会随着调用类方法对象的不同而不同，属于相对性的概念。
 
进一步考虑，this.属性表示的就是当前对象中的属性。
 
 
 
作于202004051735，已归档
 
———————————————————————————————————
 
本文为博主原创文章，转载请注明出处！
 
若本文对您有帮助，轻抬您发财的小手，关注/评论/点赞/收藏，就是对我最大的支持！
 
祝君升职加薪，鹏程万里！

java外部类如何调用内部类的属性和方法
 
 
 
解决方法：
 
    直接看代码
 
public static void main(String[] args) {
 
      //调用静态内部类的方式1
 
      TestChild testChild = new TestChild();
 
      testChild.test();
 
      //调用静态内部类的方式2
 
      TestChild testChild2 = new TestFather.TestChild();
 
      testChild2.test();
 
     
 
      //调用非静态内部类的方式：http://www.yayihouse.com/yayishuwu/chapter/1955
 
}
 
 

 
反射的定义及概述
 
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法（类名，方法名，参数类型，返回值类型）；对于任意一个对象，都能够调用它任意的一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
 
 总结来说就是，反射就是把java类中的各种成分映射成一个个   java对象例如：一个类有：成员变量、方法、构造方法，包等信息，利用反射技术可以对一个类进行解剖，把各个组成部分映射成一个个对象
 
 
反射的相关函数介绍：
 
  
获取类的三种方法 
    
 
第一种方式-->Class.forName("类名字符串")
 
      
 
Class c1=Class.forName("com.edu.Student");
 
 
第二种方式-->先创建对象,再用对象调用getClass()方法，即实例对象.getClass().返回运行时类
 
      
 
Student s=new Student();
 
 
Class c2 = s.getClass();
 
 
第三种方式-->类名.class。返回Class的对象。(每个类都有class属性)
 
      
 
Class c2 = s.getClass();    
 (!!!Class类用于表示.class文件（字节码），获取某个类时的前提条件就是获取该类的Class)
获取属性 
    
获取方法 
    
获取构造函数 
    
获取其他信息 
    
 
具体代码实现：
 
  
​​​​​​​引入工程截图 
    
​​​​​​​
获取类的类名 
    
​​​​​​​实体类Student  
      
​​​​​​​略
获取代码实现 
      
获取类的构造方法 
    
​​​​​​​Student类的构造方法 
      
​​​​​​​
获取的代码实现 
      
​​​​​​​
获取类的方法 
    
​​​​​​​Student类的方法 
      
​​​​​​​
获取的代码实现 
      
​​​​​​​
获取类的属性 
    
​​​​​​​Student类的属性 
      
​​​​​​​
获取属性的代码实现 
      
​​​​​​​
获取类的其他信息 
    
​​​​​​​获取的代码实现 
      
​​​​​​​
 
 
参考文献：
 
 
https://blog.csdn.net/sinat_38259539/article/details/71799078
https://blog.csdn.net/ylyang12/article/details/53469957
https://blog.csdn.net/qq_24341197/article/details/77964172
 
 
 
 
 
 
 
 
 
 
 
 
 

前面介绍了，反射调用类的构造方法来创建类的实例对象。一个类的结构包含方法(构造，静态,非静态)和属性（静态和非静态）。按照循环渐进的方式，接下来，介绍反射类中属性和普通的方法。
 
在这里简单介绍，反射调用属性和方法会用到的新类，Method类和Field类。
 
Method类的常用API：
 
getModifiers() : 获取方法的修饰符
getName(): 获取到方法的名称
getParameterTypes() : 获取到方法的全部参数类型
getReturnType(): 获取到方法的返回值类型
getException():获取方法中全部抛出的异常
invoke(Object obj,Object ... args):反射调用类中的方法
 
Field类的常用API:
 
get(Object obj):获取到属性的具体内容
set(Object ,Object value):设置指定属性的具体内容
getModifiers() : 获取属性的修饰符
isAccessible():判断属性是否可以被外部访问
setAccessible(boolean flag):设置这属性可以被外部访问。
 
案例实战
 
 
1. 定义一个接口：
 
定义一些行为，作为抽象方法。用于测试，反射调用实现类（覆盖重写的）方法。
 
package com.xingen.classdemo;

public interface ClassTestInterface {
    void testMethod(String name,String work);
}
 
2. 构建一个父类：
 
添加一些属性，进行封装。用于测试，反射调用父类私有属性。
 
package com.xingen.classdemo;

import java.lang.reflect.Constructor;

public class ClassTest2 {
    private String name;
    private String work;

    /**
     * 构建一个默认的构造方法
     */
    public ClassTest2() {
    }

    /**
     * 构建有参数构造方法
     *
     * @param name
     * @param work
     */
    public ClassTest2(String name, String work) {
        this.name = name;
        this.work = work;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getWork() {
        return work;
    }

    public void setWork(String work) {
        this.work = work;
    }

}
 
3. 创建一个子类：
 
该子类的作用有以下几点：
 
继承父类
实现若干接口，覆盖重写抽象方法，例如：testMethod(String name, String work)
定义自己本身的私有属性，例如：age字段
 
package com.xingen.classdemo;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ClassTest3 extends ClassTest2 implements ClassTestInterface {

    private int age;

    public ClassTest3() {
    }

    @Override
    public void testMethod(String name, String work) {
        this.setName(name);
        this.setWork(work);
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        StringBuffer stringBuffer = new StringBuffer();
        if (getName() != null) {
            stringBuffer.append("name: ");
            stringBuffer.append(getName());
            stringBuffer.append("\n");
        }
        if (getWork() != null) {
            stringBuffer.append("work: ");
            stringBuffer.append(getWork());
            stringBuffer.append("\n");
        }
        if (getAge() > 0) {
            stringBuffer.append("age: ");
            stringBuffer.append(getAge());
        }
        return stringBuffer.toString();
    }

}
 
4. 各种常用的反射场景：
 
4.1 案例之反射获取父类的信息：
 
先获取到Class对象，然后调用getSuperclass()获取到父类的Class对象。 
 众所众知，单继承，多实现，因此父类只有一个。这里，输出父类所属于的包信息。
 
    /**
     * 获取父类的信息
     */
    public static void testSuperClass() {
        try {
            Class<?> mClass = ClassTest3.class;
            //获取继承的父类
            Class<?> superClass = mClass.getSuperclass();
            System.out.println("获取继承父类的包路径：\n" + superClass.getName());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
输出结果是：
 
获取继承父类的包路径：
com.xingen.classdemo.ClassTest2
 
4.2 案例之反射获取实现接口的信息：
 
先获取到Class对象，然后调用getInterfaces()获取到全部实现接口的Class数组。因ClassTest3实现了一个接口，所以这里的数组索引值是0。接口的Class对象可以获取到接口中的完整信息，这里输出接口所属于的包信息。
 
    /**
     * 获取实现接口的信息
     */
    public static void testInterface() {
        try {
            Class<?> mClass = ClassTest3.class;
            /**
             * 获得全部实现的接口：Class<?>[] getInterfaces()得到的数组中，接口对象顺序和这个对象所表示的类中implements子句中接口名的顺序，是一致的。
             */
            Class<?>[] interfaceArray = mClass.getInterfaces();
            Class<?> interfaces = interfaceArray[0];
            System.out.println("获取实现接口的包路径： \n" + interfaces.getName());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
输出结果是：
 
获取实现接口的包路径： 
com.xingen.classdemo.ClassTestInterface
 
4.3 案例之反射调用覆盖重写的方法
 
先获取Class对象，然后通过getMethod()获取到指定的需要调用的方法。接下来，处理是否需要添加访问权限setAccessible(true)，最后通过invoke()进行方法调用。
 
    /**
     * 测试覆盖重写的方法
     */
    public static void testSuperMethod() {
        try {
            Class<ClassTest3> mClass = ClassTest3.class;
            ClassTest3 instance = mClass.newInstance();
            Method method = mClass.getMethod("testMethod", String.class, String.class);
            if (!method.isAccessible()) {
                method.setAccessible(true);
            }
            method.invoke(instance, "xinGen", "Android Lirary Developer");
            System.out.println("反射访问覆盖重写的方法：\n " + instance.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
输出结果是：
 
反射访问覆盖重写的方法：
name: xinGen
work: Android Lirary Developer
 
4.4 案例之反射调用本类定义的私有属性
 
先获取到Class对象，然后通过getDeclaredField()获取到本类定义的私有属性，再调用setAccessible()赋予访问权限，最后调用set()对私有属性内容修改。
 
     /**
     * 测试调用本身定义的私有属性
     */
    public static void testSelfField() {
        try {
            Class<ClassTest3> mClass = ClassTest3.class;
            ClassTest3 instance = mClass.newInstance();
            Field field = mClass.getDeclaredField("age");
            field.setAccessible(true);
            field.set(instance, 24);
            System.out.println("反射访问本类中Private修饰的属性：\n " + instance.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
输出结果是：
 
反射访问本类中Private修饰的属性：
age: 24
 
4.5 案例之反射调用父类中私有属性
 
先获取到Class对象，然后通过getSuperclass()获取到父类的Class对象，再调用getDeclaredField()获取到父类的私有属性，最后调用set()，对私有属性进行内容修改。这里，最后输出修改后的内容。
 
  /**
     * 测试调用父类私有属性
     */
    public static void testSuperField() {
        try {
            Class<ClassTest3> mClass = ClassTest3.class;
            ClassTest3 instance = mClass.newInstance();
            Field field = mClass.getSuperclass().getDeclaredField("name");
            field.setAccessible(true);
            field.set(instance, "xinGen");
            System.out.println("反射访问父类中Private修饰的属性：\n " + instance.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
输出结果是：
 
反射访问父类中Private修饰的属性：
name: xinGen
 
5. 运行main()入口程序
 
package com.xingen.classdemo;

public class Client {

    public static void main(String[] args) {
        useClassFieldAndMethod();
    }
    /**
     * 使用Class类：读写属性和方法
     */
    public static void useClassFieldAndMethod() {
        ClassTest3.testInterface();
        ClassTest3.testSuperClass();
        ClassTest3.testSuperMethod();
        ClassTest3.testSelfField();
        ClassTest3.testSuperField();
    }
}
 
 
反射调用属性的归纳总结：
 
先判断该属性是否public修饰
若是，则使用getField()获取。
反之，则判断是否是类本身单独定义属性。
若是，则使用getDeclaredField（）去获取。
反之，则先通过getSuperclass()获取到父类的Class对象，再去调用getDeclaredField()去获取。
 
同理，反射调用方法和调用属性的思路类似。
 
本案例的项目代码： https://github.com/13767004362/JavaDemo/tree/master/ClassDemo