package com.java.TypeDome;
public class TypeDome {
    public static void main(String[] args) {
        // 1、自动类型转换
        // 占内存小的类型的变量可以赋值给内存占的大的类型的变量
        byte a = 10;
        int b = a;  // 发生了自动的类型转换
        System.out.println(a);
        System.out.println(b);
        System.out.println("---------------------------------------------");
        // 2、表达式的自动类型转换
        // 表达式的最终结果类型由表达式中的最高类型决定
        int i = 10;
        int j = 10;
        double ij = 1.0;
        // int ji = i + j + ij;  java: 不兼容的类型: 从double转换到int可能会有损失
        double ji = i + j + ij;
        System.out.println(ji);
        // 在表达式中，byte、short、char是直接转换成int类型参与运算的
        byte one = 20;
        byte two = 25;
        // byte three = one + two;  java: 不兼容的类型: 从int转换到byte可能会有损失
        int three = one + two;
        System.out.println(three);
        System.out.println("---------------------------------------------");
        // 3、强制类型转换
        // 强制类型转换可能造成数据的丢失
        // 下面的数据都为有符号位
        int o = 1500;  // 00000101 11011100
        byte t = (byte) o;  // 11011100
        System.out.println(t);  // 输出结果：-36
        // 小数强制转换为整数是直接舍弃小数保留整数
        double dou = 81.5;
        int interesting = (int) dou;
        System.out.println(interesting);  // 输出结果：81
    }
}

package com.java.operator;
public class Operators {
    public static void main(String[] args) {
        // 1、运算符有+、-、*、/、%，和c、和python中的运算符一模一样
        // 2、+除了做基本的数学运算符，在与字符串进行+运算时会被当成连接符，其结果还是字符串；加法口诀：能算则算，不能算则拼接成字符串
        int i = 10;
        String str = "Thank You";
        System.out.println((str + i));  // 输出显示：Thank You10
        System.out.println("---------------------------------------------");
        // 3、自增运算符++和自减运算符--的运算规则：++或者--在变量的前面表示先自增或者自减后再运算，在变量的后面表示先运算再自增或者自减
        int m = 10;
        int n = m++;
        System.out.println(m);  // 11
        System.out.println(n);  // 10
        System.out.println("---------------------------------------------");
        // 4、赋值运算符：+=、-=、*=、/=、%=；赋值运算符格式：变量 赋值运算符 (变量的类型) 值
        int o = 10;
        double t = 20.0;
        o += t;
        System.out.println(o);  // 显示结果：30
        System.out.println("---------------------------------------------");
        // 5、条件运算符：==、!=、>=、<=、>、<；如果条件成立就返回true，条件不成立就返回false
        int d1 = 10;
        int d2 = 5;
        System.out.println(d1 == d2);  // 显示结果：false
        System.out.println("---------------------------------------------");
        // 6、逻辑运算符：逻辑与(&)、逻辑或(|)、逻辑非(!)、逻辑异或(^)、短路与(&&)、短路或(||);
        // 逻辑与：必须都为true，有一个false就为false，但前一个为false后一个依旧执行
        System.out.println((d1 <= d2) & (++d2 >= 10));
        System.out.println(d2);
        // 短路与：必须都为true，有一个false就为false，但前一个为false后一个就不执行
        System.out.println((d1 <= d2) && (++d2 >= 10));
        System.out.println(d2);
        // 逻辑或：得有一个为true，全部为false就为false。但前一个为true后一个依旧执行
        // 短路或：得有一个为true，全部为false就为false。但前一个为true后一个就不执行
        // 逻辑非：取反
        // 逻辑异或：相同是false，不同是true
        System.out.println("---------------------------------------------");
        // 7、三元运算符格式：条件表达式？条件表达式为true时返回的值: 条件表达式为false时返回的值；
        int zhen = d1 >= d2? d1: d2;
        System.out.println(zhen);
    }
}

package com.java.ProcessControl;
import java.util.Scanner;
public class IfElse {
    public static void main(String[] args) {
        // if(条件表达式1) {
        //  条件表达式1返回值为true时执行的代码……
        // } else if(条件表达式2) {
        //  条件表达式1不成立但条件表达式2成立时执行的代码
        // }……else {
        //  如果上面的所有条件表达式都不成立时执行的代码
        // }
        Scanner sca = new Scanner(System.in);
        System.out.println("请输入该同学的成绩：");
        int grades = sca.nextInt();
        if (grades < 0 || grades > 100) {
            System.out.println("成绩不存在");
        }else  if (grades >= 90) {
            System.out.println("该同学必成龙凤！！");
        }else if (grades >= 80) {
            System.out.println("该同学成绩优秀");
        }else if (grades >= 70) {
            System.out.println("该同学成绩一般");
        }else if (grades >= 60) {
            System.out.println("该同学成绩及格，还需努力！");
        }else {
            System.out.println("挂科");
        }
    }
}

package com.java.ProcessControl;
import java.util.Scanner;
public class SwitchCase {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入当前汽车挡位");
        int i = s.nextInt();  // 输入一个整形数据
        switch (i) {  // switch (表达式) {}中表达式不支持double、float、long类型
            case 1:  // case给出的值不允许重复，且只能是字符串常量或字面量。
                System.out.println("很稳健！");
                break;  // 不要忘记写break，不然会往下执行，直到退出switch
            case 2:
                System.out.println("你准备加速了!");
                break;
            case 3:
                System.out.println("请注意别超速");
                break;
            case 4:
                System.out.println("请注意减速！");
                break;
            case 5:
                System.out.println("你开的太快了！");
                break;
            case '6':
                System.out.println("此车没有倒挡！");
                break;
            default:
                System.out.println("没有此挡位！");
        }
    }
}

package com.java.circulate;
public class Circulate {
    public static void main(String[] args) {
        /*
        * for (初始化数据语句;循环条件;迭代语句) {
        *   循环代码;
        * }
        * */
        int sum=0;
        for (int i=1;i<6;i++) {
            sum += i;
        }
        System.out.println(sum);
        /*
        * while (循环条件) {
        *   循环语句;
        *   迭代语句;
        * }
        * */
        int i=1;
        while (i<=1000) {
            int num=1;
            int j=i;
            for (;i!=0;i/=10) {
                num*=(i%10);
            }
            i=j;
            if (num == i) {
                System.out.println(i);
            }
            i++;
        }
        /*
        * do {
        *   循环语句;
        *   迭代语句;
        * } while (循环条件);
        * do{}while循环的特点：一定会先执行一次循环体里的内容。
        * */
        int n=1;
        do {
            System.out.println("我是" + n);
            n++;
        }while (n%2==0);
        /*
        * break:跳出并结束当前所在循环的执行，或者结束所在switch分支的执行
        * continue：用于跳出当前循环的当次执行，进入下一次循环，只能在循环中使用
        * */
    }
}

