java内存指向

拼搏现实的明天。 2024-04-06 11:58 10阅读 0赞

### 一、类与对象的关系 ###

1.什么是对象

我们来看一下代码：分析一下java的数据调用

![5afac941496145678907d573cddd995b.png][]

![703033915ff64d52b6cf0a177d9e355d.png][]

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

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

![667526a88d0a499fb1954ac1c6aaeac0.png][]

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

### 二、什么是类，什么是对象，类与对象的关系是什么？ ###

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

![23f8bb31a89643f2afa0f762dcc5baab.png][]

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

### 三、方法的执行顺序----------》这里可以将多线程 ###

### 四、有没有哪些专属于对象的方法呢？------this ###

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

![6643ddd9ba7941c5ade042cea929f981.png][]

重点强调：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();
    	}

那么有兄嘚会问你直接使用this在main方法当中调用不可以吗？

![93130336a0c84ad3a114f9292110a2dd.png][]

注意：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()同时使用

![fcb34e014e67425c917bca232fa7d70c.png][]

四、有没有哪些专属于类的方法呢？------static

在《Java编程思想》当中有这样一段话：

“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”

总结一下就是static：方便在没有创建对象的情况下来进行调用（方法/变量）

很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

\--------------------------------------------------------------------------------------------------------------------

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=中国\]

![3f9881670eb74a8dbcb4219ec53e58fb.png][]

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

二、static修饰符

重点：static属于类

![88c9d5f0b8c449d0a5a1aaa5d3f41370.png][]

### 五、类的加载顺序 ###

以下代码的输出结果是什么？

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("----");
        }
    }

输出：

11
    ====+++
    22
    ====----

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

以下是测试用例

/**
     * @ClassName TRRest
     * @Description TODO
     * @Author heaboy@heaboy.com
     * @Version 1.0.0
     */
    public class InitializeDemo {	
        private static int k = 1;
        private static InitializeDemo t1 = new InitializeDemo("t1");
        private static InitializeDemo t2 = new InitializeDemo("t2");
        private static int i = print("i");
        private static int n = 99;
        {
            print("构造块");
            j=100;
        }
        public InitializeDemo(String str) {
            System.out.println((k++) + ":" + str + "   i=" + i + "    n=" + n);
            ++i;
            ++n;
        }
        static {
            print("静态块");
            n=100;
        }
        private int j = print("j");
        public static int print(String str) {
            System.out.println((k++) + ":" + str + "   i=" + i + "    n=" + n);
            ++n;
            return ++i;
        }
    
    }

五、值传递和引用传递 -----》java之后值传递

![09aff796b5a6429ab767767be17c9714.png][]

值传递：值传递是将值得地址值传递过去

![5b8f1df71d9348cbb5564d597eda61b9.png][]

引用传递：将句柄的地址传递过去

![584abd05823b4e349f2b38509f008a74.png][]

我们可以看一下代码：

public static void main(String[] args) {
    		
    		String nameString = "张三";
    		
    		name(nameString);
    		
    		System.out.println("main--->"+nameString);
    	}
    	
    	public static void name(String name) {
    		name = "李四";
    		System.out.println("name--->"+name);	
    	}

这一次拷贝的是nameString 值"张三"，name的值就是张三，所以当name的值不管怎么变化，nameString是不变的。

![33d2fcb737bc46d6ab971c8ae177ea69.png][]

那我们来看一下这个

public class Person {
    	
    	private String nameString;
    	private int age;
    	public Person(String nameString,int age) {
    		this.age = age;
    		this.nameString = nameString;
    	}
    	@Override
    	public String toString() {
    		return "Person [nameString=" + nameString + ", age=" + age + "]";
    	}
    	public static void name(Person person) {
    		person.age =20;
    		person.nameString="李四";
               person = null;
    	}
    	public static void main(String[] args) {
    		Person person = new Person("张三",18);
    		System.out.println(person.toString()); //参数改变前
    		name(person);
    		System.out.println(person.toString()); // 参数改变后
    	}
    	
    	
    }

输出答案

Person \[nameString=张三, age=18\]

Person \[nameString=李四, age=20\]

