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

最新推荐文章于 2022-01-21 08:01:51 发布

qq_44725165

最新推荐文章于 2022-01-21 08:01:51 发布

阅读量223

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/qq_44725165/article/details/102335391

版权

Java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

文章目录

构造方法
对象的创建步骤
- 创建一个对象的步骤
面向对象的练习
- 长方形案例练习
static关键字
帮助文档
- 如何使用JDK提供的帮助文档
Math类的随机数功能
猜数字小游戏案例

复习

package org.westos.demo;
import java.util.Scanner;
public class MyTest {
    public static void main(String[] args) {
        //二维数组：数组元素是一维数组的数组
        int[][] arr = new int[3][];//定义了长度为3的二维数组，元素的默认值 null（因为根本没有初始化一维数组）
        int[][] arr2 = new int[3][2];//定义了长度为3的二维数组，会初始化3个一维数组，3个一维数组的初始值是0
        //arr[1][1] 式子取值赋值都可以
        int[][] arr3 = {{20}, {1}, {4}};//静态初始化的简写 直接赋值写数据就行
        System.out.println(arr3.length);  //打印数组长度 arr3.length

        //遇到错误：解决问题能力  可以分段注释看报错情况

        //递归：Java中指的是：在方法中调用方法本身的现象
        //递归：要有出口，递归次数不能过多
        //递归体现的思想；拆分合并的思想

        //面向对象：new 对象  ；  调方法
        //类：体现的就是一种封装的思想，封装 属性和功能  class{}
        //类是抽象的概念，使用这个类，要对这个类进行实例化，所谓实例化就是用new创建该类对象
        //这个对象，才是该类的一个具体表现
        //例如Student stu=new Student()
        //stu.属性   stu.功能()  //可以调用对象的属性和方法 //不管功能内部怎么封装的 我把它拿来传参 拿来用就行
        /*Scanner scanner = new Scanner (System.in);
        //scanner.nextInt(); */ //Scanner这个类是别人写的 你只要关心拿到之后调nextInt方法 怎么用就行
        //内存图
        //成员变量：在类中方法外     局部变量：在方法定义中或者方法声明上

        //参数的传递：基本类型的传递 值传递 形参的改变不影响实参
        //引用类型的传递：传递对象（地址值）形参的改变会影响实参

        //如果你以后看到一个方法的形参要一个 类 类型 你就传该类的一个对象
        //匿名对象  没有名字构造对象
        //private 私有的 权限修饰符 修饰成员变量和成员方法 被修饰的成员只能在本类中访问
        //public（公共的）      private（私有的）
        //一般情况我们都会把 成员变量私有掉 提供公共的get set 方法
        /*setAge(int age){
            this.age=age } */    
        //this 代表本类的一个引用，或者你理解为本类的一个对象，哪个对象调用这个方法，这个方法中的this 他就代表谁
    }
}

复习

        //构造方法：我们要对一个类进行实例化，必须借助构造方法
        //自定义的类，默认存在无参构造
        //语法：权限修饰符 构造方法名和类名相同(参数类型 参数名){}

        //如果你给出了有参构造，默认无参构造方法就没有了
        //建议你手动给出无参构造
        //借助有参构造给该对象成员变量赋值

        //static 状态修饰符：修饰成员变量和成员方法。修饰成员变量后，此变量为共享变量 存在方法区的静态区
        //被静态所修饰的成员，随着类的加载而加载，只加载一次
        // 静态方法里面，只能访问静态所修饰的成员  静态方法里面不能出现this
        //非静态的方法，既可以访问静态的又可以访问非静态的

构造方法

构造方法概述和格式

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

举例 (Student)

package org.westos.demo;

public class Student {
    //成员变量 成员属性
    //权限修饰符: public 公共的 可以修饰成员变量，成员方法，类，被他所修饰的可以在任意的地方访问到
    //权限修饰符有四个: public > protected受保护的 >缺省的（默认的）>private
    private String name; //private私有化
    private int age;