package com.java.ArrayDemo;
public class JavaArray {
    public static void main(String[] args) {
        // 数据类型[] 数组名称 = new 数据类型[]{元素1、元素2……}  // new代表创建的意思
        int[] arr1 = new int[] {1,2,3,4,5,6};
        // 简化写法：
        int[] arr2 = {7,8,9,10,11,12,13,14,15};
        // 取值：数组名[索引];
        System.out.println(arr2[5]);
        int i = arr1[3];
        System.out.println(i);
        // 赋值：数组名[索引] = 值;
        arr2[3] = 100;
        System.out.println(arr2[3]);
        // 获取数组最大的长度：数组名.length;
        System.out.println(arr2.length);
        // 数组其他写法：数据类型 数组名称[]
        int arr3[] = {1,2,3,4,5};
        // 什么类型的数组只能存放什么类型的数据
        // 数组一旦定义出来之后，类型和长度也就固定了
        /*
        * 动态初始化数组：当前还不清楚要存哪些数据就使用动态初始化数组
        * byte、short、char、int、long动态初始化默认值为0；float、double动态初始化默认值为0.0；boolean动态初始化默认值为false
        * 类、API接口、数组、String动态初始化数组为null
        * */
        int[] arr4 = new int[3];
        System.out.println(arr4[0]); // 0
        System.out.println(arr4[1]); // 0
        arr4[2] = 100;
        System.out.println(arr4[2]); // 100
    }
}

package com.java.method;
public class Methods {
    public static void main(String[] args) {
        /* 方法格式：
        *修饰符 返回值类型 方法名(形参列表){
        *   方法中要执行的代码
        *   return 要返回的值;  // 方法声明了具体的返回值类型，内部必须使用return返回对应的数据类型的数据
        * }
        * 注意：基本类型数据传入到方法中是传入的值，修改传入到方法的值是不会影响到全局变量；
        * 而引用类型数据传入到方法中的是地址，修改方法内的值是会改变全局变量的
        * */
        int s = sum(100,200);
        System.out.println(s);
    }
    public  static int sum(int a,int b) {
        return a+b;
    }
}

package com.java.ClassObject;
/*
 * JAVA类声明中关键字public起到什么作用呢？如下ClassMethod类的声明:
 * 按着字面的意思理解是：ClassMethod类是公共的，要求ClassMethod类与类文件名必须保持一致，并且一个java文件中只能有一个public关键字声明的类。
 * public是表示公有的，private是表示私有的，私有的只能在面向对象中访问。
 * */
/*
* Java面向对象底层原理：
* Java面向对象底层是由三个区域组成，分别是方法区、栈内存、堆内存，执行流程大概如下所示：
* 1、将类加载到方法区
* 2、将类中的main方法压入栈内存当中
* 3、执行main方法中的代码，如果创建对象又会将对象对应的类加载到方法区，并且将对象的相对偏移地址压入栈内存中存储，而对象在堆内存中存储。
* 4、堆内存中的对象不仅可以存储属性数据，还可以存储方法（即对象的方法），但方法是以引用地址的形式存储在堆内存当中，方法代码需要通过引用地址去方法区调用。
* 5、方法区中存储了类的结构信息，包括类的属性、方法、常量池等。
* */
public class ClassMethod {
    public static void main(String[] args) {
        // 创建对象：类名 对象名 = new 类名();
        Zoo z = new Zoo("市中心动物园", 10);
        z.n = 1;
        z.main("长颈鹿", 11.4, 0.8);
    }
}

package com.java.ClassObject;
public class Zoo {
    public String name;
    public int num;
    // 定义无参数构造器，构造器就是对面向对象属性进行初始化
    public Zoo() {
        System.out.println("这是无参数构造器！");
    }
    // 定义有参数构造器
    public Zoo(String name, int num) {
        this.name = name;  // this关键字代表用于存储当前对象的存储地址
        this.num = num;
        System.out.println("动物园叫" + name + "，动物园有" + num + "动物园区");
        System.out.println("这是有参数构造器！");
    }
    // 定义/初始化变量：修饰符 数据类型 变量名称 = 初始化值;
    public int n;
    public static void dong_wu(String name,double h,double w) {
        System.out.println("在动物园看到了" + name + ",它身高有" + h + "米，它宽度有" + w + "米");
    }
    public void main(String z, double h, double w) {
        for (;n!=0;n--) {
            dong_wu(z, h, w);
        }
    }
}

