526互联

0x05.HelloJAVA

发布时间 2023-12-04 18:15:35作者: Tra3r

基础知识

  • java的类目和文件名必须相同（区分大小写）

  • java文件，先编译成字节码（.class文件），然后在JAVA的虚拟机JVM上以解释方式执行字节码

  • java的项目里面包含了源代码、依赖、配置文件，会直接打包，生成编译后的项目

  • java的包，com.aaa.bbb相当于三个文件夹"."可以理解成/

    属于某一个包的JAVA文件，必须声明包的名字（自动生成）


变量

  • 字符串变量只能用双引号，字符型变量只能用单引号
String str1 = "apple";
char str2 = 'a';
  • 变量在创建的时候，必须声明它的类型，后续使用不需要声明
String str = "hello";
System.out.println(str);

函数

  • 函数需要声明返回值的类型，函数的形参也需要声明，构造方法不需要声明
  • 作用域：代码块/函数的内部可以访问外部，外部不能访问内部
  • 调用顺序：父类的代码块，父类的构造函数，当前类的代码块，当前类的构造函数
访问控制修饰符  返回值类型  函数名(形参){ 
    函数体
}

//函数
public String get_str(){
        return "hello";
}

//代码块
{
    执行内容
}

  • 调用函数的时候，先实例化

构造方法

//构造方法
  public Test(){
        System.out.println("构造方法");
    }
//含参构造方法
    public Test(String a){
        System.out.println(a);
    }

Test test = new Test("apple");//调用要传入对应的类型

静态方法和非静态的方法

​ 非静态方法里面可以直接调用静态方法

​ 静态方法不能直接调用非静态方法

函数的形参和成员变量

​ 当函数的形参与成员变量名相同的时候，函数内会引用形参。但如果想要引用成员变量，使用this。this就是指调用该函数下的变量

访问控制修饰符

不声明的话，默认是default

son继承了test类，但是并没有在同一个包里面，而且变量a的修饰符是default，所以无法访问到。如果想要访问到，在变量a前面加上public

抽象类

抽象类不能被实例化，用于被其他类继承。抽象类可以包含抽象方法和具体方法


抽象方法：

  • 在抽象类中声明但没有提供实现的方法。子类必须提供抽象方法的实现

  • 抽象方法不能有主体，不可以加大括号


Animal作为抽象类

Dog类继承Animal类，并且Dog类会提供抽象方法的实现

由于抽象函数不能直接实例化，通过创建抽象类的非抽象子类的实例来间接实例化。这种隐式转换，无法直接调用子类的属性和方法，可以用反射的方法调用


接口

接口是一种抽象类型，类可以实现一个或多个接口，从而扩展其功能。接口是实现多继承的一种方式，并且通过接口，可以定义类之间的契约。

  • 定义接口：和抽象类不同的是，接口里面不能有具体的方法。接口里的方法默认是抽象的

  • 实现接口：类使用implements关键字实现继承，并且实现接口的类需要提供接口的所有抽象方法的实现

  • 接口调用，和抽象类一样，接口不能直接实例化。只能通过实现接口的类进行间接实例化

数组

只能保存同一种数据类型

在Java中，有多种方法可以创建数组。以下是其中的一些方式：

  • 静态初始化：
// 初始化整数数组
int[] numbers = {1, 2, 3, 4, 5};

// 初始化字符串数组
String[] names = {"Alice", "Bob", "Charlie"};
  • 动态初始化：
// 初始化整数数组，指定长度
int[] numbers = new int[5];

// 初始化字符串数组，指定长度
String[] names = new String[3];
  • 使用 new 关键字：
// 初始化整数数组
int[] numbers = new int[]{1, 2, 3, 4, 5};

// 初始化字符串数组
String[] names = new String[]{"Alice", "Bob", "Charlie"};
  • 多维数组：
// 初始化二维数组
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
  • 使用 Arrays 类：
// 使用 Arrays 类创建并初始化数组
int[] numbers = Arrays.copyOfRange(originalArray, from, to);

//originalArray 是要复制的原始数组，from 和 to 分别是复制的起始索引和结束索引。