    //类，是一个抽象的概念，不能直接使用，要使用类中的属性和功能，必须对类进行实例化
    //我们在创建对象时，除了使用关键字new之外，还有 调用构造方法 来 完成对类的实例化
    //构造方法的语法：方法名跟类名相同, 没有返回值，连void 也没有 //(类叫Student 方法名也叫Student)

    //我们自定义的类，默认存在一个空参构造方法 “public Student(){}” 不写它也存在
    public Student(){    //调用方法 作用  完成对类的实例化
        System.out.println("空参的构造方法调用了");
    }
    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;
    }
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        Student student = new.Student();//第一次new 第一次调用“public Student(){System.out.println("..");}”
       
        student.setName("张三");//间接访问 private String name;
        student.setAge(100);
        System.out.println(student.getName());
        System.out.println(student.getAge());

        System.out.println("-----------------------------");
        //我们在创建对象时，除了使用关键字new之外，还有 调用构造方法 来 完成对类的实例化
        new.Student();//第二次new 第二次调用“public Student(){System.out.println(".."); }”
         //这个构造方法括号()里面没有参数 所以现在调用的是空参构造
         //即在Student.java中自定义的类里面 默认存在一个空参构造 不写它也有
        
        //每一次new创建对象 都要调用空参来构造方法 从而完成对类的一个实例化
    }
}

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

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

package org.westos.demo;

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

    public Teacher(){    //默认存在的空参构造 public Teacher(){}  //不写也存在
    //默认存在时里面没有逻辑 你可以自己写 比如写“System.out.println("空参构造调用了");”
        System.out.println("空参构造调用了");
    }//如果这个空参构造调不到  那类是无法实例化的 
    //什么时候调不到呢？变成"private Teacher(){}"私有化构造的时候 
    //我有一个类 不想让别人new我这个类的时候就可以private私有化
    
    //构造方法的重载
    public Teacher(String name) {
        System.out.println("一个参数的构造调用了"+name);//(String name) 一个参数
    }
    public Teacher(String name,int age) {
        System.out.println("两个参数的构造调用了" + name+"==="+age);//(String name,int 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;
    }
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        //借助空参构造，来创建该类对象
       Teacher teacher = new Teacher();//空参构造调用了
       
        //使用有参构造来创建对象
        Teacher teacher1 = new Teacher("zhansan");//打印出：一个参数的构造调用了zhansan
        Teacher teacher2 = new Teacher("wangwu", 25);//打印出：两个参数的构造调用了wangwu=====25
    }
}

举例 (Dog)

package org.westos.demo;

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

    //手动写出无参构造
    public Dog(){}

    //如果你手动给出了一个有参构造，那么默认无参构造就没有了  //如果你还想使用无参构造创建对象，为了不报错，建议你手动写出无参构造
    public Dog(int 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;
    }
}

package org.westos.demo;

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

举例 (Cat)

package org.westos.demo;

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

    public Cat(){        //无参构造 调用
        System.out.println("无参构造调用了");
    }
    public Cat(String name,int age){       //有参构造 调用
        System.out.println("有参构造调用了"+name+"==="+age);
        this.name=name;//this代表new的对象在调用  //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;
    }
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat(); //无参构造 调用

        //1.无参构造中 借助set方法 给成员变量 设置值
        cat.setName("汤姆");
        cat.setAge(20);
        System.out.println(cat.getName());
        System.out.println(cat.getAge());
        System.out.println("-----------------------");

        //2.采用有参构造 给成员变量 设置值
        Cat cat1 = new Cat("加菲猫", 2);//构造方法 打印出 ：有参构造调用了加菲猫===2
        //想要将传过来的两个数据 “ ("加菲猫", 2) ” 设给我new的对象 想让传过来之后给成员变量设值
        System.out.println(cat1.getName());
        /*如果  有参构造 “public Cat(String name,int age){}”  中没有“this.name=name;”这行语句给成员变量设过值 
        也没有调过set方法 
        那么就会没有值 就会打印出 ：null     */
        System.out.println(cat1.getAge());//同理 如果有参构造中没设值就会打印出 ：0
    }
}