public class Student {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

class SubClass extends SuperClass {
    // SubClass 类的属性和方法
}

public class SubClass extends SuperClass {   public SubClass(int x, int y) {      super(x); // 调用父类的有参构造器      // 子类的构造器逻辑   }}

public class SubClass extends SuperClass {   public SubClass(int x) {      this(x, 0); // 调用本类的有参构造器   }
   public SubClass(int x, int y) {      super(x); // 调用父类的有参构造器      // 子类的构造器逻辑   }}

class Animal {
    public void makeSound() {
        System.out.println("未知的叫声");
    }
}
class Dog extends Animal {
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}
class Cat extends Animal {
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal dog = new Dog();
        Animal cat = new Cat();
        animal.makeSound();
        dog.makeSound();
        cat.makeSound();
    }
}

未知的叫声
汪汪汪
喵喵喵

interface Animal {
    void makeSound();
}
class Dog implements Animal {
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}
class Cat implements Animal {
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
        dog.makeSound();
        cat.makeSound();
    }
}

汪汪汪
喵喵喵

class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}
class Cat extends Animal {
    public void eat() {
        System.out.println("Cat is eating");
    }
}
class Dog extends Animal {
    public void eat() {
        System.out.println("Dog is eating");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal a = new Animal();
        Animal b = new Cat();
        Animal c = new Dog();
        a.eat(); // Animal is eating
        b.eat(); // Cat is eating
        c.eat(); // Dog is eating
    }
}

public class Animal {
    public void move() {
        System.out.println("动物在移动");
    }
}
public class Dog extends Animal {
    @Override
    public void move() {
        System.out.println("狗在奔跑");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.move(); // 输出：动物在移动
        Dog dog = new Dog();
        dog.move(); // 输出：狗在奔跑
    }
}

package com.java.day1_static;
public class User {
    public static int usernum;
    public static int Val(int num1, int num2) {
        return Math.max(num1, num2);
    }
}

package com.java.day2_static_code;
public class StaticCode {
    // 静态代码块：如果在启动系统时对静态资源进行初始化，则建议使用静态代码块完成数据的初始化作用
    public static String username;
    static {
        System.out.println("静态代码块对静态资源进行初始化啦！");
        username = "张三";
    }
    public static void main(String[] args) {
        System.out.println("main方法开始执行了！");
    }
}

public abstract class Animal {  // abstract表示该类是抽象类
    private String name;
    public Animal(String name) {
        this.name = name;
    }
    public abstract void move();
    public void eat() {
        System.out.println(name + "在吃东西");
    }
}
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    @Override
    public void move() {
        System.out.println(super.getName() + "在奔跑");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("小狗");
        animal.move();
        animal.eat();
    }
}

public interface 接口名 {
    // 常量定义
    // 方法声明
}

public interface Animal {
    int LEGS = 4;
    void move();
}
public class Dog implements Animal {
    @Override
    public void move() {
        System.out.println("狗在奔跑");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.move();
        System.out.println("狗有" + Animal.LEGS + "条腿");
    }
}

public class Outer {
    private int x = 10;
    public class Inner {
        public void print() {
            System.out.println("x = " + x);
        }
    }
}

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.print();

public class Outer {
    private static int x = 10;
    public static class Inner {
        public void print() {
            System.out.println("x = " + x);
        }
    }
}

Outer.Inner inner = new Outer.Inner();
inner.print();

public class Outer {
    private int x = 10;
    public void test() {
        class Inner {
            public void print() {
                System.out.println("x = " + x);
            }
        }
        Inner inner = new Inner();
        inner.print();
    }
}

Outer outer = new Outer();
outer.test();

new 父类构造器/接口() {
    // 匿名内部类的内容
}

public interface Animal {
    void move();
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal() {
            @Override
            public void move() {
                System.out.println("动物在移动");
            }
        };
        animal.move();
    }
}

package com.java.day5_exception;
// 1、自定义运行时异常类必须让这个类继承RuntimeException，这样才可以成为一个运行时异常类
// 2、需要重写构造器，当我们创建异常对象时可能需要将参数传给有参构造器进行初始化
public class AgeUnreasonableRuntimeException extends RuntimeException{
    public AgeUnreasonableRuntimeException() {
    }
    public AgeUnreasonableRuntimeException(String message) {  // message参数是用来封装我们自定义异常出现的原因
        // 将封装我们自定义异常出现的原因的参数传给父类的有参构造器，最后由父类来封装我们自定义异常出现的原因
        super(message);
    }
}

package com.java.day5_exception;
// 1、自定义编译时异常类必须让这个类继承Exception，这样才可以成为一个编译时异常类
// 2、需要重写构造器，当我们创建异常对象时可能需要将参数传给有参构造器进行初始化
public class AgeUnreasonableException extends Exception{
    public AgeUnreasonableException() {
    }
    public AgeUnreasonableException(String message) {  // message参数是用来封装我们自定义异常出现的原因
        // 将封装我们自定义异常出现的原因的参数传给父类的有参构造器，最后由父类来封装我们自定义异常出现的原因
        super(message);
    }
}

package com.java.day5_exception;
import java.util.Scanner; //导入 java.util 包下的 Scanner 类。
public class ExceptionOne {
    public static void main(String[] args) {
        // try……catch用于捕获和处理可能出现的异常。
        try {
            System.out.println("请输入合理的年龄：");
            // 创建了一个Scanner对象，并将System.in作为其参数。System.in取得用户输入的内容后,交给Scanner来作一些处理。
            Scanner scan = new Scanner(System.in);
            // nextInt()方法会等待用户输入一个整数，并将其返回。如果用户输入的内容不是一个有效的整数，则会抛出InputMismatchException异常。
            int num = scan.nextInt();
            // 调用detection方法，如果年龄符合我们定义的合理年龄就正常执行，如果不合理detection方法就会向这里抛出AgeUnreasonableRuntimeException异常
            detection(num);
        } catch (RuntimeException e) { // 如果执行try中代码捕获到RuntimeException异常类以及其子类的对象，那就会执行catch中的代码
            // 打印异常信息
            e.printStackTrace();
        }
        try {
            System.out.println("请输入合理的年龄：");
            Scanner scan2 = new Scanner(System.in);
            int num2 = scan2.nextInt();
            // 调用detection2方法，如果年龄符合我们定义的合理年龄就正常执行，如果不合理detection2方法就会向这里抛出AgeUnreasonableException异常
            detection2(num2);
        } catch (Exception e) {  // 如果执行try中代码捕获到Exception异常类以及其子类的对象，那就会执行catch中的代码
            // 打印异常信息
            e.printStackTrace();
        }
    }
    // 编译时异常
    public static void detection2(int age) throws AgeUnreasonableException{
        if (age>0 && age<150) {
            System.out.println(age + "岁年龄是合理的");
        }else {
            // 用一个编译时异常对象封装这个问题。那我们就需要自己创建一个编译时异常类，所以我创建了一个编译时异常类AgeUnreasonableRuntimeException
            // throw：用于抛出这个异常对象，它会将异常对象先抛到方法的入口这里，再抛给方法的调用者。
            // 所以我们自定义异常会将编译时异常对象先抛到detection方法入口处，再抛给detection方法的调用者。
            // 我们将需要自定义编译时异常类抛出的异常信息作为参数传给了我们自定义的编译时异常类的有参构造器并创建一个编译时异常对象，并将创建的编译时异常对象抛出去。
            // 编译时异常写代码的时候就会强烈提醒你，所以我们自定义编译时异常类被实例化的时候报错是正常的。想要解决这个报错需要用到throws
            // throws：用在方法上，它会将方法内部的异常抛给调用该方法的上层。如果用在main方法上，那就会将main方法内部的异常抛给JVM虚拟机。
            throw new AgeUnreasonableException("The age you entered is" + age +  "years old is not reasonable");
        }
    }
    // 运行时异常
    public static void detection(int age) {
        if (age>0 && age<150) {
            System.out.println(age + "岁年龄是合理的");
        }else {
            // 用一个运行时异常对象封装这个问题。那我们就需要自己创建一个运行时异常类，所以我创建了一个运行时异常类AgeUnreasonableRuntimeException
            // throw：用于抛出这个异常对象，它会将异常对象先抛到方法的入口这里，再抛给方法的调用者。
            // 所以我们自定义异常会将运行时异常对象先抛到detection方法入口处，再抛给detection方法的调用者。
            // 我们将需要自定义运行时异常类抛出的异常信息作为参数传给了我们自定义的运行时异常类的有参构造器并创建一个运行时异常对象，并将创建的运行时异常对象抛出去。
            throw new AgeUnreasonableRuntimeException("The age you entered is" + age +  "years old is not reasonable");
        }
    }
}

package com.java.day5_exception;
import java.util.Scanner;
public class ExceptionTwo {
    public static void main(String[] args) {
        try {
            runs();
        } catch (Exception e) { // 如果调用runs方法因为输入非int型的数据触发了Exception异常就打印对应的中文异常信息
            System.out.println("您需要输入整数型数据，而非其他类型数据！");
        }
    }
    public static void runs() throws Exception{
        System.out.println("请输入合理的年龄：");
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        try {
            detection(num);
            detection2(num);
        } catch (AgeUnreasonableRuntimeException e) { // 如果出现我们自定义的运行时异常就打印对应的中文异常信息提醒用户
            System.out.println("您输入的年龄不合理！触发了运行时异常。");
        } catch (AgeUnreasonableException e) { // 如果出现我们自定义的编译时异常就打印对应的中文异常信息提醒用户
            System.out.println("您输入的年龄不合理！触发了编译时异常。");
        }
    }
    // 编译时异常
    public static void detection2(int age) throws AgeUnreasonableException{
        if (age>0 && age<150) {
            System.out.println(age + "岁年龄是合理的");
        }else {
            throw new AgeUnreasonableException("The age you entered is" + age +  "years old is not reasonable");
        }
    }
    // 运行时异常
    public static void detection(int age) {
        if (age>0 && age<150) {
            System.out.println(age + "岁年龄是合理的");
        }else {
            throw new AgeUnreasonableRuntimeException("The age you entered is" + age +  "years old is not reasonable");
        }
    }
}

package com.java.day5_exception;
import java.util.Scanner;
public class ExceptionThree {
    public static void main(String[] args) {
        // 捕获到下层抛来的异常对象就告诉用户需要重新输入，并重新执行runs方法，直到用户输入的int型数据合理就会break
        while (true) {
            try {
                runs();
                break;
            } catch (Exception e) {
                System.out.println("您需要输入整数型数据，而非其他类型数据，需要您重新输入！");
            }
        }
    }
    // 如果捕获到AgeUnreasonableRuntimeException、AgeUnreasonableException异常对象就让用户重新输入。
    // 想要终止输入，就需要用户输入的int型数据合理就会break
    // 如果捕获到Exception异常对象而非我们自定义的异常对象，就将Exception异常对象抛给上层调用者。
    public static void runs() throws Exception{
        while (true) {
            System.out.println("请输入合理的年龄：");
            Scanner scan = new Scanner(System.in);
            int num = scan.nextInt();
            try {
                detection(num);
                detection2(num);
                break;
            } catch (AgeUnreasonableRuntimeException e) {
                System.out.println("您输入的年龄不合理！触发了运行时异常。");
            } catch (AgeUnreasonableException e) {
                System.out.println("您输入的年龄不合理！触发了编译时异常。");
            }
        }
    }
    // 编译时异常
    public static void detection2(int age) throws AgeUnreasonableException{
        if (age>0 && age<150) {
            System.out.println(age + "岁年龄是合理的");
        }else {
            throw new AgeUnreasonableException("The age you entered is" + age +  "years old is not reasonable");
        }
    }
    // 运行时异常
    public static void detection(int age) {
        if (age>0 && age<150) {
            System.out.println(age + "岁年龄是合理的");
        }else {
            throw new AgeUnreasonableRuntimeException("The age you entered is" + age +  "years old is not reasonable");
        }
    }
}

package com.java.day6_reflect;
import com.java.day5_exception.ExceptionThree;
public class ReflectClass {
    public static void main(String[] args) throws Exception{
        // 第一种方式：Class<这里需要获取的Class对象的类名，不知道就可以填?> 变量名 = 类名.class;
        Class<ExceptionThree> a = ExceptionThree.class;
        System.out.println(a.getName());  // 获取class对象的完整类名
        // 第二种方式：调用Class提供的方法获取类的class对象。
        // 格式：Class<?> 变量名 = Class.forName(类的完整路径);
        Class<?> b = Class.forName("com.java.day5_exception.ExceptionThree");
        System.out.println(b.getSimpleName());  // 获取class对象的类名
        // 第三种方式：通过类的对象调用Object提供的getClass方法获取类的class对象。
        ExceptionThree c = new ExceptionThree();
        Class<?> d = c.getClass();  // 格式：Class<?> 变量名 = Object.getClass();
        // 这三种方式获取的ExceptionThree类的class对象是同一份class对象，只是获取方式不一样。
        // 因为ExceptionThree类的class对象在内存中肯定只有一份
        if (a == b) {
            System.out.println("这三种方式获取类的class对象是同一份class对象");
        }else {
            System.out.println("这三种方式获取类的class对象不是同一份class对象");
        }
    }
}

package com.java.day6_reflect;
public class Zoon {
    public String name;
    public int age;
    public Zoon(String name, int age) {
        this.name = name;
        this.age = age;
    }
    private Zoon(){
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

Class<?> a = Zoon.class;  // 想要完成反射第二步、第三步，那都需要得到类的Class对象

Constructor[] b = a.getConstructors();

for (Constructor constructor : b) {
    System.out.println("这是第一种方式获得的构造器对象："+constructor.getName()+"，这个构造器有"+constructor.getParameterCount()+"个参数！");
}

Class<?> a = Zoon.class;  // 想要完成反射第二步、第三步，那都需要得到类的Class对象

Constructor[] c = a.getDeclaredConstructors();

for (Constructor constructor : c) {
    System.out.println("这是第二种方式获得的构造器对象："+constructor.getName()+"，这个构造器有"+constructor.getParameterCount()+"个参数！");
}

Class<?> a = Zoon.class;  // 不管怎样，想要获取Class对象中的各种信息，第一步永远是获取类的Class对象

// 获取有参构造器需要往getConstructor方法中填写对应有参构造器的参数类型来匹配有参构造器
Constructor e = a.getConstructor(String.class, int.class);
System.out.println("这是第三种方式获得的有参构造器对象："+e.getName()+"，这个构造器有"+e.getParameterCount()+"个参数！");

Constructor d = a.getConstructor();
System.out.println("这是第三种方式获得的无参构造器对象："+d.getName());

Class<?> a = Zoon.class;

// 获取有参构造器需要往getConstructor方法中填写对应有参构造器的参数类型来匹配有参构造器
Constructor e = a.getConstructor(String.class, int.class);
System.out.println("这是第三种方式获得的有参构造器对象："+e.getName()+"，这个构造器有"+e.getParameterCount()+"个参数！");

Constructor d = a.getConstructor();
System.out.println("这是第三种方式获得的无参构造器对象："+d.getName());

package com.java.day6_reflect;
import org.junit.Test;
import java.lang.reflect.Constructor;
public class ReflectConstructors {
    // @Test注释是JUnit框架中用于标记测试方法的注释。通过使用@Test注释，JUnit可以识别并执行被标记的方法作为测试用例。
    // 在使用@Test注释之前，需要引入JUnit框架。可以通过在项目中添加JUnit依赖来实现。
    // 被@Test修饰的方法必须是公共的、方法必须不能带有参数、方法必须没有返回值。
    // 被@Test注释标记的方法不能抛出任何异常。如果测试方法需要测试某个异常情况，可以使用@Test注释的expected参数来指定期望的异常类型。
    @Test
    public void test() {
        // 第一种方式：获取全部构造器(只能获取public修饰的)
        Class<?> a = Zoon.class;  // 想要完成反射第二步、第三步，那都需要得到类的Class对象
        // 调用类的getConstructors方法，可以得到类的全部构造器。但是这个方法会把类的每一个构造器都封装成构造器对象，然后把所有构造器对象放到一个构造器数组里面去。
        Constructor[] b = a.getConstructors();
        // 验证：遍历构造器数组中的每一个构造器对象，并打印构造器名称和参数个数
        for (Constructor constructor : b) {
            System.out.println("这是第一种方式获得的构造器对象："+constructor.getName()+"，这个构造器有"+constructor.getParameterCount()+"个参数！");
        }
    }
    @Test
    public void test1() {
        // 第二种方式：获取全部构造器(只要存在就能拿到)
        Class<?> a = Zoon.class;
        Constructor[] c = a.getDeclaredConstructors();
        // 验证：遍历构造器数组中的每一个构造器对象，并打印构造器名称和参数个数
        for (Constructor constructor : c) {
            System.out.println("这是第二种方式获得的构造器对象："+constructor.getName()+"，这个构造器有"+constructor.getParameterCount()+"个参数！");
        }
    }
    @Test
    public void test2() throws Exception{
        // 第三种方式：获取某一个构造器(只能获取public修饰的)
        Class<?> a = Zoon.class;
        // 格式：Constructor 变量 = 类的class.getConstructor(Class<?>... parameterTypes);
        // 获取有参构造器
        // 获取有参构造器需要往getConstructor方法中填写对应有参构造器的参数类型来匹配有参构造器
        Constructor e = a.getConstructor(String.class, int.class);
        System.out.println("这是第三种方式获得的有参构造器对象："+e.getName()+"，这个构造器有"+e.getParameterCount()+"个参数！");
        Constructor d = a.getConstructor(); // 获取无参构造器
        System.out.println("这是第三种方式获得的无参构造器对象："+d.getName());
    }
    @Test
    public void test3() throws Exception{
        // 第四种方式：获取某一个构造器(只要存在就能拿到)
        Class<?> a = Zoon.class;
        // 格式：Constructor 变量 = 类的class.getDeclaredConstructor(Class<?>... parameterTypes);
        Constructor d = a.getDeclaredConstructor(); // 获取无参构造器
        System.out.println("这是第四种方式获得的无参构造器对象："+d.getName());
        // 获取有参构造器
        // 获取有参构造器需要往getDeclaredConstructor方法中填写对应有参构造器的参数类型来匹配有参构造器
        Constructor e = a.getDeclaredConstructor(String.class, int.class);
        System.out.println("这是第四种方式获得的有参构造器对象："+e.getName()+"，这个构造器有"+e.getParameterCount()+"个参数！");
    }
}

@Test
public void test4() throws Exception{
    Class<?> a = Zoon.class;
    Constructor f = a.getDeclaredConstructor(String.class, int.class);
    f.setAccessible(true);  // 将构造器对象方法setAccessible的flag参数设置为true，表示禁止检查访问控制(暴力反射)。简而言之：就算是修饰为私有的，我也能在外面访问。
    // 通过newInstance构造器对象方法调用此构造器对象表示的构造器，并传入参数，完成对象的初始化并返回
    Zoon f2 = (Zoon) f.newInstance("长颈鹿", 3);  // 因为我们在获取类的构造器的时候，接收构造器对象的变量在接收时并不知道这个构造器是哪个类的构造器，导致构造器对象返回的类型还是Object类型，所以需要在这里强转类型。
}

package com.java.day6_reflect;
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class ReflectField {
    @Test
    public void fields1() throws Exception{
        // 第一种方式：获取类的全部成员变量(只能获取public修饰的)
        Class<?> a = Zoon.class;
        // 调用类的getFields方法，可以得到类的全部成员变量。但是这个方法会把类的每一个成员变量都封装成成员变量对象，然后把所有成员变量对象放到一个成员变量数组中去，只是只能获取public修饰的成员变量。
        Field[] b = a.getFields();
        // 验证：遍历成员变量数组中的每一个成员变量对象，并打印成员变量名称和成员变量类型
        for (Field field : b) {
            System.out.println("这是第一种方式获得的成员变量对象" + "成员变量名称：" + field.getName() + "，" + "成员变量类型：" + field.getType());
        }
    }
    @Test
    public void fields2() throws Exception{
        // 第二种方式：获取类的全部成员变量(只要存在就能拿到)
        Class<?> a = Zoon.class;
        // 调用类的getDeclaredFields方法，可以得到类的全部成员变量。这个方法也会把类的每一个成员变量都封装成成员变量对象，然后把所有成员变量对象放到一个成员变量数组中去，但是只要存在就能拿到。
        Field[] b = a.getDeclaredFields();
        // 验证：遍历成员变量数组中的每一个成员变量对象，并打印成员变量名称和成员变量类型
        for (Field field : b) {
            System.out.println("这是第二种方式获得的成员变量对象" + "成员变量名称：" + field.getName() + "，" + "成员变量类型：" + field.getType());
        }
    }
    @Test
    public void fields3() throws Exception{
        // 第三种方式：获取类的某个成员变量(只能获取public修饰的)
        Class<?> a = Zoon.class;
        // 调用类的getField方法，可以得到类的某个成员变量。这个方法想要获取到某个成员变量，就需要告诉它要获取的成员变量的名字，只是只能获取public修饰的成员变量。
        Field b = a.getField("name");
        // 验证：打印获取到的某个成员变量的成员变量名称和成员变量类型
        System.out.println("这是第三种方式获得的成员变量对象" + "成员变量名称：" + b.getName() + "，" + "成员变量类型：" + b.getType());
    }
    @Test
    public void fields4() throws Exception {
        // 第四种方式：获取类的某个成员变量(只要存在就能拿到)
        Class<?> a = Zoon.class;
        // 调用类的getDeclaredField方法，可以得到类的某个成员变量。这个方法想要获取到某个成员变量，就需要告诉它要获取的成员变量的名字，但是只要存在就能拿到。
        Field b = a.getDeclaredField("name");
        Field c = a.getDeclaredField("age");
        // 验证：打印获取到的某个成员变量的成员变量名称和成员变量类型
        System.out.println("这是第四种方式获得的成员变量对象" + "成员变量名称：" + b.getName() + "，" + "成员变量类型：" + b.getType());
        System.out.println("这是第四种方式获得的成员变量对象" + "成员变量名称：" + c.getName() + "，" + "成员变量类型：" + c.getType());
    }
    @Test
    public void fields5() throws Exception{
        // 使用类的成员变量
        Class<?> a = Zoon.class;
        Field[] b = a.getDeclaredFields();
        Zoon c = new Zoon();
        for (Field field : b) {
            // 在使用Field类来设置值或获取值时，都需要先获取到该成员变量的对象，然后通过Field对象来进行操作。
            // 而且不管是设置值、还是获取值，都需要告诉Field对象需要对哪个对象的这个成员变量进行操作。
            if (field.getName().equals("age")) {
                field.setAccessible(true); // 禁止检查访问控制(暴力反射)
                field.set(c, 5);  // Field类.set(需要设置值的成员变量所属对象, 想要设置的值)
            }else {
                field.set(c, "老虎");
            }
            System.out.println(field.get(c));
        }
    }
}

package com.java.day6_reflect;
import org.junit.Test;
import java.lang.reflect.Method;
public class ReflectMethod {
    @Test
    public void methods1() throws Exception{
        // 第一种方式：获取类的全部成员方法(只能获取public修饰的)
        Class<?> a = Zoon.class;
        // 调用类的getMethods方法，可以得到类的全部成员方法。但是这个方法会把类的每一个成员方法都封装成成员方法对象，然后把所有成员方法对象放到一个成员方法数组中去，只是只能获取public修饰的成员方法。
        Method[] b = a.getMethods();
        // 验证：遍历成员方法数组中的每一个成员方法对象，并打印成员方法名称和成员方法参数个数以及成员方法返回值类型
        for (Method method : b) {
            System.out.println("这是第一种方式获得的成员方法对象" + "成员方法名称：" + method.getName() + "，"
                    + "成员方法参数个数：" + method.getParameterCount() + "，"
                    + "成员方法返回值类型：" + method.getReturnType());
        }
    }
    @Test
    public void methods2() throws Exception{
        // 第二种方式：获取类的全部成员方法(只要存在就能拿到)
        Class<?> a = Zoon.class;
        // 调用类的getDeclaredMethods方法，可以得到类的全部成员方法。这个方法也会把类的每一个成员方法都封装成成员方法对象，然后把所有成员方法对象放到一个成员方法数组中去，但是只要存在就能拿到。
        Method[] b = a.getDeclaredMethods();
        // 验证：遍历成员方法数组中的每一个成员方法对象，并打印成员方法名称和成员方法参数个数以及成员方法返回值类型
        for (Method method : b) {
            System.out.println("这是第二种方式获得的成员方法对象" + "成员方法名称：" + method.getName() + "，"
                    + "成员方法参数个数：" + method.getParameterCount() + "，"
                    + "成员方法返回值类型：" + method.getReturnType());
        }
    }
    @Test
    public void methods3() throws Exception{
        // 第三种方式：获取类的某个成员方法(只能获取public修饰的)
        Class<?> a = Zoon.class;
        // 调用类的getMethod方法，可以得到类的某个成员方法。getMethod方法想要获取到某个成员方法，就需要告诉它要获取的成员方法的名字以及参数类型，只是只能获取public修饰的成员方法。
        Method b = a.getMethod("getName");
        // 验证：打印获取到的某个成员方法的成员方法名称和成员方法参数个数以及成员方法返回值类型
        System.out.println("这是第三种方式获得的成员方法对象" + "成员方法名称：" + b.getName() + "，"
                + "成员方法参数个数：" + b.getParameterCount() + "，"
                + "成员方法返回值类型：" + b.getReturnType());
    }
    @Test
    public void methods4() throws Exception {
        // 第四种方式：获取类的某个成员方法(只要存在就能拿到)
        Class<?> a = Zoon.class;
        // 调用类的getDeclaredMethod方法，可以得到类的某个成员方法。getDeclaredMethod方法想要获取到某个成员方法，就需要告诉它要获取的成员方法的名字以及参数类型，但是只要存在就能拿到。
        Method b = a.getDeclaredMethod("setName", String.class);
        // 验证：打印获取到的某个成员方法的成员方法名称和成员方法参数个数以及成员方法返回值类型
        System.out.println("这是第四种方式获得的成员方法对象" + "成员方法名称：" + b.getName() + "，"
                + "成员方法参数个数：" + b.getParameterCount() + "，"
                + "成员方法返回值类型：" + b.getReturnType());
    }
    @Test
    public void methods5() throws Exception{
        // 触发类的成员方法执行
        Class<?> a = Zoon.class;
        // 在使用Method类来触发类的成员方法执行时，需要先获取到该成员方法的对象，然后通过Method对象来进行操作。
        // 而且想要触发某个类的成员方法执行都需要告诉Method对象需要对哪个对象的这个成员方法进行操作。
        Method b = a.getDeclaredMethod("getName");
        Method c = a.getDeclaredMethod("setName", String.class);
        Zoon d = new Zoon();
        c.setAccessible(true); // 禁止检查访问控制(暴力反射)
        c.invoke(d, "熊猫");  // Method类.invoke(需要执行的成员方法所属对象, 执行成员方法所需参数)
        System.out.println(b);
    }
}

const/4 p5, 0x1 //p5赋值1
const/16 v0, 0xa //v0赋值10，在16进制里a表示10

//一个私有、静态、不可变的方法   方法名
.method private static final onCreate$lambda-2([Ljava/lang/String;)Z//(这里面是方法的参数)这里是方法返回值类型，表示布尔值类型，返回假或真

...fill-array-data v0, :array_0  // 将字面量数组数据填充到 v0 寄存器所代表的数组中，:array_0为字面量数组数据的偏移地址(偏移量)...:array_0    .array-data 2            // 表示每个数组元素占用两个字节        0x14ebs             // 数组元素值为 0x14eb（short 类型）        0x15f0s             // 数组元素值为 0x15f0（short 类型）        0x15c7s             // 数组元素值为 0x15c7（short 类型）        0x15c7s             // 数组元素值为 0x15c7（short 类型）        0x15c7s             // 数组元素值为 0x15c7（short 类型）        0x15c7s             // 数组元素值为 0x15c7（short 类型）        0x15c7s             // 数组元素值为 0x15c7（short 类型）        0x15c7s             // 数组元素值为 0x15c7（short 类型）...

switch (this.mType) {            case 1:                return Math.signum(0.5d - (getP(d) % 1.0d));            case 2:                abs = Math.abs((((getP(d) * 4.0d) + 1.0d) % 4.0d) - 2.0d);                break;            case 3:                return (((getP(d) * 2.0d) + 1.0d) % 2.0d) - 1.0d;            case 4:                abs = ((getP(d) * 2.0d) + 1.0d) % 2.0d;                break;            case 5:                return Math.cos(this.PI2 * getP(d));            case 6:                double abs2 = 1.0d - Math.abs(((getP(d) * 4.0d) % 4.0d) - 2.0d);                abs = abs2 * abs2;                break;            default:                return Math.sin(this.PI2 * getP(d));        }

packed-switch v0, :pswitch_data_5e   # 带着v0寄存器中的值跳转到索引表偏移量:pswitch_data_5e位址寻找对应的case指令偏移量的索引     .line 120    # default分支语句    iget-wide v0, p0, Landroidx/constraintlayout/motion/utils/Oscillator;->PI2:D     invoke-virtual {p0, p1, p2}, Landroidx/constraintlayout/motion/utils/Oscillator;->getP(D)D     move-result-wide p1     mul-double/2addr v0, p1     invoke-static {v0, v1}, Ljava/lang/Math;->sin(D)D     move-result-wide p1     return-wide p1     .line 132    :pswitch_17 # case 6    invoke-virtual {p0, p1, p2}, Landroidx/constraintlayout/motion/utils/Oscillator;->getP(D)D     move-result-wide p1     mul-double/2addr p1, v1     rem-double/2addr p1, v1     sub-double/2addr p1, v3     invoke-static {p1, p2}, Ljava/lang/Math;->abs(D)D     move-result-wide p1     sub-double p1, v5, p1     mul-double/2addr p1, p1     :goto_25  # 所有case的出口，也可以说是在case中执行break后跳转到此处    sub-double/2addr v5, p1     return-wide v5     .line 130    :pswitch_27 # case 5    iget-wide v0, p0, Landroidx/constraintlayout/motion/utils/Oscillator;->PI2:D     invoke-virtual {p0, p1, p2}, Landroidx/constraintlayout/motion/utils/Oscillator;->getP(D)D     move-result-wide p1     mul-double/2addr v0, p1     invoke-static {v0, v1}, Ljava/lang/Math;->cos(D)D     move-result-wide p1     return-wide p1     .line 128    :pswitch_33 # case 4    invoke-virtual {p0, p1, p2}, Landroidx/constraintlayout/motion/utils/Oscillator;->getP(D)D     move-result-wide p1     mul-double/2addr p1, v3     add-double/2addr p1, v5     rem-double/2addr p1, v3     goto :goto_25 # 跳转到偏移量为goto_25的目标位址     .line 126    :pswitch_3b # case 3    invoke-virtual {p0, p1, p2}, Landroidx/constraintlayout/motion/utils/Oscillator;->getP(D)D     move-result-wide p1     mul-double/2addr p1, v3     add-double/2addr p1, v5     rem-double/2addr p1, v3     sub-double/2addr p1, v5     return-wide p1     .line 124    :pswitch_44 # case2    invoke-virtual {p0, p1, p2}, Landroidx/constraintlayout/motion/utils/Oscillator;->getP(D)D     move-result-wide p1     mul-double/2addr p1, v1     add-double/2addr p1, v5     rem-double/2addr p1, v1     sub-double/2addr p1, v3     invoke-static {p1, p2}, Ljava/lang/Math;->abs(D)D     move-result-wide p1     goto :goto_25 # 跳转到偏移量为goto_25的目标位址     :pswitch_51 # case 1    const-wide/high16 v0, 0x3fe0000000000000L    # 0.5     .line 122    invoke-virtual {p0, p1, p2}, Landroidx/constraintlayout/motion/utils/Oscillator;->getP(D)D     move-result-wide p1     rem-double/2addr p1, v5     sub-double/2addr v0, p1     invoke-static {v0, v1}, Ljava/lang/Math;->signum(D)D     move-result-wide p1     return-wide p1     :pswitch_data_5e    .packed-switch 0x1 # 索引表，case常量从1开始，依次递增        :pswitch_51 # case 1        :pswitch_44 # case 2        :pswitch_3b # case 3        :pswitch_33 # case 4        :pswitch_27 # case 5        :pswitch_17 # case 6    .end packed-switch

switch (transit) {            case 4097:                return 8194;            case 4099:                return 4099;            case 8194:                return 4097;            default:                return 0;        }

sparse-switch p0, :sswitch_data_e  # sparse-switch指令，传入寄存器p0的值作为查找表的索引，:sswitch_data_e是查询表的偏移量                                       .line 2025                    # 源代码的行号    :goto_4                       # 这里是所有case的出口，如果case常量没匹配上查询表中的值，那么v0寄存器中的值就为0，这里就返回零，也就是default下的代码return 0;    return v0                     # 返回v0寄存器中的值     .line 2016                    # 源代码的行号    :sswitch_5                    # 标签，对应表中的第一个case常量0x1001    const/16 v0, 0x2002           # 将0x2002赋值给v0寄存器                    .line 2017                    # 源代码的行号    goto :goto_4                  # 无条件跳转到:goto_4标签处执行     .line 2019                    # 源代码的行号    :sswitch_8                    # 标签，对应表中的第三个case常量0x2002    const/16 v0, 0x1001           # 将0x1001赋值给v0寄存器          .line 2020                    # 源代码的行号    goto :goto_4                  # 无条件跳转到:goto_4标签处执行     .line 2022                    # 源代码的行号                          :sswitch_b                    # 标签，对应表中的第二个case常量0x1003    const/16 v0, 0x1003           # 将0x1003赋值给v0寄存器    goto :goto_4                  # 无条件跳转到:goto_4标签处执行     .line 2014                    # 源代码的行号    :sswitch_data_e               # 标签，作为查询表的偏移量    .sparse-switch                # 表示接下来是一个查询表        0x1001 -> :sswitch_5      # case常量0x1001跳转到标签:sswitch_5处执行        0x1003 -> :sswitch_b      # case常量0x1003跳转到标签:sswitch_b处执行        0x2002 -> :sswitch_8      # case常量0x2002跳转到标签:sswitch_8处执行    .end sparse-switch            # 标志着查询表的结束

iput-object v0, p0, Lbin/mt/apksignaturekillerplus/HookApplication;->appPkgName:Ljava/lang/String;

iput-object v0, p0, Lbin/mt/apksignaturekillerplus/HookApplication;->appPkgName:Ljava/lang/String;

iput-wide v1, p0, Lcom/alipay/android/phone/mrpc/core/l;->e:J

iput v0, p0, Lcom/alipay/android/phone/mrpc/core/e;->a:I

iget-object v4, p0, Lbin/mt/apksignaturekillerplus/HookApplication;->appPkgName:Ljava/lang/String;

iget-boolean v1, p0, Lbin/mt/plugin/api/translation/TranslationEngine$ConfigurationBuilder;->acceptTranslated:Z

iget-wide v3, p0, Lcom/alipay/android/phone/mrpc/core/l;->g:J

iget v1, v8, Landroid/util/TypedValue;->data:I

sput-object v0, Lbin/tools/inject/InjectedLog;->TIME_FORMAT1:Ljava/text/SimpleDateFormat;

sput-boolean v6, Lcom/alipay/sdk/cons/a;->r:Z

sput-wide v0, Lcom/alipay/sdk/app/PayTask;->i:J

sput v0, Lcom/google/android/material/appbar/AppBarLayout;->DEF_STYLE_RES:I

sget-object v17, Ljava/lang/System;->out:Ljava/io/PrintStream;

sget-boolean v1, Lbin/mt/plus/Features;->ۘf:Z

sget-wide v2, Lcom/alipay/android/phone/mrpc/core/b;->a:J

sget v0, Landroid/os/Build$VERSION;->SDK_INT:I

sget-object v17, Ljava/lang/System;->out:Ljava/io/PrintStream; const-string/jumbo v18, "PmsHook success." invoke-virtual/range {v17 .. v18}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V

.class public interface abstract Landroid/support/v4/os/IResultReceiver;// 这个类是android.support.v4.os这个包下名为IResultReceiver的接口类.super Ljava/lang/Object; // 该类继承了父类java.lang.Object.source "IResultReceiver.java" // 这个smali文件在还是Java文件时，文件名为IResultReceiver.java

**.field <访问权限> static [修饰关键字] <字段名>:<字段类型>**

.field private static final PARAMETER_BUFFER:Ljava/lang/ThreadLocal;

.field <访问权限> [修饰关键字] <字段名>:<字段类型>

.field public final mConstructorArgs:[Ljava/lang/Object;

# direct methods.method <访问权限> [修饰关键字] <方法名称、参数还有返回值>    <.registers>  // 指定了方法中寄存器的总数，这个数量是参数寄存器和本地寄存器的总和。    <.local>  // 这个指令表明方法中非参数寄存器(本地寄存器)的个数    [.param]  // 表明了方法的参数，每个.param指令表示一个参数，方法使用了几个参数就有几个.param指令。    [.prologue]  // 表明了方法中代码的开始处    [.line]  // 表名了该处代码在源代码中的行号    <代码体>.end method

.method public static spatialSampling(Landroid/gesture/Gesture;IZ)[F// 定义一个公共静态方法，返回一个浮点数数组// 方法名为spatialSampling，参数为Gesture对象、整型bitmapSize和布尔型keepAspectRatio    .locals 0    // 定义本地寄存器数为0     .param p0, "gesture"    # Landroid/gesture/Gesture;    // 定义一个参数p0，类型为Gesture，表示手势对象    .param p1, "bitmapSize"    # I    // 定义一个参数p1，类型为整型，表示位图大小    .param p2, "keepAspectRatio"    # Z    // 定义一个参数p2，类型为布尔型，表示是否保持宽高比     new-instance p0, Ljava/lang/RuntimeException;    // 创建一个RuntimeException对象，将其引用赋值给p0     invoke-direct {p0}, Ljava/lang/RuntimeException;-><init>()V    // 调用RuntimeException对象的构造方法，初始化该对象     throw p0    // 抛出RuntimeException对象 .end method// 方法结束

# virtual methods.method <访问权限> [修饰关键字] <方法名称、参数还有返回值>    <.registers>  // 指定了方法中寄存器的总数，这个数量是参数寄存器和本地寄存器的总和。    <.local>  // 这个指令表明方法中非参数寄存器(本地寄存器)的个数    [.param]  // 表明了方法的参数，每个.param指令表示一个参数，方法使用了几个参数就有几个.param指令。    [.prologue]  // 表明了方法中代码的开始处    [.line]  // 表名了该处代码在源代码中的行号    <代码体>.end method

# virtual methods// 定义虚方法 .method public final createConnectionKeepAliveStrategy()Lorg/apache/http/conn/ConnectionKeepAliveStrategy;// 方法名为createConnectionKeepAliveStrategy，返回值类型为ConnectionKeepAliveStrategy对象// final关键字表示该方法不能被子类重写    .locals 1    // 定义本地寄存器数为1     new-instance v0, Lcom/alipay/android/phone/mrpc/core/f;    // 创建一个com.alipay.android.phone.mrpc.core.f类的实例对象，并将其引用赋值给v0     invoke-direct {v0, p0}, Lcom/alipay/android/phone/mrpc/core/f;-><init>(Lcom/alipay/android/phone/mrpc/core/d;)V    // 调用v0对象的构造方法，将p0对象作为参数传入。    // 这里要注意v0寄存器中存放的是com.alipay.android.phone.mrpc.core.f类的实例对象，也可以说是java中的this。     return-object v0    // 将v0对象返回.end method// 方法结束

# interfaces .implements <接口名>

# interfaces .implements Ljava/lang/reflect/InvocationHandler;// 当前类实现了接口Ljava/lang/reflect/InvocationHandler;

<type signature> ::= <class type> | <array type> | <type variable><class type> ::= L <fully qualified class name> ; <type arguments>*<array type> ::= [ <type><type variable> ::= T <identifier> ;<type arguments> ::= <type argument>*<type argument> ::= <wildcard> | <reference type><wildcard> ::= ? <wildcard bound>?<wildcard bound> ::= extends <reference type> | super <reference type><reference type> ::= <class type> | <type variable>

# annotation.annotation [注解属性] <注解类名>    [注解字段 = 值].end annotation

.class public interface abstract annotation Ll/۬ۘ;.super Ljava/lang/Object;.source "H5TW" # annotation// 定义注解.annotation runtime Ljava/lang/annotation/Retention;// 定义一个运行时注解Retention// runtime表示该注解在运行时可见，即可以通过反射获取该注解信息// Ljava/lang/annotation/Retention表示Retention注解的类型签名    value = .enum Ljava/lang/annotation/RetentionPolicy;->CLASS:Ljava/lang/annotation/RetentionPolicy;    // 枚举类型，表示Retention注解的保留策略为CLASS    // .enum表示定义一个枚举类型    // Ljava/lang/annotation/RetentionPolicy表示RetentionPolicy枚举的类型签名    // ->表示枚举类型的访问符    // CLASS表示RetentionPolicy枚举的一个值，表示注解保留在类文件中，但在运行时不可见.end annotation// 注解定义结束

.method public onTouch(Landroid/view/View;Landroid/view/MotionEvent;)Z    .locals 0    .annotation build Landroid/annotation/SuppressLint;    // 定义一个编译时注解SuppressLint    // build表示该注解是Android SDK提供的注解    // Landroid/annotation/SuppressLint表示SuppressLint注解的类型签名    value = {        "ClickableViewAccessibility"    }    // 定义注解的属性value，表示需要忽略的lint警告类型    // "ClickableViewAccessibility"表示需要忽略的lint警告类型，即点击事件缺少无障碍支持.end annotation// 注解定义结束

.field public top:F    .annotation runtime Ljava/lang/Deprecated;    // 定义一个运行时注解Deprecated    // runtime表示该注解在运行时可见，即可以通过反射获取该注解信息    // Ljava/lang/Deprecated表示Deprecated注解的类型签名    .end annotation    // 注解定义结束 .end field

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:gravity="center">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />
    <Button
        android:id="@+id/skip"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="跳转" />
</LinearLayout>

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:gravity="center">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/my_activity1"/>
</LinearLayout>

<resources>
    <string name="app_name">My Application</string>
    <string name="my_activity1">My First Activity</string>
</resources>

package com.example.myapplication;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
public class MyActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my);
    }
}

package com.example.myapplication;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button skip = findViewById(R.id.skip);
        skip.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent();
                intent.setClass(MainActivity.this, MyActivity.class);
                startActivity(intent);
            }
        });
    }
}

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.MyApplication"
        tools:targetApi="31">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name=".MyActivity"/>
    </application>
