Java基础补习---Day 07

一、类和对象

（一）类和对象比较

1、类：类别；对具体事物的一些抽象认识，概括的是一类事物共性的属性和行为。是一个抽象的概念，并非实际存在。

2、对象：一个真实存在的事物，是属性和行为的具体体现。是属性的载体，是行为的执行者。

（二）类的说明

1、类：是定义了一组属性和行为的集合

2、格式：

class 类名 {

}

3、属性：对事物特征的描述，一般是变量

属性就是一个变量，只不过定义的位置发生了变化，以前定义在方法中，现在定义在类中方法外，和方法是平级关系

4、行为：对事物功能的描述，是方法

功能就是一个方法，和以前定义的位置一样，只不过以前修饰是【public static】，现在改为【public】

public class Demo01_Class {
    }
    /**
    * 一个java文件中只能有一个public class，可以有多个class
    * public class是程序的入口
    * 并且每一个类编译之后都会生成一个.class文件
    */
    class MyClass {
    //属性 成员变量
    String name;
    int age;
    String sex;
    //行为 成员方法
    public void eat() {
    System.out.println("吃饭");
    }
    public void sleep() {
    System.out.println("睡觉");
    }
    public void study() {
    System.out.println("学习");
}

（三）对象的创建使用

1、对象：是一个实实在在存在的个体，是属性的载体，是行为的执行者

2、格式：

类名 对象名 = new 类名();
Scanner sc = new Scanner(System.in);

3、说明：

（1）类名：创建的是哪个类的对象，就写那个类的类名

（2）对象名：就是一个变量名，小驼峰原则，存储的是地址值

（3）=：对象是引用数据类型，所以=是将右侧堆内存中的地址值赋值给对象名

（4）new：只要一看到new，就在堆内存中开辟空间

（5）注意：赋值符号右侧的类名目前为止保持一致

（6）()：目前什么都不写

4、访问属性：

（1）访问：对象名.属性名

（2）修改：对象名.属性名 = 属性值;

5、访问方法：对象名.方法名();

public class Demo01_Class {
    public static void main(String[] args) {
    //类名 对象名 = new 类名();
    Person p1 = new Person();
    /**
    * 4、访问属性：
    * （1）访问：对象名.属性名
    * （2）修改：对象名.属性名 = 属性值;
    * 5、访问方法：对象名.方法名();
    */
    System.out.println(p1.name);
    p1.name = "赵四";
    System.out.println(p1.name);
    p1.eat();
    }
    }
    /**
    * 一个java文件中只能有一个public class，可以有多个class
    * public class是程序的入口
    * 并且每一个类编译之后都会生成一个.class文件
    * 在同一个包下，不能出现同名类名
    */
    class Person {
    //属性 成员变量
    String name;
    int age;
    String sex;
    //行为 成员方法
    public void eat() {
    System.out.println("吃饭");
    }
    public void sleep() {
    System.out.println("睡觉");
    }
    public void study() {
    System.out.println("学习");
}

（四）练习

定义一个汽车类，汽车有名字、颜色、轮胎数、跑，创建对象，测试调用

package com.hqyj.demos;
    public class Demo02_Exercise {
    //调整代码格式：ctrl + alt + L
    public static void main(String[] args) {
    /**
    * 定义一个汽车类，汽车有名字、颜色、轮胎数、跑，创建对象，测试调用
    */
    Car c = new Car();
    c.name = "梅赛德斯奔驰";
    c.color = "黑色";
    c.num = 4;
    System.out.println(c.name + "..." + c.color + "..." + c.num);
    c.run();
    }
    }
    class Car {
    //属性
    String name;
    String color;
    int num;
    //行为
    public void run() {
    System.out.println("汽车跑");
}

二、创建对象的内存理解

（一）创建两个对象的内存图

public class Demo03_Student {
    public static void main(String[] args) {
    Student stu1 = new Student();
    stu1.name = "张无忌";
    stu1.age = 23;
    Student stu2 = new Student();
    stu2.name = "洪七公";
    stu2.age = 60;
    System.out.println(stu1.name + "..." + stu1.age);
    System.out.println(stu2.name + "..." + stu2.age);
    stu1.study();
    stu2.study();
    }
    }
    class Student {
    String name;
    int age;
    public void study() {
    System.out.println(name + "学习");
    }
}

创建步骤：

（1）将要执行的java文件所产生的的class文件加载进方法区，首先加载【public class】修饰的类型

（2）将主方法加载进栈内存，需要创建Student的对象，将student.class文件加载进方法区，并将其中的成员方法以及成员变量加载进来

（3）在主方法中开辟用于存储对象地址值的空间，在堆内存中开辟空间用于存储真正的对象，并且对象包含的成员变量具有默认值，对象隐含一份所属类型的地址值，并将对象的地址值赋值给对象名所在的

空间内（栈中的空间）

（二）两个引用指向同一个对象

public class Demo03_Student {
    public static void main(String[] args) {
    Student stu1 = new Student();
    stu1.name = "张无忌";
    stu1.age = 23;
    Student stu2 = stu1;
    stu2.name = "洪七公";
    stu2.age = 60;
    System.out.println(stu1.name + "..." + stu1.age);
    System.out.println(stu2.name + "..." + stu2.age);
    stu1.study();
    stu2.study();
    }
    }
    class Student {
    String name;
    int age;
    public void study() {
    System.out.println(name + "学习");
    }
}

三、其它内容

（一）成员变量和局部变量的区别

1、成员变量：是一个变量，定义在类中方法外，属于类的成员

2、局部变量：是一个变量，定义在方法中，属于方法的成员，对于类而言他是一个局部变量

3、不同点：

（1）代码层面，定义位置不同

成员变量：定义在类中方法外

局部变量：定义在方法中

（2）内存层面，内存空间不同

成员变量：随着对象创建在堆内存中

局部变量：随着方法创建在栈内存中

（3）内存层面，生命周期不同

成员变量：属于对象，随着对象的加载而加载，随着对象的消亡而消亡

局部变量：属于方法，随着方法的进栈而加载，随着方法的出栈而消亡

（4）初始化状态不同

成员变量：具有默认值

局部变量：必须先赋值后调用

（二）方法的形式参数是引用数据类型

public class Demo04_MethodParamIsAddress {
    //方法的形式参数是引用数据类型
    public static void main(String[] args) {
    //引用数据类型的本质是在操作地址值
    Cell c = new Cell();
    //将创建对象的地址值作为参数列表进行传递，调用方法
    update(c);
    c.show();
    }
    public static void update(Cell ce) {
    ce.name = "华为";
    ce.price = 5999;
    }
    }
    class Cell {
    String name;
    int price;
    public void show() {
    System.out.println(name + "..." + price);
}

（三）方法的返回值类型是引用数据类型

public class Demo05_Phone {
    public static void main(String[] args) {
    Phone p = update();
    p.show();
    }
    public static Phone update() {
    Phone p = new Phone();
    p.name = "小米";
    p.price = 3999;
    return p;
    }
    }
    class Phone {
    String name;
    int price;
    public void show() {
    System.out.println(name + "..." + price);
    }
}

四、匿名对象

1、概述：没有名字的对象

2、定义格式：

new 类名();

3、说明

（1）匿名对象可以赋值，但是没有必要，没有办法去进行调用对应的值

（2）匿名对象在传递的过程中可能会变成有名字的对象

public class Demo06_NoName {
    public static void main(String[] args) {
    /*new Fruit().name = "苹果";
    new Fruit().color = "红色";
    new Fruit().show();*/
    //匿名对象作为参数列表进行传递
    updateOne(new Fruit());
    //匿名对象作为返回值类型
    Fruit f = updateTwo();
    f.name = "西瓜";
    f.color = "红色";
    f.show();
    }
    //匿名对象作为返回值类型 匿名对象在传递的过程中可能会变成有名字的对象
    public static Fruit updateTwo() {
    return new Fruit();
    }
    //匿名对象作为参数列表进行传递 匿名对象在传递的过程中可能会变成有名字的对象
    public static void updateOne(Fruit f) {//Fruit f = new Fruit();
    f.name = "香蕉";
    f.color = "黄色";
    f.show();
    }
    }
    class Fruit {
    String name;
    String color;
    public void show() {
    System.out.println(name + "..." + color);
    }
}

五、Random

1、nextInt(int n)：用于生成0到n之间的随机数，不包括n

2、nextDouble()：返回0.0到1.0之间的随机数，不包含1.0

import java.util.Random;
public class Demo07_Random {
    public static void main(String[] args) {
        Random random = new Random();
        int count = 0;
        for (int i = 0; i < 5000; i++) {
            int dou = (int) (random.nextDouble() * 100) + 1;
            System.out.print(dou + " ");
            count++;
            if (count % 40 == 0) {
                System.out.println();
            }
        }
    }
private static void test() {
    Random r = new Random();
    int count = 0;
    for (int i = 0; i < 10000; i++) {
        int num = r.nextInt(100) + 1;
        System.out.print(num + " ");
        count++;
            if (count % 40 == 0) {
                System.out.println();
            }
        }
    }
}