这一次我们也是拷贝的是一个副本，拷贝的是person对象的副本，拷贝过来的对象和原对象指向同一内存的存储空间，所以当（person -- 拷贝）改变值的时候原person也改变值。

我们知道其实在栈内存当中原person里面存贮着堆内存当中的Person类的内存地址，而java在这里传输的是原person的存贮着的地址值

![5a33b4e2f9f642ecac62abeebbe5a25a.png][]

结论：java 只有值传递

\---------------------------------------------------------------------------------------------------------------------------------

public class Student {
    	private String name; 
    	private int age;
    	public Student(String name,int age) {
    		this.name = name;
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "Student [name=" + name + ", age=" + age + "]";
    	}
    	public static void change(Student s1, Student s2){
    		Student temp = new Student("王五",20);
    		temp = s1;
    		s1 = s2;
    		s2 = temp;
    	}
    	public static void main(String[] args) {
    		Student zhangsan = new Student("张三", 18);
    		Student lisi = new Student("李四", 20);
    		Student.change(zhangsan, lisi);
    		System.out.println(zhangsan.toString());
    		System.out.println(lisi.toString());
    	}
    }

Student \[name=张三, age=18\]

Student \[name=李四, age=20\]

\--------------------------------------------------------------------------------------------------------------------------

public class Student {
    	private String name;
    	private int age;
    	public Student(String name,int age) {
    		this.name = name;
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "Student [name=" + name + ", age=" + age + "]";
    	}
    	public static void change(Student s1, Student s2){
    		Student temp = new Student("王五",20);
    		temp.name = s1.name;
    		s1.name = s2.name;
    		s2.name = temp.name;
    		
    	}
    	public static void main(String[] args) {
    		Student zhangsan = new Student("张三", 18);
    		Student lisi = new Student("李四", 20);
    		Student.change(zhangsan, lisi);
    		System.out.println(zhangsan.toString());
    		System.out.println(lisi.toString());
    	}
    	
    
    }

以下是案例代码：

class Two{
    	Byte x;
    }
    public class Student {
    	public static void main(String[] args) {
    		Student student = new Student();
    		student.start();
    	}
    	void start() {
    		Two two = new Two();
    		System.out.print(two.x +"  ");
    		Two two2 = fix(two);
    		System.out.println(two.x + " "+two2.x);
    	}
    	Two fix(Two tt) {
    		tt.x = 42;
    		return tt;
    	}
    }

A: null null 42
    B：null 42 42 
    C:0 0 42 
    D:0 42 42 
    E:Anexception is thrown at runtime

[5afac941496145678907d573cddd995b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/3d6b257711b049769746cdc75ce3a827.png
[703033915ff64d52b6cf0a177d9e355d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/312ed86e71e04c59b6e604fa329e8486.png
[667526a88d0a499fb1954ac1c6aaeac0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/cae9800b50094c8ebc74b0b757e8a50d.png
[23f8bb31a89643f2afa0f762dcc5baab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/b041313e75394ffcaee318a13fef1cdd.png
[6643ddd9ba7941c5ade042cea929f981.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/6d53dc041e8240319a205e9f5cb21ad2.png
[93130336a0c84ad3a114f9292110a2dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/99670adccd524fe6af6e4b13b9555dda.png
[fcb34e014e67425c917bca232fa7d70c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/010eda7d4b3d471d9aab376687fad278.png
[3f9881670eb74a8dbcb4219ec53e58fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/58532a5c031d498d9850ad52e5213c9e.png
[88c9d5f0b8c449d0a5a1aaa5d3f41370.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/8b2e7d1a17724160ad2e48dafbdc0f1a.png
[09aff796b5a6429ab767767be17c9714.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/826a9b05f80f4ffb8747db1586aa4f8d.png
[5b8f1df71d9348cbb5564d597eda61b9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/dae993bcb3084e7fbee662a50ccf602b.png
[584abd05823b4e349f2b38509f008a74.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/ed076c0fbea24ba3bb1af989575c0a0b.png
[33d2fcb737bc46d6ab971c8ae177ea69.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/a691e8ed69f64b88ae6810456fdd6ed1.png
[5a33b4e2f9f642ecac62abeebbe5a25a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/1c61cedd7b964a5bbff4543a8dbea1e4.png