</manifest>

# classes3.dex
.class public Lcom/example/myapplication/MainActivity;
.super Landroidx/appcompat/app/AppCompatActivity;
.source "MainActivity.java"
# direct methods
.method public constructor <init>()V
    .registers 1
    .line 10
    invoke-direct {p0}, Landroidx/appcompat/app/AppCompatActivity;-><init>()V
        return-void
.end method
# virtual methods
.method protected onCreate(Landroid/os/Bundle;)V
    .registers 4
    .param p1, "savedInstanceState"  # Landroid/os/Bundle;
    .line 14
    invoke-super {p0, p1}, Landroidx/appcompat/app/AppCompatActivity;->onCreate(Landroid/os/Bundle;)V
        .line 15
    sget v0, Lcom/example/myapplication/R$layout;->activity_main:I
        invoke-virtual {p0, v0}, Lcom/example/myapplication/MainActivity;->setContentView(I)V
        .line 16
    sget v0, Lcom/example/myapplication/R$id;->skip:I
        invoke-virtual {p0, v0}, Lcom/example/myapplication/MainActivity;->findViewById(I)Landroid/view/View;
        move-result-object v0
        check-cast v0, Landroid/widget/Button;
        .line 17
    .local v0, "skip":Landroid/widget/Button;
    new-instance v1, Lcom/example/myapplication/MainActivity$1;
        invoke-direct {v1, p0}, Lcom/example/myapplication/MainActivity$1;-><init>(Lcom/example/myapplication/MainActivity;)V
        invoke-virtual {v0, v1}, Landroid/widget/Button;->setOnClickListener(Landroid/view/View$OnClickListener;)V
        .line 25
    return-void