IO流

  • Stream

    • 数据的输入和输出都是以“流”操作进行

    • 流是用来运输数据的工具，所以每次要先实例化对象

    • InputStream，Reader，OutputStream，Writer都是抽象类，只能通过实例化子类对象，才能创建

  • 输入流和输出流

    • 输入流：数据从硬盘（外存，包括磁盘光盘等存储设备的数据）中读取到内存中

    • 输出流：数据从内存输出，有可能是文件，数据库，网站等。写入文件

  • 字节流和字符流

    • 字节流：以字节为单位进行读写，适合处理二进制数据
    • 字符流：以字符为单位进行读写，适合处理文本数据
    • 字节流不需要编码，字符流需要编码

  • 文件：保存数据的地方

字节流

  • 输入流
        FileInputStream fileInputStream = new FileInputStream("1.txt");
        byte[] bytes = new byte[fileInputStream.available()];//装入数组,创建数组,里面代表当前数据的总大小
        fileInputStream.read(bytes);//返回值是一个正常读取的字节数,如果读取完毕,访问最后一个字节,就返回-1
        String str = new String(bytes);//将字节型数组转为字符串
        System.out.println(str);
        fileInputStream.close();
  • 输出流
        FileOutputStream fileOutputStream = new FileOutputStream("3.txt");
        String str = "abcdhello";
        fileOutputStream.write(str.getBytes());//要获取字节
        fileOutputStream.close();

字符流

  • 输入流
        FileReader fileReader = new FileReader("1.txt");
        char[] chars = new char[20];//多余的位置是很多的小方框
        fileReader.read(chars);
        System.out.println(chars);
        fileReader.close();
  • 输出流
        FileWriter fileWriter = new FileWriter("3.txt");
        String str = "apple";
        fileWriter.write(str);
		fileWriter.flush();
        fileWriter.close();

转换流(字节流转化为字符流)

解决乱码问题，比如一个文件采用国标ANSI，中国一般实GBK，用字符流读取文件会乱码。但是如果是字节流的话，可以修改编码方式，可以改成utf-8(默认就是utf-8)，为了看清楚效果，可以这样写

InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"gbk");

  • 输入
        FileInputStream fileInputStream = new FileInputStream("1.txt");
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);//输入 字节流转换成字符流
        char[] chars = new char[20];
        inputStreamReader.read(chars);//变成字符流，FileReader
        fileInputStream.close();
        inputStreamReader.close();
  • 输出
        FileOutputStream fileOutputStream = new FileOutputStream("2.txt");
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream);//输出
        String str = "halo";
        outputStreamWriter.write(str);//FileWrite
        outputStreamWriter.write("星期日",0,2);//追加内容
        outputStreamWriter.flush();
        outputStreamWriter.close();
        fileOutputStream.close();

缓冲流

缓冲流意思是从内存中开辟一段空间, 先将普通的输入流传入其中, 等到读写操作的时候, 直接从内存中进行读取, 从而提高读写的速度

 		//字节流输入
 		FileInputStream fileInputStream = new FileInputStream("1.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        byte[] bytes = new byte[bufferedInputStream.available()];
        bufferedInputStream.read(bytes);
        String str = new String(bytes);
        System.out.println(str);
        //其他的都类同

        //bufferedReader可以使用readLine一次性读取一行数据
         BufferedReader bufferedReader = new BufferedReader(new FileReader("1.txt"));
          String res = bufferedReader.readLine();
          System.out.println(res);

        //其他几种
		BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("1.txt"));//字节输入流
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("1.txt"));//字节输出流

        BufferedReader bufferedReader = new BufferedReader(new FileReader("2.txt"));//字符输入流
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("1.txt"));//字符输出流

命令执行

  • Runtime类
Runtime runtime = Runtime.getRuntime();//单例模式实例化  使用Runtime.getRuntime() 访问静态方法进行实例化
Process process = runtime.exec("whoami");//命令执行  传入需要执行的命令, 执行后返回process对象

InputStream inputStream = process.getInputStream();//获取执行结果的输入流
//获取执行结果的输入流
int a = -1;
byte[] bytes = new byte[100];
while((a = inputStream.read(bytes)) != -1){
    System.out.println(new String(bytes));
};

Runtime类不能直接实例化，只能采用单例模式实例化

  • processbuilder类
ProcessBuilder processBuilder = new ProcessBuilder("whoami");//打开一个进程 向构造方法传入执行的命令
Process pb = processBuilder.start();//执行命令, 返回process对象
InputStream inputStream = pb.getInputStream();//获取执行命令程序的输入流
//循环装箱读取
int a = -1;
byte[] bytes = new byte[100];
while((a = inputStream.read(bytes)) != -1){
    System.out.println(new String(bytes));
};