举例 (Tiger)

package org.westos.demo;

//类的构成；成员变量，构造方法，成员方法
public class Tiger {
    private String name="小老虎";  //成员变量
    private int age; //成员变量

    //构造方法//无参构造 鼠标右键 弹出窗口里选择Generate 点击Constructor 弹出的窗口下方点击Select None
    public Tiger() {
    }

    //构造方法//有参构造 鼠标右键 弹出窗口里选择Generate 点击Constructor 然后Ctrl+A全选name：String和age：int
    public Tiger(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
 //成员方法//成员方法getset 鼠标右键弹出窗口选择Generate 点击Getter and Setter 然后Ctrl+A全选name：String和age：int
    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;
    }
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        Tiger tiger = new Tiger();//new 采用无参构造 来设置对象 //无参构造调值 只能采用 get set 方法去设
        tiger.setName("老虎");
        tiger.setAge(20);

       Tiger tiger1 = new Tiger("东北虎", 20);//new 采用有参构造 来设置对象 //有参构造调值 在构造方法中调值
        System.out.println(tiger1.getName());
        System.out.println(tiger1.getAge());
    }
}

一个标准学生类的代码

完善学生的类

给成员变量赋值：
a:setXxx()方法
b:构造方法
输出成员变量值的方式：
a:通过getXxx()分别获取然后拼接
b:通过调用show()方法搞定

对象的创建步骤

创建一个对象的步骤

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

面向对象的练习

长方形案例练习

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

package org.westos.demo;

public class Rectangle {
    //成员属性
    private double width;
    private double height;
    
    //提供无参，有参构造
    
    public Rectangle() {
    }
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    //提供get set 方法

    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 getLength() {    //已经定义属性了 宽高就不需要传参
        return (this.width + this.height) * 2; //这是对象的属性 肯定要对象来调 this肯定有 不写也有
    }

    //提供获取面积的方法
    
    public double getArea() {
        return height * width; //前面也有this 没显示出来而已
    }
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();//通过空参构造 调set方法进行设值
        rectangle.setWidth(20);
        rectangle.setHeight(30);
        double area = rectangle.getArea();
        double length = rectangle.getLength();
        
        System.out.println("面积是："+area);
        System.out.println("周长是："+length);

        System.out.println("--------------------------");
        Rectangle rectangle1 = new Rectangle(60, 30);//通过有参构造 在new这个对象时 已经把宽高传过去了
        double area1 = rectangle1.getArea();
        double length1 = rectangle1.getLength();

        System.out.println("面积是：" + area1);
        System.out.println("周长是：" + length1);
    }
}
//别人封装好后 作为使用者我只调用 不关心他是怎么求周长求面积的  我只要 new对象 调方法 传数据 就行 ---> 面向对象

static关键字

static关键字的引入

案例演示
通过一个案例引入static关键字。
人类：Person。每个人都有国籍，中国。

package org.westos.demo;

public class Person {
    public String name; //实例变量 只能用对象去调
    public static  String guoji="中国"; //类变量 还可以用类名调   不推荐用对象调
     //static 静态的：可以修饰成员变量，成员方法，修饰成员变量，此变量就变成了共享变量
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        //如果 三个人名字不同 但是p2.guoji="中国";p2.guoji="中国";p3.guoji="中国";三个人国籍都是中国
        //想把"中国"这个数据，设置成共享数据，让多个对象，去共享这个数据
        //public String guoji = "中国";变成public static String guoji = "中国";  加了static
        
