8.局部变量、成员变量、jvm垃圾回收机制 、封装、this关键字、匿名对象

最新推荐文章于 2023-06-29 16:56:59 发布
最新推荐文章于 2023-06-29 16:56:59 发布
阅读量125 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44385781/article/details/120596982
版权

1.局部变量

package com.qfedu.a_var;

import java.util.Arrays;

public class Demo1 {


    public static void main(String[] args) {
        //int i = 0;//成员变量
        for (int i = 0; i < 10; i++) {
            //局部的变量  i  只能局部使用
            System.out.println(i);
            int[] arr ={1,3,4,5,6};
        }

        //test(arr);
        //System.out.println(i);
    }
    public static void test(int[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

2.局部变量和成员变量的区别

区别成员变量局部变量
定义的位置定义在类的大括号内定义在方法或者代码块大括号以内
作用描述当前的类对象的属性用于在代码中保存数据，数值和参数的
初始值是对应当前数据的"0"值没有赋值不能使用
所处内存空间类对象在堆区栈
作用域谁持有类对象的地址，谁就可以使用只能在大括号中
生存期对象创建，出现成员变量。销毁对象，成员变脸销毁只能在大括号中

3.jvm的垃圾回收机制

jvm是虚拟的软件，可以在任何平台上运行。

GC jvm虚拟机的垃圾回收机制

图书管理员

​ jvm的gc在一段时间内，自动检测整个内存。是否有无主内存。如果存在就回收。如果没有，就等待下一次的回收机制。

4.封装

java三大特性：封装 继承 多态

封装是java面向对象的一种思想

类的封装。方法的封装，包的封装等的

在写类的时候，之前的成员变量，什么也没有修饰。谁都可以使用这个变量。只要通过对象.属性就可以来直接操作咱们的成员变量。这样是有一定的隐患的。如果咱们向要对数据添加一定的限制和判断怎么办?

使用关键字private （私有的） 修饰

package com.qfedu.a_var;

public class Person {
    //成员变量
    private String name;//姓名
    private int age;//年龄
    private char gender;//性别


    public Person() {
    }

    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setGender (char gender) {
        this.gender = gender;
    }
    public char getGender () {
        return gender;
    }
    //设置了年龄
    public void setAge(int age) {
        if (age > 0 && age < 120) {
            this.age = age;
        } else {
            this.age = 0;
        }
    }
    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
}

总结：

​ 如果想要对类的属性进行封装的话。

​ 1.对成员变量进行私有化（包装了）

​ 2.写成员变量对应的set和get方法

注意事项：

​ 1.从今天开始，你写的类下面的所有的成员变量全部都要私有化（private）。这是一种规范。

​ 2.可以更加规范对于成员变量的操作

​ 3.可以隐藏一部分代码的操作过程

package com.qfedu.a_var;

//实体类
public class Bird {
    //成员变量
    //种类
    private String kind;
    private String color;
    private boolean size;

    public Bird() {
    }

    public String getKind() {
        return kind;
    }

    public void setKind(String kind) {
        this.kind = kind;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public boolean isSize() {
        return size;
    }

    public void setSize(boolean size) {
        this.size = size;
    }

    @Override
    public String toString() {
        return "Bird{" +
                "kind='" + kind + '\'' +
                ", color='" + color + '\'' +
                ", size=" + size +
                '}';
    }
}

5.this关键字

字面意思：

​ 这儿,这个

1.表示调用当前方法的类对象

​ 可以使用this调用类对象的成员变量和成员方法

​ 也可以用于操作当前类对象

2.this可以调用构造方法（考点）

​ 格式：

​ this(实际参数);

​ a.有且只能用在构造方法内。

​ b.this()在类内调用其他的构造方法。是根据传参不同决定调用哪个构造方法

​ c.不能调用本身的构造方法

​ d.this(实际参数)，有且只能放在当前构造方法的第一行。

package com.qfedu.testThis;

class Dog {
    private String name;
    private int age;
    private char gender;
    public Dog() {
        System.out.println("无参数的构造方法");
    }
    public Dog(String name) {
        this("狗蛋", 12, '女');//相当于在有参数的构造方法中调用了无参数构造方法
        this.name = name;

        System.out.println("带有String类型的构造方法");

    }

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("带有String,int类型的构造方法");
    }

    public Dog(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        System.out.println("带有String,int,char类型的构造方法");
    }
    public void test() {
        System.out.println(this);
    }
}
public class Demo1 {
    public static void main(String[] args) {
//        Dog dog = new Dog();
//        /*
//        *
//        * java中如果两个类的对象的空间地址是一样的，就证明是同一个对象
//        * */
//        dog.test();
//        System.out.println(dog);
        Dog dog1 = new Dog("旺财");
        //dog1.test();

        System.out.println(dog1);
    }
}

6.多类合作的练习题

1.人类

​ 属性：name,age,sex,cat

2.猫类

​ 属性：name age

​

package com.qfedu.class1;

public class Person {
    private String name;
    private int age;
    private boolean sex;
    private Cat cat;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }
}


package com.qfedu.class1;

public class Cat {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


package com.qfedu.class1;

public class Demo1 {
    public static void main(String[] args) {
        Person person = new Person();
        Cat cat = new Cat();
        cat.setName("rose");
        cat.setAge(12);
        person.setName("zixin");
        person.setAge(78);
        person.setCat(cat);
        Cat cat1 = person.getCat();
        System.out.println(cat1);

    }
}

汽车类：

​ 属性：颜色，品牌，车轮胎个数

​ 行为:飙车

修理厂：

​ 属性：店的名字,地址，练习方式

​ 行为：修车

修理厂修车的方法：

​ 方法需要一个外来数据。一个别人的车

​ c车是一个类对象。当前修车方法的参数是一个汽车类的对象

​

package com.qfedu.class2;

/*
*
* 汽车类：

​		属性：颜色，品牌名字，车轮胎个数

​		行为:飙车
* */
public class Car {
    //成员变量
    private String color;
    private String name;
    private int wheelCount;

    public Car() {
    }

    public Car(String color, String name, int wheelCount) {
        this.color = color;
        this.name = name;
        this.wheelCount = wheelCount;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

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

    public int getWheelCount() {
        return wheelCount;
    }

    public void setWheelCount(int wheelCount) {
        this.wheelCount = wheelCount;
    }
    /*飙车方法：要求轮胎必须是4个，缺一不可*/
    public void race () {
        if (wheelCount == 4) {
            System.out.println("开着"+ color + name + ",在航海中路上以200km/h飙车");

        } else {
            System.out.println("去修理厂！！！");
        }
    }
}


package com.qfedu.class2;

/*修理厂：

​		属性：店的名字,地址，联系方式

​		行为：修车*/
public class Factory {
    private String name;
    private String addr;
    private String tel;

    public Factory() {
    }

    public Factory(String name, String addr, String tel) {
        this.name = name;
        this.addr = addr;
        this.tel = tel;
    }

    public String getName() {
        return name;
    }

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

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public String getTel() {
        return tel;
    }

    public void setTel(String tel) {
        this.tel = tel;
    }
    /*
    * 修理厂有一个修车的方法，
    * 分析方法：
    *       方法名字：repair
    *       形式参数的列表：
    *               该方法的参数是一个有问题的车，是一个Car类的对象
    *        返回值类型：
    *               void
    * public void repair(Car car) {}
    * */

    /**
     * 修理厂类的修车方法，这个里面传入的是car对象
     * @param car
     */
    public void repair (Car car) throws InterruptedException {
        //传入car对象的时候，轮胎的个数是否是4个？
        if (car.getWheelCount() < 4) {
            System.out.println("修理中........");
            Thread.sleep(10000);//睡10秒  10000ms
            car.setWheelCount(4);
            System.out.println("修理完成，请付款，2w");

        } else if (car.getWheelCount() == 4) {
            System.out.println("你脑子瓦特了吧");
        }
    }
}


package com.qfedu.class2;

public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        Car car = new Car("green", "法拉利",4 );
        for (int i = 0; i < 10; i++) {
            car.race();
            Thread.sleep(1000);

        }
        System.out.println("轮胎跑掉一个。。。。");
        car.setWheelCount(3);
        car.race();
        Factory factory = new Factory();
        factory.setName("boge汽修");
        factory.setAddr("航海中路60号海为科技园12楼");
        factory.setTel("138后面随便");
        factory.repair(car);
        for (int i = 0; i < 20; i++) {
            car.race();
        }
    }
}

键盘类

​ 属性：品牌，按键的个数

​ 行为：敲代码

屏幕类

​ 属性：品牌 尺寸

​ 行为：显示bug

电脑类

​ 属性：键盘类对象，屏幕类对象

​ 行为：换键盘，换屏幕，写bug

package com.qfedu.class3;

/*
*
* 属性：品牌，按键的个数

​		行为：敲代码
* */
public class Keybord {
    private String name;
    private int keyCount;

    public Keybord() {
    }

    public Keybord(String name, int keyCount) {
        this.name = name;
        this.keyCount = keyCount;
    }

    public String getName() {
        return name;
    }

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

    public int getKeyCount() {
        return keyCount;
    }

    public void setKeyCount(int keyCount) {
        this.keyCount = keyCount;
    }
    public void coding () {
        System.out.println("噼里啪啦的敲代码！！！");
    }
}


package com.qfedu.class3;

/*屏幕类

​		属性：品牌  尺寸

​		行为：显示bug*/
public class Screen {
    private String name;
    private double size;

    public Screen() {
    }

    public Screen(String name, double size) {
        this.name = name;
        this.size = size;
    }

    public String getName() {
        return name;
    }

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

    public double getSize() {
        return size;
    }

    public void setSize(double size) {
        this.size = size;
    }
    public void show () {
        System.out.println("显示咱们无处遁形的bug");
    }
}


package com.qfedu.class3;

/*
* 电脑类

​		属性：键盘类对象，屏幕类对象

​		行为：写bug
* */
public class Computer {
    private Keybord keybord;
    private Screen screen;

    public Computer() {
    }

    /**
     * 大电脑类带的两个参数，是键盘类的对象和屏幕类的对象
     * @param keybord
     * @param screen
     */
    public Computer(Keybord keybord, Screen screen) {
        this.keybord = keybord;
        this.screen = screen;
    }

    public Keybord getKeybord() {
        return keybord;
    }

    public void setKeybord(Keybord keybord) {
        this.keybord = keybord;
    }

    public Screen getScreen() {
        return screen;
    }

    public void setScreen(Screen screen) {
        this.screen = screen;
    }
    public void writeBug() {
        System.out.println("使用"+ keybord.getName() + ":" + keybord.getKeyCount()+
                "," + screen.getName()+ ":" + screen.getSize() + "写bug");
    }
}


package com.qfedu.class3;

public class Demo1 {
    public static void main(String[] args) {
        Keybord keybord = new Keybord("双飞燕", 87);
        Screen screen = new Screen("京东方", 15.6);

        Computer computer = new Computer(keybord, screen);
        computer.writeBug();
        //使用罗技键盘
        Keybord keybord1 = new Keybord("罗技", 108);
        computer.setKeybord(keybord1);
        computer.writeBug();
        //换个屏幕
        Screen screen1 = new Screen("SONY", 32.0);
        computer.setScreen(screen1);
        computer.writeBug();


    }
}

7.匿名对象（很好用）

语法格式：

​ 创建对象：

​ 类名 对象名字 = new 类名()

​ 赋值号左侧只是在内存的栈区定义了一个变量而已。而这个变量是引用数据类型。

​ 赋值号右侧在内存的堆区创建了类的对象。并且把当前类对象内存的空间首地址,赋值给了左侧的引用数据类型

​ 匿名对象：

​ 就是没有对象名字的对象!!

​ 语法格式：

​ new 类名（）

​ 用途：

​ 1.直接调用类的成员方法

​ 2.使用匿名对象当成参数传给一个方法

​

package com.qfedu.niming;

class Person {
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void eat() {
        System.out.println("民以食为天");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        //Person person = new Person();
//        Person person = new Person();
//        Person person1 = new Person();
//        person.setName("狗蛋");
//        person1.getName()

        //使用匿名对象
        new Person().eat();
        new Person().setName("狗蛋儿");
        //肉包子打狗一去不会，new 一个Person就是新的对象
        System.out.println(new Person().getName());
        //Person person = new Person();
        test(new Person());

    }
    public static void test(Person person) {
        person.eat();
    }
}

作业：

1.今天的代码敲上三遍以上

2.成人类下面有孩子类，孩子类下面玩具类

3.十二生肖 今天加封装

孤狼程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 局部变量 回收_java局部变量对垃圾回收的影响
weixin_42170790的博客
02-12 596
结论局部变量表中的变量是很重要的垃圾回收根节点，被局部变量表中变量直接或者间接引用的对象都不会被回收。实验看如下代码，使用JVM的-XX:+PrintGC参数运行下面代码(在main函数中分别执行localVarGcN的每一个函数)package com.winwill.jvm.basic;public class GcTest {private static final int SIZE = 6...
2023年java初级试题库.doc
11-05
Java中的垃圾回收机制可以自动回收不再使用的对象，避免了内存泄露的问题。Java程序员可以使用System.gc()方法来提示垃圾回收机制，但是垃圾回收机制并不是由操作系统自动执行的。 12. Java中的异常处理： Java中...
day7 局部变量和封装
qq_55436118的博客
03-18 131
1.局部变量 package com.qfedu.a_var; import java.util.Arrays; public class Demo1 { public static void main(String[] args) { //int i = 0;//成员变量 for (int i = 0; i < 10; i++) { //局部的变量 i 只能局部使用 System.out.printl
java 对象被回收的例子_java类中的成员成员变量赋值之后什么时候会被回收，有什么办法监听到某一个对象被回收吗...
weixin_32342639的博客
02-16 301
一个对象是否被回收并不是仅仅靠当前对象是否被引用这么简单粗暴的方法去判断。JVM中判断是否回收一个对象使用的是可达性分析算法，GC ROOT不可到达的节点都将会被标记上，一个对象如果被标记了两次就会被回收掉。至于这个可达性分析算法你可以自行百度一下，原理是很简单的。那么用什么方法来监听一个对象是否被回收呢？当然用fianlize了;请看代码：public class Test {private s...
java类变量、垃圾回收（2018-9-6）
AriesTina的博客
09-06 575
java中类变量和一般变量的区别 Java虚拟机垃圾回收(二) 垃圾回收算法：标记-清除算法 复制算法 标记-整理算法 分代收集算法 火车算法https://blog.csdn.net/tjiyu/article/details/53983064（里面含各种算法的应用场景） 标记-清除算法会使内存产生碎片，那么如何解决这个问题，很显然，清除以后再整理一下内存不就行了么。 然而标记-整...
java面向对象知识点总结[参考].pdf
10-11
This 关键字是用来代表当前对象的，普通方法访问到的成员前边都有 this 关键字。This 关键字可以用来在构造函数中调用本类与之相对应的构造函数。 成员变量和局部变量 成员变量是定义在类中的，在整个类中都起作用...
Java岗面试核心MCA版.pdf
10-14
1. 成员变量和局部变量的区别：成员变量是类的成员变量，而局部变量是方法或构造器中的变量。 2. 作用域和存储位置：变量的作用域和存储位置取决于变量的声明位置。 3. 生命周期：变量的生命周期取决于变量的...
【05-面向对象(下)】
07-03
•final既可修饰成员变量，也可以修饰局部变量。 final修饰成员变量 •成员变量是随类的初始化或对象初始化而初始化的。final修饰的成员变量必须由程序员指定初始值。 •对于类属性而言，要么在静态初始化...
java笔记整理（超详细）.pdf
07-13
3. 从变量在内存中的生命周期来看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。 4. 成员变量如果没有被赋初值，则会自动以类型的默认值而赋值（一种情况例外被final修饰...
成员变量与局部变量的区别 内存管理 垃圾回收机制
dizi1802的博客
08-06 515
成员变量与局部变量的区别： 成员变量 定义位置:在方法外，类体中 默认值:有默认值,构造器中可以不对成员变量初始化 内存位置:在堆中 生命周期:从对象实例化开始出现，到对象消失 局部变量 定义位置:在方法内(包含小括号内的形参) 默认值: 没有默认值，必须初始化再使用 ...
java成员变量垃圾回收_java面向对象，垃圾回收机制
weixin_31539461的博客
02-16 601
一.类的属性属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。\二.UML图三.类和对象1.对象是具体的事物;类是对对象的抽象;2.类可以看成一类对象的模板，对象可以看成该类的一个具体实例。3.类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具有的共同的属性、方法。四。面向...
javascript权威指南_JavaScript垃圾回收机制
weixin_39863008的博客
11-29 113
一、垃圾回收的必要性1. 概述下面这段话引自《JavaScript权威指南（第四版）》由于字符串、对象和数组没有固定大小，所有当他们的大小已知时，才能对他们进行动态的存储分配。JavaScript程序每次创建字符串、数组或对象时，解释器都必须分配内存来存储那个实体。只要像这样动态地分配了内存，最终都要释放这些内存以便他们能够被再用，否则，JavaScript的解释器将会消耗完系统中所有可用的内存，...
java 局部变量 回收_Java局部变量对垃圾回收的影响
weixin_39764487的博客
02-12 815
public class GcTest{public void localvarGc1() {byte[] a = new byte[6*1024*1024];System.gc();}public void localvarGc2() {byte[] a = new byte[6*1024*1024];a=null;System.gc();}public void localvarGc3(){{...
java成员变量垃圾回收_JAVA 对象被垃圾回收后其成员变量可用吗？ | 学步园
weixin_36402316的博客
02-16 349
我们知道JVM中一个对象实例超出作用域或无引用的时候会被垃圾回收，那么他被垃圾回收后，依赖其成员变量的其他实例是否还能正常使用呢？经过测试后发现即使一个实例被垃圾回收，如果他内部的数据被其他对象使用，是不受影响的，下面看这个示例package test;public class mytest {public static void main(String[] args) throws Except...
Java - JVM 那些事之“全局变量 & 局部变量”
牧码的博客
07-28 560
基本数据类型是放在栈中还是放在堆中，这取决于基本类型声明的位置。 第一种、在方法中声明的变量，即该变量是局部变量，每当程序调用方法时，系统都会为该方法建立一个方法栈，其所在方法中声明的变量就放在方法栈中，当方法结束系统会释放方法栈，其对应在该方法中声明的变量随着栈的销毁而结束，这就局部变量只能在方法中有效的原因。 （1）当声明是基本类型的变量的时，其变量名及值（变量名及值是两个概念）是放在方法栈中。 （2）当声明的是引用变量时，所声明的变量（该变量实际上是在方法中存储的是内存地址值）是放在方法的栈.
成员变量以及局部变量 封装
初心不改，事在人为
01-05 249
package 面向对象基础; public class 成员变量与局部变量 { // 位（位置（定义的位置 内存位置））初（初始化值，作用域）生（生命周期） /* 成员变量 局部变量 1.定义的位置 方法的外部只在类中 方法的内部， 2.作用范围 整个类可...
Java局部变量对垃圾回收的影响
xigua355的博客
03-04 839
public class GcTest { public void localvarGc1() { byte[] a = new byte[6*1024*1024]; System.gc(); } public void localvarGc2() { byte[] a = new byte[6*1024*1024]; a=null; System...
关于局部变量的垃圾回收
m0_73513215的博客
06-29 440
但如果在同一函数内部，又声明了一个新的局部变量int y，而且y的类型和大小与x相同，那么编译器可能会选择复用之前x的内存空间来存储y的值，而不再重新分配新的内存空间。然而，由于编译器的优化机制，新声明的局部变量可能会复用之前已经释放的内存空间，以提高资源利用效率。这种情况下，旧的局部变量可能没有被显式地进行垃圾回收，但其占用的内存空间已经被重新利用，从而达到了节省资源的目的。前提：如果一个局部变量出了其作用域，那么在其作用域之后声明新的局部变量就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的。
jvm垃圾回收机制是什么
最新发布
07-25
JVM（Java虚拟机）的垃圾回收机制是自动管理和释放内存的过程。它通过检测不再使用的对象并回收它们所占用的内存来避免内存泄漏和溢出。 JVM中的垃圾回收器通常使用以下几种策略来判断对象是否可以被回收： 1. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值