课堂笔记7.11

一、对象的属性

把其他自定义类作为属性

Dog宠物狗

/**
 * 宠物狗
 */
public class Dog {
    private String name; //名字

    //构造器
    public Dog() {
    }
    public Dog(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

Person人类

/**
 * 人类
 *  属性
 *      姓名
 *      拥有宠物狗
 *
 *  行为
 *      领养狗
 *      给狗起名字
 *      介绍自己的宠物狗
 */
public class Person {
    private String name; //姓名
    private Dog dog; //宠物
    /**
     * 领养狗
     * @param dog
     */
    public void adoptDog(Dog dog){
        System.out.println(this.name+"领养了"+dog.getType()+"品种的狗");
        //把要领养的狗，设置到人类属性中
        this.dog=dog;
    }
    /**
     * 给宠物狗起名字
     */
    public void giveName(){
        //健壮性处理
        if(this.dog==null){
            System.out.println("-->警告：勇敢的少年啊，快去领养一条宠物狗吧");
            return;
        }

        System.out.println("-->请输入宠物狗的新名字：");
        String dogName = new Scanner(System.in).next();
        //this.dog就代表当前这个人类的宠物狗属性
        this.dog.setName(dogName);
    }
    /**
     * 介绍自己的宠物狗
     */
    public void say(){
        System.out.print("我叫"+name+"，我有一条"+this.dog.getType());
        System.out.println("品种的宠物狗，名字叫"+this.dog.getName());
    }

    //构造器
    public Person() {
    }
    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }
}

测试使用

/**
 * 测试人类领养宠物狗
 */
public class Test {
    public static void main(String[] args) {
        //创建几个宠物狗（new运算符调用Dog类构造器来创建对象）
        Dog d1 = new Dog("中华田园犬");
        Dog d2 = new Dog("哈士奇");
        Dog d3 = new Dog("萨摩耶");
        Dog d4 = new Dog("边境牧羊犬");
        Dog d5 = new Dog("藏獒");

        //创建人类
        Person p1 = new Person("ss");
        Person p2 = new Person("xx");

        //领养狗
        p1.adoptDog(d2);
        p1.giveName();
        p1.say();

        p2.adoptDog(d3);
        p2.giveName();
        p2.say();

    }
}

二、局部变量和全局变量

1、局部变量：

在方法内的，如参数，方法体内声明的变量

生命周期，只要当前所在位置代码执行结束，就会销毁

public void setName(String name) {//参数name是局部变量
    this.name = name;
    //name=name; //属性是全局变量，会和同名的局部变量冲突？变成局部变量
    			//如何引用被隐藏的全局变量，使用this
}

this就代指当前对象（方法的调用者）

2、全局变量：

直接在类中，属于类的属性，可以在本类的所有实例方法中访问（非static修饰的）

public static void testAccess(){
    //System.out.println(name);//全局实例变量变量不能静态方法中被访问
    //System.out.println(this.name);
}

生命周期，全局变量属于属性，只要对象在，就一直在，等到堆内存的对象被销毁才会销毁

三、值传递和引用传递

值（基本数据类型）在栈内存中

引用（对象）在堆内存中

/**
 * 值传递和引用传递的区别
 *  值传递（值是基本数据类型）
 *  引用传递（引用是对象）
 */
public class ParamTest {
    /**
     * 值传递（传到方法中的数值已经和原数据没有任何的联系）
     * @param n
     */
    public static void test1(int n){
        n=2;//方法中改变了n保存的值，猜测和外部的变量n是否有联系？
        System.out.println("方法中n = " + n);
    }
    /**
     * 引用传递（传到方法中的对象和原对象仍然有联系！！！）
     * @param arr
     */
    public static void test2(int[]arr){
        arr[0]=100;//改变数组对象0下标的元素
        System.out.println("方法中arr = " + Arrays.toString(arr));
    }
    public static void main(String[] args) {
        //值传递测试
        int n = 1;
        test1(n);
        System.out.println("外部n = " + n);

        //引用传递测试
        int[]arr={1,2};
        test2(arr);
        System.out.println("外部arr = " + Arrays.toString(arr));

    }
}

问题：当我们传参的时候，传出去的数据是否还和原本的变量有关系？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tSnPwSHS-1657540825239)(Img\yy.png)]

//把对象在堆内存的首地址（位置）保存给不同的变量
int[]brr = {100};

