擒贼先擒王
擒贼先擒王

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作

Java 教程：https://www.runoob.com/java/java-modifier-types.html

1、环境搭建

jdk、jre

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第1张图片

  • JRE，（ Java Runtime Envrionment ），Java 运行时环境。含JVM和运行必备的类库。 电脑上想要运行java程序，就必须安装JRE。

  • JDK，（ Java Development Kit ），Java开发工具【包含JRE】、【Java开发】。含JRE 和 开发必备的工具。 工具包含：编译工具javac.exe 和 运行工具java.exe 想要开发Java应用程序，就必须安装JDK。

接下来，下载后直接解压。然后配置下环境变量。

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第2张图片

JDK 安装成功之后就可以编写 Java 代码并编译 & 运行。

  • 编写 Hello.java文件

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

打开终端编译并运行

>>>javac Hello.java

>>>java Hello

编写代码建议使用 IDE（集成开发环境）来提供开发效率。

集成开发工具 IDE

编写Java代码时建议大家使用IDE（集成开发环境）来提供开发效率。这里推荐使用 idea

官网地址：https://www.jetbrains.com/zh-cn/idea/

2、初识 Java

代码的初步分析： Hello.java

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

文件名

  • 一个文件中最多只能有一个public类，文件名需要与此public类一致。
  • 如果文件中有多个类，文件名与public类名一致。
  • 如果文件中有多个类 且 无public类，文件名可与任意类名一致。

类名

一般首字母大写，例如：Hello、UserInfo

Java 修饰符

Java 语言提供了很多修饰符，主要分为以下两类：

  • 访问修饰符
  • 非访问修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。

public class ClassName {
   // ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
   // 方法体
}

访问控制 ( public、private、protected ) 修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

  • default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

  • private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

  • public : 对所有类可见。使用对象：类、接口、变量、方法

  • protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

我们可以通过以下表来说明访问权限：

访问控制
修饰符 当前类 同一包内 子孙类(同一包) 子孙类(不同包) 其他包
public Y Y Y Y Y
protected Y Y Y Y/N（说明） N
default Y Y Y N N
private Y N N N N

默认访问修饰符-不使用任何关键字

如果在类、变量、方法或构造函数的定义中没有指定任何访问修饰符，那么它们就默认具有默认访问修饰符。

默认访问修饰符的访问级别是包级别（package-level），即只能被同一包中的其他类访问。

如下例所示，变量和方法的声明可以不使用任何修饰符。

访问控制和继承

请注意以下方法继承的规则：

  • 父类中声明为 public 的方法在子类中也必须为 public。

  • 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。

  • 父类中声明为 private 的方法，不能够被子类继承。

类 修饰符：public、default ( 默认 )

// public，表示此类可以被任意类调用，例如：
src
├── Hello.java
└── utils
    └── Request.java


// Request.Java文件
package utils;

public class Request {
    public void show(){
        System.out.println("哈哈哈哈哈");
    }
}


// Hello.java文件
import utils.Request;

public class Hello {
    // 程序入口
    public static void main(String[] args) {
        // 根据类创建了一个对象
        Request req = new Request();
        // 对象.show()
        req.show();
    }
}

// default，表示此类只能在当前包被调用，例如：
src
├── Hello.java
└── utils
    ├── Helper.java
    └── Request.java

// Request.Java文件
package utils;
class Request {
    public void show(){
        System.out.println("哈哈哈哈哈");
    }
}

// Helper.java文件
package utils;
import utils.Request;
public class Helper {
    public void doAction(){
        Request req = new Request();
        req.show();
    }
}

// Hello.java文件
import utils.Helper;
public class Hello {
    public static void main(String[] args) {
        Helper req = new Helper();
        req.doAction();
    }
}

类 成员 修饰符：public、private、protected

  • public，只要有权访问类，在任意情况下都可以调用。
  • private，只允许自己类调用，在其他类中无法调用到。

class Other {
    private static void doSomething() {
        System.out.println("DoSomething");
    }

    public static void doing() {
        System.out.println("doing");
        doSomething();
    }
}

public class Hello {

    private static void show() {
        System.out.println("show");
    }

    public static void main(String[] args) {
        show(); // 可以
        // Other.doSomething(); // 不可以
        Other.doing(); // 可以
    }
}

  • protected，对同一包内的类和所有子类可见（不是同一个包）。

package utils;

public class Helper {

    protected void doIt(){
    }
    
    void doAction(){
    }
}

package xx;
import utils.Helper;

public class Db extends Helper {
    public void exec(){
        doIt(); // 可以访问
        // doAction(); 无法访问
    }
}

  • default，在同一包内可见。

非访问 ( static、final、abstract、synchronized  ) 修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

  • static 修饰符，用来修饰类方法和类变量。
  • final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
  • abstract 修饰符，用来创建抽象类和抽象方法。

    抽象类：抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。抽象类可以包含抽象方法和非抽象方法。

    抽象方法：抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。
    抽象方法不能被声明成 final 和 static。
    任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
    如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。抽象方法的声明以分号结尾，

  • synchronized 和 volatile 修饰符，主要用于线程的编程。

synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
transient 修饰符
序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。

static 修饰符

  • 静态变量：static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

  • 静态方法：static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

对类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问。

静态成员 不需要实例化，而是直接通过类就能调用。

class Person {
    /**
     * 静态方法
     */
    public static void f1() {
        System.out.println("f1");
    }


    public String name;
    public Integer age;

    /**
     * 构造方法
     *
     * @param n1 姓名
     * @param n2 年龄
     */
    public Person(String n1, int n2) {
        this.name = n1;
        this.age = n2;
    }

    /**
     * 实例方法
     */
    public void f2() {
        System.out.println("f2" + this.name);
    }

}

public class Hello {

    public static void main(String[] args) {
        Person.f1();

        Person p1 = new Person("武沛齐", 999);
        p1.f2();
    }
}

返回值

方法有返回值就必须要在定义是指定。

class Person {
    
    // void，无返回值。
    public static void f1() {
        System.out.println("f1");
    }

    // 字符串类型返回值
    public static String f2() {
        return "哈哈哈哈";
    }
    
    public static int f3() {
        return 12;
    }

}

public class Hello {

    public static void main(String[] args) {
        Person.f1();

        String res = Person.f2();
    }
}

参数

Java中传参时需要指定类型和形参。

class Person {

    public static void f1(String name,int age) {
        System.out.println("f1");
    }

}

public class Hello {

    public static void main(String[] args) {
        Person.f1("武沛齐",888);
    }
}

JAVA：将类、抽象类、接口当成方法的参数传入

  • 将类当成参数传入方法，其实就是将类的对象传入方法，
  • 如果是抽象类，其实就是将抽象类的子类的对象传入方法，
  • 如果是接口，其实就是将接口实现类的对象传入方法。

总结：类当成方法参数传入，其实就是传对象。抽象类和接口其实就是传其子类或实现类的对象。

"普通类对象" 作为方法参数

class Person {
    public void eat() {
        System.out.println("吃饭");
    }
}

public class Test {

    public static void operatePerson(Person p){
        p.eat();
    }

    public static void main(String[] args) {
        Test.operatePerson(new Person());
    }
}

"抽象类" 作为方法参数

//抽象类
abstract class Animal { public abstract void eat(); }

//Animal的子类
class Cat extends Animal {
    //重写方法
    public void eat() { System.out.println("猫吃鱼"); }
}

public class Test {
    public static void operateAnimal(Animal a){a.eat();}
    public static void main(String[] args) {
        Animal a = new Cat();
        operateAnimal(new Cat()); //或 operateAnimal(a);
    }
}

当然，还要以通过内部类一次性传参

operateAnimal(
    new Animal(){
        //重写animal抽象方法
        public void eat(){System.out.println("猫还吃饭");}
    }
);

要求传入父类对象，但可以传入任意子类对象，这样就使得扩展性得到提高
operateAnimal(new Cat());
operateAnimal(new Dog());
operateAnimal(new Bird());

传入什么类，就调用什么类的功能，这就是多态的实现。

"接口实现类的对象" 作为方法参数

interface Smoking {
    public abstract void smoking();
}

//实现类
class People implements Smoking {
    //实现接口方法
    public void smoking() {
        System.out.println("抽烟中....");
    }
}

public class Test {
    public static void operateSmoking(Smoking s) {
        s.smoking();
    }

    public static void main(String[] args) {
        Smoking s = new People();
        operateSmoking(s);
        operateSmoking(new People());
        operateSmoking(new Smoking() {
            //重写接口方法
            public void smoking() {System.out.println("不准吸烟"); }
        });
    }
}

3、注释

/**
 * 类的注释
 * 类的注释
 */
public class Hello {

    /**
     * 方法的注释
     * @param args 参数...
     */
    public static void main(String[] args) {
        // 1.单行注释
        
        /*
        2.多行注释
        多行注释
         */
    }
}

4、变量、常量 ( const )

Java中定义变量的格式：变量类型 变量名 = 值;

public class Hello {

    public static void main(String[] args) {
        String name = "武沛齐";
        int age = 18;
        String firstName = "xxx"; // python first_name

        String email;
        email = "[email protected]";

        String hobby = null;
        hobby = "玩游戏";
    }
}

输入、输出

import java.util.Scanner;

public class Hello {

    public static void main(String[] args) {

        // 输入
        Scanner input = new Scanner(System.in);
        System.out.print("用户：");
        String name = input.nextLine();
        
        System.out.print("年龄：");
        int age = input.nextInt(); // 将输入的内容转化弄成int类型
        
        String message = String.format("姓名：%s，年龄:%d",name,age);
        System.out.println(message);
    }
}

import java.util.Scanner;

public class Hello {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("用户：");
        String name = input.nextLine();

        System.out.print("密码：");
        String pwd = input.nextLine();

        // name.equals("武沛齐") && pwd.equals("123")
        if (name == "武沛齐" && pwd == "123") {
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }

    }
}

5、条件语句

import java.util.Scanner;

public class Hello {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入年龄：");
        int age = input.nextInt();
        
        if (age < 18) {
            System.out.println("少年");
        } else if (age < 40) {
            System.out.println("大叔");
        } else {
            System.out.println("老汉");
        }
    }
}

import java.util.Scanner;

public class Hello {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入序号：");
        int num = input.nextInt(); // 任意数字

        switch (num) {
            case 1:
                System.out.println("话费查询");
                break;
            case 2:
                System.out.println("电话预约");
                if (1 == 1) {
                    System.out.println("哈哈哈哈");
                }
                break;
            default:
                System.out.println("输入错误");
                break;
        }
    }
}

6、循环语句

while

import java.util.Scanner;

public class Hello {

    public static void main(String[] args) {
        int count = 0;
        while (count < 3) {
            Scanner input = new Scanner(System.in);
            System.out.print("用户：");
            String name = input.nextLine();

            System.out.print("密码：");
            String pwd = input.nextLine();

            // name == "武沛齐" && pwd == "123"
            if (name.equals("武沛齐") && pwd.equals("123")) {
                System.out.println("登录成功");
                break;
            } else {
                System.out.println("登录失败");
            }
            count += 1;
        }

    }
}

do while

import java.util.Scanner;

public class Hello {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入序号：");
        int num = input.nextInt();

        do {
            System.out.println("符合规范");
        } while (num < 3);
    }
}

for 循环

public class Hello {

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(i); // continue/break
        }
    }
}

public class Hello {

    public static void main(String[] args) {

        String[] dataArray = {"武沛齐", "Alex", "日天", "张开"}; // 列表
        for (String item : dataArray) {
            System.out.println(item);
        }
        for(int i=0;i             String item = dataArray[i];
            System.out.println(item);
        }
    }
}

7、数据类型相关

7.1 整数类型

  • byte，字节 【1字节】表示范围：-128 ~ 127 即：-2^7 ~ 2^7 -1
  • short，短整型 【2字节】表示范围：-32768 ~ 32767
  • int，整型 【4字节】表示范围：-2147483648 ~ 2147483647
  • long，长整型 【8字节】表示范围：-9223372036854775808 ~ 9223372036854775807

public class Hello {

    public static void main(String[] args) {
        byte v1 = 32;
        short v2 = 10000;
        int v3 = 22221331;
        long v4 = 554534353424L;
    }
}

public class Hello {

    public static void main(String[] args) {

        short v1 = 32;

        // 强制类型转换
        int v2 = (int)v1;
        System.out.println(v2);
    }
}

特别提醒：在逆向时经常会看到 byte 数组表示字符串。

import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        // byte数组，每个元素都是一个字节 [11,22,33,44,55]
        byte[] data = {97, 105, 100, 61, 50, 52, 54, 51, 56, 55, 53, 55, 49, 38, 97, 117, 116, 111, 95, 112, 108, 97, 121, 61, 48, 38, 99, 105, 100, 61, 50, 56, 57, 48, 48, 56, 52, 52, 49, 38, 100, 105, 100, 61, 75, 82, 69, 104, 69, 83, 77, 85, 74, 104, 56, 116, 70, 67, 69, 86, 97, 82, 86, 112, 69, 50, 116, 97, 80, 81, 107, 55, 87, 67, 104, 67, 74, 103, 38, 101, 112, 105, 100, 61, 48, 38, 102, 116, 105, 109, 101, 61, 49, 54, 50, 55, 49, 48, 48, 57, 51, 55, 38, 108, 118, 61, 48, 38, 109, 105, 100, 61, 48, 38, 112, 97, 114, 116, 61, 49, 38, 115, 105, 100, 61, 48, 38, 115, 116, 105, 109, 101, 61, 49, 54, 50, 55, 49, 48, 52, 51, 55, 50, 38, 115, 117, 98, 95, 116, 121, 112, 101, 61, 48, 38, 116, 121, 112, 101, 61, 51}; // 这里应该表示的是一个字符串。

        String dataString = new String(data);
        System.out.println("字节数组转换为字符串：" + dataString);

        
        
        // 字符串也可以转换成字节
        byte[] res = dataString.getBytes();
        System.out.println(Arrays.toString(res));

        try{
            String name = "武沛齐";
            // v1 = [-50, -28, -59, -26, -58, -21] Java中
            // v2 = [206, 228, 197, 230, 198, 235] Python中
            byte[] v1 = name.getBytes("GBK");
            System.out.println(Arrays.toString(v1));

            byte[] v2 = name.getBytes("UTF-8"); // 默认
            System.out.println(Arrays.toString(v2));
        }catch (Exception e){

        }
    }
}

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第3张图片

需求来了：某个app逆向，在Java代码中得到一个字节数组 [-50,-28,-59,-26,-58,-21]，请通过Python代码将这个字节数组转换成字符串？

在 Java 中的字节范围：-128~127；   byte_list = [-50,-28,-59,-26,-58,-21]

Python中字节的范围：0~255。 

让数字转化弄成字节并拼接起来 bytearray

# Python 脚本，方便以后使用。
byte_list = [-50, -28, -59, -26, -58, -21]

bs = bytearray() # python字节数组
for item in byte_list:
    if item < 0:
        item = item + 256
    bs.append(item)
str_data = bs.decode('gbk')  # data = bytes(bs)
print(str_data)

进制转换：在 java 中除了十进制以外，其他的进制都是用字符串来表示。

public class Hello {

