面向对象内存

最新推荐文章于 2024-05-12 13:07:45 发布

玉龙1989

最新推荐文章于 2024-05-12 13:07:45 发布

阅读量278

点赞数

分类专栏：基础

本文链接：https://blog.csdn.net/weixin_38955858/article/details/77852844

版权

基础专栏收录该内容

30 篇文章 0 订阅

订阅专栏

1. 面向对象

内存图

java的内存机制

Java 把内存划分成两种：一种是栈内存，另一种是堆内存。在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，当在一段代码块定义一个变量时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。

　　堆内存用来存放由 new 创建的对象和数组，在堆中分配的内存，由 Java 虚拟机的自动垃圾回收器来管理。在堆中产生了一个数组或者对象之后，还可以在栈中定义一个特殊的变量，让栈中的这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或者对象，引用变量就相当于是为数组或者对象起的一个名称。引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配，即使程序运行到使用 new 产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用，但仍然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉）。

　　这也是 Java 比较占内存的原因，实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针！

案例1：

public class Person {

public String name;

public int age;

public void change(int i,int j){

i=100;

j=200;

}

public class TestPerson {

public static void main(String[] args) {

Person p = new Person();

int i=888;

int j=999;

p.change(i, j);

System.out.println("i="+i+",j="+j);

}

内存图1：结果 i=888,j=999

案例2：

public class Person {

public String name;

public int age;

public void change(int i,Person p){

i=100;

p.name = "喜羊羊";

p.age = 10;

//System.out.println("**内存地址："+p.toString());

}

public class TestPerson {

public static void main(String[] args) {

Person p = new Person();

//System.out.println("内存地址："+p.toString());

p.name="灰太狼";

p.age = 88;

int i=888;

p.change(i, p);

System.out.println("i="+i+",p.name="+p.name+",p.age="+p.age);

}

内存分析：

结果：i=888,p.name=喜羊羊,p.age=10

案例3：

public class Person {

public String name;

public int age;

public void change(int i,Person p){

i=100;

p = new Person();

p.name = "喜羊羊";

p.age = 10;

//System.out.println("**内存地址："+p.toString());

}

public class TestPerson {

public static void main(String[] args) {

Person p = new Person();

//System.out.println("内存地址："+p.toString());

p.name="灰太狼";

p.age = 88;

int i=888;

p.change(i, p);

//System.out.println("##内存地址："+p.toString());

System.out.println("i="+i+",p.name="+p.name+",p.age="+p.age);

}

i=888,p.name=灰太狼,p.age=88

案例4：

public class Student {

String name;

int age;

public void study(){

System.out.println(name+"在看书");

}

public void say(String sname){

System.out.println(name+"跟"+sname+"说你好");

}

public static void main(String[] args) {

Student stu = new Student();

stu.name="张三";

stu.age = 10;

stu.study();

stu.say("李四");

}

案例5：

public class Student {

String name;

int age;

Computer com; //电脑

public void study(){

System.out.println(name+"在看书");

}

public void say(String sname){

System.out.println(name+"跟"+sname+"说你好");

}

public class Computer {

String brand; //品牌

int cpuspeed; //处理速度

}

public class TestStudent {

public static void main(String[] args) {

Student stu = new Student();

stu.name = "张三";

stu.age = 10;

Computer c = new Computer();

c.brand = "联想";

c.cpuspeed = 10000;

stu.com = c;

System.out.println(stu.com.brand);

}

案例6：

总结： Java 中只存在值传递，基本数据类型传递的是基本数据类型的值，引用数据类型传递的是地址

一个栈只能指向一个堆，一个堆可以被多个栈引用

注意：栈 :自动分配连续的内存空间，后进先出。放置：局部变量

堆：不连续，放置：new出的对象

方法区：（也是堆）存放类的代码信息，static变量和方法，常量池（字符串常量）

1.1. 构造方法

构造方法的命名

构造方法使用和类相同的名字，而方法则不同。按照习惯，方法通常用小写字母开始，而构造器通常用大写字母开始。构造器通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作。

构造方法的作用

为了方便参数的传递，允许在新建对象的时候，同时对这个对象的一些属性进行初始化。

构造方法分为两种：

（1）无参构造方法

public 类名(){

（2）有参构造方法

public 类名(参数类型1 参数名称1,参数类型2 参数名称2){}

构造方法如何修饰？

（1）允许没有修饰（default）

（2）访问的修饰： public, protected, private

（3）不能有以下非访问性质的修饰： abstract, final, native, static

例题1：

/**

* 只关心你所关心的属性

* 1个类可以有多个构造方法，调用的时候，参数的类型和顺序和定义构造时一致。

* @author Administrator

public class Penguin {

public String name; //名字

public int health;// 健康值

public int love; //亲密度

public String sex; //性别

/**

* 无参构造

public Penguin(){

System.out.println("调用了Penguin()无参构造");

}

/**

* 带4个参数的构造

* @param sex

* @param love

* @param health

* @param name

public Penguin(String sex,int love,int health,String name){

this.sex = sex;

this.love = love;

this.health = health;

this.name = name;

System.out.println("调用了Penguin(sex,love,health,name)带4个参数的构造");

}

/**

* 带4个参数的构造

* @param love

* @param health

* @param name

* @param sex

public Penguin(int love,int health,String name,String sex){

this.sex = sex;

this.love = love;

this.health = health;

this.name = name;

System.out.println("调用了Penguin(sex,love,health,name)带4个参数的构造");

}

/**

* 带3个参数的构造

* @param love

* @param name

* @param sex

public Penguin(int love,String name,String sex){

this.sex = sex;

this.love = love;

this.name = name;

System.out.println("调用了Penguin(sex,love,name)带3个参数的构造");

}

/**

* 带2个参数的构造

* @param love

* @param name

public Penguin(int love,String name){

this.love = love;

this.name = name;

System.out.println("调用了Penguin(love,name)带2个参数的构造");

}

/**

* 显示宠物信息

public void print(){

System.out.println("宠物的自白:\n我叫"+name+",我的健康值是："+health+",和主人的亲密度为："+love+",我的性别是："+sex);

}

public class TestPet03 {

public static void main(String[] args) {

//new语法创建对象，调用无参构造

Penguin pgn = new Penguin();

//给属性赋值

pgn.name = "美美";

pgn.health = 70;

pgn.love = 30;

pgn.sex = "Q妹";

//调用方法显示信息

pgn.print();

}

public class TestPet04 {

public static void main(String[] args) {

//调用带4个参数的构造

Penguin pgn = new Penguin(20, 90, "小强","Q仔");

pgn.print();

System.out.println("-------------------------\n");

//调用带2个参数的构造

Penguin pgn2 = new Penguin(20,"jack");

pgn2.print();

System.out.println("-------------------------\n");

//调用带3个参数的构造

Penguin pgn3 = new Penguin(40,"jack3","Q仔");

//pgn3.health = 91;

pgn3.print();

}

注意：

（1）每个类都必须有构造方法，如果你不写任何构造方法，则系统会默认提供一个无参构造方法。你也可以自己写构造方法。

（2）构造方法调用必须通过new语法,构造函数在创建对象的时候自动调用。

（3）如果类中已经定义了有参构造方法，则系统不会默认分配无参方法，如果需要调用无参构造，则必须显式定义。如果显式的调用了带参构造，那么默认执行带参构造，而不会调用无参构造

（4）一个类可以有多个构造函数,构造方法不能被继承快捷键无参： alt+ / 带参shift +alt +s 再按字母 o ，按tab-->tab(2次)选中所有属性，enter 确认，shift+tab 光标定位到ok ，再按enter生成

练习：

（1）编写一个Computer类，声明三个成员变量，类型分别为String、boolean、int，但不要给成员变量赋值，写一个方法show，输出这三个变量的值。在main方法中调用方法show，观察默认值是什么。

（2）根据Person这个模板，创建一个小明对象和一个小红对象，编写有参构造方法，在main中实例化该类时，通过构造方法传入参数，而不是通过属性直接赋值。分别调用showName输出“我是小明”和“我是小红”

//提示

Person ming = new Person();

ming.name = "小明";

ming.age = 18;

ming.sex = true;

ming.showName();//我是小明

（3）编写一个学校类School，属性至少包含名称、教室数量、学生人数、就业率，方法至少包含推荐就业，推荐就业方法每调用一次，将学生人数-1并输出学生人数。根据这个类，实例化一个网博对象，给各种属性赋值，最后使用for循环调用10次就业方法。

（4）账户登录。编写一个用户类User，属性至少包含用户名name和密码pwd，在构造函数中将用户名和密码初始化为admin和123456。User类的方法包含一个密码判断checkPwd。该方法接收两个参数，分别是用户名和密码，业务逻辑是将接收到的两个参数与类的属性用户名、密码比较，判断用户名和密码是否正确，如果是，返回true。在main中从控制台分别接收输入用户名和密码，创建一个User对象，调用checkPwd方法，传入接收到的用户名和密码。如果返回true输出登录成功，返回false输出登录失败。

（5）改一改。创建User对象对象时，能够将admin和123456通过构造函数传入。

1.2. Static静态

public static void main

（1）类只是用来存储和被调用的，而对象是需要执行的，执行时就必定需要知道程序的入口，这个入口就是由main所在的位置。

（2）Java的类中没有main方法，因为它不需要执行，想执行需要自己加。

（3）Java所编写的程序是由其他程序来启动执行的（由某程序找到Java程序的入口，打开门后将操作的权限暂时交给Java程序，待到Java程序执行完毕再将权限收回），因此仅仅找到位置是不行的，还得有权限，如果没有权限，就像是你找到了门但是没有钥匙，一样进不了屋子。

（4）static的数据或方法，属于整个类的而不是属于某个对象的，是不会和类的任何对象实例联系到一起。所以子类和父类之间可以存在同名的static方法名，这里不涉及重载。所以不能把任何方法体内的变量声明为static，例如：

fun() {

static int i=0; //非法。

}

static表示全局或者静态的意思， static修饰的变量和方法叫做静态变量和静态方法。

示例1：（无法直接调用方法，需要实例化）

Person.showName();

示例2：

加static后可以使用Person.showName();

总结：

（1）静态方法可以直接通过类名调用，但静态方法内只能访问静态变量、只能调用静态方法。非静态可以调用静态。

（2） Main方法需要调用其他方法，所以自己必须在运行期间始终保持在内存中，所以使用static修饰。

交叉比较区别：成员变量和静态变量的区别

（1）两个变量的生命周期不同

成员变量随着对象的创建而存在，随着对象被回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

注：加载顺序：启动类的static block最先加载
(父类静态成员、静态代码块—>子类静态成员、静态代码块—>父类实例成员、非static代码块——>父类构造函数—>子类实例成员、非static代码块—>子类构造函数)

（2）调用方式不同

成员变量只能被对象调用。

静态变量可以被对象调用，还可以被类名调用。

（3）别名不同

成员变量也称为实例变量。

静态变量也称为类变量。

什么时候使用static，什么时候不用static？

对静态变量的修改会被始终保留下来。创建两个人的对象，会导致密码相同。

举例说明

有违Java的面向对象的封装特性，增加的耦合。

多次使用某一个方法或变量的时候用static如数据库连接串等，因为static是在程序初始化时就已分配了内存空间，直到退出前才被释放出来，而new则是在变量进入作用域时被分配，离开时释放，每new时每创建一个类的实例，都会在内存中为非静态成员新分配一块存储，所以，常用的时候用static，只在程序初始化时分配内存空间，为各个类的实例所共用，无论类创建了多少实例，类的静态成员在内存中只占同一块区域，所以常用方法或变量可以考虑用static，大型网站一般不推荐多用static因为他长时间的占用内存空间，另外static它不属于类的某一个具体的实例，而是属于类本身,所以其中不能用this等关键字，静态方法效率上要比实例化高，缺点是不能自行销毁，而实例化的可以自行销毁，网上有人说，static失去了面向对象的特性，这一点我认为是正确的，因为static不需要new根本就产生不了对象