.end method

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Reverse the first software！"
        android:textSize="24sp"
        android:layout_gravity="center" />
</LinearLayout>

# classes3.dex
.class Lcom/example/myapplication/MainActivity$1;
.super Ljava/lang/Object;
.source "MainActivity.java"
# interfaces
.implements Landroid/view/View$OnClickListener;
# annotations
.annotation system Ldalvik/annotation/EnclosingMethod;
    value = Lcom/example/myapplication/MainActivity;->onCreate(Landroid/os/Bundle;)V
.end annotation
.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x0
    name = null
.end annotation
# instance fields
.field final synthetic this$0:Lcom/example/myapplication/MainActivity;
# direct methods
.method constructor <init>(Lcom/example/myapplication/MainActivity;)V
    .registers 2
    .param p1, "this$0"  # Lcom/example/myapplication/MainActivity;
    .line 17
    iput-object p1, p0, Lcom/example/myapplication/MainActivity$1;->this$0:Lcom/example/myapplication/MainActivity;
        invoke-direct {p0}, Ljava/lang/Object;-><init>()V
        return-void
.end method
# virtual methods
.method public onClick(Landroid/view/View;)V
    .registers 5
    .param p1, "v"  # Landroid/view/View;
    .line 20
    new-instance v0, Landroid/content/Intent;
        invoke-direct {v0}, Landroid/content/Intent;-><init>()V
        .line 21
    .local v0, "intent":Landroid/content/Intent;
    iget-object v1, p0, Lcom/example/myapplication/MainActivity$1;->this$0:Lcom/example/myapplication/MainActivity;
        const-class v2, Lcom/example/myapplication/MyActivity;
        invoke-virtual {v0, v1, v2}, Landroid/content/Intent;->setClass(Landroid/content/Context;Ljava/lang/Class;)Landroid/content/Intent;
        .line 22
    iget-object v1, p0, Lcom/example/myapplication/MainActivity$1;->this$0:Lcom/example/myapplication/MainActivity;
        invoke-virtual {v1, v0}, Lcom/example/myapplication/MainActivity;->startActivity(Landroid/content/Intent;)V
        .line 23
    return-void
