Java基础（三）

四.类和对象

类

是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。

现实中，描述一类事物：

• 属性：该事物的状态信息。
• 行为：就是该事物能够做什么。

举例：小猫

• 属性：名字，体重，年龄，颜色等
• 行为：走，跑，跳。

对象

是一类事物的具体体现，对象是类的一个实例，必然具备该类事物的属性和行为。

类和对象的关系

• 类是对一类事物的描述：是抽象的。
• 对象是一类事物的实例；是具体的。
• 类是对象的模板，对象是类的实体。

类的定义

事物与类的对比

现实世界的一类事物

• 属性：事物的状态信息。
• 行为：事物能够做什么。

Java中用class描述事物也是如此：

• 成员变量：对应事物的属性。
• 成员方法：对应事物的行为。

类的定义格式

public class Demo{
    //成员变量
    //成员方法
}

• 定义类：就是定义类的成员，包括成员变量和成员方法。
• 成员变量：和以前定义变量几乎是一样的，只不过位置发生了改变，在类中，方法外。
• 成员方法：和以前定义方法几乎是一样的，只不过把static去掉。

/*定义一个类，用来模拟“学生”事物，其中就有两个组成部分
属性（是什么），
        姓名
        年龄
行为（能做什么）
        吃饭
        睡觉
        学习
        对应到Java的类当中

成员变量（属性）
    String name;//姓名
    int age;//年龄
成员方法（行为）
    public void eat() {}//吃饭
    public void sleep() {}//睡觉
    public void study() {}//学习

注意事项：
        1.成员变量是直接定义在类当中，在方法外边；
        2.成员方法不要写static关键字
* */
public class Student {
    //成员变量
    String name;//姓名
    int age;//年龄
    //成员方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public  void  study(){
        System.out.println("学习");
    }
}

对象的创建及使用

使用上面的Student类，且两者还处在同一个包中。

/*
* 通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才可以使用
* 创建对象的步骤
* 1.导包：指出需要使用的类在何位置。格式：import 包名称.类名称
* 对于和当前类属于同一个包的情况，可以省略导包语句
* 2.创建：格式：类名称 对象名 = new 类名称（）;
* 3.使用：分为两种情况；
* 使用成员变量：对象名.成员变量名
* 使用成员方法：对象名.成员方法名（参数）
* （也就是说，使用谁，就用对象名加点谁）
*
* 注意事项：
* 如果成员变量没有赋值，那么就会有一个默认值，规则和数组一样
* */
public class Demo025Student {
    public static void main(String[] args) {
        //1.导包
        //需要使用Student类，但在同一包下，就可以省略导包语句

        //2.创建：格式
        //类名称 对象名 = new 类名称();
        //根据Student类，创建一个名为Stu的对象
        Student stu = new Student();

        //3.使用其中的成员变量，格式
        //对象名.成员变量名
        System.out.println(stu.name);// null
        System.out.println(stu.age);// 0

        System.out.println("===============");

        //改变对象的当中的成员变量数值的内容
        //将右侧的字符串，赋值交给stu对象当中的name成员变量
        stu.name = "张三";
        stu.age = 18;
        System.out.println(stu.name);
        System.out.println(stu.age);
        System.out.println("===============");
        //使用对象的成员方法，格式；
        //对象名.成员方法名
        stu.eat();
        stu.sleep();
        stu.study();
    }
}

练习：手机类

Phone类：

package HeiMa.Demo01;
/*
* 定义一个类，用来模拟”手机“事物
*
* 属性：品牌、价格、颜色
* 行为：通话，发短信，
*
* 对应到类中：
* 成员变量(属性);
*   String brand;//品牌
*   double price;//价格
*   String color;//颜色
* 成员方法(行为);
*   public  void  call(String who){}//打电话
    public  void  sendMessage(){}//群发短信
* */
public class Phone {

    //成员变量
    String brand;//品牌
    double price;//价格
    String color;//颜色

    //成员方法
    public  void  call(String who){//打电话
        System.out.println("给"+who+"打电话");

    }
    public  void  sendMessage(){//群发短信
        System.out.println("群发短信");
    }
}

PhoneOne类：

package HeiMa.Demo01;

public class PhoneOne {
    public static void main(String[] args) {
        //根据phone类 创建一个名为one的对象
        //格式：类名称 对象名 = new 类名称();
        Phone  one = new Phone();
        System.out.println(one.brand);//null
        System.out.println(one.price);//0.0
        System.out.println(one.color);//null
        System.out.println("=============");

        one.brand = "苹果";
        one.price = 6799;
        one.color = "黑色";
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
        System.out.println("=============");

        one.call("乔布斯");
        one.sendMessage();
    }
}

关于手机对象的内存图

两个对象使用一个同一个方法的内存

package HeiMa.Demo01;

