Java 局部变量和成员变量

Wait Together

已于 2023-02-25 15:35:57 修改

阅读量171

点赞数

分类专栏： Java基础文章标签： java Powered by 金山文档

于 2023-02-24 19:00:05 首次发布

本文链接：https://blog.csdn.net/m0_65030141/article/details/129206821

版权

Java基础专栏收录该内容

24 篇文章 0 订阅

订阅专栏

零、复习昨日

一、一日一题（数组，OOP）

package com.qf0208;
import java.util.Arrays;
public class Task2 {
	public static void main(String[] args) {
		int[] arr1 = {1,2,5,8,9};
		int[] arr2 = {1,3,0};
		plus(arr1, arr2);
	}

	/* 写一个方法 用于合并两个int类型的数组  合并法则如下
     *    {1,2,5,8,9}{1,3,0}---->{0,1,2,3,5,8,9}
     */
	public static void plus(int[] arr1,int[] arr2) {
		 
		// 合并
		int[] arr3 = new int[arr1.length + arr2.length];
		System.arraycopy(arr1, 0, arr3, 0, arr1.length);
		System.arraycopy(arr2, 0, arr3, arr1.length, arr2.length);
		System.out.println(Arrays.toString(arr3));
		
		// 去重
		// 创建新数组,存放不重复的元素
		int[] arr4 = new int[arr3.length];
		Arrays.sort(arr3);
		arr4[0] = arr3[0];
		int index = 1;
		// 取源数组
		for (int i = 1; i < arr3.length; i++) {
			boolean flag = false;// 不重复
			// 去重后数组的元素
			for (int j = 0; j < arr4.length; j++) {
				if (arr3[i] == arr4[j]) {
					flag = true;
				}
			}
			if (!flag) {
				arr4[index] = arr3[i];
				index++;
			}
		}
		System.out.println(Arrays.toString(arr4));
		int[] arr5 = new int[index];
		System.arraycopy(arr4, 0, arr5, 0, index);
		System.out.println(Arrays.toString(arr5));
	}
}

同一个Java文件中只能有一个公共的类，且公共的类的名字要和外面的文件名一样。

二、面向对象练习（方法参数返回值）

联系方法参数，进行返回值

package com.qf0213;

/**
 * @escription:
 * @author:灰总
 * @time:
 */

public class Phone {
    String brand;
    double price;

    public boolean call(String num){
        System.out.println(brand + "打电话");
        return true;
    }
}

class TestPhone{
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.brand = "MI";
        phone.price = 1888.0;
        boolean isok = phone.call("110");
        System.out.println("打电话是否成功？" + isok);
    }
}

三、局部变量&成员变量

成员变量属于对象。

	局部变量	成员变量
位置	方法参数列表和方法体内	类中方法外
作用域	只能在方法内部使用	类中所有方法
初始值	使用前必须主动赋值	成员变量会随着创建对象时被赋默认值
内存位置	在栈的栈帧中	在内存的堆中
生命周期	会随着方法进栈而出现，方法执行完出栈而消失	在对象创建时出现并赋初始值，失去引用后会被gc(垃圾回收机制处理)回收

public class Phone {

    /**
     * 成员属性就是成员变量
     * 1 类中方法外
     * 2 类中所有方法都可以使用
     * 3 成员变量会随着创建对象时被赋默认值(即可以不用主动考虑初始值的事)
     * 4 成员变量在内存的堆中
     * 5 在对象创建时出现并初始化,失去引用后,会把垃圾回收机制处理(GC)
     */
    String brand;
    double price;

    /**
     * 局部变量
     * 1 方法参数列表内和方法体内
     * 2 只能在方法内部使用
     * 3 局部变量使用前必须主动赋值
     * 4 局部变量是在栈的栈帧中
     * 5 随着方法进栈而出现,方法执行完出栈而消失
     */
    public boolean call(String num) {
        int a = 1;
        System.out.println(a );
        System.out.println(brand + "打电话" + num);
        System.out.println("这个手机价格:" + price);
        return true;
    }
}

四、this关键字

this就是代表当前对象
当前对象就是指谁调用这个方法，this就代表调用这个方法的对象。