    public static void main(String[] args) {
        // 十进制转其他
        int n = 18;
        
        String v2 = Integer.toBinaryString(n); // 二进制，字符串形式
        String v8 = Integer.toOctalString(n);
        String v16 = Integer.toHexString(n);
        String v3 = Integer.toString(n,3);
        
        String dataStr = Integer.toString(n); // "18"
        
        // 其他转十进制
        String data = "10010";
        int v10 = Integer.parseInt(data,2);
        
        // 其实：Integer.toString 和 Integer.parseInt 其实就是整型和字符串之间的转换。
    }
}

7.2 字符

char v1 = '武'; // 字符
String v2 = "武沛齐"; // 字符串

字符，char 【2字节】对应的是unicode中的码点，用于存储单个字符。

public class Hello {

    public static void main(String[] args) {
        String text = "天王盖地虎宝塔镇河妖";

        char v1 = text.charAt(1);
        System.out.println(v1); // l

        char v2 = text.charAt(2);
        System.out.println(v2); // e

        char v3 = '中'; // 单引号
        System.out.println(v3);

        char v4 = 'A'; // 单引号   65
        char v5 = '#'; // 单引号   35
        
        int v6 = v4 + v5; // 十进制 100
        System.out.println(v6); //100

        char v7 = (char)v6;
        System.out.println(v7); // d
    }
}

7.3 字符串

注意：字符串是由多个字符串组成。

import java.io.UnsupportedEncodingException;

public class Hello {

    public static void main(String[] args) throws UnsupportedEncodingException {
        String v1 = "武沛齐";
        String v2 = new String("武沛齐");

        // char[] data = new char[]{'武', '沛', '齐'};
        // char[] data = {'武', '沛', '齐'};
        // String v3 = new String(data);
        String v3 = new String(new char[]{'武', '沛', '齐'});

        String v4 = new String(new byte[]{-26, -83, -90, -26, -78, -101, -23, -67, -112});
        String v5 = new String(new byte[]{-50, -28, -59, -26, -58, -21},"GBK");
        
        // 上面都是不可变  "alex" + "测试" + "xx" + "xxxx"
        // 可变字符串 "name=wupeiqi"
        StringBuilder sb = new StringBuilder(); 
        sb.append("name");
        sb.append("=");
        sb.append("wupeiqi");
        sb.append("&");
        sb.append("age=");
        sb.append("999");
        // String v6 = sb.toString(); //name=wupeqi&age=999
        String v6 = new String(sb);

        StringBuffer strBuffer = new StringBuffer(); // 线程安全（多线程）
        strBuffer.append("name");
        strBuffer.append("=");
        strBuffer.append("wupeiqi");
        strBuffer.append("&");
        strBuffer.append("age=");
        strBuffer.append("999");
        // String v6 = strBuffer.toString();
        String v7 = new String(strBuffer);
        
        // 其他类型的方法执行，直接返回一个字符串
        String v8 = Integer.toString(123123);
        String v9 = Double.toString(3.14);
        
        // 或者
        String v10 = String.valueOf(123);
    }
}

对于字符串，内部提供了很多方便的方法对他进行操作，例如：

public class Hello {

    public static void main(String[] args) {
        String origin = "alex是个大DB";

        char v1 = origin.charAt(5); // 指定字符
        int len = origin.length();  // 长度
        for (int i = 0; i < len; i++) {
            char item = origin.charAt(i);
        }

        String v2 = origin.trim(); // 去除空白

        String v3 = origin.toLowerCase(); // 小写
        String v4 = origin.toUpperCase(); // 大写

        String[] v5 = origin.split("是"); // 分割

        String v6 = origin.replace("D", "S"); // 替换

        String v7 = origin.substring(2, 6);  // 子字符串

        boolean v8 = origin.equals("alex是个大SB");

        boolean v9 = origin.contains("el");

        boolean v10 = origin.startsWith("a");

        String v11 = origin.concat("哈哈哈");
    }
}

关于 StringBuilder，在 Java 开发中经常会使用，用于对字符串进行拼接处理。

public class Hello {

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("name=");
        sb.append("wupeiqi");
        sb.append("age=");
        sb.append("18");
        sb.append("&");
        
        // 删除指定位置的字符
        sb.deleteCharAt(sb.length()-1); // name=wupeiqiage=18
        
        sb.insert(12,"&"); // name=wupeiqi&age=18
        String dataString = sb.toString();

        System.out.println(dataString); //name=wupeiqi&age=18
    }
}

data = []
data.append("name")
data.append("=")
data.append("18")
data_string = "".join(data)

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第4张图片

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第5张图片

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第6张图片

7.4 数组

数据，具有 相同数据类型且定长 的元素集合。【定长】。注意：数组一旦创建个数就不可调整。

import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        int[] numArray = new int[3];
        numArray[0] = 11;
        numArray[1] = 22;
        numArray[2] = 33;
        System.out.println(Arrays.toString(numArray));

        String[] names = new String[]{"武沛齐", "alex", "张开"};
        System.out.println(Arrays.toString(names));

        short[] number = {66, 99};
        System.out.println(Arrays.toString(number));

        for (int i = 0; i < names.length; i++) {
            String item = names[i];
            System.out.println(item);
        }

        for (String item : names) {
            System.out.println(item);
        }

    }
}

public class Hello {

    public static void main(String[] args) {
        /*
            多维数据
              data=[
                    [11,22],
                    [33,44]
                    [55,66]
                ]
         */
        int[][] numArray = new int[3][2];
        numArray[0] = new int[]{11, 22};
        numArray[1] = new int[]{33, 44};
        numArray[2] = new int[]{55, 66};
    }
}

关于 Object

  • 在Python中每个类都默认继承Object类（所有的类都是Object的子类）。

  • Java中所有的类都继承 Object，Object 可以表示所有的类型。

用基类可以泛指他的子类的类型。

import sun.lwawt.macosx.CSystemTray;

import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        // String v1 = "wupeiqi";
        Object v1 = new String("wupeiqi");
        System.out.println(v1);
        System.out.println(v1.getClass());

        Object v2 = 123;
        System.out.println(v2);
        System.out.println(v2.getClass());
    }
}

import sun.lwawt.macosx.CSystemTray;

import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        // 声明数组，数组中元素必须int类型;
        int[] v1 = new int[3];

        // 声明数组，数组中元素必须String类型;
        String[] v2 = new String[3];

        // 声明数组，数组中可以是必须int/String类型;
        Object[] v3 = new Object[3];
        v3[0] = 123;
        v3[1] = "wupeiqi";

    }
}

所以，如果以后想要声明的数组中想要是混合类型，就可以用Object来实现。

import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        // v1是指上字符串对象；String
        String v1 = new String("wupeiqi");
        String res = v1.toUpperCase();
        System.out.println(res);

        // v2本质是字符串对象；Object
        Object v2 = new String("wupeiqi");
        String data = (String)v2;
    }
}

import java.util.Arrays;

public class Hello {

    public static void func(Object v1) {
        // System.out.println(v1);
        // System.out.println(v1.getClass());
        if (v1 instanceof Integer) {
            System.out.println("整型");
        } else if (v1 instanceof String) {
            System.out.println("字符串类型");
        } else {
            System.out.println("未知类型");
        }
    }

    public static void main(String[] args) {
        func(123);

        func("123");
    }
}

  • List 系列，相当于 Python 的列表。
  • Map 系列，相当于 Python 的字典。

7.5 List 系列

List 是一个接口，常见实现这个接口的有两个类，用于实现变长的数组。

  • ArrayList，连续的内存地址的存储（内部自动扩容）。
  • LinkedList，底层基于链表实现（自行车链条）。

Java中接口，是用来约束实现他的类，约束他里面的成员必须有xx。

Java 接口 示例：

interface List{
    public void add(Object data);   // 接口中的方法，不写具体的实现，只用于约束。
}

// 类ArrayList实现了接口List，此时这个类就必须有一个add方法。
class ArrayList implements List{
    public void add(Object data){
         // 将数据data按照连续存储的方法放在内存。
        // ..
    }
}

// 类LinkedList实现了接口List，此时这个类就必须有一个add方法。
class LinkedList implements List{
    public void add(Object data){
         // 将数据data按照链表的形式存储
        // ..
    }
}

ArrayList 示例：

import java.util.ArrayList;
import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        
        // ArrayList，内部存放的是混合数据类型。
        // ArrayList data = new ArrayList();
        ArrayList data = new ArrayList();
        data.add("武沛齐");
        data.add("alex");
        data.add(666);
        data.add("tony");
        
        String value = data.get(1);
        
        // String value = (String) data.get(1);
        Object temp = data.get(1);
        String value = (String) temp; // 转化可转换的数据
        System.out.println(value);


        int xo = (int) data.get(2);
        System.out.println(xo);

        data.set(0, "哈哈哈哈");
        System.out.println(data);

        data.remove("eric");
        data.remove(0);
        System.out.println(data);

        int size = data.size();
        System.out.println(size);

        boolean exists = data.contains("武沛齐");
        System.out.println(exists);


        for (Object item : data) {
            System.out.println(item);
        }

        for (int i = 0; i < data.size(); i++) {
            Object item = data.get(i);
            System.out.println(item);
        }
    }
}

LinkedList 示例：

import java.util.LinkedList;

public class Hello {

    public static void main(String[] args) {
        LinkedList v1 = new LinkedList();
        v1.add(11);
        v1.add(22);

        LinkedList v2 = new LinkedList();
        v2.add("有阪深雪");
        v2.add("大桥未久");
        v2.add(666);
        v2.add(123);

        //v2.remove(1);
        //v2.remove("路飞");

        v2.set(2, "苍老师");
        v2.push("哈哈哈");
        // v2.addFirst(11);


        for (int i = 0; i < v2.size(); i++) {
            Object item = v2.get(i);
            System.out.println(item);
        }

        for (Object item : v2) {
            System.out.println(item);
        }
    }
}

关于 迭代器

import java.util.*;

public class Hello {

    public static void main(String[] args) {

        ArrayList s1 = new ArrayList();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");


        Iterator it = s1.iterator(); // 迭代器
        while (it.hasNext()) {
            String item = (String) it.next();
            System.out.println(item);
        }
    }
}

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第7张图片

关于 foreach

import java.util.*;

public class Hello {

    public static void main(String[] args) {

        ArrayList s1 = new ArrayList();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");

        // JDK8
        s1.forEach(item -> {
            System.out.println(item);
        });
    }
}

关于 List、ArrayList、LinkedList

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Hello {

    public static void main(String[] args) {
        List v1 = new LinkedList();
        v1.add(11);
        v1.add(22);

        List v2 = new ArrayList();
        v2.add(11);
        v2.add("哈哈哈");

        List v3 = new ArrayList();
        v1.add(11);
        v1.add(22);
    }
}

直接创建

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Hello {

    public static void main(String[] args) {
        List v1 = new LinkedList() {
            {
                add(11);
                add(22);
            }
        };

    }
}

7.6 Set 系列

Set 是一个接口，常见实现这个接口的有两个类，用于实现不重复的多元素集合。

  • HashSet，去重，无序。
  • TreeSet，，去重，内部默认排序（ascii、unicode）【不同的数据类型，无法进行比较】。

import java.util.*;

public class Hello {

    public static void main(String[] args) {
        // Set s1 = new HashSet();
        // HashSet s1 = new HashSet();
        HashSet s1 = new HashSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");
        s1.add("P站");
        s1.add(666);
        System.out.println(s1); // [B站, A站, P站,666]

        HashSet s2 = new HashSet(){
            {
                add("东京热");
                add("东北热");
                add("南京热");
            }
        };
        System.out.println(s2); // [B站, A站, P站]

        // Set s2 = new TreeSet();
        // TreeSet s2 = new TreeSet();
        TreeSet s3 = new TreeSet();
        s3.add("P站");
        s3.add("B站");
        s3.add("A站");
        s3.add("P站");
        // s3.add(666); //不可以

        System.out.println(s3); // [B站, A站, P站]

        TreeSet s4 = new TreeSet(){
            {
                add("P站");
                add("B站");
                add("A站");
                add("P站");
            }
        };
        System.out.println(s4); // [B站, A站, P站]

    }
}

关于交并差：

import java.util.*;

public class Hello {

    public static void main(String[] args) {
        // Set s1 = new HashSet();
        HashSet s1 = new HashSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");
        s1.remove("P站");
        System.out.println(s1); // [B站, A站, P站]

        boolean exists = s1.contains("B站");
        System.out.println(exists);

        HashSet s2 = new HashSet();
        s2.add(123);
        s2.add(456);


        HashSet v1 = new HashSet();
        v1.addAll(s1);
        v1.retainAll(s2); // 交集
        System.out.println(v1);


        HashSet v2 = new HashSet();
        v2.addAll(s1);
        v2.addAll(s2); // 并集
        System.out.println(v2);

        HashSet v3 = new HashSet();
        v3.addAll(s1);
        v3.removeAll(s2); // 差集 s1 - s2
        System.out.println(v3);


        HashSet v4 = new HashSet();
        v4.addAll(s2);
        v4.removeAll(s1); // 差集 s2 - s1
        System.out.println(v4);
    }
}

关于循环获取：

import java.util.*;

public class Hello {

    public static void main(String[] args) {

        TreeSet s1 = new TreeSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");

        for (Object item : s1) {
            System.out.println(item);
        }

        // 不用这种循环
        for(int i=0;i             // Object item = s1[i]     不支持
            // Object item = s1.get(i) 不支持
        }
    }
}

关于迭代器：

import java.util.*;

public class Hello {

    public static void main(String[] args) {

        TreeSet s1 = new TreeSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");


        Iterator it = s1.iterator();
        while (it.hasNext()) {
            String item = (String) it.next();
            System.out.println(item);
        }
    }
}

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第8张图片

关于 foreach

import java.util.*;

public class Hello {

    public static void main(String[] args) {

        TreeSet s1 = new TreeSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");


        s1.forEach(item -> {
            System.out.println(item);
        });
    }
}

7.7 Map 系列

Map是一个接口，常见实现这个接口的有两个类，用于存储键值对。

  • HashMap，无序。
  • TreeMap，默认根据 key 排序。（常用）

import java.util.*;

public class Hello {

    public static void main(String[] args) {
        HashMap h1 = new HashMap();
        h1.put("name","alex");
        h1.put("age",18);
        h1.put("hobby","男");
        System.out.println(h1); // {gender=男, name=alex, age=18}

        HashMap h2 = new HashMap();
        h2.put("name","alex");
        h2.put("age","18");
        h2.put("hobby","男");
        System.out.println(h2); // {gender=男, name=alex, age=18}


        HashMap h3 = new HashMap(){
            {
                put("name","alex");
                put("age","18");
                put("hobby","男");
            }
        };
        System.out.println(h3); // {gender=男, name=alex, age=18}


        Map h4 = new HashMap();
        h4.put("name","alex");
        h4.put("age",18);
        h4.put("hobby","男");
        System.out.println(h4); // {gender=男, name=alex, age=18}
    }
}

import java.util.*;

public class Hello {

    public static void main(String[] args) {
        TreeMap h1 = new TreeMap(); // 改为了TreeMap
        h1.put("name","alex");
        h1.put("age",18);
        h1.put("hobby","男");
        System.out.println(h1); // {age=18, hobby=男, name=alex}

        TreeMap h2 = new TreeMap();
        h2.put("name","alex");
        h2.put("age","18");
        h2.put("hobby","男");
        System.out.println(h2); // {age=18, hobby=男, name=alex}


        TreeMap h3 = new TreeMap(){
            {
                put("name","alex");
                put("age","18");
                put("hobby","男");
            }
        };
        System.out.println(h3); // {age=18, hobby=男, name=alex}


        Map h4 = new TreeMap();
        h4.put("name","alex");
        h4.put("age",18);
        h4.put("hobby","男");
        System.out.println(h4); // {age=18, hobby=男, name=alex}
    }
}

