类和对象 构造器 访问器和更改器 拷贝

类和对象
.java文件通过jdk变成.class文件再通过jre
java申请一个足够大的数组（块），其中有方法区，包含类常量池和静态常量池（被static修饰的部分）
随后是方法的运行，方法的运行要依托栈结构，随着栈的进行会在堆中创建大量的对象，堆里有字符串常量池，程序计数器和本地方法栈之后会学习类的封装，封装后我们只需要知道怎么使用，而不需要知道其内部的实现原理

构造器和方法实现构造
构造方法的隐含参数是对象
1.构造器和类同名
2.每个类有一个以上构造器
3.构造器可以有0个，一个或者多个参数
4.构造器没有返回值
5.构造器伴随new一起使用，已经new过的对象不能再使用构造器

person类

package com;

public class Person {
    public String name;
    public int age;
    public Person() {
        System.out.println("============");
    }
    public Person(String n,int a) 
    {
        age=a;
        name=n;
        System.out.println("#######");
    }
    public String toString() { //非静态方法，必须依托对象存在。
        return "age:"+age+"name:"+name;//如果不定义此方法返回对象类型和类地址
    }
    public static Person of(String n,int a) {//方法实现构造
        return new Person(n,a);
        
    }
}

main方法

package com;
import java.util.*;
public class Test11 {
    public static void main(String[] arg) {
    Person x1=new Person();
    x1.name="张三";
    x1.age=33;
    Person x2=new Person("李四",14);
    System.out.println(x1);//如果不重写tostring，输出一个对象就是输出对象名称和地址，对象占用8字节，内存条是8字节
    System.out.println(x1.toString());//不管是否重定义，直接输出和调用toString效果一样
    System.out.println(x2);
    System.out.println(x2.toString());
    Person x3=Person.of("王五",12);
    System.out.println(x3.toString());
    }
    
}

更改器和访问器
当变量设置为私有private变量的时候我们需要使用访问器get和更改器set对其进行操作，这种方法阻止不了任何安全问题，只是多线程的时候用，它本身没有任何安保问题，但是我们可以修改让其实现只读或者只写，比如一个数组，只是给他增加访问器，由于引用类型的特性，这个数组尽管被设为私有类型但是它仍旧可以被修改，但是我们可以new一个数组，这个其实就是深拷贝，拷贝值而不拷贝地址
person类

package com;

public class Person {
    private String name;
    private int age;
    private static int[] arr= {1,2,3}; //field是属性，constructor构造器   method方法  这三种组成一个类，说全一点其实应该还有注解信息@
    public int getAge() {
        return age;
    }
    public void setAge(int n) {
        age=n;
    }
    public String getName() {
        return name;
    }
    public void setName(String n) {
        name=n;
    }
    public int[] getArr() {
        return arr;
    }
    public int[] getArr2() {
        int[] arrNew=new int[arr.length];
        for(int i=0;i<arr.length;i++) {
            arrNew[i]=arr[i];
        }
        return arrNew;
    }
    public static int[] getArr3() {
        int[] arrNew=new int[arr.length];
        for(int i=0;i<arr.length;i++) {
            arrNew[i]=arr[i];
        }
        return arrNew;
    }
    public String toString() { //非静态方法，必须依托对象存在。
        return "age:"+age+"name:"+name;//如果不定义此方法返回对象类型和类地址
    }
}

main方法

package com;
import java.util.*;
public class Test11 {
    public static void main(String[] arg) {
    Person x1=new Person();
    x1.setName("张三");
    x1.setAge(33);
    System.out.println(x1);
    int[] w=x1.getArr();
    w[0]=99;
    System.out.println(w[0]);//通过访问器没有实现安全还是可以对数组进行修改
    System.out.println(x1.getArr()[0]);
    int[] w2=x1.getArr2();
    w2[0]=9;
    System.out.println(w2[0]);
    System.out.println(x1.getArr()[0]);
    int[] w3=x1.getArr2();//需知道w2和w3不是一个arrNew，每次调用arrNew都是拷贝一份压入栈，每一份都new了一个arrNew重新分配地址，初始值为0，通过循环让他等于arr，其他语言也一样，执行方法都是拷贝一份执行
    w3[0]=6;
    System.out.println(w3[0]);
    System.out.println(x1.getArr()[0]);
    
    //static和非static结果是一样的
    int[] w4=Person.getArr3();
    w4[0]=100;
    System.out.println(w4[0]);
    System.out.println(x1.getArr()[0]);
    int[] w5=Person.getArr3();
    System.out.println(w5[0]);
    }

    

}

一个类文件里可以有多个类，但是只能有一个public类
私有方法只能类内调用
主方法操作系统会把他当作一个进程来对待，否则他是个线程