因为this代表的是对象，所以它就可以调用对象的属性和方法
this.属性；
this.方法()；

package com.qf.oop;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc
 */
public class Car {

    String brand;
    double price;

    public void run() {
        int a = 1;
        String brand = "五菱";
        System.out.println("this:"+this );// 输出的是car的地址,代表car对象
        /**
         * 当成员变量和局部变量重名时
         * 使用时,默认使用方法自己的局部变量(就近原则)
         * 如果必须使用成员变量,就使用this来调用
         * 因为this代表对象,所以可以调用对象属性
         */
        System.out.println(this.brand + "车跑动,跑了"+a+"公里" );
        
        // this调用方法
        this.didi();
    }

    public void didi() {
        System.out.println("车鸣笛" );
    }

}
class TestCar {
    public static void main(String[] args) {

        Car car = new Car( );
        System.out.println("car:" + car );
        car.brand = "BYD";
        car.price = 150000;

        car.run();
    }
}

使用this的场景总结：
当成员变量和局部变量重名时，用this属性来代表成员变量

五、构造方法【重要】

构造方法又叫构造器（constructor），是用来创建对象的。
类名对象名 = new 类名();
其实这个语法应该这么叫：
类名对象名 = new 构造方法();

特点：

每个类都默认有一个无参构造
没有返回值，也不能写void
方法名必须是类名，类名必须大写
只能通过new来调用

特殊的：类中没有一个显示构造方法，那么就会提供一个隐式无参构造，一旦显示写出任何一个构造方法，隐式的不再提供。

具体作用（构造方法一旦执行）
在堆中开辟空间，分配地址空间
属性和方法被初始化
然后执行构造方法内部的代码
对象创建成功将地址值赋给变量（对象名）

有参构造

在创建对象时，调用有参构造方法，方法内部有属性赋值的过程，所以有参构造创建出的对象的属性是指定值。

public class Student {
    String name;
    int age;

    /**
     * 显示的写出无参构造
     * 构造方法语法特点
     * 1. 没有返回值,也不能写void
     * 2. 方法名必须是类名
     */
    public Student(){
        System.out.println("无参构造" );
    }

    /**
     * 有参构造
     */
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public void coding(){
        System.out.println("敲代码" );
    }
}
class TestStudent{
    public static void main(String[] args) {
        // ???? 能不能创建出的对象,内部的属性直接有值
        // 能!!! 有参构造
        Student s2 = new Student("奥利安娜", 20);

        System.out.println(s2.age );
        System.out.println(s2.name);
    }
}

总结有参构造和无参构造的区别
相同点：都能创建出对象
不同点：无参构造创建出的对象属性是默认值；有参构造创建出的对象属性是指定值

即两者都是创建对象，只是不同的效果，看情况选择使用

六、重载

重载：overload；方法的重载

方法是在同一个类中
方法名相同，参数列表不同
参数列表不同：个数、类型、顺序不同都叫不同

好处：
方便调用，根据传入的参数的个数、顺序、类型决定执行那个方法，不同的设计取不同的方法名。

七、封装

类的封装：将代码封装在一个类中，隐藏一些代码实现的逻辑，对外提供一个公共的访问方式

类的封装实现步骤：
属性私有
提供对应的set、get方法

set、get方法，很固定
一定是set+首字母大写 setXxx getXxx
set方法有参数无返回值
get方法无参数有返回值

package com.qf0213;

/**
 * @escription:
 * @author:灰总
 * @data:
 */

public class People {

    // 私有化，这个属性就只能在当前类中使用
    private int age;
    private String name;

    // 提供set方法供赋值
    public void setAge(int age){
        if (age <= 120 && age >= 0){
            this.age = age;
        } else {
            System.out.println("年龄有误！");
        }
    }

    // 提供get方法取值
    public int getAge(){
        return age;
    }

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

    public String getName(){
        return name;
    }
}

class TestPeople{
    public static void main(String[] args) {
        People people = new People();
//        people.name = "liuzhuo";
//        people.age = 23;
        people.setAge(23);
        int age = people.getAge();
        people.setName("liuzhuo");
        String name = people.getName();
//        System.out.print(people.name + " ");
        System.out.print(name);
        System.out.println(age);
    }
}