您好，登录后才能下订单哦！
密码登录
登录注册
点击 登录注册 即表示同意《亿速云用户服务条款》
这篇文章将为大家详细讲解有关java中怎么控制对象和内存，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。
一、对象与内存控制的知识点
1.java变量的初始化过程，包括局部变量，成员变量（实例变量和类变量）。
2.继承关系中，当使用的对象引用变量编译时类型和运行时类型不同时，访问该对象的属性和方法是有区别的。
3.final修饰符特性。
二、java变量的划分与初始化过程
java程序的变量大体可以分为成员变量和局部变量，成员变量可以分为实例变量（非静态变量）和类变量（静态变量），一般我们遇到的局部变量会在下列几种情况中出现：
（1）形参：在方法签名中定义的局部变量，由调用方为其赋值，随着方法结束消亡。
（2）方法内的局部变量：在方法内定义的局部变量必须在方法内显示的初始化（赋初始值），随着变量初始化完成开始，到方法结束而消亡。
（3）代码块内的局部变量：在代码块内定义的局部变量必须在代码块内显示的初始化（赋初始值），随着初始化完成开始生效，随着代码块的结束而消亡。
package com.zlc.array;
public class TestField {
{
String b ;
//如果不初始化，编译器就会报The local variable b may not have been initialized
System.out.println(b);
}
public static void main(String[] args) {
int a ;
//如果不初始化，编译器就会报The local variable a may not have been initialized
System.out.println(a);
}
} 使用static修饰的成员变量是类变量，属于类本身，没有用static修饰的成员变量是实例变量，属于该类的实例，在同一个JVM里面，每个类只能对应一个Class对象，但每个类可以创建多个java对象。（也就是说一个类变量只需一块内存空间，而该类每创建一次实例，就需要为实例变量分配一块空间）
实例变量的初始化过程：从语法角度来说，程序可以在三个地方对实例变量执行初始化：
（1）定义实例变量时指定初始值。
（2）非静态块中对实例变量指定初始值。
（3）构造器中对实例变量指定初始值。
其中（1）和（2）这两种方式初始化时间都比（3）在构造器中要早，（1）和（2）两种初始化顺序是按照他们在源码中的排列顺序决定的。
package com.zlc.array;
public class TestField {
public TestField(int age){
System.out.println("构造函数中初始化 this.age = "+this.age);
this.age = age;
}
{
System.out.println("非静态块中初始化");
age = 22;
}
//定义的时候初始化
int age = 15;
public static void main(String[] args) {
TestField field = new TestField(24);
System.out.println("最终 age = "+field.age);
}
} 运行结果为：非静态块中初始化
构造函数中初始化 this.age = 15
最终 age = 24
如果会使用javap的话，可以通过javap -c XXXX（class文件）看下改java类是如何编译的。
定义实例变量时指定初始值，初始化块中为实例变量指定初始值语句地位是平等的，当经过编译器编译处理之后，他们都被提到构造器中，上面所说的 int age = 15;会划分下面两个步骤执行：
1）int age;创建java对象时系统根据该语句为该对象分配内存。
2）age = 15;这条语句会被提取到java类的构造器中执行。
类变量的初始化过程：从语法角度来说，程序可以从两个地方对类变量进行初始化赋值。
（1）定义类变量时指定初始值。
（2）静态块中对类变量指定初始值。
两种执行顺序和他们在源码中的排列顺序相同，我们举个小变态的例子：
package com.zlc.array;
class TestStatic {
//类成员 DEMO TestStatic实例
final static TestStatic DEMO = new TestStatic(15);
//类成员 age
static int age = 20;
//实例变量 curAge
int curAge;
public TestStatic(int years) {
// TODO Auto-generated constructor stub
curAge = age - years;
}
}
public class Test{
public static void main(String[] args) {
System.out.println(TestStatic.DEMO.curAge);
TestStatic staticDemo = new TestStatic(15);
System.out.println(staticDemo.curAge);
}
} 输出结果有两行打印，一个是打印TestStatic类属性DEMO的实例变量，第二个通过java对象staticDemo输出TestStatic的实例属性，根据我们上面分析的实例变量和类变量的初始化流程可以进行推断：
1）初始化第一阶段，加载类的时候为类变量DEMO、age分配内存空间，此时DEMO和age的默认值分别是null和0。
2）初始化第二阶段，程序按顺序依次给DEMO、age赋初始值，TestStatic(15)需要调用TestStatic的构造器，此时age = 0 所以打印结果为 -15，而当staticDemo被初始化的时候，age已经被赋值等于20了，所以输出结果为5。
三、在继承关系中继承成员变量和继承成员方法的区别。
当创建任何java对象时，程序总会先调用父类的非静态块、父类构造器，最后才调用本类的非静态块和构造器。通过子类的构造器调用父类的构造器一般分为两种情况，一个是隐式调用，一个通过super显示调用父类的构造器。
子类的方法可以调用父类的实例变量，这是因为子类继承了父类就会获取父类的成员变量和方法，但父类的方法不能访问子类的实例变量，因为父类不知道它将被哪个类继承，它的子类将会增加什么样的成员变量，当然在一些极端的例子里面还是可以实现父类调用子类变量的，比如：子类重写了父类的方法，一般都会打印出默认值，因为这个时候子类的实例变量还没有初始化。
package com.zlc.array;
class Father{
int age = 50;
public Father() {
// TODO Auto-generated constructor stub
System.out.println(this.getClass());
//this.sonMethod();无法调用
info();
}
public void info(){
System.out.println(age);
}
}
public class Son extends Father{
int age = 24;
public Son(int age) {
// TODO Auto-generated constructor stub
this.age = age;
}
@Override
public void info() {
// TODO Auto-generated method stub
System.err.println(age);
}
public static void main(String[] args) {
new Son(28);
}
//子类特有的方法
public void sonMethod(){
System.out.println("Son method");
}
} 按照我们正常推断，通过子类隐式的调用父类的构造器，而在父类的构造器中调用了info()方法（注意：我这里没有说调用父类的），按道理来说是输出了父类的age实例变量，打印结果预计是50，但实际输出的结果为0，分析原因：
1）java对象的内存分配不是在构造器中完成的，构造器只是完成了初始化赋值的过程，也就是在调用父类的构造器之前，jvm已经给这个Son对象分类好了内存空间，这个空间存放了两个age属性，一个是子类的age，一个是父类的age。
2）在调用new Son(28)的时候，当前的this对象代表着是子类Son的对象，我们可以通过把对象.getClass()打印出来就会得到class com.zlc.array.Son的结果，但是当前初始化过程又是在父类的构造器中进行的，通过this.sonMethod()又无法被调用，这是因为this的编译类型是Father的缘故。
3）在变量的编译时类型和运行时类型不同时，通过该变量访问它的引用对象的实例变量时，该实例变量的值由声明该变量的类型决定，但通过该变量调用它引用的对象的实例方法时，该方法的行为由它实际引用的对象决定，所以这里调用的是子类的info方法，所以打印的是子类的age,由于age还没来得急初始化所以打印默认值0。
通俗的来说也就是，当声明的类型和真正new的类型不一致的时候，使用的属性是父类的，调用的方法是子类的。
通过javap -c我们更能直接的体会为什么继承属性和方法会有很大的区别，如果我们把上面例子里面，子类Son的info重写方法去掉，这个时候调用的会是父类的info方法，是因为在进行编译的时候会把父类的info方法编译转移到子类里面去，而声名的成员变量会留在父类中不进行转移，这样子类和父类拥有了同名的实例变量，而如果子类重写了父类的同名方法，则子类的方法会完全覆盖掉父类的方法（至于为什么java要这么设计，个人也不太清楚）。同名变量能同时存在不覆盖，同名方法子类会彻底覆盖父类同名方法。
总的来说对于一个引用变量而言，当通过该变量访问它所引用的对象的实例变量时，该实例变量的值取决于声明该变量时类型，当通过该变量访问它所引用的对象的方法时，该方法行为取决于它所实际引用的对象的类型。
最后拿个小case复习下：
package com.zlc.array;
class Animal{
int age ;
public Animal(){
}
public Animal(int age) {
// TODO Auto-generated constructor stub
this.age = age;
}
void run(){
System.out.println("animal run "+age);
}
}
class Dog extends Animal{
int age;
String name;
public Dog(int age,String name) {
// TODO Auto-generated constructor stub
this.age = age;
this.name = name;
}
@Override
void run(){
System.out.println("dog run "+age);
}
}
public class TestExtends {
public static void main(String[] args) {
Animal animal = new Animal(5);
System.out.println(animal.age);
animal.run();
Dog dog = new Dog(1, "xiaobai");
System.out.println(dog.age);
dog.run();
Animal animal2 = new Dog(11, "wangcai");
System.out.println(animal2.age);
animal2.run();
Animal animal3;
animal3 = dog;
System.out.println(animal3.age);
animal3.run();
}
}
想要调用父类的方法：可以通过super来调用，但super关键字没有引用任何对象，它不能当做真正的引用变量来使用，有兴趣的朋友可以自己研究下。
上面介绍的都是实例变量和方法，类变量和类方法要简单多了，直接使用类名.方法就方便了很多，也不会遇到那么多麻烦。
四、final修饰符的使用（特别是宏替换）
final可以修饰变量，被final修饰的变量被赋初始值之后，不能对他重新赋值。
final可以修饰方法，被final修饰的方法不能被重写。
final可以修饰类，被final修饰的类不能派生子类。
被final修饰的变量必须显示的指定初始值：
对于是final修饰的是实例变量，则只能在下列三个指定位置赋初始值。
（1）定义final实例变量时指定初始值。
（2）在非静态块中为final实例变量指定初始值。
（3）在构造器中为final实例变量指定初始值。
最终都会被提到构造器中进行初始化。
对于用final指定的类变量：只能在指定的两个地方进行赋初始值。
（1）定义final类变量的时候指定初始值。
（2）在静态块中为final类变量指定初始值。
同样经过编译器处理，不同于实例变量的是，类变量都是提到静态块中进行赋初始值，而实例变量是提到构造器中完成。
被final修饰的类变量还有一种特性，就是“宏替换”，当被修饰的类变量满足在定义该变量的时候就指定初始值，而且这个初始值在编译的时候就能确定下来（比如：18、"aaaa"、16.78等一些直接量），那么该final修饰的类变量不在是一个变量，系统就会当成“宏变量”处理（就是我们常说的常量），如果在编译的时候就能确定初始值，则就不会被提到静态块中进行初始化了，直接在类定义中直接使该初始值代替掉final变量。我们还是举那个年龄减去year的例子：
package com.zlc.array;
class TestStatic {
//类成员 DEMO TestStatic实例
final static TestStatic DEMO = new TestStatic(15);
//类成员 age
final static int age = 20;
//实例变量 curAge
int curAge;
public TestStatic(int years) {
// TODO Auto-generated constructor stub
curAge = age - years;
}
}
public class Test{
public static void main(String[] args) {
System.out.println(TestStatic.DEMO.curAge);
TestStatic static1 = new TestStatic(15);
System.out.println(static1.curAge);
}
} 这个时候的age 被final修饰了，所以在编译的时候，父类中所有的age都变成了20，而不是一个变量，这样输出的结果就能达到我们的预期。
特别是在对字符串进行比较的时候更能显示出
package com.zlc.array;
public class TestString {
static String static_name1 = "java";
static String static_name2 = "me";
static String statci_name3 = static_name1+static_name2;
final static String final_static_name1 = "java";
final static String final_static_name2 = "me";
//加final 或者不加都行 前面兩個能被宏替換就行了
final static String final_statci_name3 = final_static_name1+final_static_name2;
public static void main(String[] args) {
String name1 = "java";
String name2 = "me";
String name3 = name1+name2;
//(1)
System.out.println(name3 == "javame");
//(2)
System.out.println(TestString.statci_name3 == "javame");
//(3)
System.out.println(TestString.final_statci_name3 == "javame");
}
} 用final修饰方法和类没有什么好说的，只是一个不能被子类重写（和private一样），一个不能派生子类。
用final修饰局部变量的时候，Java要求被内部类访问的局部变量都是用final修饰，这个是有原因的，对于普通局部变量而言，它的作用域就停留在该方法内，当方法结束时，该局部变量也就消失了，但内部类可能产生隐式的“闭包”，闭包使得局部变量脱离他所在的方法继续存在。
有时候在会在一个方法里面new 一个线程，然后调用该方法的局部变量，这个时候需要把改变量声明为final修饰的。
关于java中怎么控制对象和内存就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。