int[]crr = brr;
int[]drr = brr;
//请问：brr、crr、drr，一共几个数组？
// 1个（三个变量保存的是同一个对象的地址，表示的是同一个数组对象）

crr[0] = 200;//改变crr变量保存的数组对象的元素，另外两个变量也跟着改变
System.out.println("brr[0] = " + brr[0]);//200
System.out.println("crr[0] = " + crr[0]);//200
System.out.println("drr[0] = " + drr[0]);//200

四、方法重载

在同一个类中，方法名相同，参数不同，可以定义多个同名的方法

根据不同的参数，可以调用不同的方法

• 参数的个数不同
• 参数的类型不同
• 参数的个数相同，类型不同

测试使用重载的方法

/**
 * 测试使用方法的重载
 */
public class Test {

    public static void sum(int a,int b){
        System.out.println(a+"+"+b+"="+(a+b));
    }
    public static void sum(double a,double b){
        System.out.println(a+"+"+b+"="+(a+b));
    }
    public static void main(String[] args) {
        Test.sum(1,2);
        Test.sum(1.1,2.2);
    }
}

五、static

类中的属性和方法，称为类的成员

成员分为：实例成员和类成员

1、实例成员

实例成员属于对象，只有对象才能引用和访问

2、类成员

类成员不属于任何对象，所有对象都可以共享和访问，可以直接通过类名和对象名引用和访问

类方法中不能直接访问实例成员

​ 因为实例成员必须由对象引用

​ 而类方法由于也可以被类名直接引用，所以本身是没有对象的，所以无法访问实例成员

3、static静态代码块

用于类加载后的静态属性的初始化

学生类花班费和花自己钱案例

学生类

/**
 * 学生类
 */
public class Student {
    private String name;
    private double money; //自己的钱
    private static double clazzMoney; //班费 （类成员）
    //static静态代码快
    static{
        clazzMoney=10000;//初始化班费（类变量）
    }
    /**
     * 花自己钱的方法
     */
    public void flowerMoney(double money){
        System.out.println(this.name+"原有钱"+this.money);
        this.money-=money;
        System.out.println("花了"+money+"元，还剩"+this.money);
    }
    /**
     * 花班费的方法
     */
    public void flowerClazzMoney(double money){
        System.out.println("班费原有钱"+clazzMoney);
        clazzMoney-=money;
        System.out.println("花了"+money+"元，班费还剩"+clazzMoney);
    }
    //构造器
    public Student() {
    }
    public Student(String name, double money) {
        this.name = name;
        this.money = money;
    }

    public String getName() {
        return name;
    }

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

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public static double getClazzMoney() {
        return clazzMoney;
    }

    public static void setClazzMoney(double clazzMoney) {
        Student.clazzMoney = clazzMoney;
    }
}

测试类

/**
 * 测试花钱
 */
public class Test {
    public static void main(String[] args) {
        //创建两个学生对象
        Student s1 = new Student("xx", 1000000);
        Student s2 = new Student("ss", 500);

        //花自己的钱测试（每个人自己的钱和别人的没关系，每个对象都有自己的实例属性）
        s1.flowerMoney(5000);
        s2.flowerMoney(10);


        //花班费测试（班费是共享的，大家访问的都是同一个）
        s1.flowerClazzMoney(5000);//挪用班费买手机
        s2.flowerClazzMoney(20);//挪用班费买个手机壳

    }
}

运行结果

xx原有钱1000000.0
花了5000.0元，还剩995000.0
ss原有钱500.0
花了10.0元，还剩490.0
班费原有钱10000.0
花了5000.0元，班费还剩5000.0
班费原有钱5000.0
花了20.0元，班费还剩4980.0

的钱测试（每个人自己的钱和别人的没关系，每个对象都有自己的实例属性）
s1.flowerMoney(5000);
s2.flowerMoney(10);

    //花班费测试（班费是共享的，大家访问的都是同一个）
    s1.flowerClazzMoney(5000);//挪用班费买手机
    s2.flowerClazzMoney(20);//挪用班费买个手机壳

}

}

运行结果

xx原有钱1000000.0
花了5000.0元，还剩995000.0
ss原有钱500.0
花了10.0元，还剩490.0
班费原有钱10000.0
花了5000.0元，班费还剩5000.0
班费原有钱5000.0
花了20.0元，班费还剩4980.0