常见操作：

import java.util.*;

public class Hello {

    public static void main(String[] args) {
        TreeMap h1 = new TreeMap(); // 改为了TreeMap
        h1.put("name", "alex");
        h1.put("age", "18");
        h1.put("hobby", "男");
        h1.put("hobby", "女人");

        h1.remove("age");
        int size = h1.size();

        Object value = h1.get("name"); // 不存在，返回null
        System.out.println(value);

        boolean existsKey = h1.containsKey("age");
        boolean existsValue = h1.containsValue("alex");

        h1.replace("name", "李杰");
        System.out.println(h1);


        // 循环: 示例1
        Set> s1 = h1.entrySet();
        Iterator it1 = s1.iterator();
        while (it1.hasNext()) {
            Map.Entry entry = (Map.Entry) it1.next();
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
        }

        // 循环: 示例2
        Set s2 = h1.entrySet();
        Iterator it2 = s2.iterator();
        while (it2.hasNext()) {
            Map.Entry entry = (Map.Entry) it2.next();
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
        }

        // 循环: 示例3
        TreeMap h2 = new TreeMap(); // 改为了TreeMap
        h2.put("name", "alex");
        h2.put("age", "18");
        for (Map.Entry entry : h2.entrySet()) {
            String k = entry.getKey();
            String v = entry.getValue();
        }

        // 循环: 示例4
        TreeMap h3 = new TreeMap(); // 改为了TreeMap
        h3.put("name", "alex");
        h3.put("age", 18);
        for (Object entry : h3.entrySet()) {
            Map.Entry entryMap = (Map.Entry) entry;
            String k = entryMap.getKey();
            Object v = entryMap.getValue();
            if (v instanceof Integer) {
                System.out.println("数字：" + Integer.toString((Integer) v));
            } else if (v instanceof String) {
                System.out.println("字符串：" + (String) v);
            } else {
                System.out.println("未知类型：" + v.toString());
            }
        }

        // 循环: 示例5（JDK8）
        TreeMap h4 = new TreeMap(); // 改为了TreeMap
        h4.put("name", "alex");
        h4.put("age", 18);
        h4.forEach((k, v) -> {
            System.out.print(k + "：" + v + "   v的类型是：");
            System.out.println(v.getClass());
        });
    }
}

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第9张图片

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第10张图片

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第11张图片

8、面向对象

8.1 类和对象

class Person {

    // 实例变量
    public String name;
    public Integer age;
    public String email;

    // 构造方法1
    public Person() {
        this.name = "Eric";
        this.age = 99999;
    }

    // 构造方法2
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
        this.email = "[email protected]";
    }

    // 构造方法3
    public Person(String name, String email) {
        this.name = name;
        this.age = 83;
        this.email = email;
    }
    
    // 定义函数（重载）
    public void doSomething() {
        System.out.println(this.name);
    }

    // 定义函数（重载）
    public void doSomething(String prev) {
        String text = String.format("%s-%s", prev, this.name);
        System.out.println(text);
    }

}

public class Hello {

    public static void main(String[] args) {
        
        // 实例化对象时，体现的主要是封装。
        Person p1 = new Person();
        Person p2 = new Person("alex", 73);
        Person p3 = new Person("tony", "[email protected]");

        p1.doSomething();
        p1.doSomething("你好呀，");

        p2.doSomething();
        p2.doSomething("你好呀，");
        
        p3.doSomething();
        p3.doSomething("你好呀，");
    }
}

静态成员

本质：静态属于类；非静态属于对象。

class Person {
    // 静态变量
    public static String city = "北京";
    
    // 实例变量
    public String name;
    public Integer age;

    // 构造方法1
    public Person() {
        this.name = "Eric";
        this.age = 99999;
    }
    
    // 绑定方法
    public void showInfo(){
        System.out.println("哈哈哈哈");
    }
    
    // 静态方法
    public static void showData(){
        System.out.println("哈哈哈哈");
    }
}

Person.city;
Person.showData();


Person obj = new Person();
obj.name;
obj.age;
obj.showInfo();

8.2 继承、多态

Java 只支持 单继承

（同时只能继承一个基类）。

class Base {
    public String email;

    public Base(String email) {
        this.email = email;
    }

    public String getSubInfo() {
        return String.format("%s", this.email);
    }
}

class Person extends Base {

    public String name;
    public Integer age;

    public Person(String name, Integer age, String email) {
        super(email);
        this.name = name;
        this.age = age;
    }

    public String getInfo() {
        return String.format("%s-%d-%s", this.name, this.age, this.email);
    }

    public String getSubInfo() {
        return String.format("%s-%s", this.name, this.email);
    }
}

public class Hello {

    public static void main(String[] args) {
        Person p = new Person("武沛齐", 73, "[email protected]");
        String text = p.getInfo();
        System.out.println(text);

        String subText = p.getSubInfo();
        System.out.println(subText);
    }
}

用父类泛指子类的对象。可以实现 多态。

class Base {
    public String email;

    // 构造方法
    public Base(String email) {
        this.email = email;
    }

    public String getInfo() {
        return "哈哈哈哈";
    }

    // 方法getSubInfo
    public String getSubInfo() {
        return String.format("%s", this.email);
    }
}

class Person extends Base {

    public String name;
    public Integer age;

    public Person(String name, Integer age, String email) {
        // 找父类中的 构造方法并执行  this=self
        super(email);

        this.name = name;
        this.age = age;
    }

    public String getInfo() {
        return String.format("%s-%d-%s", this.name, this.age, this.email);
    }

    public String getSubInfo() {
        return String.format("%s-%s", this.name, this.email);
    }
}

public class Hello {

    public static void main(String[] args) {
        // 1. 实例化Person对象  p = {email="[email protected]" name="武沛齐",age=73 }
        Base p = new Person("武沛齐", 73, "[email protected]");

        System.out.println(p.getClass());  // class Person
        // 1.可以自己判断类型，然后再做其他的处理。
        // 2.p可以强制类型转化弄成Person类型。
        // 3.做了泛指之后，
        String text = p.getSubInfo();  // 找到实际是那个类的对象，就去找当前对象对应类中的方法。
        System.out.println(text);    // 武沛齐[email protected]

        String data = p.getInfo();  // 武沛齐[email protected]
        System.out.println(data);


        // 调用p的getInfo方法。
//        String text = p.getInfo();
//        System.out.println(text);
//
//        // 调用p的getSubInfo
//        String subText = p.getSubInfo();
//        System.out.println(subText);
    }
}

使用类的继承关系，也可以在 传参 或 指定类型时，可以用基类 泛指 所有继承他的子类（多态）。

import java.util.ArrayList;

class Base {
    public String name;
    public Integer age;
    public String email;

    public Base(String name, Integer age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public String getSubInfo() {
        return String.format("%s", this.email);
    }
}

class Person extends Base {

    public Person(String name, Integer age, String email) {
        super(name, age, email);
    }

    public String getInfo() {
        return String.format("%s-%d-%s", this.name, this.age, this.email);
    }

    public String getSubInfo() {
        return String.format("%s-%s", this.name, this.email);
    }
}

public class Hello {

    public static void main(String[] args) {

        Base[] v1 = {
                new Base("alex", 73, "[email protected]"),
                new Base("武沛齐", 23, "[email protected]"),
                new Person("日天", 83, "[email protected]"),
                new Person("张开", 13, "[email protected]"),
        };

        ArrayList v2 = new ArrayList() {
            {
                add(new Base("alex", 73, "[email protected]"));
                add(new Base("武沛齐", 23, "[email protected]"));
                add(new Person("日天", 83, "[email protected]"));
                add(new Person("张开", 13, "[email protected]"));
            }
        };

        for (Base item : v2) {
            String info = item.getSubInfo(); 
            System.out.println(info);
        }
        
        for (Base item : v2) {
            String info = null;
            if (item instanceof Person) {
                info = ((Person) item).getInfo();
            } else {
                info = item.getSubInfo();
            }
            System.out.println(info);
        }
        
    }
}

class Base {
    public String name;
    public Integer age;
    public String email;

    public Base(String name, Integer age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public String getSubInfo() {
        return String.format("%s", this.email);
    }
}

class Person extends Base {

    public Person(String name, Integer age, String email) {
        super(name, age, email);
    }

    public String getInfo() {
        return String.format("%s-%d-%s", this.name, this.age, this.email);
    }

    public String getSubInfo() {
        return String.format("%s-%s", this.name, this.email);
    }
}

public class Hello {

    public static void action(Base obj) {
        String info = obj.getSubInfo();
        System.out.println(info);
    }

    public static void main(String[] args) {
        Base p1 = new Base("alex", 73, "[email protected]");
        Person p2 = new Person("日天", 83, "[email protected]");
        Base p3 = new Person("张开", 83, "[email protected]");

        action(p1);
        action(p2);
        action(p3);
    }
}

8.3 接口

接口的作用：

  • 约束，实现他的类。
  • 泛指 "实现" 他了类。

约束：

import java.util.ArrayList;

interface IMessage {
    public void send();
}

class Wechat implements IMessage {
    public void send() {
        System.out.println("发送微信");
    }
}

class DingDing implements IMessage {
    public void send() {
        System.out.println("发送钉钉");
    }
}

class Sms implements IMessage {
    public void send() {
        System.out.println("发送短信");
    }
}

public class Hello {

    public static void main(String[] args) {
        ArrayList objList = new ArrayList() {
            {
                add(new Wechat());
                add(new DingDing());
                add(new Sms());
            }
        };
        objList.get(0).send();

    }
}

interface IPerson {
    public void f1();

    public void f1(int age);

    public void f2(String info);
}

interface IUser {
    public String f3(int num);
}

class Base {
    public String name;
    public Integer age;
    public String email;

    public Base(String name, Integer age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public String getSubInfo() {
        return String.format("%s", this.email);
    }
}

class Person extends Base implements IUser, IPerson {

    public Person(String name, Integer age, String email) {
        super(name, age, email);
    }

    public String getInfo() {
        return String.format("%s-%d-%s", this.name, this.age, this.email);
    }

    public String getSubInfo() {
        return String.format("%s-%s", this.name, this.email);
    }

    public void f1() {
        System.out.println("F1,无参数");
    }

    public void f1(int age) {
        System.out.println("F1,age参数");
    }

    public void f2(String info) {
        System.out.println("F2");
    }

    public String f3(int num) {
        return "哈哈哈";
    }
}

public class Hello {


    public static void main(String[] args) {
        Person p = new Person("日天", 83, "[email protected]");
        p.f1();
    }
}

泛指一些类型：

interface IAnimal {
    public void exec();

}

class Dog implements IAnimal {
    public void exec() {
        System.out.println("狗子");
    }
}

class Cat implements IAnimal {
    public void exec() {
        System.out.println("猫咪");
    }
}

public class Hello {

    public static void action(IAnimal obj) {
        obj.exec();
    }

    public static void main(String[] args) {
        IAnimal[] v1 = {
                new Dog(),
                new Dog(),
                new Cat(),
                new Cat(),
        };
        for (IAnimal item : v1) {
            item.exec();
        }

        for (IAnimal item : v1) {
            action(item);
        }
    }
}

interface IPerson {
    public void f1();

    public void f1(int age);

    public void f2(String info);
}

interface IUser {
    public String f3(int num);
}

class Base {
    public String name;
    public Integer age;
    public String email;

    public Base(String name, Integer age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public String getSubInfo() {
        return String.format("%s", this.email);
    }
}

class Person extends Base implements IUser, IPerson {

    public Person(String name, Integer age, String email) {
        super(name, age, email);
    }

    public String getInfo() {
        return String.format("%s-%d-%s", this.name, this.age, this.email);
    }

    public String getSubInfo() {
        return String.format("%s-%s", this.name, this.email);
    }

    public void f1() {
        System.out.println("F1,无参数");
    }

    public void f1(int age) {
        System.out.println("F1,age参数");
    }

    public void f2(String info) {
        System.out.println("F2");
    }

    public String f3(int num) {
        return "哈哈哈";
    }
}

public class Hello {


    public static void main(String[] args) {
        IPerson[] v1 = {
                new Person("日天", 83, "[email protected]"),
                new Person("张开", 13, "[email protected]"),
        };
        for (IPerson item : v1) {
            item.f1();
            // item.f3(); 错误
        }
    }
}

支持 实现 多个接口

在Java中：不支持同时继承多个类；支持实现多个接口。

interface IPerson {
    public void f1();

    public void f1(int age);

    public void f2(String info);
}

interface IUser {
    public String f3(int num);
}

class Base {
    public String name;
    public Integer age;
    public String email;

    public Base(String name, Integer age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public String getSubInfo() {
        return String.format("%s", this.email);
    }
}

class Person extends Base implements IUser, IPerson {

    public Person(String name, Integer age, String email) {
        super(name, age, email);
    }

    public String getInfo() {
        return String.format("%s-%d-%s", this.name, this.age, this.email);
    }


    public void f1() {
        System.out.println("F1,无参数");
    }

    public void f1(int age) {
        System.out.println("F1,age参数");
    }

    public void f2(String info) {
        System.out.println("F2");
    }

    public String f3(int num) {
        return "哈哈哈";
    }
}

public class Hello {

    public static void main(String[] args) {
        Person p = new Person("日天", 83, "[email protected]");
        p.f1();
    }
}

场景：

拿到 apk，关于关键字去搜索：f2 ，定位到一个接口了。接下来，你就应该去看都有哪些类 实现了 IPerson 接口。

  • 只有1个类实现 IPerson。
  • 多类类实现 IPerson 接口，筛选到底是那个类？

8.4 抽象

在 Java 开发中可以基于 抽象方法 & 抽象类实现。

// 抽象类
abstract class Base {

    // 抽象方法（约束子类中必须有这个方法）
    public abstract void play(String name);

    // 普通方法
    public void stop() {
        System.out.println("Stop");
    }
}

class Son extends Base {
    public void play(String name) {
        System.out.println("play");
    }
}

public class Hello {

    public static void main(String[] args) {
        Son obj = new Son();
        obj.play("hahha");
        obj.stop();
    }
}

也可以实现多态：

abstract class Base {
    public abstract void play(String name);

    public void stop() {
        System.out.println("Stop");
    }
}

class Son extends Base {

    public void play(String name) {
        System.out.println("play");
    }
}

public class Hello {
    public static void func(Base obj){
        obj.play("hahha");
        obj.stop();
    }
    public static void main(String[] args) {
        Son obj = new Son();
        func(obj);
    }
}

8.5 包

src
├── Hello.java
└── utils
    └── Helper.java

// hello.java
import utils.Helper;

public class Hello {

    public static void main(String[] args) {

        String data = Helper.getInfo();
        System.out.println(data);

    }
}

// helper.java
package utils;

public class Helper {
    public static String getInfo() {
        return "哈哈哈";
    }
}

关于包中类的修饰符：

  • public，公共（任何人都能调用包中的类）。
  • default，只能在当前包中被调用。

类成员修饰符