.end method

# classes3.dex
.class public Lcom/example/myapplication/MyActivity;
.super Landroidx/appcompat/app/AppCompatActivity;
.source "MyActivity.java"
# direct methods
.method public constructor <init>()V
    .registers 1
    .line 8
    invoke-direct {p0}, Landroidx/appcompat/app/AppCompatActivity;-><init>()V
        return-void
.end method
# virtual methods
.method protected onCreate(Landroid/os/Bundle;)V
    .registers 3
    .param p1, "savedInstanceState"  # Landroid/os/Bundle;
    .line 11
    invoke-super {p0, p1}, Landroidx/appcompat/app/AppCompatActivity;->onCreate(Landroid/os/Bundle;)V
        .line 12
    sget v0, Lcom/example/myapplication/R$layout;->activity_my:I
        invoke-virtual {p0, v0}, Lcom/example/myapplication/MyActivity;->setContentView(I)V
        .line 13
    return-void
.end method

sget v0, Lcom/example/myapplication/R$layout;->activity_new:I

# 往期推荐

1、IOFILE exploit入门

2、入门编译原理之前端体验

3、如何用纯猜的方式逆向喜马拉雅xm文件加密(wasm部分)

4、反恶意软件扫描接口(AMSI)如何帮助您防御恶意软件

5、sRDI — Shellcode反射式DLL注入技术

6、对APP的检测以及参数计算分析