JAVA反射

未完待续

序列化

反序列化漏洞：程序在反序列化期间，通过特殊的调用链引发的一系列安全问题。当目标程序对攻击者可控的数据进行反序列化处理时产生的安全问题。

  • 1.序列化就是在保存数据时，保存数据的值和数据类型。对象----->字节流

  • 2.反序列化就是在恢复数据时，恢复数据的值和数据类型。字节流----->对象

  • 3.需要让某个对象支持序列化机制，必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一:

    • Serializable //这是一个标记接口，没有方法（被序列化的对象的类，要有这个接口的意思）
    • Externalizable //该接口有方法需要实现，因此我们一般实现上面的

  • 4.读取（反序列化）的顺序需要和你保存的数据（序列化）的顺序一致

  • 5.序列化对象时，默认将里面所有属性都进行序列化，除了static和transient，transient表示在对象序列化过程中应该被忽略。

  • 6.序列化对象时，要求里面属性的类型也需要实现序列化接口（上面这些，是因为父类有Serializable接口，如果没有，直接f4给它加上）

  • 7.序列化具备可继承性，也就是如果某类已经实现了序列化， 则它的所有子类也已经默认实现了序列化

         OutputStream outputStream = new FileOutputStream("1.ser");//硬盘数据需要通过文件流读取，文件流读取之后，再放到外面，也就是到了OutputStream，再走到对象流里
         ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
         objectOutputStream.writeInt(100);
         objectOutputStream.writeBoolean(true);
         objectOutputStream.writeChar('a'); 
         objectOutputStream.writeDouble(9.5);
         objectOutputStream.writeUTF("星期日");//str类型
         objectOutputStream.writeObject(new Test());
         //这些类型都是可以序列化的，就比如integer，他的父类是number，这个父类有serializable接口
         //这些是序列化的过程，反序列化需要和序列化的顺序一致

 // 创建一个 FileInputStream 来读取序列化文件
        FileInputStream fileInputStream = new FileInputStream("1.ser");

        // 创建一个 ObjectInputStream 来从文件输入流中读取对象
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);

        // 使用不同的方法读取序列化文件中的数据
        int intValue = objectInputStream.readInt();
        boolean booleanValue = objectInputStream.readBoolean();
        byte byteValue = objectInputStream.readByte();
        byte[] byteArrayValue = new byte[5];
        objectInputStream.readFully(byteArrayValue);
        double doubleValue = objectInputStream.readDouble();
        String stringValue = objectInputStream.readUTF();

        // 打印读取的数据
        System.out.println("int: " + intValue);
        System.out.println("boolean: " + booleanValue);
        System.out.println("byte: " + byteValue);
        System.out.println("byte array: " + new String(byteArrayValue));
        System.out.println("double: " + doubleValue);
        System.out.println("String: " + stringValue);

        // 关闭输入流
        objectInputStream.close();

代码

helloJAVA

  • Main.java
import com.ccc.*;

public class Main {
    public static void main(String[] args) {
//        System.out.println("hello world");
//
//        String str = "hello";
//        System.out.println(str);
//
//        String str1 = "apple";
//        char str2 = 'a';

//        Test test = new Test("apple");
//        System.out.println(test.get_int());
//        System.out.println(test.get_str());
//        test.get_void();

//        调用静态方法
//        test.no_sta();

//        作用域
//        Son son = new Son("bana");

//        抽象类
//        Animal dog = new Dog();
//        dog.makeSound();
//        dog.sleep();

//        接口
//        interf bob = new bobInter();
//        bob.eat();
//        bob.getup();

//        for循环
          int[] ints = {1,2,3,4,5,6,7,8,9,10};
//          方法一
//          for(int i=0;i<10;i++){
//              System.out.println(ints[i]);
//          }

//          方法二foreach
            for (int j:ints){
                System.out.println(j);
            }


    }
}
  • Test.java
package com.ccc;

public class Test {
    String a = "外部变量";
    //代码块
    {
        System.out.println("代码块");
    }
    //无参的构造函数
    public Test(){
        System.out.println("构造方法");
    }
    //含参的构造方法
    public Test(String a){
        System.out.println(a);
        System.out.println(this.a);
    }
    //字符串
    public String get_str(){
        return "hello";
    }
    //整型
    public int get_int(){
        return 12345;
    }
    //无返回值
    public void get_void(){
        System.out.println("没有返回值的函数");
    }