  • public，公共，所有的只要有权限访问类，类中的成员都可以访问到。
  • private，私有，只允许自己类调用。
  • protected，同一个包 或 子类可以访问（即使没有在同一个包内，也可以访问父类中的受保护成员）。
  • default，只能在同一个包内访问。

Java "内部类" 和 "匿名内部类"

内部类

其实内部类是十分简单的，我们根据其字里行间的意义就可以知道内部类应该是一个类当中的一个类，相当于一个类进行了嵌套，就如同循环的嵌套一般。

内部类有一个特征：内部类当中可以调用外部类当中的属性和方法，而外部类却不能调用内部类当中的。除了这特征就没啥特征了，我们来看看代码了解一下（点击代码上方的文档小图标就可以复制代码，因为我加了代码的行号看起来整洁一些，但是复制可能不太方便）：

package com.company;
 
 
public class Innerclass {
    public static void main(String[] args) {
        System.out.println("下面是是内部类的程序展示");
 
        //创建外部类和内部类的方法有点不相同
        AAA a=new AAA();
 
        // 这里开始创建内部类的对象，这是创建内部类对象的专用格式，
        // 相当于在创建了一个外部类对象的基础上再创建一个内部类对象2
        AAA.BBB b=new AAA().new BBB();
 
        a.say2();
        b.sayit();
    }
}
 
class AAA
{
    int waibu=12;
    public void say2()
    {
        System.out.println("这是外部类当中的方法");
    }
    class BBB
    {
        int neibu=13;
        public void sayit()
        {
            System.out.println("这是内部类里面的方法");
            System.out.println("使用内部类和外部类当中的数值进行想加的结果是"+(neibu+waibu));
            //之所以内部类可以使用外部类的属性是因为在创建对象的时候，
        //已经给内部类的对象附加了一个外部类的对象，内部类的对象是建立在外部类对象的基础上的。
        }
    }
}

最终的sayit()方法输出结果是25=（13+12），从中可以证明内部类确实是可以调用外部类的属性的，但如果外部类调用内部类的属性则会发生报错。

匿名内部类

首先我们应该知道匿名内部类匿名是因为匿名内部类的具体名字不会被我们在程序当众编写出来，因为它已经在主方法当中被实例化了。

匿名内部类可以继承两类数据结构：

  • 一：抽象类
  • 二：接口。

比如我们的代码有：

package com.company;
 
 
public class Innerclass {
    public static void main(String[] args) {
 
        Chouxiang c = new Chouxiang() {
            String name = "Geek Song too";
 
            public void say3() {
                System.out.println("这是匿名内部类当中的方法，重写了抽象类的方法");
                System.out.println(name);
            }
        };
    }
}
 
 
abstract class Chouxiang
{
    String name="Geek Song";//抽象类的属性是不会被调用的，除了方法
    public void say3()
    {
        System.out.println("这是抽象类当中的方法,抽象类当中是允许有具体方法来进行实现的，接口不行");
    }
}

这显然继承了一个抽象类，并且在主方法当中创建了抽象类的对象，本来我们是应该先继承这个抽象类再开始创建对象的，否则对象是无法创建的，但是为了简便，人们创建了了匿名内部类，允许我们在主方法当中进行抽象类的实例化，同时也可以进行对象的创建。这个程序就等同于如下的程序：

package com.company;
 
 
public class Innerclass {
    public static void main(String[] args) {
        System.out.println("下面是是内部类的程序展示");
        //创建外部类和内部类的方法有点不相同
        AAA a=new AAA();
        AAA.BBB b=new AAA().new BBB();
        a.say2();
        b.sayit();
        System.out.println("现在开始匿名内部类程序的编写\n");
        Chouxiang2 c=new Chouxiang2();
        c.say3();
    }
}
 
class AAA
{
    int waibu=12;
    public void say2()
    {
        System.out.println("这是外部类当中的方法");
    }
    class BBB
    {
        int neibu=13;
        public void sayit()
        {
            System.out.println("这是内部类里面的方法");
            System.out.println("使用内部类和外部类当中的数值进行想加的结果是"+(neibu+waibu));
            //之所以内部类可以使用外部类的属性是因为在创建对象的时候，
            //已经给内部类的对象附加了一个外部类的对象，内部类的对象是建立在外部类对象的基础上的。
        }
    }
}
 
abstract class Chouxiang
{
    String name="Geek Song";//抽象类的属性是不会被调用的，除了方法
    public void say3()
    {
        System.out.println("这是抽象类当中的方法,抽象类当中是允许有具体方法来进行实现的，接口不行");
    }
 
}
 
class Chouxiang2 extends Chouxiang
{
    public void say3()
    {
        System.out.println("这是继承的方法");
    }
}

因此这里就会涉及到多态和向上转型了，我们输出的子类的方法，父类的属性，匿名内部类也是相同的。输出的匿名内部类的方法，以及父类的属性。

完整的程序如下，方便大家进行知识点的理解：

package com.company;
 
 
public class Innerclass {
    public static void main(String[] args) {
        System.out.println("下面是是内部类的程序展示");
        //创建外部类和内部类的方法有点不相同
        A a = new A();
        A.B b = new A().new B();
        a.say2();
        b.sayit();
        System.out.println("现在开始匿名内部类程序的编写\n");
        Chouxiang c = new Chouxiang() {
            String name = "Geek Song too";
 
            public void say3() {
                System.out.println("这是匿名内部类当中的方法，重写了抽象类的方法");
                System.out.println(name);
            }
        };//在使用匿名内部类的时候，当这个类在陈述完之后，是需要打分号的。
        c.say3();
        System.out.println("我们来看看这个name到底是抽象类当中的name还是匿名内部类当中的" + c.name);
        //结果果然是父类当中的属性，和我们多态的性质相重合了
        //这就是所谓的向上转型。现在我们再来试试接口的匿名内部类实现
        Jiekou yui = new Jiekou() {
            @Override//由于必须实现接口当中的方法，因此计算机就自动为我们写上了override的标识符了
            public void say5() {
                System.out.println("这是继承的接口当中的方法");
            }
        };
        yui.say5();
    }
}
 
class A {
    int waibu = 12;
 
    public void say2() {
        System.out.println("这是外部类当中的方法");
    }
 
    class B {
        int neibu = 13;
 
        public void sayit() {
            System.out.println("这是内部类里面的方法");
            System.out.println("使用内部类和外部类当中的数值进行想加的结果是" + (neibu + waibu));
            //之所以内部类可以使用外部类的属性是因为在创建对象的时候，
            // 已经给内部类的对象附加了一个外部类的对象，
            // 内部类的对象是建立在外部类对象的基础上的。
        }
    }
}
 
// 虽然内部类的程序已经成功了，但是匿名内部类的程序还没有成功，
// 现在我们来创建一个匿名内部类(在主方法当中,首先应该创建一个抽象类或者接口)
abstract class Chouxiang {
    String name = "Geek Song";//抽象类的属性是不会被调用的，除了方法
 
    public void say3() {
        System.out.println("这是抽象类当中的方法,抽象类当中是允许有具体方法来进行实现的，接口不行");
    }
 
}
 
interface Jiekou {
    public void say5();
 
}

9、Java 高级特性

​Java 高级特性：https://blog.csdn.net/w252064/article/details/79923999
[Java高级特性详解]：https://blog.csdn.net/qq_37977176/article/details/78941649
菜鸟教程 之 Java 教程：https://www.runoob.com/java/java-tutorial.html

内容主要有集合框架及泛型，实用类，输入和输出处理，注解与多线程，网络编程与XML技术

9.1 集合框架

集合框架 是一套性能优良、使用方便的接口和类（位于 java.util 包中）解决数组在存储上不能很好适应元素数量动态变化，查找效率低的缺陷 

  • 集合接口： Map、Collection(子接口List、Set) 、 Iterator
  • 接口实现类：HashMap  TreeMap 、ArrayList  LinkedList、 HashSet  TreeSet  实现map、list、set接口
  • 集合工具类：Arrays 、Collections  提供对集合元素进行操作的算法

9.2 接口的区别

Collection 接口存储一组可重复，无序的对象（包括 List  Set 接口）通用方法：

clear()    清除元素    
isEmpty()  判断集合是否为空
iterator() 获得集合的迭代器  
toArray()  集合转换为数组

List 接口存储一组可重复，有序的对象
Set 接口存储一组唯一，无序的对象
Map 接口存储一组键值对象，键是唯一的，Map和Set很像

9.3 接口实现类

ArrayList

在内存中分配连续的空间。根据下标遍历元素和随机访问元素的效率比较高，而增加和删除由于位置移动操作很慢

常用方法：

add(Objiect o)         在列表末尾顺序添加元素
get(int index)         返回指定索引位置处的元素
size()                 返回列表中的元素个数
contains(Objiect o)    判断列表中是否存在指定元素
remove(Objiect o)      删除列表中的元素

LinkedList

采用链表存储方式。所有顺序查找的时候很慢，而插入、删除元素时无需移动位置，效率比较高常用方法：

addFirst(Objiect 0)    在列表首部添加元素
addLast(Objiect 0)     在列表尾部添加元素
getFirst()             获得当前集合的第一个元素
getLast()              获得当前集合的最后一个元素
removeFirst()          删除并返回列表中的第一个元素
removeFirst()          删除并返回列表中的最后一个元素

TreeSet | TreeMap 比较

底层是二叉树结构；

TreeMap、TreeSet都保存了对象的排列次序；

TreeSet只存储一个对象，而TreeMap存储两个对象Key和Value；

存储速度比Hash集合慢。

HashSet | HashMap 比较：

底层数据结构为哈希表；

HashMap存储键值对，键唯一，而HashSet仅仅存储对象，对象唯一；

HashMap使用唯一的键来获取对象，速度相对较快。

HashSet 集合方法

add(Objiect o)       添加对象
size()               返回元素个数
contains(Objiect o)  判断是否存在
remove(Objiect o)    移除有关对象

HashMap 集合方法

put（key,value）                 添加键值对
get(key)                         获取与key有关的值
remove(key)                      移除与key有关的映射，并返回旧值
containsKey( ) containsValue( )  判断是否存在key value
size()                           返回元素个数
keySet()                         获取所有key的集合
values()                         获取所有values的集合

9.4 集合遍历

三种方法：普通 for 循环  增强 for 循环  Iterator 迭代器遍历