        Person.guoji="英国"; //想再变成英国 不用使用实例去调 直接类名去调 三个人全变成英国
        //被静态所修饰的成员，属于类的 推荐使用 类名直接调用 
        //被static所修饰的成员变量，我们称之为类变量
        
        Person p1 = new Person();
        p1.name = "张三";// public String name;公共的就可以直接p1.name = ".."这样设
       // p1.guoji = "中国"; // 如果变成 p1.guoji = "美国"; 由于加了static 三个人国籍就都是美国 可以画内存图理解
        
        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(p2.name);
        System.out.println(p2.guoji);
        System.out.println(p3.name);
        System.out.println(p3.guoji);
    }
}

static的内存图解

画图演示: 带有static的内存图

static关键字的特点

static关键字的特点
a:随着类的加载而加载 //字节码文件得初始化被修饰的东西所以类进内存 static就得执行
b:优先于对象存在 //对象是后来才new出来的
c:被类的所有对象共享
举例：咱们班级的学生应该共用同一个班级编号。//这个编号就是被共享的
其实这个特点也是在告诉我们什么时候使用静态?
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
举例：
饮水机(用静态修饰) //饮水机被共享
水杯(不能用静态修饰) //每人一个水杯不共享
d:可以通过类名调用
其实它本身也可以通过对象名调用。
推荐使用类名调用。
静态修饰的内容一般我们称其为：与类相关的，类成员

package org.westos.demo;

public class Cat {
    public String name; //实例变量
    public static int num = 20;  //static 方法区的静态区 被类的所有对象所共享 //类变量

    //实例方法：非静态方法
    public void test() {
        System.out.println("这是一个非静态的test方法");
        //非静态的方法，既能访问静态的，也能访问非静态的
        System.out.println(name);
        System.out.println(num);
    }

    //静态方法：静态方法只能访问静态的，不能访问非静态的
    public static void show() {    //static
        System.out.println("这是一个静态的show方法");
        //System.out.println(name);  访问不到name 为什么呢
        /* 这是加载时机的问题 被静态所修饰的成员，随着类的加载而加载  加载时机早
        实例变量创建对象的时候才存在，是后来才有的
        被static修饰的show()方法随类的加载而加载 而name是实例变量创建对象new的时候才存在的 
        但是现在这个静态的方法一进来就要拿name的值 肯定拿不到 */
        // 先来的肯定找不到后来的
        // System.out.println(name);
        System.out.println(num);
    }

    public void test2() {
        //方法中有一个隐藏的对象this
        this.test();//在test2()方法里面 对象调下test()方法// 实例方法可以访问非静态方法
    }

    //在静态方法里面，不能出现this this也是代表一个对象，对象是后来才有的
    public static void test3() {
        //方法中有一个隐藏的对象this 对象是后来才有的 static里面不能出现this
        // this.test(); //报错  //静态方法不能访问非静态的
        Cat.show();// 静态方法只能访问静态的 //前面是 类Cat 而不是 对象this
    }

    //静态只能访问静态的；非静态的既能访问静态的，又能访问非静态的
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        //被静态所修饰的成员，他是属于类，随着类的加载，而加载，优先于对象存在，推荐使用类名调用
        org.westos.demo.Cat.num = 200;
        org.westos.demo.Cat.show();
        Cat cat = new Cat();
        cat.test(); //实例方法 用对象调
        System.out.println(org.westos.demo.Cat.num);
        System.out.println(cat.num);
    }
}

package org.westos.demo;

public class MyTest2 {
    static int num = 100;//MyTest2测试类里面可以定义成员变量 它需要一个入口

