Java核心：内存指向

1.什么是对象？

public class Cat {
	public int age;
	public String name;
	public char sex;
	public void run(int ag) {
		this.age=ag;
	}
	public static void main(String[] args) {
		Cat cat1=new Cat();
		Cat cat2=new Cat();
		Cat cat3=new Cat();
		
		cat1.run(10);
		cat2.run(11);
		System.out.println(cat1.age);
		System.out.println(cat2.age);
	}
}

---

我们调用cat1的run()方法和cat2的run()方法，执行run()方法，然后在去操作我们的变量进行值得更改，最后我们输出每一个cat1和cat2的age值,我们会发现输出并不一致，那么这就说明了我们在内存当中至少有两个age变量，分别属于cat1和cat2，那么我们也可以以此推出cat3当中有一个age变量。

 那么我们在上边至少能说明在内存当中分别一块属于cat1、cat2、cat3管理的有着数据和方法所组成的内存空间。

 上图我们可以得知这一块内存就是我们的对象

 2.什么是类，什么是对象，类与对象的关系是什么？

类当中只有关于信息的定义而对象有这些信息的值

 类是对象的模板，我们可以将类想象成制作小甜饼的切割机，将对象想象成小甜饼，由类构造对象的过程叫做类的实例化。

3. this

Java 中为解决变量的命名冲突和不确定性问题，引入关键字 this 代表其所在方法的当前对象的引用

---

this代表当前对象

1.this.属性名

一个方法当中的局部变量和成员变量名称相同，我们的程序需要在这个方法当中访问成员变量，这个时候就必须使用this关键字，用来区分成员变量和方法当中的参数。例如，我们set方法

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

---

2.this.方法名

让类中的一个方法来访问类中的另一个方法或者实例变量

public void souPerson() {
		System.out.println("我是一个人。。。。");
	}
	
	public void name() {
		this.souPerson();
	}
	
	public static void main(String[] args) {
		Person person = new Person();
		person.name();
	}

static关键字是对类而言的，this关键字是指当前对象，因此staic修饰的方法中不能使用this

---

3.this（）---this访问构造函数

this()可以用来访问本类的构造方法

public Person(String name,int age) { this.age = age; this.name = name; } public Person() { this("张三",10); }

注意：

①this()不能在普通方法中使用，只能在构造方法中使用

②this（）在构造方法中使用必须是第一条语句

③在一个类下两个构造方法中不能通过this()相互调用

④不能与super()同时使用

 4.static

static方便在没有创建对象的情况下来进行调用（方法/变量）。很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

 public class Person {
	static String from;
    public static void Run() {
		System.out.println("run");
	}
	public static void main(String[] args) {
		Person.from = "中国";
        Person.Run();
	}
}

方便在没有创建对象的情况下来进行调用（方法/变量）

1、static内存使用

static关键字存储在我们的方法区当中的静态常量池当中，static修饰的方法、变量和代码块都是可以被用来共享的

public class Person {
	private int age ;
	private String name;
	static String from;
	public Person(int age, String name) {
		this.age = age;
		this.name = name;
	}
	@Override
	public String toString() {
		return "Person [age=" + age + ", name=" + name + ", from=" + from + "]";
	}
	public static void main(String[] args) {
		Person person1 = new Person(20,"张三");
		Person person2 = new Person(21,"李四");
		Person.from = "中国";
		System.out.println(person1.toString());
		System.out.println(person2.toString());
	}
}
/*
Person [age=20, name=张三, from=中国]
Person [age=21, name=李四, from=中国]
*/

 person1和person2的name和age属性的值都在堆内存当中进行存储，且是该对象私有的，但是from属性扥值是存储在方法区的静态常量池当中的，是属于公共的。

---

2.static修饰符

static属于类

 5.类的加载顺序

public class Test extends Base{
	 // 扫描(受检异常)-----》加载父类-----》子类-----》创建父类对象----》子类对象
    // 子类调用父类的方法
    static{
        System.out.println("test static");
    }
     
    public Test(){
        System.out.println("test constructor");
    }
     
    public static void main(String[] args) {
        new Test();
    }
}
 
class Base{
     
    static{
        System.out.println("base static");
    }
     
    public Base(){
        System.out.println("base constructor");
    }
}

---

---

先来想一下这段代码具体的执行过程，在执行开始，先要寻找到main方法，因为main方法是程序的入口，但是在执行main方法之前，必须先加载Test类，而在加载Test类的时候发现Test类继承自Base类，因此会转去先加载Base类，在加载Base类的时候，发现有static块，便执行了static块。在Base类加载完成之后，便继续加载Test类，然后发现Test类中也有static块，便执行static块。在加载完所需的类之后，便开始执行main方法。在main方法中执行new Test()的时候会先调用父类的构造器，然后再调用自身的构造器。因此，便出现了上面的输出结果。

 所有的静态的类的初始化都交给类的第一个对象去执行

public class Demo {
    public Demo(String aa){
        System.out.println("===="+aa);
    }

    static {
        System.out.println("11");
    }

    public static Demo demo = new Demo("+++");  

    static {
        System.out.println("22");
    }

}

class Test{
    public static void main(String[] args) {
        Demo demo = new Demo("----");
    }
}

---