JAVA学习笔记你知道的越多，你不知道的越多系列一

Posted 2021-06-23 沉默着忍受

JAVA学习笔记

【JAVA学习笔记】你知道的越多，你不知道的越多之多系列一

---

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• JAVA学习笔记
• 前言
• 一、什么是可变参数
• 二、Class类的作用，生成Class对象的方法
• • 2. 1 Class类的作用
  • 2.2 生成Class对象的方法
  • • 2.2.1 通过new 语句实例化一个对象
    • 2.2.2 通过反射机制创建对象
    • 2.2.3 通过clone()方法创建一个对象
    • 2.2.4 通过反序列化的方式创建对象

---

前言

你知道的越多，你不知道的越多。今天分享的知识你知道吗？关注博主，每天带你轻松学java。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、什么是可变参数

可变参数允许调用参数数量不同的方法。请看下面例子中的求和方法。此方法可以调用1个int参数，或2个int参数，或多个int参数。
我们通过代码验证：

public class Deom {
    public static void main(String[] args) {

        int a1 =  sum(1,2,3,4,5,6);
        int a2 =  sum(10,20,30,40,50);
        int a3 =  sum(-1,-2,-3);
        System.out.println("第一个结果是"+a1);
        System.out.println("第二个结果是"+a2);
        System.out.println("第三个结果是"+a3);

    }


    public static  int sum(int... numbers) {
        int sum = 0;
        for (int number: numbers) {
            sum += number;
        }
        return sum;
    }
}

是不是很神奇，其实它的实现原理和重载是类似的，如果你在一个类中要实现重载，在保证参数类型是一致的情况下，可以使用改可变参数，但是要注意方法体对参数的使用情况，如果需要区分参数的使用，不可以使用可变参数进行操作。

二、Class类的作用，生成Class对象的方法

2. 1 Class类的作用

Class类是Java 反射机制的起源和入口，用于获取与类相关的各种信息，提供了获取类信息的相关方法。Class类继承自Object类
Class类是所有类的共同的图纸。每个类有自己的对象，好比图纸和实物的关系；每个类也可看做是一个对象，有共同的图纸Class，存放类的 结构信息，能够通过相应方法取出相应信息：类的名字、属性、方法、构造方法、父类和接口
我们通过代码验证

class Student{   //student是该类的名称
    private  String  name;
    private  int age;
    private  String sex;
    private  int xuehao;
    private  int school;
    //该类的属性：学生姓名，年龄，性别，学号，学校等等；

    public Student() {  //该类的无参构造方法

    }
    public Student(String  name) { //该类的有参构造方法
        this.name = name;
    }

    public void study(){ //该类的一个典型的活动，我们叫方法或函数
        System.out.println("我正在学习");
    }

}

public class Democlass {
    public static void main(String[] args) {
        Student student1 = new Student("沉默着忍受"); //实例化一个学生类，名字叫沉默着忍受
        student1.study();//调用该类的study方法，此时控制台就运行该方法；

    }
}

2.2 生成Class对象的方法

共有4种创建对象的方法。

2.2.1 通过new 语句实例化一个对象

Student student -= new Student();

2.2.2 通过反射机制创建对象

package reflection;
import java.lang.reflect.Constructor;
import charactor.Hero;
public class TestReflection {
  
    public static void main(String[] args) {
        //传统的使用new的方式创建对象
        Hero h1 =new Hero();
        h1.name = "teemo";
        System.out.println(h1);
          
        try {
            //使用反射的方式创建对象
            String className = "charactor.Hero";
            //类对象
            Class pClass=Class.forName(className);
            //构造器
            Constructor c= pClass.getConstructor();
            //通过构造器实例化
            Hero h2= (Hero) c.newInstance();
            h2.name="gareen";
            System.out.println(h2);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

2.2.3 通过clone()方法创建一个对象

@Data
public class Person implements Cloneable {
    private String name;
    private Integer age;
    private Address address;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
 
@Test
public void testShallowCopy() throws Exception{
  Person p1=new Person();
  p1.setAge(31);
  p1.setName("Peter");
 
  Person p2=(Person) p1.clone();
  System.out.println(p1==p2);//false
  p2.setName("Jacky");
  System.out.println("p1="+p1);//p1=Person [name=Peter, age=31]
  System.out.println("p2="+p2);//p2=Person [name=Jacky, age=31]

2.2.4 通过反序列化的方式创建对象

反序列化创建对象的过程，需要将流转换为对象。那么，可以通过序列化，将对象的状态写在流里面，根据需要把该流读取出来重新构造一个相同的对象。
首先创建一个Car类实现Serializable接口，因为所有要实现序列化的类都必须实现Serializable接口。

package test.fanxuliehua;

import java.io.Serializable;

public class Car implements Serializable {
    private int height;
    private String color;

    public Car(int height, String color) {
        this.height = height;
        this.color = color;
    }

    @Override
    public String toString() {
        return "Car{" +
                "height=" + height +
                ", color='" + color + '\\'' +
                '}';
    }
}

1、通过序列化，将对象的状态写在流里面：
先构造一个对象流ObjectOutputStream oss，使用oos的writeObject的方法将实例对象car1的状态写到流（字节流文件car1.ser）里面。
2、根据需要把该流读取出来重新构造一个相同的对象：
先构造一个对象流ObjectInputStream ois读取字节流文件car1.ser，使用ois的readObject的方法重新构造一个相同的对象car2。

package test.fanxuliehua;

import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //序列化过程
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("car1.ser"));
        Car car1 = new Car(175, "白色");
        oos.writeObject(car1);
        oos.close();

        //反序列化过程
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("car1.ser"));
        Car car2 = (Car) ois.readObject();
        System.out.println("car2:" + car2);
        ois.close();
    }
}

执行结果：

car2:Car{height=175, color='白色'}

打印结果表明反序列化创建car2成功，且属性值与car1一致。