    public static void main(String[] args) {
    //为什么设计主函数是public为什么是static  
    //首先public公共的 主函数不能让私有 私有的话JVM就调不了肯定要设置成公共的 
    //其次static静态的 JVM不需要去new这个对象MyTest2 JVM想直接调主方法
    //因为字节码一进来信息就有了 就直接调主方法了 这属于入口的一个特点
        // this.test2(); //静态方法里面不能存在this

        test();//主方法被static修饰 静态的只能访问静态的 所以能调test() 不能调test2()
        // test2(); //调不到test2()

        MyTest2 myTest2 = new MyTest2();
        myTest2.test2();//拿myTest2来调test2()方法
        System.out.println(myTest2.num); 
        //如果前面是int num = 100;也可以拿实例去访问num 
        //从System.out.println(num);变为System.out.println(myTest2.num);就可以访问到了
        System.out.println(num);
       //如果前面是int num = 100; num是个实例变量 没有拿静态修饰 但主方法是静态 现在加个static 
       //变为static int num = 100;就可以访问到了
        int num = MyTest2.num;//拿类名MyTest2就可以调用到实例变量 //推荐使用类名调用
     //如果test2()方法不加static还想被主方法调到 就拿实例来调 new MyTest2()
    }

    public static void test() {
    //不加static也不会报错 但是因为我们现在想在主方法里面调test() 所以加上
    }

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

static的注意事项

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

java里为什么主函数前面要加static修饰

先说一下static
1.static 修饰的域，我们叫静态域，它是归类所有的，被所有对象所共享，只有一个
2.static修饰的区块，域只会初始化一次
3.static修饰的域或方法，可以直接通过类的名字加上.进行调用
4.static修饰的方法内不能直接使用非静态成员
static关键字，告知编译器main函数是一个静态函数。也就是说main函数中的代码是存储在静态存储区的，静态方法在内存中的位置是固定的，即当定义了类以后这段代码就已经存在了。如果main()方法没有使用static修饰符，那么编译不会出错，但是如果你试图执行该程序将会报错，提示main()方法不存在。因为包含main()的类并没有实例化（即没有这个类的对象），所以其main()方法也不会存。而使用static修饰符则表示该方法是静态的，不需要实例化即可使用。
main方法是一个程序的入口，如果写成非静态的，那么就必须实例化一个对象再来调用它，既然是入口这样肯定是不可以的；静态方法是属于类的，直接用类名就可以调用
static方法不需要创建对象可以直接访问这样main方法就不需要做特殊处理
static方法在静态数据区中，这样就可以直接调用不需要每次调用都要重新生成。
静态函数在调用时不用实例化
静态,一上来就装入内存
main函数其实也是所在类的一个方法，就比如一个类是test，那么该类的main其实就是test.main(String[] args)，众所周知如果一个方法不是静态的，则要先实例化该类，比如要这样 test t=new test(); 然后才能调用 test.main();
而这对于运行一个程序的主函数来说是不现实的，所以比如把main函数定义为static，使test.main()可以直接被调用。
因为main就是这个类的主函数,入口,如果每次进这个入口的时候再去实例话然后再去调用这个入口方法,就很罗嗦。
注：以上很多事网上查来的，最精彩的解答是在csdn上，一个问题引发的深邃的回答，最后亚里士多德都出来了，有兴趣的围观吧http://bbs.csdn.net/topics/200084223。

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

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

        //局部变量和成员变量的区别？成员变量：在类中方法外   局部变量：在方法定义中或者方法声明上
        //静态变量和成员变量的区别？
        //静态变量：存储在方法区的静态区，
        //成员变量：存储在堆内存
        //静态变量：随着类的加载的加载，随着类的消失而消失
        //成员变量：随着对象的创建而产生，随着对象的回收而消失
        //静态变量属于类，我们也叫做类变量；成员变量属于对象，也叫做实例变量

帮助文档

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

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

//我们可以通过官方提供的文档，去学习Java的常用类
//JDK1.8  JDk1.6

//Scanner在电脑中 C:\Program Files\Java\jdk1.8.0_212\jre\lib 中rt.jar这个压缩包中
//打开rt.jar这个压缩包 进入sun文件 进入util文件 里面能找到Scanner.class这个CLASS文件 
//这是个字节码文件 因为你只要用它的字节码就行 不需要重新编译 
//当你要用Scanner时 JVM就会加载这个类进内存执行

//java.lang 这个包下的类不要import导入

Math类的随机数功能

打开JDK提供的帮助文档学习

Math类概述
类包含用于执行基本数学运算的方法
Math类特点
由于Math类在java.lang包下，所以不需要导包。
没有构造方法，因为它的成员全部是静态的。
获取随机数的方法
public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
我要获取一个1-100之间的随机数，肿么办?
int number = (int)(Math.random()*100)+1;

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
// Math 类里面没有提供构造方法:因为它里面的成员变量和成员方法，都是静态static修饰的
//直接可以使用类名调用，所以没有必要new对象
        
