7、面向对象（构造方法、对象的创建、static关键字、帮助文档、Math类的随机数功能）

1、构造方法概述和格式

A:构造方法概述和作用
    创建对象,给对象中的成员进行初始化
B:构造方法格式特点
    a:方法名与类名相同
    b:没有返回值类型，连void都没有
    c:没有具体的返回值

2、构造方法的重载及注意事项

A:案例演示
    构造方法的重载
B:构造方法注意事项
    a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
    b:如果我们给出了有参数构造方法，系统将不再提供默认的无参构造方法。
        注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
C:给成员变量赋值的两种方式
    a:setXxx()方法
    b:构造方法
 

public class MyTest {
    public static void main(String[] args) {
        //创建一个类的实例 ，要使用 new 这个关键字
        //我们创建一个类的实例，要使用 new  关键字 调用构造方法来完成类的实例化的。
        //构造方法的作用：用来对类进行实例化，完成类的数据的初始化。

        Person person = new Person();
        //借助有参构造来创建对象
        Person person1 = new Person("呵呵");

        Person person2 = new Person("哈哈", 20);

    }
}


class Person {
    //当你自定义的类，里面默认就存在一个空参的构造方法。
    //构造方法的语法：方法名和类名相同，没有返回值类型，连void 也没有
    //一旦你手动写出了有参构造，那么默认的无参构造方法，就没有了，如果说你还想用空参构造创建对象，建议你手动写出来
    public Person() {
        System.out.println("空参构造调用了");
    }

    //构造方法也可以重载
    public Person(String name) {
        System.out.println("一个参数的构造方法调用了" + name);
    }

    public Person(String name, int age) {
        System.out.println("两个参数的构造方法调用了" + name + "====" + age);
    }
}

3、一个标准学生类的代码及测试

A:案例演示
    完善一下我们的学生的类
B:给成员变量赋值：
    a:setXxx()方法
    b:构造方法
C:输出成员变量值的方式：
    a:通过getXxx()分别获取然后拼接
    b:通过调用show()方法搞定

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

    public Student() {
        System.out.println("空参构造调用了");
    }

    public Student(String name, int age) {
        //给成员变量赋值
        this.name = name;
        this.age = 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;
    }
}

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("王老虎");
        student.setAge(20);
        System.out.println(student.getName());
        System.out.println(student.getAge());
        System.out.println("===========================");
        Student student1 = new Student("王百万", 30);
        System.out.println(student1.getName());
        System.out.println(student1.getAge());

        //类的构成：构造方法，成员变量，成员方法。

    }
}

4、创建一个对象的步骤

A:画图演示
    画图说明一个对象的创建过程做了哪些事情?
    Student s = new Student();
步骤:
    (1):加载Student.class文件进内存
    (2):在栈内存为s开辟空间
    (3):在堆内存为学生对象开辟空间
    (4):对学生对象的成员变量进行默认初始化
    (5):对学生对象的成员变量进行显示初始化
    (6):通过构造方法对学生对象的成员变量赋值
    (7):学生对象初始化完毕，把对象地址赋值给s变量

5、长方形案例练习

public class Rectangle {
    //属性
    private double width;
    private double height;

    public Rectangle() {
    }

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    //定义获取面积的方法
    public double getArea() {
        return this.height * this.width;
    }

    public double getPerimeter() {
        return (height + width) * 2;
    }
}

public class MyTest {
    public static void main(String[] args) {
        //使用空参构造来创建对象
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(60);
        rectangle.setHeight(30);
        double area = rectangle.getArea();
        double perimeter = rectangle.getPerimeter();
        System.out.println("面积是：" + area);
        System.out.println("周长是：" + perimeter);
        System.out.println("================================");
        Rectangle rectangle1 = new Rectangle(50, 25);
        double area1 = rectangle1.getArea();
        double perimeter1 = rectangle1.getPerimeter();
        System.out.println("面积是：" + area1);
        System.out.println("周长是：" + perimeter1);
    }
}

6、static的内存图解

7、static关键字的特点

static关键字的特点
    a:随着类的加载而加载
    b:优先于对象存在

    c:被类的所有对象共享

class Student {
    int age = 20;
    public static double sal = 50;

    //在非静态方法里面，既可以访问静态的变量，也可以访问非静态变量。
    public void show() {
        System.out.println(age);
        System.out.println(sal);
    }