    //静态方法和非静态方法
    public void no_sta() {
        System.out.println("非静态的方法");
        sta();
    }

    public static void sta() {
        System.out.println("这是静态方法");
//        no_sta();
    }


}
  • Son.java
import com.ccc.Test;

public class Son extends Test{
    public Son(String a){
        super(a);
    }
}
  • Animal.java 抽象类
package com.ccc;

public abstract class Animal {
    //抽象方法，没有实现
    public abstract void makeSound();
    public void sleep(){
        System.out.println("Zzz");
    }
}
  • Dog.java 继承抽象类
package com.ccc;

public class Dog extends Animal{
    public void makeSound(){
        System.out.println("Bark");
    }
}
  • interf.java 接口
package com.ccc;

public interface interf {
    public void eat();
    public void getup();
}
  • bobInter.java 调用接口
package com.ccc;

public class bobInter implements interf{
    public void eat(){
        System.out.println("happy");
    }
    public void getup(){
        System.out.println("fuck");
    }
}

helloIO

Main.java

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        //字节流  输入流
//        FileInputStream fileInputStream = new FileInputStream("2.txt");
//        byte[] bytes = new byte[fileInputStream.available()];
//        fileInputStream.read(bytes);
//        String str =new String(bytes);
//        System.out.println(str);
//        fileInputStream.close();

        //字节流   输出流
//        FileOutputStream fileOutputStream = new FileOutputStream("3.txt");
//        String str = "哈哈哈haha";
//        fileOutputStream.write(str.getBytes());
//        fileOutputStream.close();

        //字符流   输入流
//        FileReader fileReader = new FileReader("3.txt");
//        char[] chars = new char[100];
//        fileReader.read(chars);
//        System.out.println(chars);
//        fileReader.close();

        //字符流 输出流
//        FileWriter fileWriter = new FileWriter("4.txt");
//        String str = "你好hello你好";
//        fileWriter.write(str);
//        fileWriter.close();

        //缓冲流    字节输入流
//        FileInputStream fileInputStream = new FileInputStream("3.txt");
//        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
//        byte[] bytes = new byte[bufferedInputStream.available()];
//        bufferedInputStream.read(bytes);
//        String str = new String(bytes);
//        System.out.println(str);
//        bufferedInputStream.close();

        //缓冲流 字节输出流
//        FileOutputStream fileOutputStream = new FileOutputStream("5.txt");
//        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
//        String str = "ininin";
//        bufferedOutputStream.write(str.getBytes());
//        bufferedOutputStream.close();

        //缓冲流   字符输入流
//        FileReader fileReader = new FileReader("3.txt");
//        BufferedReader bufferedReader = new BufferedReader(fileReader);
//        char[] chars = new char[100];
//        bufferedReader.read(chars);
//        System.out.println(chars);
//        bufferedReader.close();

        //缓冲流 字符输出流
//        FileWriter fileWriter = new FileWriter("6.txt");
//        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
//        String str = "kkkkkklllllllll";
//        bufferedWriter.write(str);
//        bufferedWriter.close();

        //字符转换成字节   输入流
//        FileInputStream fileInputStream = new FileInputStream("3.txt");
//        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
//        char[] chars = new char[100];
//        inputStreamReader.read(chars);
//        System.out.println(chars);
//        inputStreamReader.close();

        //字符转换成字节  输出流
//        FileOutputStream fileOutputStream = new FileOutputStream("7.txt");
//        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream);
//        String str = "pppppppppppppppppppiiiii";
//        outputStreamWriter.write(str);
//        outputStreamWriter.close();

        //命令执行
        //Runtime类
//        Runtime runtime = Runtime.getRuntime();
//        Process process = runtime.exec("ipconfig");
//
//        InputStream inputStream = process.getInputStream();
//        byte[]  bytes = new byte[20];
//        int a = -1;
//        while ((a=inputStream.read(bytes))!=-1){
//            System.out.println(new String(bytes));
//        }

        //ProcessBuilder类
//        ProcessBuilder processBuilder = new ProcessBuilder("ipconfig");
//        Process process = processBuilder.start();
//
//        InputStream inputStream = process.getInputStream();
//        int a=-1;
//        byte[] bytes = new byte[20];
//        while ((a=inputStream.read(bytes))!=-1){
//            System.out.println(new String(bytes));
//        }

    }
}

helloSerialization