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

1.构造方法概述和格式

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

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

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

1.

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);
    }
}

 2.3.

public class MyTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Dog dog1 = new Dog(20);
    }
}

class Dog {
    public Dog() {
    }

    //一旦你手动写出了有参构造，那么默认的无参构造方法，就没有了，如果说你还想用空参构造创建对象，建议你手动写出来
    public Dog(int num) {

    }
}

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

1.完善一下学生类
2.给成员变量赋值：
    a:setXxx()方法
    b:构造方法
3.输出成员变量值的方式：
    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.一个标准手机类的代码及测试

模仿学生类，完成手机类代码

public class MyTest {
    public static void main(String[] args) {
        Phone p1=new Phone();
        p1.setName("小米");
        p1.setPrice(5555.0);
        System.out.println(p1.getName());
        System.out.println(p1.getPrice());
        System.out.println("======================");
        Phone p2=new Phone("华为",6666.0);
        System.out.println(p2.getName());
        System.out.println(p2.getPrice());

    }
}
class Phone {
    private String name;
    private double price;

    public Phone(){
        System.out.println("空参方法调用了");
    }

    public Phone(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

 有参构造快速生成方法：

5.创建一个对象的步骤

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

public class MyTest {
    public static void main(String[] args) {
        Student s = new Student("王五", 36);
    }
}

class Student {
    private String name = "张三";
    private int age = 23;

    public Student() {
    }

    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;
    }
}

6.长方形案例练习

    需求：
        定义一个长方形(Rectangle)类,定义求周长(length)和面积(area)的方法,
        然后定义一个测试类Test，进行测试。

Rectangle类：

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);
    }
}

7.static关键字的引入

通过一个案例引入static关键字。
人类：Person。每个人都有国籍，中国。
带有static的内存图

public class MyTest {
    public static void main(String[] args) {
        //这3个对象国籍是一样的，我就想把这个国籍这个数据，设置为公共数据，让所有对象共享这个一份数据。
        Person.guoji = "法国";
        Person p1 = new Person();
        p1.name = "张三";
        //p1.guoji = "美国";

        Person p2 = new Person();
        p2.name = "李四";
        //p2.guoji = "日本";

        Person p3 = new Person();
        p3.name = "王五";
        //p3.guoji = "英国";

        System.out.println(p1.name);
        //System.out.println(p1.guoji);

        System.out.println("==============================");
        System.out.println(p2.name);
        // System.out.println(p2.guoji);

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

        System.out.println(p3.name);
        //System.out.println(p3.guoji);

        System.out.println(Person.guoji);
    }
}

class Person {
    public String name;
    //static 静态的，可以修饰成员方法，和成员变量，
    // 修饰成员变量，此变量为共享变量，被该类的所有对象所共享。
    public static String guoji = "中国";
}

8.static关键字的特点

1.static关键字的特点
    a:随着类的加载而加载
    b:优先于对象存在
    c:被类的所有对象共享
        举例：咱们班级的学生应该共用同一个班级编号。
        其实这个特点也是在告诉我们什么时候使用静态?
            如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
        举例：
            饮水机(用静态修饰)
            水杯(不能用静态修饰)
    d:可以通过类名调用
        其实它本身也可以通过对象名调用。
        推荐使用类名调用。
        静态修饰的内容一般我们称其为：与类相关的，类成员
2.案例演示
    static关键字的特点

9.static的注意事项

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

学生类：

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;

    }
}

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

public class MyTest {
    private int num = 100;
    static int cc = 20;

    //主方法静态修饰的
    public static void main(String[] args) {
        // show();
        MyTest myTest = new MyTest();
        myTest.show();
        System.out.println(myTest.num);
        //System.out.println(num);
        System.out.println(cc);


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

    public void show() {
        System.out.println("show");
    }
}

主方法 为什么 有 public static 修饰符

public class MyTest2 {
    //主方法 为什么 有 public static 修饰符
    //JVM 来调用主方法 方法的权限修饰符要public
    //主方法 static 来修饰 JVM调用方便，不要需要创建入口类的对象，而去调用主方法。
    public static void main(String[] args) {

    }
}

10.静态变量和成员变量的区别

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

之前学习的Scanner也是一个类
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();

11.如何使用JDK提供的帮助文档

1.找到文档，打开文档
2.点击显示，找到索引，出现输入框
3.你应该知道你找谁?举例：Scanner
4.看这个类的结构(需不需要导包)
    java.lang包下的内容不需要我们手动导入
    其它包下的内容需要我们手动导入
    类                        API文档
        成员变量                字段摘要
        构造方法                构造方法摘要
        成员方法                方法摘要
5.看这个类的说明(简单的了解一下)
6.看开始版本
G:看构造方法
7.看成员方法
    看左边:
        是否是static的,如果是我们就不需要创建对象,直接可以使用类名调用该方法;看返回值,返回值是什么我就使用什么接收
    看右边:
        看参数列表: 参数的个数 , 参数的类型 ; 要什么参数我是用的时候,就传递什么参数                    
8.然后使用

获取 1--100 之间的随机整数中的100.

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 < 10000; i++) {
            int num = (int) (Math.random() * 100 + 1);
            if (num == 100) {
                System.out.println(num);
            }
            //System.out.println(num);
        }

    }
}

12.猜数字小游戏案例

需求：猜数字小游戏(数据在1-100之间)

public class MyTest3 {
    public static void main(String[] args) {
        //猜数字小游戏
        int num = (int) (Math.random() * 100 + 1);
        while (true) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请猜一个1--100之间的数字");
            int userNum = sc.nextInt();
            if (userNum > num) {
                System.out.println("猜大了");
            } else if (userNum < num) {
                System.out.println("猜小了");
            } else {
                System.out.println("恭喜你！猜对了！");
                break;
            }
        }

    }
}