        //Math类里面的一个静态方法:random，可以生成随机小数
        double num = Math.random();//生成 随机数范围在 0----1之间 的小数
        System.out.println(num);

     //需求：我现在想要生成随机整数 范围 1---100 包含1和100；//将方法random改造一下
        for (int i = 0; i < 100; i++) {
            int num2 = (int) (Math.random() * 100 + 1);
//Math.random()是0点几几几...的数（0----1之间的随机小数） 
//乘上100变为0点几几几到99点几几几 加1变成1点几几几到100点几几几
//再强转为整型int把小数点后面的都舍弃 就随机生成了包含1 100 在内的1---100随机整数
            System.out.println(num2);
        }
    }
}

猜数字小游戏案例

案例演示: 需求：猜数字小游戏(数据在1-100之间)

//生成一个随机数 让用户来猜这个随机数
package org.westos.demo;

import java.util.Scanner;

public class GuessNumberGame {
    public static void main(String[] args) {
        int num = (int) (Math.random() * 100 + 1);
        Scanner scanner = new Scanner(System.in);
        
        while (true){  
    //不知道用户猜几次会猜对 用while循环 //如果知道循环几次 用for循环
            System.out.println("请输入一个整数 范围1---100，包含1和100");
            int userNum = scanner.nextInt();果
            
            if (userNum > num) {
                System.out.println("猜大了");
            } else if (userNum < num) {
                System.out.println("猜小了");
            } else if (userNum == num) {
                System.out.println("恭喜你猜对了");
                break; //要给个结束条件 不能成为死循环
            }
            
        }
    }
}

//给五次猜数字的机会
package org.westos.demo;

import java.util.Scanner;

public class GuessNumberGame {
    public static void main(String[] args) {
        
        int num = (int) (Math.random() * 100 + 1);
        Scanner scanner = new Scanner(System.in);
        
        for (int i = 1; i <= 5; i++) {  //循环5次 
            System.out.println("请输入一个整数 范围1---100，包含1和100");
            int userNum = scanner.nextInt();
            
            if (userNum > num) {
                System.out.println("猜大了");
            } else if (userNum < num) {
                System.out.println("猜小了");
            } else if (userNum == num) {
                System.out.println("恭喜你猜对了");
                break;
            }
            //没进入break说明还没猜对 可以把关于剩余次数的代码放在下面即可
            if((5 - i)>0){ //提示剩余次数
                System.out.println("你还剩余：" + (5 - i) + " 次机会");
            }else{
                System.out.println("Game Over");
            }
        }
    }
}

qq_44725165

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
12 面对对象（构造方法；对象的创建步骤；面向对象的练习；static关键字；帮助文档；Math类的随机数功能）

文章目录构造方法构造方法概述和格式构造方法的重载及注意事项一个标准学生类的代码及测试一个标准手机类的代码及测试对象的创建步骤创建一个对象的步骤面向对象的练习长方形案例练习员工类案例练习static关键字static关键字的引入static的内存图解static关键字的特点static的注意事项静态变量和成员变量的区别帮助文档如何使用JDK提供的帮助文档Math类的随机数功能猜数字小游戏案例复习...
复制链接

扫一扫