    //静态方法里面，访问非静态变量，访问不到
    //被静态所修饰的成员：是随着类的加载而加载，是优先于对象而存在的。
    //age是实例变量，他是创建对象的时候，才初始化的，我们的静态方法，随着类的加载而加载，他要访问后来才有的，是访问不到
    //所以在静态方法里面，只能访问到，静态变量，访问不到非静态变量
    public static void test() {
        //System.out.println(age);
        System.out.println(sal);
    }

    public void haha() {
        show();
        show2();
        System.out.println(this);
    }

    //静态方法里面，不能存在this关键字
    //被静态所修饰的成员：是随着类的加载而加载，是优先于对象而存在的。
    public static void show2() {
        //this 代表一个对象。 静态所修饰的，优先于对象而存在的。所以访问不到this
        //System.out.println(this);
    }

    //静态访问里面，只能访问静态成员。
    public static void hehe() {
        //haha();
        show2();
    }
}

可以通过类名调用
        其实它本身也可以通过对象名调用。
        推荐使用类名调用。
        静态修饰的内容一般我们称其为：与类相关的，类成员 

public class MyTest {
    public static void main(String[] args) {
        //被静态所修饰的成员：是随着类的加载而加载，是优先于对象而存在的。
        //被静态所修饰的成员是属于类的，静态的成员我们推荐使用类名调用，而不需要对象名调用，当然可以调用，只是不推荐

        //静态成员，我们推荐使用类名调用。
        Student.show2();
        Student.hehe();
        Student.test();
        double sal = Student.sal;

    }
}

8、static的注意事项

static的注意事项
    a:在静态方法中是没有this关键字的
        如何理解呢?
            静态是随着类的加载而加载，this是随着对象的创建而存在。
            静态比对象先存在。
    b:静态方法只能访问静态的成员变量和静态的成员方法
    简单记：静态只能访问静态,非静态可以访问静态的也可以访问非静态的

* 入口类（有main方法的这个类）他只是作为一个程序的入口，这个入口的这个类中，我们调用其他类中的属性和方法。
* 所以，我们一般不会在入口类中，定义其他的成员方法和成员变量。

//主方法 为什么 有 public static 修饰符
//JVM 来调用主方法 方法的权限修饰符要public
//主方法 static 来修饰 JVM调用方便，不要需要创建入口类的对象，而去调用主方法。

9、静态变量和成员变量的区别

A:所属不同
    静态变量属于类，所以也称为类变量
    成员变量属于对象，所以也称为实例变量(对象变量)
B:内存中位置不同
    静态变量存储于方法区的静态区，JDK1.7之后静态变量存储在堆内存中
    成员变量存储于堆内存
C:内存出现时间不同
    静态变量随着类的加载而加载，随着类的消失而消失
    成员变量随着对象的创建而存在，随着对象的消失而消失
D:调用不同
    静态变量可以通过类名调用，也可以通过对象调用,推荐使用类名调用
    成员变量只能通过对象名调用

10、学习Math类的随机数功能

打开JDK提供的帮助文档学习
A:Math类概述
    类包含用于执行基本数学运算的方法
B:Math类特点
    由于Math类在java.lang包下，所以不需要导包。
    没有构造方法，因为它的成员全部是静态的。
C:获取随机数的方法
    public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0

D:如何获取一个1-100之间的随机数
    int number = (int)(Math.random()*100)+1;
 

public class MyTest2 {
    public static void main(String[] args) {
        //Math Java提供的一个类， 包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
        //Math 类中的成员全是static修饰的，那也就是说，我们不用创建对象，使用类名就可以调用。
        // new Math(); Math 类的空参构造被私有了，你不能new对象。
        // random()
        //           返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
        //生成随机小数 范围 0---1之间

     /*   for (int i = 0; i < 100; i++) {
            double num = Math.random();
            System.out.println(num);

        }*/
        System.out.println("===============================");
        //我想用获取 1--100 之间的随机整数。变通一下  random()

        // 0.235252525*100+1
        //  0.999998*100+1
        for (int i = 0; i < 100; i++) {
            int num = (int) (Math.random() * 100 + 1);

                System.out.println(num);
            
            //System.out.println(num);
        }

    }
}