浅谈 java和goland 实列对象

 goland 创建实列的方法：

	//第一种方式
	var per01 Person
	per01.Name = "south01"
	per01.Age = 20
	fmt.Print(per01)

	//第二种方式
	per02 := Person{"south02", 21}
	fmt.Println(per02)

	//第三种方式（返回的是结构体指针）
	var per03 *Person = new(Person)
	(*per03).Name = "south03"
	(*per03).Age = 22
	fmt.Print(per03)
	//第四种方式（与第三种方法类似，但是写法不同），go编译底层对 per04.Name 做了转化成 
    (*per04).Name = "south"
	per04 := new(Person)
	per04.Name = "south04"
	per04.Age = 24
	fmt.Print(per04)
	
	//第五种方式（返回的是结构体指针）
	var per05 *Person = &Person{"south05", 25}
	fmt.Print(per05)
	//第六种方式（和第五种方式一样），go编译底层对 per06.Age 做了转化成 (*per06).Age = 18
	per06 := &Person{"south06", 26}
	per06.Age = 18
	fmt.Print(per06)

java创建实列的方法 

    private static void create() throws Exception {

        /**
         * 第一种创建方式（常规）
         */
        //（对象属性赋值通过get和set方法进行操作）
        Person per01 = new Person();
        per01.setName("south01");
        per01.setAge(20);
        //（对象属性赋值通过构造函数进行赋值）
        Person per02 = new Person(21,"south02");
        System.out.println(per02);
        /**
         * 第二种创建方式（反射）
         */
        //通过反射进行创建
        Class<?> person = Class.forName("test.Person");
        Person per03 = (Person) person.newInstance();
        per03.setAge(22);
        per03.setName("south03");
        System.out.println(per03);
        /**
         * 第三种创建方式（克隆）
         * 优点： 1 、高性能。 2 、逃避构造函数的约束。3、进行对象拷贝的时候方便
         * 缺点： 1 、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一
         * 定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 2 、必须实现
         */
        //克隆方式创建
        Person person1 = new Person(23,"south04");
        Person per04 = person1.clone();
        System.out.println(per04);
        /**
         * 第四种创建方式（反序列化）
         */
        //反序列化方式创建
        String path  = "C:\\Users\\south\\Desktop\\holle.txt";
        File file = new File(path);
        FileInputStream fis = new FileInputStream(file);
        ObjectInputStream ois = new ObjectInputStream(fis);
        Person per05 =(Person) ois.readObject();
        System.out.println(per05);
    }


/**
 * 实现Cloneable接口是为了可以使用克隆方式创建实体
 * 实现Serializable接口是为了可以使用反序列化创建对象
 */
public class Person implements Cloneable, Serializable {
    private Integer age;
    private String name;

    //克隆创建对象的时候需要
    @Override
    protected Person clone() throws CloneNotSupportedException {
        Person person =(Person) super.clone();
        return person;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public Person() {
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

 goland ：代码精简没有花里胡哨的的东西，并且对于元素的操作直接明了但是实列形势比较单一，并且直接运用了指针以及内存地址等理解可能会比较抽象

java：实列形势比较丰富可以解决多种场景下的问题，并且代码面向对象程度化比较搞代码容易理解但是代码过于臃肿很多goland一行代码就能完事的事情java硬是要干出5行来