JAVA学习笔记
【JAVA学习笔记】你知道的越多，你不知道的越多之多系列一提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
前言
你知道的越多，你不知道的越多。今天分享的知识你知道吗？关注博主，每天带你轻松学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一致。