  • 1. for (int i = 0 ;i
  • 2. for (Object object : list) { System.out.println(object); }
  • 3. Iterator iterator = list.iterator();while(iterator.hasNext()){ int i = (Integer) iterator.next();  System.out.println(i); }

Iterator方法：

  • HasNext()    判断是否存在下一个可访问的元素，如果可以，返回true
  • Next()          返回要访问的下一个元素

9.5 Collections工具类

作用：实现对元素的排序、查找和替换操作
如果要比较一个类的对象之间的大小，必须要实现Comparable接口。
Comparable接口：对实现它的每个类的对象进行自然排序。
comparableTo(Object obj)方法：用于比较此对象与指定对象的顺序
返回值：0等于、1大于、-1小于指定对象obj

方法：

fill( )            替换集合中所有元素为相同元素的方法
sort( )            对集合进行排序的方法
binarySearch( )    对集合进行查找的方法
max( )\min( )      查找最大值、最小值

9.6 泛型 集合

泛型即参数化类型，通过指定集合中的元素类型来实现约束

作用：将对象的类型作为参数，指定到其他类或者方法上，从而保证类型转换的安全性和稳定性

举例：List list=new ArrayList( );

ArrayList students = new ArrayList();

典型的泛型集合：ArrayList、HashMap

泛型类： public class User{}

泛型接口：public interface Pair{}

泛型方法： public  void getMiddle(T[] b) {}  注意的位置

在泛型中，基本类型是不可以做泛型参数，只能使用包装类、引用数据类型。

9.7 实用的 类

Java API：Java应用程序的编程接口、Java帮助文档
实用类：   由Java API提供的常用类

学习这部分一定要多看 Java API 。Java 帮助文档提供的常用包如下：

lang包  :包含基础类和接口  如 Comparable接口 、包装类、  String、Math类
Util包  :包含系统辅助类 如 Collection、Map接口、 Date、Arrays类
Io包    :与输入输出有关类 如 Serializable接口、File、Reader、Writer类
Net包   :与网络有关类  如CookieStore接口 、Socket、URL、ServerSocket类
Sql包   :与数据库有关类  如 Statement接口、DriverManager、DriverPropertyInfo类

枚举

指由一组固定的常量组成的类型。使用enum关键字定义

举例：定义：public enum Genders{男,女} 调用：Genders.男

作用：类型安全、易于输入、代码清新

包装类

概念：把基本数据类型包装为对象，方便对象的操作，体现了java面向对象的特点。 ag：int→Integer char→Character  byte→Byte

包装类作用：

  • 方便在各种类型之间的转化  如：int类型和String类型互相转换
  • 提供了基本数据类型的相关属性与方法 如：最小值、toString() 、valueOf()、equals()方法

常用方法：

toString()                 ：将基本数据类型转换为字符串类型
valueOf()                  ：静态的重载方法 将基本数据类型、字符串转换为包装类
parseInt()、parseBoolean() ：把字符串转换为相应基本数据类型

类型转换

基本类型转包装类：Integer i=5;或 Integer i=new Integer(5);或Integer i=new Integer(“5”);或Integer i=Integer.valueOf(“5”);

注意：除Character包装类外，都可以将字符串作为参数来构造实例

  • 包装类转基本类型：int intId=id.intvalue();或int intId=id；
  • 自动转换： Integer i=5;//装箱 基本→包装     int j=i;//拆箱 包装→基本

jdk 1.5以后，基本类型和包装类的转换，编译器会自动完成

String 类

在Java中，字符串常被作为String类型的对象来处理。

创建 String 对象方法：String a = "hello" 或 String a = new String("hello"); 注意：第2个方法 ，创建了两个对象：一个 "hello" 字符串对象，在堆内存中；一个s对象，在栈内存中。

常用方法：

判断:    
equals()                :判断两个字符串的内容是否相同
equalsIgnoreCase()      :判断两个字符串的内容是否相同，不区分大小写
contains(String s)      :判断一个字符串中是否包含另一个字符串
endsWith(String s)      :测试此字符串是否以指定的后缀结束
startsWith(String s)    :测试此字符串是否以指定的前缀开始
isEmpty()               :测试字符串是否为空

获取:    
int length()             :返回此字符串的长度
char charAt(int index)   :返回指定索引处的char值(字符)
int indexOf()            :返回指定字符(串)在此字符串中第一次出现处的索引
int lastIndexOf(int c)   :返回指定字符在此字符串中最后一次出现的索引

// 返回一个新字符串，它是此字符串的一个子字符串,包含头不包含尾。
String substring(int beginIndex, int endIndex)

转换:    
byte[] getBytes()          :从字符串到字节数组的方法
char[] toCharArray()       :从字符串到字符数组的方法
String valueOf(数据类型)   :把该数据类型的数据转换成字符串
String toLowerCase()       :把字符串转换成小写
String toUpperCase()       :把字符串转换成大写
String concat(String str)  :将指定字符串连接到此字符串的结尾

替换分割: 
String replace(char oldChar, char newChar) :用新字符替换旧字符
String[] split(String regex)               :根据指定的字符串把一个字符串分割成一个字符串数组
String trim()                              :去除字符串的前后空格
int compareTo(String anotherString)        :按字典顺序比较两个字符串
int compareToIgnoreCase(String str)        :按字典顺序比较两个字符串，不考虑大小写

StringBuffer

相当于给字符串一个缓冲区，是String的增强类。对字符串频繁修改（如字符串连接）时，使用StringBuffer类可以大大提高程序执行效率。StringBuffer 声明：

StringBuffer strb = new StringBuffer();
StringBuffer strb = new StringBuffer("aaa");

常用方法：

增加:
append("**")      :追加各种类型的数据到字符串之后
insert (1, "**")  : 在容器指定位置插入各种类型的数据

删除:
deleteCharAt()  :删除指定位置的字符
delete()        :清空StringBuffer的缓冲区

替换:
replace()  :用新字符替换旧字符
toString() :将StringBuffer类型的字符串转换为String类型的对象

获取:
charAt() :返回指定索引处的char值(字符串)
length() :返回此字符串的长度

JDK5.0 后提供了 StringBuilder，等价 StringBuffer。但是是单线程的，效率相对较高，但是不保证线程安全。

Math 类

提供了常用的数学运算方法和两个静态常量E（自然对数的底数）和PI（圆周率）

常用方法：

abs()     :返回绝对值；
max()     :返回最大值；
random()  :返回随机数

生成[0,10)区间的整数 int random = (int)(Math.random()*10);

Random 类

是产生随机数的一个类常用方法：

构造方法

Random()          创建一个新的随机数生成器。
Random(long seed) 使用单个种子创建一个新的随机数生成器。
注意：种子数只是随机算法的起源数字，和生成的随机数字的区间无关
ag：Random rand = new Random(10);

成员方法

int nextInt()      返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
int nextInt(int n) 返回一个伪随机数，该值介于[0,n)的区间。
ag：生成[0,10)区间的整数     int num = rand.nextInt(10);

Scanner 类

位于java.util包，是获取从键盘的输入数据的一个类

构造方法

Scanner(InputStream source)    创建一个用来解析基本类型和字符串的文本扫描器
ag：Scanner sc = new Scanner(System.in);

成员方法

hasNext()     判断扫描器中当前扫描位置后是否还存在下一段。
hasNextLine() 如果在此扫描器的输入中存在另一行，则返回 true。
nextInt()     将输入信息的下一个标记扫描为一个int，接受整型变量。
next()     以换行或空格符为分界线接收下一个String类型变量。如：输入hello world!,接收到的只是hello
nextLine() 以换行为分界线接收下一个String类型变量。如：输入hello world!,接收到的是hello word!

Date 类

位于java.util包，表示日期和时间的类

构造方法

Date()  分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
Date(long date) 分配Date对象并初始化此对象，以表示从标准基准时间（即1970年1月1日00:00:00GMT）以来的指定毫秒数。

成员方法

int compareTo(Date anotherDate) 比较两个日期的顺序
boolean equals(Object obj)      比较两个日期的相等性。

SimpleDateFormat类

位于java.text包，格式化和解析日期的具体类。固定写法：

//创建日期对象 Date date = new Date();
//定制日期格式 SimpleDateFormat f= new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);
String now = f.format(date);  System.out.println(now);

Calendar类

位于java.util包，用于设置和获取日期/时间数据的特定部分

int get(int field)       返回给定日历字段的值

YEAR  指示年     MONTH   指示月

DAY_OF_MONTH   指示一个月中的某天

DAY_OF_WEEK        指示一个星期中的某天

输入 / 输出、文件操作

File 类

位于java.io包，用来操作文件目录和属性

构造方法：

File(String pathname)             指定文件路径
File(String dir,String subpath)   dir参数指定目录路径，subpath参数指定文件名
File(File parent,String subpath)  parent参数指定目录文件，subpath参数指定文件名

常用方法：

创建：
boolean createNewFile( )  创建名称的空文件，不创建文件夹
boolean mkdir()           创建由该File对象表示的目录（一级文件夹）
boolean mkdirs()          创建包括父目录的目录（二级文件夹）

判断：
boolean exists( )       判断文件或目录是否存在
boolean isFile( )       判断是否是文件
boolean isDirectory( )  判断是否是目录

获取：
String getPath( )           返回此对象表示的文件的相对路径名
String getAbsolutePath( )   返回此对象表示的文件的绝对路径名
String getName( )   返回此对象表示的文件或目录的名称
String getParent()  返回此对象父目录的路径名；
long length()       返回文件的长度，单位为字节, 如果文件不存在，则返回0L

删除：
boolean delete( )   删除此对象指定的文件或目录

相对路径与绝对路径

相对路径：从中间目录出发，到目前位置路径。

绝对路径：从根目录出发，到目前位置的路径。

Java IO 流

指二进制的字节序列，是一连串流动的字符，是以先进先出方式发送信息的通道

分类：

  • (1) 按照流操作的数据类型分为：字节流和字符流。字节流是8 位通用字节流，字符流是16位Unicode字符流
  • (2) 按照流的流向分为：输入流，输出流（相对计算机程序而言，先入后出、先读后写）。源数据源（键盘、硬盘）→输入流（读）→程序→输出流（写）→目标数据源（控制台）

IO 流 常用 基类

注意：( )里面是子类 如File**类，Buffered**类

Buffered**类带有缓冲区，有按行读取内容的readLine()方法

字节流

字节输入流：InputStream  (FileInputStream、BufferedInputStream)
字节输出流：OutputStream (FileOutputStream、BufferedOutStream)

字符流

字符输入流：Reader  (FileReader、BufferedReader)
字符输出流：Writer  (FileWriter、BufferedWriter)

常用基类的方法

字节输入流InputStream类方法

void close()       关闭此输入流并释放与该流关联的所有系统资源
int read()         读取一个字节数据
int read(byte[] b) 读取一定数量的字节，并将其存储数组中
int read(byte[] b, int off, int len)  将输入流中最多 len 个数据字节，保存到字节数组b中

字节输出流OutputStream类方法

void close()         关闭此输出流并释放与此流有关的所有系统资源
write(int b)         写入一个字节数据
void write(byte[] b) 写入数组b的所有字节
void write(byte[] b, int off, int len) 将字节数组中从偏移量 off 开始的 len 个字节写入到输出流

字符输入流Reader类方法

void close()        关闭输入流
int read()          读取单个字符
int read(char[] c)  将c.length长度的字符读入数组c中
int read(char[] c, int off, int len)  将最多len长度的字符读入数组c，保存位置从off位置开始

字符输出流Writer类方法

void close()           关闭输出流
void flush()           刷新输出流
int read()             读取单个字符。
int read(char[] cbuf)  将字符读入数组
int read(char[] cbuf, int off, int len)  将字符读入数组的某一部分

节点流、包装流

节点流：创建对象时，参数是字符串或File类对象

包装流:创建对象时，参数是流对象。

包装的作用：1.提高效率 2.方便书写代码

使用字节流读写文本文件

使用 FileInputStream 读文本文件

//构造字节输入流对象
FileInputStream fis= new FileInputStream(“c:\\test.txt”);
//循环读取文件数据  最后关闭流对象fis.close();
System.out.println(“可读取的字节数”+fis.available());
byte []buf = new byte[1024];   int len=0;
while((len=fis.read(buf))>0){ System.out.write(buf, 0, len); }

使用FileOutputStream 写文本文件

//构造字节输入流对象
FileOutputStream fos=new FileOutputStream(“f:/java.txt”);
//把数据写入文本文件 最后关闭流对象fos.close();
int num=12345;String s=String.valueOf(num);
fos.write(s.getBytes(), 0, s.getBytes().length);

使用字符流读写文本文件

使用FileReader/BufferedReader读取文件

//创建FileReader/BufferedReader对象
Reader fr= new FileReader(“D:\\myDoc\\简介.txt”);//节点流
BufferedReader br=new BufferedReader(fr); //包装流
//调用readLine()方法读取文本文件的数据  最后关闭流对象
String s=null; while((s=br.readLine())!=null){…}

使用FileWriter/BufferedWriter写文件

//创建FileWriter/BufferedWriter对象
FileWriter fw= new FileWriter(“D:\\myDoc\\简介.txt”);
BufferedWriter bw=new BufferedWriter(fw);
//调用write()方法写文本文件的数据  最后关闭流对象
fw.write();  fw.close();

解决读取时中文乱码

//使用InputStreamReader并设置编码格式
InputStreamReader fr=new InputStreamReader(fis,"UTF-8");

//以字节数组的形式读取
byte []buf = new byte[1024];  fis.read(buf)

读写二进制文件

使用FileInputStream/DataInputStream读取二进制文件

//构造数据输入对象
FileInputStream fis=new FileInputStream(“C:\\HelloWorld.class”);
DataInputStream dis=new DataInputStream(fis);
//调用read()方法读取
dis.readInt();  dis.close();

使用FileOutputStream/DataOutputStream写二进制文件

//构造数据输出对象
FileOutputStream outFile=newFileOutputStream(“C:\\temp.txt”);
DataOutputStream out=new DataOutputStream(outFile);

//调用write()方法写入
out.write();  out.close();

序列化、反序列化

序列化：将对象的状态写入到特定的流中的过程。对象 —> 流

反序列化：从特定的流中获取数据重新构建对象的过程。流 —> 对象

作用：Java对象序列化后，得到的二进制字节序列可以方便的保存到磁盘或者云上。二进制序列可以方便地跨平台传输，不用担心因平台问题而显示异常。

实现步骤：

  • 1、实现Serializable接口
  • 2、创建对象输出流ObjectOutputStream(序列化)/输入流ObjectInputStrean(反序列化)
  • 3、调用writeObject()/readObject ()方法将对象写入文件(序列化)/读取对象(反序列化)
  • 4、关闭对象输入流

注意：使用transient关键字修饰对象的某些属性时，这些属性将不再被序列化

java 反射

反射：指java程序能自描述和自控制，它允许程序在运行时才加载、探知、使用编译期间完全未知的类

反射机制：指在运行状态中，动态获取类信息以及动态调用对象方法的功能

反射常用API：

  • Class类 — 可获取类和类的成员信息
  • Field类 — 可访问类的属性
  • Method类 — 可调用类的方法
  • Constructor类 — 可调用类的构造方法

使用反射的步骤：

  • 1、导入java.lang.reflect.*;
  • 2、获取需要操作类的Class对象
  • 3、调用Class的方法获取Field、Method等对象
  • 4、使用反射API进行操作

反射的应用：

  • 获取Class对象：getClass()方法  Class.forName()方法  .class 方法
  • 创建Class对象：newInstance()方法
  • 访问类的属性：getXxx()方法  setXxx()方法
  • 访问类的方法：getMethod()方法  invoke()方法

注解

Java代码里的特殊标记。它为在代码中添加用Java程序无法表达的额外信息提供了一种形式化的方法。注解可以看成修饰符，修饰程序元素。

注解可以在编译、类加载、运行时被读取。而注释不会被程序所读取。

(1) 内建注解：标准注解类型;

@Overrid          限定重写父类方法
@Deprecated       标示已过时
@SuppressWarnings 抑制编译器警告

(2) 元注解: 修饰其他的注解定义

@Target      指定被其修饰的注解能用于修饰哪些程序元素
@Retention   指定该注解可使用反射读取
@Documented  指定该注解将被JavaDoc工具提取成文档
@Inherited   指定被其修饰的注解将具有继承性

(3)自定义注解: 注解类型是一种接口

使用关键字@interface定义新注解，如：public @interface AnnotationTest{}

读取注解信息

AnnotatedElement接口是所有程序元素的父接口，指定了程序中可以接受注解的程序元素。通过反射获取对象信息。

getAnnotation()方法：返回该程序元素上存在的、指定类型的注解

getAnnotations()方法：返回该程序元素上存在的所有注解

进程、线程

  • 程序：是对数据描述与操作的代码的集合。
  • 进程：指程序的一次动态执行过程。是系统运行程序的基本单位，有独立的内存空间和系统资源
  • 线程：指进程中的一个执行流程。是进程中执行运算的最小单位，真正在处理机上运行的是线程，一个进程中至少要有一个线程。

线程创建与启动：

（1）继承 java.lang.Thread类         如：class MyThread extends Thread{}

（2）实现 java.lang.Runnable接口  如：class MyThread implements Runnable{}

都需要重写 run()方法，调用 start() 方法

MyThread myThread = new MyThread();      new Thread(myThread).start();

线程状态

   ↙阻塞|睡眠状态↘

新生状态—>可运行状态<—>运行状态—>死亡状态

新生状态：线程对象已经创建，还没有在其上调用start()方法。

可运行状态：当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。

运行状态：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态

等待/阻塞/睡眠状态：是线程有资格运行、只是没有条件使线程苏醒所处的状态。

死亡状态：当线程的run()方法完成时就认为线程死去

线程调度

多个线程处于可运行状态，线程调度会根据优先级来决定线程进入可运行状态的次序。
线程的优先级用1～10 表示，10的优先级最高，默认值是5
设置优先级：setPriority(int grade)  如：myThread.setPriority(3);

调度方法：

join()  ：将指定的线程加入到当前线程。先执行完调用该方法的线程再继续执行本线程
sleep() ：当前线程在指定毫秒内停止执行而转入不可运行状态
yield() ：当前线程转入暂时停止运行的状态

线程同步

当两个或多个线程需要访问同一资源时，需要以某种顺序来确保该资源某一时刻只能被一个线程使用。同步就相当于上锁，上了锁的线程首先访问资源，其他线程等待。

实现线程同步：

同步方法: 用 synchronized关键字修饰的方法

public synchronized void save(){}

同步代码块: 用synchronized关键字修饰的代码块

synchronized(object){}

注意：多线程使用同步存在”死锁”的潜在危险。

死锁：如果多个线程都处于等待状态而无法被唤醒，就构成了死锁。比如同步方法里面有sleep()方法，那么这个锁就成了死锁。

线程通信

线程同步可以阻止并发访问同一资源，但不能实现不同线程之间的消息传递。所以需要用到线程通信。注意下面方法只能在同步方法或同步代码块中使用

wait()方法  ：挂起当前线程，并释放共享资源的锁
notify()方法：唤醒线程。在因调用该对象的wait()方法而阻塞的线程中
              随机选择一个解除阻塞，但要等到获得锁后才可执行
notifyAll()方法：将因调用该对象的wait()方法而阻塞的所有线程一次性全部解除阻塞

网络编程

1、基本概念

网络：是信息传输、接收、共享的虚拟平台，把各个点、面、体的信息联系到一起，从而实现资源共享

网络编程：通过使用套接字来达到进程间通信目的的编程

2、IP地址（Internet Protocol）

概念：唯一标识网络上的每一台计算机

IP组成：32位，由4个8位二进制数组成(ipv4)

11000000.10101000.00000001.11001000–>192.168.1.200

IP地址=网络地址+主机地址

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第12张图片

3、IP检测

查看IP地址：cmd—ipconfig

检测网络是否通畅：ping IP地址

4、DNS

域名解析器，把IP地址映射到域名。实现网站通过域名访问

5、网络服务器

指在网络环境下，具有较高计算能力，能够提供用户服务功能的计算机(邮件服务器；web服务器 如Apache Tomcat 阿里云)

客户机→服务器 （Client/Server） （ c/s）

浏览器→服务器 （Browser/Server）（ b/s）

6、网络通信协议

为了在网络中不同的计算机之间进行通信而建立的规则、标准或约定的集合

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第13张图片

应用层     HTTP FTP TFTP  SMTP  SNMP  DNS协议
传输层     TCP     UDP 协议
网络层     ICMP   IGMP  IP  ARP  RARP 协议
数据链路层和物理层      由底层网络定义的协议

 7、Socket编程

  • Socket(套接字)：是通信链路的端点。也是Java提供的接口。因为Socket的底层机制复杂，所以Java提供了API方便我们使用Socket编程
  • Socket通信模型：进行网络通信时，Socket需要借助数据流来完成数据的传递工作
  • 流式套接字：基于TCP协议的Socket网络编程

1、客户端Socket 类

//创建一个客户端Socket
Socket socket = new Socket("localhost"，端口参数)

//通过输出流，发送请求 getOutputStream( ) write()
OutputStream os=Socket.get OutputStream( );
byte[] infos=info.getBytes();
os.write(infos);

//关闭输出流
socket.shutdownOutput();

// 通过输入流，接收服务端响应
Inputstream  is = socket.getInputStream();

//释放资源

2、服务器端ServerSocket类

//创建一个服务器Socket
ServerSocket serverSocket=new ServerSocket(5000)

//使用accept()方法等待客户的通信
Socket socket=serverSocket.accpet();

//获得输入流，获得客户端请求
InputStream is=socket.getInputStream();

//把获得的字节流包装成字符流
BufferedReader br=new BufferedReader(new IputStreamReader(is));

//通过输出流，发送响应
OutputStream os = socket.getOutputStream();  Os.write(replys);

//释放相应资源

  • 数据包式套接字：基于UDP协议的Socket网络编程

        ① 利用DatagramPacket对象封装数据包
        ② 利用DatagramSocket发送数据包(send())
        ③ 利用DatagramSocket接收数据包(receive())
        ④ 利用DatagramPacket处理数据包

  • TCP 与 UDP 的区别
TCP UDP
是否连接 面向连接 面向非连接
传输可靠性 安全可靠 不可靠
速度 慢 快

 XML 技术

1、XML简介

XML(Extensibel Markup Language)：即可扩展标记语言，是一种简单的数据存储语言，使用一些列简单的标记描述数据。

特点：与操作系统、开发平台无关；规范统一

作用：数据交互；配置应用程序和网站；Ajax基石

2、XML基本结构

（1）XML声明。如：

（2）唯一的根元素。如： 

（3）元素描述信息。  如java编程思想

3、XML标签

<元素名  属性名 = “属性值”>元素内容

如：    

注意：属性值用双引号包裹。有多个属性用空格隔开

4、XML转义符

< 对应转移符<           >  对应转移符 >

”对应转移符"      ’对应转移符'

& 对应转移符&

当元素中出现很多特殊字符时，可以使用CDATA节 ：

5、XML解析器

非验证解析器：检查文档格式是否良好 (eclipse自带)

验证解析器：  使用DTD（文档类型定义）或Schema检查文档的有效性

6、XML命名空间

写法：< xmlns：name=”url”>

举例：xmlns:canon=”http://www.canon” –XML命名空间

xmlns=”http://www.Aptech_edu.ac”  —属性命名空间

7、解析XML技术

DOM（文档对象模型）：把XML文档映射成一个倒挂的树

  • DOM：基于XML文档树结构的解析。适用于多次访问的XML文档。特点：比较消耗资源

步骤：

1.创建解析器工厂对象
DocumentBuilderFactory  dbf=DocumentBuilderFactory.newInstance( );

2.解析器工厂对象创建解析器对象
DocumentBuilder  db = dbf.newDocumentBuilder( );

3.解析器对象指定XML文件创建Document对象
Document  document = db.parse(“要解析的路径”)

4.以Document对象为起点操作DOM树
NodeList  dogList= document.getElmentsByTagName(“节点”)

DOM 接口方法

Document接口：getElementById（）getElementsByTagName（） getElementsByName（）等方法

Node接口：

getparentNode() getchildNodes() getfirstChild() getlastChild()
getnextSibling () getpreviousSibling() createTextNode( ) removeChild()等方法

Element接口：

getTagName()  createElement( )等方法

  • SAX：基于事件的解析。适用于大数据量的XML文档。特点：占用资源少，内存消耗小
  • DOM4J：非常优秀的Java XML API。性能优异、功能强大。特点：开放源代码

DOM4J解析XML方法

//创建SAXReader对象   SAXReader reader = new SAXReader();

//获取XML文档对象    Document document = reader.read("xml/users.xml");

//获取root(根)节点    Element root = document.getRootElement();

//获取节点下的所有子节点集合  List users=root.elements();

//遍历输出 for(Element user:users){…}

DOM4J创建XML方法

//创建了一个xml文档
Document document=DocumentHelper.createDocument();

//创建一个根节点 和一个子节点 并添加属性
Element root=document.addElement("users");
Element user = root.addElement("user").addAttribute("id", "1");

//设置子节点的文本
user.addElement("username").addText("zs");
user.addElement("password").addText("111");

//创建输出流对象
File file = new File("src/xml/users.xml");
FileOutputStream out = new FileOutputStream(file);

//创建一个XMLWriter的对象 调用write方法写入
writer = new XMLWriter(out, OutputFormat.createPrettyPrint());  
writer.write(document);

相关代码

package com.hfxt.demo02;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * 1.输入：***InputStream(***Reader)/输出：***OutputStream(***Writer)
 * 
 * 2.字节流：***Stream/字符流：***Reader(***Writer)
 *
 * 3.节点流：创建对象时，参数是字符串或File类对象
 *   包装流(装饰流):创建对象时，参数是流对象，包装的作用：1.提高效率 2.方便书写代码
 */
public class Demo01 {
    public static void main(String[] args) {
        File file = new File("f:/java/User.java");
        FileInputStream fis=null;
        try {
            fis=new FileInputStream(file);
/*          int data;
            while((data=fis.read())!=-1){
                System.out.print((char)data);
            }*/
            byte []buf = new byte[1024];
            int len=0;
            while((len=fis.read(buf))>0){
                //System.out.write(buf);
                System.out.write(buf, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
package com.hfxt.demo02;
import java.io.*;
//二进制文件的读写
public class ReadAndWriteBinaryFile {
    public static void main(String[] args){
        DataInputStream dis=null;
        DataOutputStream dos=null;
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            //创建输入流对象
            fis=new FileInputStream("c:\\myDoc\\star.jpg");
            dis=new DataInputStream(fis);
            //创建输出流对象
            fos=new FileOutputStream("c:\\myDoc\\new.jpg");
            dos=new DataOutputStream(fos);
            //读取文件并写入文件
            int temp;
            while((temp=dis.read())!=-1){
                dos.write(temp);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if(dis!=null){
                    dis.close();
                }
                if(dos!=null){
                    dos.close();
                }
                if(fis!=null){
                    fis.close();
                }
                if(fos!=null){
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
package com.hfxt.demo;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Demo08 {
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        User user = new User(1, "zs", "111", "zs");
        //序列化
        ObjectOutputStream oos = new ObjectOutputStream(
                new BufferedOutputStream(new FileOutputStream(new File("f:/wkjava/user.txt"))));
        oos.writeObject(user);
        if(oos!=null) oos.close();
        //反序列化
        ObjectInputStream ois = new ObjectInputStream(
                new BufferedInputStream(new FileInputStream(new File("f:/wkjava/user.txt"))));
        User user2=(User) ois.readObject();
        System.out.println(user2);
    }
}
package com.hfxt.demo;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo05 {
     /*
      * 用字符流复制文本文件
      */
    public static void main(String[] args) {
        //创建文本文件对象和流对象
        File file1 = new File("f:/wkjava/a.jpg");
        File file2 = new File("f:/wkjava/3.jpg");
        FileOutputStream fos = null;
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //将文件对象放入流对象中
            fis = new FileInputStream(file1);
            fos = new FileOutputStream(file2);
            bis=new BufferedInputStream(fis);
            bos=new BufferedOutputStream(fos);
            //创建数组
            byte []buf=new byte[1024];
            int len=0;
            //复制操作：先读后写
            while((len=bis.read(buf))>0){
                bos.write(buf, 0, len);
            }
            //清缓冲区
            //bos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {  //关闭流
            if(bis!=null)
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if(bos!=null)
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
}
}
package com.hfxt.demo;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
public class ReadXml {
    public static void main(String[] args) {
        //创建SAXReader对象 
        SAXReader reader = new SAXReader();
        try {
            //读取文件 
            Document document = reader.read("xml/users.xml");
            //获取root(根)节点 
            Element root = document.getRootElement();//获得根元素
            /*System.out.println(root.getName());
            System.out.println("*******************");
            System.out.println(root.getText());
            System.out.println("*******************");*/
            //获取节点下的所有子节点集合 
            List users=root.elements();
            //遍历  
            for(Element user:users){
                System.out.println(user.attributeValue("id"));
                System.out.println(user.elementText("username"));
                System.out.println(user.elementText("password"));
                System.out.println(user.elementText("nickname"));
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }
}
package com.hfxt.demo;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
public class WriteXml {
    public static void main(String[] args) throws Exception {
        XMLWriter writer=null;
        //创建文档:使用了一个Helper类
        Document document=DocumentHelper.createDocument();
        //添加属性  添加子节点
        Element root=document.addElement("users");
        Element user = root.addElement("user").addAttribute("id", "1");
        user.addElement("username").addText("zs");
        user.addElement("password").addText("111");
        user = root.addElement("user").addAttribute("id", "2");
        user.addElement("username").addText("ls");
        user.addElement("password").addText("222");
        String path="src/xml/users.xml";
        File file = new File(path);
        if(!file.getParentFile().exists()){
            file.getParentFile().mkdirs();
        }
        FileOutputStream out = new FileOutputStream(file);
        //writer=new XMLWriter(out);
        writer=new XMLWriter(out, OutputFormat.createPrettyPrint());
        writer.write(document);
    }
}

10、逆向常见

接口中的方法

根据调用关系，最终找到接口中的方法了。

interface IRequest {
    public void send(String url);
}

class Context {

    public IRequest req;

    public Context(IRequest req) {
        this.req = req;
    }

    public void doRequest() {
        String url = "/click/android2/";
        this.req.send(url);
    }
}


public class Hello {

    public static void main(String[] args) {

    }
}

  • 思路1：寻找实现了 IRequest 接口的类。
  • 思路2：谁传入的req？找他的调用栈。

隐藏的字节

String salt = "xxssasdfasdfadsf";

String v4 = new String(new byte[]{-26, -83, -90, -26, -78, -101, -23, -67, -112});

# Python脚本，方便你们以后使用。
byte_list = [-26, -83, -90, -26, -78, -101, -23, -67, -112]

bs = bytearray()  # python字节数组
for item in byte_list:
    if item < 0:
        item = item + 256
    bs.append(item)

str_data = bs.decode('utf-8')  # data = bytes(bs)
print(str_data)

data = "张三懵逼了"
data_bytes = data.encode('utf-8')

data_list = []
for item in data_bytes:
    data_list.append(item)
print(data_list)
# [229, 188, 160, 228, 184, 137, 230, 135, 181, 233, 128, 188, 228, 186, 134]

data = "张三懵逼了"
data_bytes = data.encode('utf-8')

data_list = bytearray()
for item in data_bytes:
    data_list.append(item)

print(data_list)

res = data_list.decode('utf-8')
print(res)

提醒：常用在 MD5 加密、加盐、AES 加密 key、iv;

UUID

理论上永远不会重复的值（网卡、mac、当前时间、...）。

import java.util.UUID;

public class Hello {

    public static void main(String[] args){
        String uid = UUID.randomUUID().toString();
        System.out.println(uid);
    }
}

抖音 udid

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第14张图片

import java.util.UUID;

public class Hello {

    public static void main(String[] args){
        String uid = UUID.randomUUID().toString();
        System.out.println(uid);
    }
}

import uuid

uid = str(uuid.uuid4())
print(uid)

随机值

import java.math.BigInteger;
import java.security.SecureRandom;

public class Hello {

    public static void main(String[] args) {
        // 随机生成80位，10个字节
        BigInteger v4 = new BigInteger(80, new SecureRandom());
        // 让字节以16进制展示
        String res = v4.toString(16);
        System.out.println(res);

    }
}

import random

open_udid = "".join([hex(i)[2:] for i in random.randbytes(10)])
print(open_udid)

抖音：openudid

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第15张图片

import java.math.BigInteger;
import java.security.SecureRandom;

public class Hello {

    public static void main(String[] args) {
        // 随机生成80位，10个字节
        BigInteger v4 = new BigInteger(80, new SecureRandom());
        // 让字节以16进制展示
        String res = v4.toString(16);
        System.out.println(res);

    }
}

import random


data = random.randbytes(10)

ele_list = []
for item in data:
    ele = hex(item)[2:]
    ele_list.append(ele)

res = "".join(ele_list)
print(res)


open_udid = "".join([hex(i)[2:] for i in random.randbytes(10)])
print(open_udid)


open_udid = "".join(["%x" % i for i in random.randbytes(10)])
print(open_udid)

补充

v1 = 8

# print(hex(v1)[2:].rjust(2, "0"))

res = "%02x" % v1
print(res)

时间戳

public class Hello {

    public static void main(String[] args) {
        String t1 = String.valueOf(System.currentTimeMillis() / 1000);
        String t2 = String.valueOf(System.currentTimeMillis());

        System.out.println(t1);
        System.out.println(t2);
    }
}

抖音：_ticket

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第16张图片

public class Hello {

    public static void main(String[] args) {
        String t1 = String.valueOf(System.currentTimeMillis() / 1000);
        String t2 = String.valueOf(System.currentTimeMillis());

        System.out.println(t1);
        System.out.println(t2);
    }
}

 十六进制字符串

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第17张图片

在Java中字节是有符号：-128 ~ 127

# name_bytes = "武沛齐".encode('utf-8')
name_bytes = [10, -26, -83, -90, -26, -78, -101, -23, -67, -112]

data_list = []

for item in name_bytes:
    item = item & 0xff   # item<0时，让item+256
    ele = "%02x" % item
    data_list.append(ele)
    
print("".join(data_list))

import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {

        String name = "\n武沛齐";
        byte[] nameBytes =name.getBytes();

        // [10, -26, -83, -90, -26, -78, -101, -23, -67, -112]
        //  0a   e6    ad   a6
        System.out.println(Arrays.toString(nameBytes));
        StringBuilder sb = new StringBuilder();
        for(int i=0;i             int val = nameBytes[i] & 255;  // 负数转换为正数（byte，正数、负数）
            if (val<16){
                sb.append("0");
            }
            sb.append(Integer.toHexString(val));
        }
        String res = sb.toString();
        System.out.println(res); // e6ada6e6b29be9bd90

    }
}

name = "武沛齐"

data_list = []
for item in name.encode('utf-8'):
    val = hex(item)
    data = val[2:].zfill(2)
    data_list.append(data)

result = ''.join(data_list)
print(result) # e6ada6e6b29be9bd90

md5 加密

Python 中 md5 操作

 import hashlib

obj = hashlib.md5()
obj.update('xxxxx'.encode('utf-8'))

# java中没有这个功能。
v1 = obj.hexdigest()
print(v1) # fb0e22c79ac75679e9881e6ba183b354

v2 = obj.digest()
print(v2) # b'\xfb\x0e"\xc7\x9a\xc7Vy\xe9\x88\x1ek\xa1\x83\xb3T'

Java 中 md5 操作

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;

public class Hello {

    public static void main(String[] args) throws NoSuchAlgorithmException {
        String name = "武沛齐";
        MessageDigest instance = MessageDigest.getInstance("MD5");
        byte[] nameBytes = instance.digest(name.getBytes());
        System.out.println(Arrays.toString(nameBytes));

        String res = new String(nameBytes);
        System.out.println(res);

        // 十六进制展示
        StringBuilder sb = new StringBuilder();
        for(int i=0;i             int val = nameBytes[i] & 255;  // 负数转换为正数
            if (val<16){
                sb.append("0");
            }
            sb.append(Integer.toHexString(val));
        }
        String hexData = sb.toString();
        System.out.println(hexData); // e6ada6e6b29be9bd90
    }
}

import hashlib

m = hashlib.md5()
m.update("武沛齐".encode("utf-8"))
v1 = m.digest()
print(v1) # b'\x175\x10\x12G$)\xd5-\x0c\r#\xd4h\x17='
v2 = m.hexdigest()
print(v2) # 17351012472429d52d0c0d23d468173d

md5 加盐

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;

public class Hello {

    public static void main(String[] args) throws NoSuchAlgorithmException {
        String name = "武沛齐";
        MessageDigest instance = MessageDigest.getInstance("MD5");
        instance.update("xxxxxx".getBytes());
        byte[] nameBytes = instance.digest(name.getBytes());
        System.out.println(Arrays.toString(nameBytes));

        String res = new String(nameBytes);
        System.out.println(res);

        // 十六进制展示
        StringBuilder sb = new StringBuilder();
        for(int i=0;i             int val = nameBytes[i] & 255;  // 负数转换为正数
            if (val<16){
                sb.append("0");
            }
            sb.append(Integer.toHexString(val));
        }
        String hexData = sb.toString();
        System.out.println(hexData); // e6ada6e6b29be9bd90
    }
}

import hashlib

m = hashlib.md5("xxxxxx".encode('utf-8'))
m.update("武沛齐".encode("utf-8"))
v1 = m.digest()
print(v1) # b'\x175\x10\x12G$)\xd5-\x0c\r#\xd4h\x17='
v2 = m.hexdigest()
print(v2) # 17351012472429d52d0c0d23d468173d

抖音：X-SS-STUB

每次发送POST请求时，抖音都会携带一些请求头：
    X-SS-STUB = "fjaku9asdf"

读取请求体中的数据，对请求体中的数据进行md5加密。

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第18张图片

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;

public class Hello {

    public static void main(String[] args) throws NoSuchAlgorithmException {
        String name = "武沛齐";
        
        MessageDigest instance = MessageDigest.getInstance("MD5");
        byte[] nameBytes = instance.digest(name.getBytes());
        // System.out.println(Arrays.toString(nameBytes));

        // String res = new String(nameBytes);
        // System.out.println(res);

        // 十六进制展示
        StringBuilder sb = new StringBuilder();
        for(int i=0;i             int val = nameBytes[i] & 255;  // 负数转换为正数
            if (val<16){
                sb.append("0");
            }
            sb.append(Integer.toHexString(val));
        }
        String hexData = sb.toString();
        System.out.println(hexData); // e6ada6e6b29be9bd90
    }
}

import hashlib

m = hashlib.md5()
m.update("武沛齐".encode("utf-8"))

v1 = m.digest()
print(v1) # b'\x175\x10\x12G$)\xd5-\x0c\r#\xd4h\x17='

v2 = m.hexdigest()
print(v2) # 17351012472429d52d0c0d23d468173d

sha-256 加密

B站：x/report/andriod2，请求体

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第19张图片

 安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第20张图片

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;

public class Hello {

    public static void main(String[] args) throws NoSuchAlgorithmException {
        String name = "武沛齐";
        MessageDigest instance = MessageDigest.getInstance("SHA-256");
        byte[] nameBytes = instance.digest(name.getBytes());
        // System.out.println(Arrays.toString(nameBytes));

        // String res = new String(nameBytes);
        // System.out.println(res);

        // 十六进制展示
        StringBuilder sb = new StringBuilder();
        for(int i=0;i             int val = nameBytes[i] & 255;  // 负数转换为正数
            if (val<16){
                sb.append("0");
            }
            sb.append(Integer.toHexString(val));
        }
        String hexData = sb.toString();
        System.out.println(hexData); // e6ada6e6b29be9bd90
    }
}

import hashlib

m = hashlib.sha256()
m.update("武沛齐".encode("utf-8"))

v2 = m.hexdigest()
print(v2)

AES加密

刷B站播放时，发送POST请求。

AES加密（请求体中的数据） -> 密文（JS央视频 key & iv & 加密）。

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第21张图片

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第22张图片

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;

public class Hello {

    public static void main(String[] args) throws Exception {
        String data = "武沛齐";
        String key = "fd6b639dbcff0c2a1b03b389ec763c4b";
        String iv = "77b07a672d57d64c";

        // 加密
        byte[] raw = key.getBytes();
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes());
        
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec, ivSpec);
        byte[] encrypted = cipher.doFinal(data.getBytes());
        
        // System.out.println(Arrays.toString(encrypted));        
    }
}

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad

KEY = "fd6b639dbcff0c2a1b03b389ec763c4b"
IV = "77b07a672d57d64c"


def aes_encrypt(data_string):
    aes = AES.new(
        key=KEY.encode('utf-8'),
        mode=AES.MODE_CBC,
        iv=IV.encode('utf-8')
    )
    raw = pad(data_string.encode('utf-8'), 16)
    return aes.encrypt(raw)

data = aes_encrypt("武沛齐")
print(data)
print([ i for i in data])

gzip压缩

抖音注册设备：设备。

  • 注册设备：生成一些值，值中包括： （cdid、手机型号、手机品牌....） 后端读取到时候，发现cdid是一个全新的请求。那么抖音就会生成 device_id、install_id、tt。（cdid、手机型号、手机品牌....） --> gzip压缩 --> 加密 密文。

  • 发送其他请求时：

    • 获取平台
    • 点赞
    • ...

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.io.OutputStream;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class Hello {

    public static void main(String[] args) throws IOException {

        // 压缩
        String data = "武沛齐";
        // System.out.println(Arrays.toString(data.getBytes()));
        ByteArrayOutputStream v0_1 = new ByteArrayOutputStream();
        GZIPOutputStream v1 = new GZIPOutputStream((v0_1));
        v1.write(data.getBytes());
        v1.close();
        
        byte[] arg6 = v0_1.toByteArray();  //gzip压缩后：arg6
        // System.out.println(Arrays.toString(arg6));

        // 解压缩
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ByteArrayInputStream in = new ByteArrayInputStream(arg6);
        GZIPInputStream ungzip = new GZIPInputStream(in);
        byte[] buffer = new byte[256];
        int n;
        while ((n = ungzip.read(buffer)) >= 0) {
            out.write(buffer, 0, n);
        }
        byte[] res = out.toByteArray();
        // System.out.println(Arrays.toString(res));
        System.out.println(out.toString("UTF-8"));

    }
}

import gzip


# 压缩
"""
s_in = "我是武沛齐".encode('utf-8')
s_out = gzip.compress(s_in)
print([i for i in s_out])
"""

# 解压缩
"""
res = gzip.decompress(s_out)
print(res)
print(res.decode('utf-8'))
"""

base64 处理

import java.util.Base64;

public class Hello {

    public static void main(String[] args) {
        String name = "武沛齐";
        Base64.Encoder encoder  = Base64.getEncoder();
        String res = encoder.encodeToString(name.getBytes());
        System.out.println(res); // 5q2m5rKb6b2Q

        Base64.Decoder decoder  = Base64.getDecoder();
        byte[] origin = decoder.decode(res);
        String data = new String(origin);
        System.out.println(data); // 武沛齐

    }
}

import base64

name = "武沛齐"

res = base64.b64encode(name.encode('utf-8'))
print(res) # b'5q2m5rKb6b2Q'


data = base64.b64decode(res)
print(data.decode('utf-8'))

11、JNI 基础

示例 1 ( JNI 调用 Java中 static 方法 )

在 JNI 中如果想要调用Java中的成员，是使用：

// Java
package com.nb.fucker;

class Query {
    public static int getData(int v1, int v2) {
        return v1 + v2;
    }
    
    public static int getData(int v1) {
        return v1 + v2;
    }
}

// JNI
jclass cls = (*env)->FindClass(env, "com/nb/fucker/Query");
jmethodID mid = (*env)->GetStaticMethodID(env, cls, "getData", "(II)I");
int res = (*env)->CallStaticIntMethod(env, cls, mid, 1,2);

示例 2

// Java
package com.nb.fucker;

class Query {
    public static String getData(int v1, int v2) {
        return v1 + v2;
    }
}

// JNI
jclass cls = (*env)->FindClass(env, "com/nb/fucker/Query");
jmethodID mid = (*env)->GetStaticMethodID(env, cls, "getData", "(II)Ljava/lang/String;");
jobject res = (*env)->CallStaticObjectMethod(env, cls, mid, 1,2);

示例 3

// java
package com.nb.fucker;

class Query {

    public static String getData(String v1, int v2) {
        return String.valueOf(v1 + v2);
    }
}

// JNI，C语言
jclass cls = (*env)->FindClass(env, "com/nb/fucker/Query");
jmethodID mid = (*env)->GetStaticMethodID(env, cls, "getData","(Ljava/lang/String;I)Ljava/lang/String;");

// C语言中的字符串不能直接在Java中使用，必须通过 NewStringUTF 转换后才能在java中使用

jstring arg1 = (*env)->NewStringUTF(env, "哈哈哈哈");
jobject res = (*env)->CallStaticObjectMethod(env, cls, mid, arg1, 2);

示例 4  ( JNI 调用 Java中 实例 方法 )

// java
package com.nb.fucker;

class Query {
    // 构造方法
    public Query(int arg1, int arg2, String arg3) {

    }
    // getData
    public String getData(int v1, int v2) {
        return String.valueOf(v1 + v2);
    }
}

// JNI
jclass cls = (*env)->FindClass(env, "com/nb/fucker/Query");
jmethodID init = (*env)->GetMethodID(env, cls, "", "(IILjava/lang/String;)V");

// 实例化出来的对象
jobject cls_object = (*env)->NewObject(env, cls, init, 1, 2, (*env)->NewStringUTF(env, "哈哈哈哈"));


jmethodID mid = (*env)->GetMethodID(env, cls, "getData", "(II)Ljava/lang/String;");

jstring arg1 = (*env)->NewStringUTF(env, "字符串呀");
jobject res = (*env)->CallObjectMethod(env, cls_object, mid, arg1, 2);

寻找 RegisterNative 函数

apk是将Java代码打包后的包，解压后发现内部都是一大堆的dex文件（代码）。

安卓手机上都是有一个虚拟机，负责读取dex代码转换成机器码去执行，除此以外，也包括：垃圾回收、Java本地方法调用（JNI）、即时编译（JIT）等。

  • 安卓4.2之前：DVM。
  • 安卓4.2之后：DVM（默认）、ART(Android Runingtime)共存。
  • 安卓5.0之后：ART。

关于两种虚拟机：

  • DVM，每次运行应用的时候，实时将字节码转化为机器码，再运行程序。【基于libdvm.so库】
  • ART，在安装应用的时候，就将应用的字节码转换为机器码，保存在手机里。每次运行应用的时候，无需实时转换，直接使用转换好的机器码。【基于libart.so库】

在JNI在进行动态注册时执行的 RegisterNatives 方法，就是在libart.so库中。

所以，如果想要hook RegisterNatives 方法，就必须要先找到他，所以，基于frida可以这么干。

基于frida中的模块来寻找。

// 列举 libart.so 中的所有导出函数（成员列表）
var symbols = Module.enumerateSymbolsSync("libart.so");

// 获取 RegisterNatives函数的内存地址，并赋值给addrRegisterNatives。
var addrRegisterNatives = null;

for (var i = 0; i < symbols.length; i++) {
    var symbol = symbols[i];
    console.log(symbol.name)
    
    //_ZN3art3JNI15RegisterNativesEP7_JNIEnvP7_jclassPK15JNINativeMethodi
    // 方式1：
    if (symbol.name.indexOf("art") >= 0 &&
        symbol.name.indexOf("JNI") >= 0 &&
        symbol.name.indexOf("RegisterNatives") >= 0 &&
        symbol.name.indexOf("CheckJNI") < 0) {
        
        addrRegisterNatives = symbol.address;
        console.log("RegisterNatives is at ", symbol.address, symbol.name);
    }
    
    
    // 方式2：
    var name = "_ZN3art3JNI15RegisterNativesEP7_JNIEnvP7_jclassPK15JNINativeMethodi";
    if(symbol.name.indexOf("art") >= 0){
        if(symbol.name.indexOf(name)>=0){
            addrRegisterNatives = symbol.address;
        }
    }
}

Hook RegisterNavtive 定位函数

找到 RegisterNatives 函数之后，就可以通过frida的拦截器来对他进行hook，以便找到注册的所有方法的对应关系。例如：

安卓逆向 --- java基础、ArrayList、LinkedList、HashMap、泛型、反射、逆向常见操作_第23张图片

参数1：JNI对象；
参数2：类
参数3：动态注册的对应关系
参数4：注册的方法数量

Interceptor.attach(addrRegisterNatives, {
    onEnter: function (args) {
        var env = args[0];        // jni对象
        var java_class = args[1]; // 类
        var class_name = Java.vm.tryGetEnv().getClassName(java_class);
        // 只有类名为com.bilibili.nativelibrary.LibBili，才打印输出
        var taget_class = "com.bilibili.nativelibrary.LibBili";
        
        if(class_name === taget_class){
            console.log("\n[RegisterNatives] method_count:", args[3]);
            
            // args[2] 就是动态注册的对应关系。
            // ptr是new NativePointer(s) 的缩写。(C语言中的指针)
            var methods_ptr = ptr(args[2]);
            var method_count = parseInt(args[3]);
            for (var i = 0; i < method_count; i++) {
                // Java中函数名字的
                var name_ptr = Memory.readPointer(methods_ptr.add(i * Process.pointerSize * 3));
                // 参数和返回值类型
                var sig_ptr = Memory.readPointer(methods_ptr.add(i * Process.pointerSize * 3 + Process.pointerSize));
                // C中的函数指针
                var fnPtr_ptr = Memory.readPointer(methods_ptr.add(i * Process.pointerSize * 3 + Process.pointerSize * 2));

                var name = Memory.readCString(name_ptr);
                var sig = Memory.readCString(sig_ptr);
                var find_module = Process.findModuleByAddress(fnPtr_ptr);
                var offset = ptr(fnPtr_ptr).sub(find_module.base) // fnPtr_ptr - 模块基地址
                // console.log("[RegisterNatives] java_class:", class_name);
                // console.log("name:", name, "sig:", sig, "module_name:", find_module.name, "offset:", offset);
                console.log("name:", name, "module_name:", find_module.name, "offset:", offset);
        }
        }
    }
});

完整脚本

frida -U --no-pause -f tv.danmaku.bili -l natives-1.js

function hook_RegisterNatives() {
    var symbols = Module.enumerateSymbolsSync("libart.so");
    var addrRegisterNatives = null;
    for (var i = 0; i < symbols.length; i++) {
        var symbol = symbols[i];

        // _ZN3art3JNI15RegisterNativesEP7_JNIEnvP7_jclassPK15JNINativeMethodi
        if (symbol.name.indexOf("art") >= 0 &&
            symbol.name.indexOf("JNI") >= 0 &&
            symbol.name.indexOf("RegisterNatives") >= 0 &&
            symbol.name.indexOf("CheckJNI") < 0) {
            addrRegisterNatives = symbol.address;
            console.log("RegisterNatives is at ", symbol.address, symbol.name);
        }
    }

    if (addrRegisterNatives != null) {
        Interceptor.attach(addrRegisterNatives, {
            onEnter: function (args) {
                var env = args[0];
                var java_class = args[1];
                var class_name = Java.vm.tryGetEnv().getClassName(java_class);
                //console.log(class_name);
                // 只有类名为com.bilibili.nativelibrary.LibBili，才打印输出
                var taget_class = "com.bilibili.nativelibrary.LibBili";
                if (class_name === taget_class) {
                    console.log("\n[RegisterNatives] method_count:", args[3]);
                    var methods_ptr = ptr(args[2]);
                    var method_count = parseInt(args[3]);

                    for (var i = 0; i < method_count; i++) {
                        // Java中函数名字的
                        var name_ptr = Memory.readPointer(methods_ptr.add(i * Process.pointerSize * 3));
                        // 参数和返回值类型
                        var sig_ptr = Memory.readPointer(methods_ptr.add(i * Process.pointerSize * 3 + Process.pointerSize));
                        // C中的函数指针
                        var fnPtr_ptr = Memory.readPointer(methods_ptr.add(i * Process.pointerSize * 3 + Process.pointerSize * 2));

                        var name = Memory.readCString(name_ptr); // 读取java中函数名
                        var sig = Memory.readCString(sig_ptr); // 参数和返回值类型
                        var find_module = Process.findModuleByAddress(fnPtr_ptr); // 根据C中函数指针获取模块

                        var offset = ptr(fnPtr_ptr).sub(find_module.base) // fnPtr_ptr - 模块基地址
                        // console.log("[RegisterNatives] java_class:", class_name);
                        // console.log("name:", name, "sig:", sig, "module_name:", find_module.name, "offset:", offset);
                        console.log("name:", name, "module_name:", find_module.name, "offset:", offset);

                    }
                }
            }
        });
    }
}

setImmediate(hook_RegisterNatives);

你可能感兴趣的:(Java,java,开发语言,jvm)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
  • 常见的 JVM 调优方法有哪些？ 爪哇天下 jvm
    常见的JVM调优方法有哪些？可以具体到调整哪个参数，调成什么值？对年轻代的EdenSurvivor的比例进行配置-XX:SurvivorRatio=8：表示设置2个Survivor区：1个Eden区的大小比值为2:8，这意味着Survivor区占整个年轻代的1/5，这个参数默认为8如果经常性的SurvivorTo放不下YGC的剩余的对象时候，可以适当的调整比例常用的CMS收集器：设置回收阈值，需要
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 切换淘宝最新npm镜像源是 hai40587 npm前端node.js
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
  • 桌面上有多个球在同时运动，怎么实现球之间不交叉，即碰撞？ 换个号韩国红果果 html小球碰撞
    稍微想了一下，然后解决了很多bug，最后终于把它实现了。其实原理很简单。在每改变一个小球的x y坐标后，遍历整个在dom树中的其他小球，看一下它们与当前小球的距离是否小于球半径的两倍？若小于说明下一次绘制该小球（设为a）前要把他的方向变为原来相反方向（与a要碰撞的小球设为b），即假如当前小球的距离小于球半径的两倍的话，马上改变当前小球方向。那么下一次绘制也是先绘制b，再绘制a，由于a的方向已经改变
  • 《高性能HTML5》读后整理的Web性能优化内容 白糖_ html5
    读后感         先说说《高性能HTML5》这本书的读后感吧，个人觉得这本书前两章跟书的标题完全搭不上关系，或者说只能算是讲解了“高性能”这三个字，HTML5完全不见踪影。个人觉得作者应该首先把HTML5的大菜拿出来讲一讲，再去分析性能优化的内容，这样才会有吸引力。因为只是在线试读，没有机会看后面的内容，所以不胡乱评价了。  
  • [JShop]Spring MVC的RequestContextHolder使用误区 dinguangx jeeshop商城系统jshop电商系统
        在spring mvc中，为了随时都能取到当前请求的request对象，可以通过RequestContextHolder的静态方法getRequestAttributes()获取Request相关的变量，如request, response等。         在jshop中，对RequestContextHolder的
  • 算法之时间复杂度 周凡杨 java算法时间复杂度效率
          在 计算机科学 中， 算法 的时间复杂度是一个 函数 ，它定量描述了该算法的运行时间。这是一个关于代表算法输入值的 字符串 的长度的函数。时间复杂度常用 大O符号 表述，不包括这个函数的低阶项和首项系数。使用这种方式时，时间复杂度可被称为是 渐近 的，它考察当输入值大小趋近无穷时的情况。 这样用大写O()来体现算法时间复杂度的记法，
  • Java事务处理 g21121 java
    一、什么是Java事务 通常的观念认为，事务仅与数据库相关。 事务必须服从ISO/IEC所制定的ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写。事务的原子性表示事务执行过程中的任何失败都将导致事务所做的任何修改失效。一致性表示当事务执行失败时，所有被该事务影响的数据都应该恢复到事务执行前的状
  • Linux awk命令详解 510888780 linux
    一.  AWK 说明   awk是一种编程语言，用于在linux/unix下对文本和数据进行处理。数据可以来自标准输入、一个或多个文件，或其它命令的输出。它支持用户自定义函数和动态正则表达式等先进功能，是linux/unix下的一个强大编程工具。它在命令行中使用，但更多是作为脚本来使用。    awk的处理文本和数据的方式：它逐行扫描文件，从第一行到
  • android permission 布衣凌宇 Permission
    <uses-permission android:name="android.permission.ACCESS_CHECKIN_PROPERTIES" ></uses-permission>允许读写访问"properties"表在checkin数据库中，改值可以修改上传 <uses-permission android:na
  • Oracle和谷歌Java Android官司将推迟 aijuans javaoracle
    北京时间 10 月 7 日，据国外媒体报道，Oracle 和谷歌之间一场等待已久的官司可能会推迟至 10 月 17 日以后进行，这场官司的内容是 Android 操作系统所谓的 Java 专利权之争。本案法官 William Alsup 称根据专利权专家 Florian Mueller 的预测，谷歌 Oracle 案很可能会被推迟。　　该案中的第二波辩护被安排在 10 月 17 日出庭，从目前看来
  • linux shell 常用命令 antlove linuxshellcommand
    grep [options] [regex] [files] /var/root # grep -n "o" * hello.c:1:/* This C source can be compiled with:
  • Java解析XML配置数据库连接(DOM技术连接 SAX技术连接) 百合不是茶 sax技术Java解析xml文档dom技术XML配置数据库连接
        XML配置数据库文件的连接其实是个很简单的问题,为什么到现在才写出来主要是昨天在网上看了别人写的,然后一直陷入其中,最后发现不能自拔 所以今天决定自己完成 ,,,,现将代码与思路贴出来供大家一起学习   XML配置数据库的连接主要技术点的博客; JDBC编程 : JDBC连接数据库 DOM解析XML:  DOM解析XML文件 SA
  • underscore.js 学习（二） bijian1013 JavaScriptunderscore
            Array Functions 所有数组函数对参数对象一样适用。1.first   _.first(array, [n])   别名: head, take       返回array的第一个元素，设置了参数n，就
  • plSql介绍 bijian1013 oracle数据库plsql
    /* * PL/SQL 程序设计学习笔记 * 学习plSql介绍.pdf * 时间：2010-10-05 */ --创建DEPT表 create table DEPT ( DEPTNO NUMBER(10), DNAME NVARCHAR2(255), LOC NVARCHAR2(255) ) delete dept; select
  • 【Nginx一】Nginx安装与总体介绍 bit1129 nginx
    启动、停止、重新加载Nginx nginx 启动Nginx服务器，不需要任何参数u nginx -s stop 快速(强制)关系Nginx服务器 nginx -s quit 优雅的关闭Nginx服务器 nginx -s reload 重新加载Nginx服务器的配置文件 nginx -s reopen 重新打开Nginx日志文件  
  • spring mvc开发中浏览器兼容的奇怪问题 bitray jqueryAjaxspringMVC浏览器上传文件
        最近个人开发一个小的OA项目,属于复习阶段.使用的技术主要是spring mvc作为前端框架,mybatis作为数据库持久化技术.前台使用jquery和一些jquery的插件.     在开发到中间阶段时候发现自己好像忽略了一个小问题,整个项目一直在firefox下测试,没有在IE下测试,不确定是否会出现兼容问题.由于jquer
  • Lua的io库函数列表 ronin47 lua io
    1、io表调用方式：使用io表，io.open将返回指定文件的描述，并且所有的操作将围绕这个文件描述 　　io表同样提供三种预定义的文件描述io.stdin,io.stdout,io.stderr 　　2、文件句柄直接调用方式,即使用file:XXX()函数方式进行操作,其中file为io.open()返回的文件句柄 　　多数I/O函数调用失败时返回nil加错误信息,有些函数成功时返回nil
  • java-26-左旋转字符串 bylijinnan java
    public class LeftRotateString { /** * Q 26 左旋转字符串 * 题目：定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。 * 如把字符串abcdef左旋转2位得到字符串cdefab。 * 请实现字符串左旋转的函数。要求时间对长度为n的字符串操作的复杂度为O(n)，辅助内存为O(1)。 */ pu
  • 《vi中的替换艺术》-linux命令五分钟系列之十一 cfyme linux命令
    vi方面的内容不知道分类到哪里好，就放到《Linux命令五分钟系列》里吧！ 今天编程，关于栈的一个小例子，其间我需要把”S.”替换为”S->”(替换不包括双引号)。 其实这个不难，不过我觉得应该总结一下vi里的替换技术了，以备以后查阅。   1 所有替换方案都要在冒号“:”状态下书写。 2 如果想将abc替换为xyz，那么就这样 :s/abc/xyz/ 不过要特别
  • [轨道与计算]新的并行计算架构 comsci 并行计算
         我在进行流程引擎循环反馈试验的过程中，发现一个有趣的事情。。。如果我们在流程图的每个节点中嵌入一个双向循环代码段，而整个流程中又充满着很多并行路由，每个并行路由中又包含着一些并行节点，那么当整个流程图开始循环反馈过程的时候，这个流程图的运行过程是否变成一个并行计算的架构呢？      
  • 重复执行某段代码 dai_lm android
    用handler就可以了 private Handler handler = new Handler(); private Runnable runnable = new Runnable() { public void run() { update(); handler.postDelayed(this, 5000); } }; 开始计时 h
  • Java实现堆栈（list实现） datageek 数据结构——堆栈
    public interface IStack<T> { //元素出栈，并返回出栈元素 public T pop(); //元素入栈 public void push(T element); //获取栈顶元素 public T peek(); //判断栈是否为空 public boolean isEmpty
  • 四大备份MySql数据库方法及可能遇到的问题 dcj3sjt126com DBbackup
    一：通过备份王等软件进行备份前台进不去？ 用备份王等软件进行备份是大多老站长的选择，这种方法方便快捷，只要上传备份软件到空间一步步操作就可以，但是许多刚接触备份王软件的客用户来说还原后会出现一个问题：因为新老空间数据库用户名和密码不统一，网站文件打包过来后因没有修改连接文件，还原数据库是好了，可是前台会提示数据库连接错误，网站从而出现打不开的情况。 解决方法：学会修改网站配置文件，大多是由co
  • github做webhooks：[1]钩子触发是否成功测试 dcj3sjt126com githubgitwebhook
    转自: http://jingyan.baidu.com/article/5d6edee228c88899ebdeec47.html github和svn一样有钩子的功能，而且更加强大。例如我做的是最常见的push操作触发的钩子操作，则每次更新之后的钩子操作记录都会在github的控制板可以看到！ 工具/原料 github 方法/步骤
  • ">的作用" target="_blank">JSP中的作用 蕃薯耀
    JSP中<base href="<%=basePath%>">的作用 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  • linux下SAMBA服务安装与配置 hanqunfeng linux
    局域网使用的文件共享服务。 一.安装包： rpm -qa | grep samba samba-3.6.9-151.el6.x86_64 samba-common-3.6.9-151.el6.x86_64 samba-winbind-3.6.9-151.el6.x86_64 samba-client-3.6.9-151.el6.x86_64 samba-winbind-clients
  • guava cache IXHONG cache
    缓存，在我们日常开发中是必不可少的一种解决性能问题的方法。简单的说，cache 就是为了提升系统性能而开辟的一块内存空间。 　　缓存的主要作用是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日常开发的很多场合，由于受限于硬盘IO的性能或者我们自身业务系统的数据处理和获取可能非常费时，当我们发现我们的系统这个数据请求量很大的时候，频繁的IO和频繁的逻辑处理会导致硬盘和CPU资源的
  • Query的开始--全局变量,noconflict和兼容各种js的初始化方法 kvhur JavaScriptjquerycss
    这个是整个jQuery代码的开始，里面包含了对不同环境的js进行的处理，例如普通环境，Nodejs，和requiredJs的处理方法。 还有jQuery生成$, jQuery全局变量的代码和noConflict代码详解  完整资源： http://www.gbtags.com/gb/share/5640.htm jQuery 源码：   (
  • 美国人的福利和中国人的储蓄 nannan408
       今天看了篇文章，震动很大，说的是美国的福利。    美国医院的无偿入院真的是个好措施。小小的改善，对于社会是大大的信心。小孩，税费等，政府不收反补，真的体现了人文主义。    美国这么高的社会保障会不会使人变懒？答案是否定的。正因为政府解决了后顾之忧，人们才得以倾尽精力去做一些有创造力，更造福社会的事情，这竟成了美国社会思想、人
  • N阶行列式计算(JAVA) qiuwanchi N阶行列式计算
    package gaodai; import java.util.List; /** * N阶行列式计算 * @author 邱万迟 * */ public class DeterminantCalculation { public DeterminantCalculation(List<List<Double>> determina
  • C语言算法之打渔晒网问题 qiufeihu c算法
    如果一个渔夫从2011年1月1日开始每三天打一次渔，两天晒一次网，编程实现当输入2011年1月1日以后任意一天，输出该渔夫是在打渔还是在晒网。 代码如下：   #include <stdio.h> int leap(int a) /*自定义函数leap()用来指定输入的年份是否为闰年*/ { if((a%4 == 0 && a%100 != 0
  • XML中DOCTYPE字段的解析 wyzuomumu xml
    DTD声明始终以!DOCTYPE开头,空一格后跟着文档根元素的名称,如果是内部DTD,则再空一格出现[],在中括号中是文档类型定义的内容. 而对于外部DTD,则又分为私有DTD与公共DTD,私有DTD使用SYSTEM表示,接着是外部DTD的URL. 而公共DTD则使用PUBLIC,接着是DTD公共名称,接着是DTD的URL.   私有DTD <!DOCTYPErootSYST