public class PhoneTwo {
    public static void main(String[] args) {
        Phone  one = new Phone();
        System.out.println(one.brand);//null
        System.out.println(one.price);//0.0
        System.out.println(one.color);//null
        System.out.println("=============");

        one.brand = "苹果";
        one.price = 6799;
        one.color = "黑色";
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
        System.out.println("=============");

        one.call("乔布斯");
        one.sendMessage();
        System.out.println("=============");


        Phone  two = new Phone();
        System.out.println(two.brand);//null
        System.out.println(two.price);//0.0
        System.out.println(two.color);//null
        System.out.println("=============");

        two.brand = "三星";
        two.price = 5999;
        two.color = "蓝色";
        System.out.println(two.brand);
        System.out.println(two.price);
        System.out.println(two.color);
        System.out.println("=============");

        two.call("欧巴");
        two.sendMessage();
    }
}

要想使两个对象产生联系，只需修改一行代码，即Phone two = new Phone();，此处是重新new的。

两个对象引用指向同一个对象空间

package HeiMa.Demo01;

public class PhoneSame {
    public static void main(String[] args) {
        Phone  one = new Phone();
        System.out.println(one.brand);//null
        System.out.println(one.price);//0.0
        System.out.println(one.color);//null
        System.out.println("=============");

        one.brand = "苹果";
        one.price = 6799;
        one.color = "黑色";
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
        System.out.println("=============");

        one.call("乔布斯");
        one.sendMessage();
        System.out.println("=============");

        //将one中的保存的对象地址值赋值给two
        Phone  two = one;
        System.out.println(two.brand);//null
        System.out.println(two.price);//0.0
        System.out.println(two.color);//null
        System.out.println("=============");

        two.brand = "三星";
        two.price = 5999;
        two.color = "蓝色";
        System.out.println(two.brand);
        System.out.println(two.price);
        System.out.println(two.color);
        System.out.println("=============");

        two.call("欧巴");
        two.sendMessage();
    }
}

使用对象类型作为方法的参数

当一个对象作为参数，传递到方法当中时，实际上传递进去的是对象的地址值。

package HeiMa.Demo01;

public class PhoneParam {
    public static void main(String[] args) {
        Phone one  = new Phone();
        one.brand = "苹果";
        one.price = 8388.0;
        one.color="土豪金";
        method(one);//传递进去的其实就是地址值
    }
    public static void method(Phone param){
        System.out.println(param.brand);//苹果
        System.out.println(param.price);//8388.0
        System.out.println(param.color);//土豪金
    }
}

使用对象类型作为方法的返回值

当使用一个对象类型作为方法的返回值时：返回值其实就是对象的地址值。

package HeiMa.Demo01;

public class PhoneReturn {
    public static void main(String[] args) {
        Phone two = getPhone();
        System.out.println(two.brand);//苹果
        System.out.println(two.price);//8388.0
        System.out.println(two.color);//玫瑰金
    }
    public  static Phone getPhone(){
        Phone one = new Phone();
        one.brand = "苹果";
        one.price = 8388.0;
        one.color = "玫瑰金";
        return  one;
    }
}

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

1. 定义的位置不一样【重点】
   1. 局部变量：在方法内部
   2. 成员变量：在方法外边
2. 作用范围不一样【重点】
   1. 局部变量：只有方法当中才可以使用，出了方法就不能再用。
   2. 成员变量：整个类都可以通用。
3. 默认值不一样【重点】
   1. 局部变量：没有默认值，如果要想使用，必须手动进行赋值
   2. 成员变量：如果没有赋值，会有默认值，规则和数组一致。
4. 内存的位置不一样【了解】
   1. 局部变量：位于栈内存
   2. 成员变量：位于堆内存
5. 生命周期不一样【了解】
   1. 局部变量：随着方法进栈而诞生，随着方法出栈而消失。
   2. 成员变量：随着对象的创建而诞生，随着对象被垃圾回收而消失。

package HeiMa.Demo03;

/*局部变量和成员变量
* 1.定义的位置不一样【重点】
* 局部变量：在方法内部
* 成员变量：在方法外边
* 2.作用范围不一样【重点】
* 局部变量：只有方法当中才可以使用，出了方法就不能再用。
* 成员变量：整个类都可以通用。
*
* 3.默认值不一样【重点】
* 局部变量：没有默认值，如果要想使用，必须手动进行赋值
* 成员变量：如果没有赋值，会有默认值，规则和数组一致。
* 4.内存的位置不一样【了解】
* 局部变量：位于栈内存
* 成员变量：位于堆内存
* 5.生命周期不一样【了解】
* 局部变量：随着方法进栈而诞生，随着方法出栈而消失
* 成员变量：随着对象的创建而诞生，随着对象被垃圾回收而消失
* */

public class VariableDifference {
    String name;//成员变量
    public void methodA(){
        int num= 20;//局部变量
        System.out.println(num);
    }
    public  void  methodB(int param){//方法参数就是局部变量
        //参数在方法调用中必然会被赋值的。
        System.out.println(param);
        int age;//局部变量没有赋值没法使用
       //System.out.println(num);//错误写法
        System.out.println(name);
//        System.out.println(age);//没有赋值
    }
}