java练习-对象03

1.面向对象的练习 01

1.1学生类的使用

在一个java文件中写两个类:一个基本的类,一个测试类。
注意:文件名称和测试类名称一致。

如何使用呢?
	创建对象使用。
	
如何创建对象呢? 
	格式:类名 对象名 = new 类名();
	
如何使用成员变量呢?
	对象名.变量名
如何使用成员方法呢?
	对象名.方法名(...)

package cn.plsite.day04.demo03;

public class StudentDemo {
    public static void main(String[] args) {
        Student st = new Student();
        st.name = "小明";
        st.eat(st);
        st.sleep();
    }
}

package cn.plsite.day04.demo03;

public class StudentDemo {
    public static void main(String[] args) {
        Student st = new Student();
        st.name = "小明";
        st.eat(st);
        st.sleep();
    }
}

答案：

//这是学生类
class Student {
	//姓名
	String name; //null
	//年龄
	int age; //0
	//地址
	String address; //null
	
	//学习
	public void study() {
		System.out.println("学生爱学习");
	}
	
	//吃饭
	public void eat() {
		System.out.println("学习饿了,要吃饭");
	}
	
	//睡觉
	public void sleep() {
		System.out.println("学习累了,要睡觉");
	}
}

//这是学生测试类
class StudentDemo {
	public static void main(String[] args) {
		//类名对象名 = new 类名();
		Student s = new Student();
		
		//输出成员变量值
		//System.out.println(s.name);
		//System.out.println(s.age);
		//System.out.println(s.address);
		//改进写法
		System.out.println(s.name+"---"+s.age+"---"+s.address);
		
		
		//给成员变量赋值
		s.name = "林青霞";
		s.age = 27;
		s.address = "北京";
		//赋值后的输出
		System.out.println(s.name+"---"+s.age+"---"+s.address);
		
		//调用方法
		s.study();
		s.eat();
		s.sleep();
	}
}

---

1.2面向对象(成员变量和局部变量的区别).

成员变量和局部变量的区别?
	A:在类中的位置不同
		成员变量:在类中方法外 			
		局部变量:在方法定义中或者方法声明上
	B:在内存中的位置不同
		成员变量:在堆内存(属于对象,进堆内存)
		局部变量:在栈内存(属于方法,进栈内存)
	C:生命周期不同
		成员变量: 随着对象的消失而消失
		局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
	D:初始化值不同
		成员变量:有默认初始化值
		局部变量:没有默认初始化值,必须定义,赋值,然后才能使用。		
	注意事项:
		局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则。
引用数据类型包括:数组、类、接口、枚举

class Varialbe {
	//成员变量
	//int num = 10;
	int num; //0
	public void show() {
		//int num2 = 20; //局部变量
		//可能尚未初始化变量num2
		//int num2; //没有默认值
		int num2 = 20;
		System.out.println(num2);
		//int num = 100;
		System.out.println(num);
	}
}
class VariableDemo {
	public static void main(String[] args) {
		Varialbe v = new Varialbe();
		System.out.println(v.num); //访问成员变量
		v.show();	
	}
}

---

1.3方法的形式参数是类名的时候如何调用

/*
	形式参数的问题:
	基本类型:形式参数的改变不影响实际参数
		引用类型:形式参数的改变直接影响实际参数,形参和实参拿到的是同一个内存地址值
*/

//形式参数是基本类型
class Demo {
	public int sum(int a,int b) {
		return a + b;
	}
}

//形式参数是引用类型
class Student {
	public void show() {
		System.out.println("我爱学习");
	}
}

class StudentDemo {
	//如果你看到了一个方法的形式参数是一个类类型(引用类型),这里其实需要的是该类的对象。
	public void method(Student s) { //调用的时候,把main方法中的s的地址传递到了这里 Student s = new Student();
		s.show();
	}
}

class ArgsTest {
	public static void main(String[] args) {
		//形式参数是基本类型的调用
		Demo d = new Demo();
		int result = d.sum(10,20);
		System.out.println("result:"+result);
		System.out.println("--------------");
		
		//形式参数是引用类型的调用
		//需求:我要调用StudentDemo类中的method()方法
		StudentDemo sd = new StudentDemo();
		//创建学生对象
		Student s = new Student();
		sd.method(s); //把s的地址给到了这里
	}
}

---

1.4匿名对象的概述和应用

/*
	匿名对象:就是没有名字的对象。
	
	匿名对象的应用场景:
		A:调用方法,仅仅只调用一次的时候。
			注意:调用多次的时候,不适合。
			那么,这种匿名调用有什么好处吗?
				有,匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
		B:匿名对象可以作为实际参数传递
*/

class Student {
	public void show() {
		System.out.println("我爱学习");
	}
}

class StudentDemo {
	public void method(Student s) {
		s.show();
	}
}

class NoNameDemo {
	public static void main(String[] args) {
		//带名字的调用
		Student s = new Student();
		s.show();
		s.show();
		System.out.println("--------------");
		
		//匿名对象
		//new Student();
		//匿名对象调用方法
		new Student().show();
		new Student().show(); //这里其实是重新创建了一个新的对象
		System.out.println("--------------");
		
		
		//匿名对象作为实际参数传递
		StudentDemo sd = new StudentDemo();
		//Student ss = new Student();
		//sd.method(ss); //这里的s是一个实际参数
		//匿名对象
		sd.method(new Student());
		
		//在来一个
		new StudentDemo().method(new Student());
	}
}

---

1.5封装的好处和设计原则

封装概述
•是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
好处:
•隐藏实现细节,提供公共的访问方式
•提高了代码的复用性
•提高安全性。
封装原则:
•将不需要对外提供的内容都隐藏起来。
•把属性隐藏,提供公共方法对其访问。

---

1.6private关键字的概述和特点

class Demo {
	//int num = 10;
	//用private修饰
	private int num = 10;
	
	public void show() {
		System.out.println(num);
	}
	
	private void method() {
		System.out.println("method");
	}
	
	public void function() {
		method();
	}
}

class PrivateDemo {
	public static void main(String[] args) {
		Demo d = new Demo();
		//不能方法私有的成员变量
		//System.out.println(d.num);
		d.show();
		//不能访问私有的成员方法
		//d.method();
		d.function();
	}
}

---

1.7private的应用标准案例

/*
	封装和private的应用:
		A:把成员变量用private修饰
		B:提高对应的getXxx()和setXxx()方法
*/

//定义学生类
class Student {
	//姓名
	private String name;
	//年龄
	private int age;
	
	//姓名获取值
	public String getName() {
		return name;
	}
	
	//姓名设置值
	public void setName(String n) {
		name = n;//自动生成的是this.name = n;
	}
	
	//年龄获取值
	public int getAge() {
		return age;
	}
	
	//年龄赋值
	public void setAge(int a) {
		age = a;
	}
}

//测试类
class StudentTest {
	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student();
		
		//使用成员变量
		//错误:被私有修饰了,外界不能直接访问了
		//System.out.println(s.name+"---"+s.age);
		System.out.println(s.getName()+"---"+s.getAge());
		
		//给成员变量赋值
		//s.name = "林青霞";
		//s.age = 27;
		//通过方法给赋值
		s.setName("林青霞");
		s.setAge(27);
		System.out.println(s.getName()+"---"+s.getAge());
	}
}

---

1.8构造方法概述和格式

/*
	构造方法:
1.new :开辟内存空间
		2.类名() :给对象的成员变量进行初始化

	格式:
		A:方法名与类名相同
		B:没有返回值类型,连void都没有
		C:没有具体的返回值
*/

class Student {
	private String name; //null
	private int age; //0
	
	public Student() {
		System.out.println("这是构造方法");
	}
}

class ConstructDemo {
	public static void main(String[] args) {
		//创建对象
		Student s = new Student();
		System.out.println(s); //Student@e5bbd6
	}
}

/*
	我们一直在使用构造方法,但是,我们确没有定义构造方法,用的是哪里来的呢?
	
	构造方法的注意事项:
		A:如果我们没有给出构造方法,系统将自动提供一个无参构造方法。
		B:如果我们给出了构造方法,系统将不再提供默认的无参构造方法。
	注意:这个时候,如果我们还想使用无参构造方法,就必须自己给出。建议永远自己给出无参构造方法
		
	给成员变量赋值有两种方式:
		A:setXxx()
		B:构造方法
*/
1、只能在对象实例化的时候调用
2、当没有指定构造方法时，系统会自动添加无参的构造方法
3、当有指定构造方法、无论是有参、无参的构造方法，都不会自动添加无参的构造方法

class Student {
	private String name;
	private int age;

	public Student() {
		//System.out.println("我给了,你还给不");
		System.out.println("这是无参构造方法");
	}
	
	//构造方法的重载格式
	public Student(String name) {
		System.out.println("这是带一个String类型的构造方法");
		this.name = name;
	}
	
	public Student(int age) {
		System.out.println("这是带一个int类型的构造方法");
		this.age = age;
	}
	
	public Student(String name,int age) {
		System.out.println("这是一个带多个参数的构造方法");
		this.name = name;
		this.age = age;
	}
	
	public void show() {
		System.out.println(name+"---"+age);
	}
}

class ConstructDemo2 {
	public static void main(String[] args) {
		//创建对象
		Student s = new Student();
		s.show();
		System.out.println("-------------");
		
		//创建对象2
		Student s2 = new Student("林青霞");
		s2.show();
		System.out.println("-------------");
		
		//创建对象3
		Student s3 = new Student(27);
		s3.show();
		System.out.println("-------------");
		
		//创建对象4
		Student s4 = new Student("林青霞",27);
		s4.show();
	}
}

---

1.9一个学生类的综合练习

/*
	一个标准代码的最终版。
	
	学生类:
		成员变量:
			name,age
		构造方法:
			无参,带两个参
		成员方法:
			getXxx()/setXxx()
			show():输出该类的所有成员变量值
			
	给成员变量赋值:
		A:setXxx()方法
		B:构造方法
		
	输出成员变量值的方式:
		A:通过getXxx()分别获取 然后拼接
		B:通过调用show()方法搞定
*/
实操：

package cn.plsite.day04.demo03;
public class Student {
    private String name;
    private int age;
    //构造方法
    public Student(){
        System.out.println("无参数构造");
    }

    public Student(String name){
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
//setter \getter
    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 void show(){
        System.out.println("name:"+this.name+",age:"+this.age);
    }
}

package cn.plsite.day04.demo03;
public class StudentDemo {
    public static void main(String[] args) {
        Student st = new Student("小明");
        st.setAge(18);

        System.out.println(st.getName()+"今年"+st.getAge()+"岁");
        st.show();
    }
}

答案：

class Student {
	//姓名
	private String name;
	//年龄
	private int age;
	
	//构造方法
	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;
	}
	
	//输出所有的成员变量值
	public void show() {
		System.out.println(name+"---"+age);
	}
}

//测试类
class StudentTest {
	public static void main(String[] args) {
		//方式1给成员变量赋值
		//无参构造+setXxx()
		Student s1 = new Student();
		s1.setName("林青霞");
		s1.setAge(27);
		//输出值
		System.out.println(s1.getName()+"---"+s1.getAge());
		s1.show();
		System.out.println("----------------------------");
		
		//方式2给成员变量赋值
		Student s2 = new Student("刘意",30);
		System.out.println(s2.getName()+"---"+s2.getAge());
		s2.show();
	}
}

---

1.10创建对象做了哪些事情

Student s = new Student();在内存中做了哪些事情?
•加载Student.class文件进内存
•在栈内存为s开辟空间
•在堆内存为学生对象开辟空间
•对学生对象的成员变量进行默认初始化
•对学生对象的成员变量进行显示初始化
•通过构造方法对学生对象的成员变量赋值
•学生对象初始化完毕,把对象地址赋值给s变量

---

1.11长方形案例练习

/*
	定义一个长方形类,定义求周长和面积的方法,
	然后定义一个测试类Test2,进行测试。

	长方形的类:
		成员变量:
			长,宽
		成员方法:
			求周长:(长+宽)*2;
			求面积:长*宽
			
	注意:
		import必须出现在所有的class前面。
*/

实操：

package cn.plsite.day04.demo03;

public class Rectangle {
    private int high;
    private int wide;

    public Rectangle() {
    }

    public Rectangle(int high, int wide) {
        this.high = high;
        this.wide = wide;
    }

    public int getHigh() {
        return high;
    }

    public void setHigh(int high) {
        this.high = high;
    }

    public int getWide() {
        return wide;
    }

    public void setWide(int wide) {
        this.wide = wide;
    }

    public int area(){
        return high * wide;
    }

    public int perimeter(){
        return (high + wide) * 2;
    }
}

package cn.plsite.day04.demo03;

public class RectangleTest {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle(30,22);
        System.out.println("面积"+rectangle.area());
        System.out.println("周长"+rectangle.perimeter());
    }
}

答案：

import java.util.Scanner;

class ChangFangXing {
	//长方形的长
	private int length;
	//长方形的宽
	private int width;
	
	public ChangFangXing(){}
	
	//仅仅提供setXxx()即可
	public void setLength(int length) {
		this.length = length;
	}
	
	public void setWidth(int width) {
		this.width = width;
	}
	
	//求周长
	public int getZhouChang() {
		return (length + width) * 2;
	}
	
	//求面积
	public int getArea() {
		return length * width;
	}
}

class Test2 {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入长方形的长:");
		int length = sc.nextInt();
		System.out.println("请输入长方形的宽:");
		int width = sc.nextInt();
		
		//创建对象
		ChangFangXing cfx = new ChangFangXing();
		//先给成员变量赋值
		cfx.setLength(length);
		cfx.setWidth(width);
		
		System.out.println("周长是:"+cfx.getZhouChang());
		System.out.println("面积是:"+cfx.getArea());
	}
}

---

1.12static关键字的引入

/*
	定义一个人类
	姓名和年龄都是变化的,这个我能接收,因为每个人的姓名和年龄是不同的。
	但是,我们现在选取的几个人都是中国人,他们的国籍是一样的。
	一样的国籍,我每次创建对象,在堆内存都要开辟这样的空间,
	我就觉得有点浪费了。怎么办呢? 
		针对多个对象有共同的这样的成员变量值的时候,
		Java就提高了一个关键字来修饰:static。
*/

class Person {
	//姓名
	String name;
	//年龄
	int age;
	//国籍
	//String country;
	static String country;
	
	public Person(){}
	
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	public Person(String name,int age,String country) {
		this.name =  name;
		this.age = age;
		this.country = country;
	}
	
	public void show() {
		System.out.println("姓名:"+name+",年龄:"+age+",国籍:"+country);
	}
}

class PersonDemo {
	public static void main(String[] args) {
		//创建对象1
		Person p1 = new Person("邓丽君",16,"中国");
		p1.show();
		
		//创建对象2
		//Person p2 = new Person("杨幂",22,"中国");
		//p2.show();
		Person p2 = new Person("杨幂",22);
		p2.show();
		
		//创建对象3
		//Person p3 = new Person("凤姐",20,"中国");
		//p3.show();
		Person p3 = new Person("凤姐",20);
		p3.show();
		
		p3.country = "美国";
		p3.show();
		
		p1.show();
		p2.show();
	}
}

运行结果：

姓名:邓丽君,年龄:16,国籍:中国
姓名:杨幂,年龄:22,国籍:中国
姓名:凤姐,年龄:20,国籍:中国
姓名:凤姐,年龄:20,国籍:美国
姓名:邓丽君,年龄:16,国籍:美国
姓名:杨幂,年龄:22,国籍:美国
Process finished with exit code 0

/*
	static的特点:(它可以修饰成员变量,还可以修饰成员方法)
		A:随着类的加载而加载
			回想main方法。 
		B:优先于对象存在
		C:被类的所有对象共享
			举例:咱们班级的学生应该共用同一个班级编号。
			其实这个特点也是在告诉我们什么时候使用静态?
				如果某个成员变量是被所有对象共享的,那么它就应该定义为静态的。
			举例:
				饮水机(用静态修饰)
				水杯(不能用静态修饰)
		D:可以通过类名调用
			其实它本身也可以通过对象名调用。
			推荐使用类名调用。
			
			静态修饰的内容一般我们称其为:与类相关的,类成员
*/

---

1.13static的注意事项

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

static特点：
1 随着类的加载而加载,静态会随着类的加载而加载,随着类的消失而消失。说明它的生命周期很长。
	2 优先于对象存在。-->静态是先存在,对象是后存在。
	3 被所有实例(对象)所共享。
	4 可以直接被类名调用	
5:静态变量（类变量）和实例变量的区别:
	1存放位置
	1:类变量随着类的加载而加载存在于方法区中.
	2:实例变量随着对象的建立而存在于堆内存中.
	2生命周期
	1:类变量生命周期最长,随着类的消失而消失.
	2:实例变量生命周期随着对象的消失而消失.
6:静态优缺点
1:优点:对对象的共享数据进行单独空间的存储,节省空间例如Person 都有
国籍。该数据可以共享可以被类名调
2:缺点:生命周期过长
	访问出现局限性。（静态只能访问静态）
7: 什么时候定义静态变量
		1:静态变量（类变量）当对象中出现共享数据
		例如:学生的学校名称。学校名称可以共享
		对象的数据要定义为非静态的存放在对内存中（学生的姓名,学生的年龄）
8:什么时候定义静态函数
如果功能内部没有访问到非静态数据（对象的特有数据。那么该功能就可以定义为静态）

---

1.14main方法的格式详细解释

/*
	main方法的格式讲解:
		public static void main(String[] args) {...}
		
		public:公共的,访问权限是最大的。由于main方法是被jvm调用,所以权限要够大。
		static:静态的,不需要创建对象,通过类名就可以。方便jvm的调用。
		void:因为我们曾经说过,方法的返回值是返回给调用者,而main方法是被jvm调用。你返回内容给jvm没有意义。
		main:是一个常见的方法入口。我见过的语言都是以main作为入口。
		String[] args:这是一个字符串数组。值去哪里了?
			这个东西到底有什么用啊?怎么给值啊?
				这个东西早期是为了接收键盘录入的数据的。
				格式是:
					java MainDemo hello world java
*/

class MainDemo {
	public static void main(String[] args) {
		//System.out.println(args); //[Ljava.lang.String;@175078b
		//System.out.println(args.length); //0
		//System.out.println(args[0]); //ArrayIndexOutOfBoundsException
		
		//接收数据后
		System.out.println(args); 
		System.out.println(args.length); 
		//System.out.println(args[0]); 
		for(int x=0; x<args.length; x++) {
			System.out.println(args[x]);
		}
	}
}

1.15 (工具类中使用静态)即静态方法

例子：

class ArrayTool {
	
	//把构造方法私有,外界就不能在创建对象了(单例模式)
	private ArrayTool(){}

	public static void printArray(int[] arr) {
		for(int x=0; x<arr.length; x++) {
			if(x == arr.length-1) {
				System.out.println(arr[x]);
			}else {
				System.out.print(arr[x]+", ");
			}
		}
	}
}

---

1.16工具类说明书的制作方法

1.写一个工具类
2.对这个工具类加上文档注释
3.用工具解析文档注释
4.格式：
javadoc -d 目录 -author -version xxx.java

制作文档说明书报错
1.找不到可以文档化的公共或受保护的类，权限不够
给类加上 public 权限
2.编译出错：编码GBK不可映射的字符
出现这样的错误，一般是因为代码中含有中文字符，注释中的中文字符也算。由于使用CMD运行java程序的时候，系统默认的编码格式是gbk。而包含中文字符的代码一般是UNICODE格式，所以直接运行含有中文字符的代码就很容易出现编码错误。可以通过终端修改编码格式来编译，或者用NotePad++修改文件编码格式来解决
javadoc -d 目录 -author -version -encoding UTF-8 xxxx.java

例子：

/**
* 这是针对数组进行操作的工具类
* @author 刘意
* @version V.10
*/
public class ArrayTool {
	
	//把构造方法私有,外界就不能在创建对象了
	/**
	* 这是私有构造
	*/
	private ArrayTool(){}

	/**
	* 这是遍历数组的方法,遍历后的格式是:[元素1, 元素2, 元素3, ...]
	* @param arr 这是要被遍历的数组
	*/
	public static void printArray(int[] arr) {
		System.out.print("[");
		for(int x=0; x<arr.length; x++) {
			if(x == arr.length-1) {
				System.out.println(arr[x]+"]");
			}else {
				System.out.print(arr[x]+", ");
			}
		}
	}
	
	/**
	* 这是获取数组中最大值的方法
	* @param  arr 这是要获取最大值的数组
	* @return 返回数组中的最大值
	*/
	public static int getMax(int[] arr) {
		int max = arr[0];
		
		for(int x=1; x<arr.length; x++) {
			if(arr[x] > max) {
				max = arr[x];
			}
		}
		
		return max;
	}
	
	/**
	* 获取指定元素在数组中第一次出现的索引,如果元素不存在,就返回-1
	* @param arr 被查找的数组
	* @param value 要查找的元素
	* @return 返回元素在数组中的索引,如果不存在,返回-1
	*/
	public static int getIndex(int[] arr,int value) {
		int index = -1;
		for(int x=0; x<arr.length; x++) {
			if(arr[x] == value) {
				index = x;
				break;
			}
		}
		
		return index;
	}
}

class ArrayDemo {
	public static void main(String[] args) {
		//定义数组
		int[] arr = {28,55,37,46,19};
		
		//遍历
		ArrayTool.printArray(arr);

		//获取最值
		int max = ArrayTool.getMax(arr);
		System.out.println("max:"+max);
		
		//获取55的索引值
		int index = ArrayTool.getIndex(arr,55);
		System.out.println("index:"+index);
	}
}

---

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

1:打开帮助文档
2:点击显示,找到索引,看到输入框
3:知道你要找谁?以Scanner举例
4:在输入框里面输入Scanner,然后回车
5:看包
	java.lang包下的类不需要导入,其他的全部需要导入。
	
	要导入:
	java.util.Scanner
6:再简单的看看类的解释和说明,别忘了看看该类的版本
7:看类的结构
	成员变量	字段摘要
	构造方法	构造方法摘要
	成员方法	方法摘要
8:学习构造方法	
	A:有构造方法	就创建对象
	B:没有构造方法	成员可能都是静态的
9:看成员方法
	A:左边
		是否静态:如果静态,可以通过类名调用
		返回值类型:人家返回什么,你就用什么接收。
	B:右边
		看方法名:方法名称不要写错
		参数列表:人家要什么,你就给什么；人家要几个,你就给几个

---

1.18获取随机数练习

/*
	Math:类包含用于执行基本数学运算的方法
	
	由于Math类在java.lang包下,所以不需要导包。
	特点:
		没有构造方法,因为它的成员全部是静态的。
		
	掌握一个方法:
		获取随机数
		public static double random():返回带正号的 double 值,该值大于等于 0.0 且小于 1.0。
*/

package cn.plsite.day04.demo03;

public class RandomMath {
    //需求:我要获取一个1-100之间的随机数
    public static void main(String[] args) {
        double num = Math.random();
        System.out.println(num);//0.31263226490323603

        int num1 = (int)(Math.random() * 100 + 1);
        System.out.println(num1);

    }
}

答案：

class MathDemo {
	public static void main(String[] args) {
		//获取一个随机数
		//double d = Math.random();
		//System.out.println(d);
		
		//需求:我要获取一个1-100之间的随机数,肿么办?
		for(int x=0; x<100; x++) {
			int number = (int)(Math.random()*100)+1;
			System.out.println(number);
		}
	}
}

---

1.19猜数字小游戏案例

/*
	猜数字小游戏(数据在1-100之间)
	
	分析:
		A:程序产生一个随机数。(被猜的)
		B:键盘录入数据。(你猜的)
		C:把你猜的和被猜的进行比较
			a:大了
			b:小了
			c:猜中了
		D:给出多次猜的机会,猜中就结束。
			while()循环,猜中就break
*/

自己写的：

package cn.plsite.day04.demo03;

import java.util.Scanner;

public class GuessGame {
    public static void main(String[] args) {
        //被猜数字
        int randomNum = (int)( Math.random() * 100 ) + 1;
        //输入数字
        Scanner sc = new Scanner(System.in);
        //循环
        while(true){
        int inputNum = sc.nextInt();
        if (randomNum == inputNum){
            System.out.println("猜中了！");
            break;
        }else{
            System.out.println(randomNum>inputNum?"小了！":"大了！");
        }
        }
    }

}

import java.util.Scanner;

class GuessNumber {
	public static void main(String[] args) {
		//程序产生一个随机数。(被猜的)
		int number = (int)(Math.random()*100)+1;
		//System.out.println(number);
		
		//给出多次猜的机会,猜中就结束。
		while(true) {
			//键盘录入数据。(你猜的)
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入你要猜的数据(1-100):");
			int guessNumber = sc.nextInt();
			
			//把你猜的和被猜的进行比较
			if(guessNumber > number) {
				System.out.println("你猜的数据"+guessNumber+"大了");
			}else if(guessNumber < number) {
				System.out.println("你猜的数据"+guessNumber+"小了");
			}else {
				System.out.println("恭喜你,猜中了");
				break;
			}
		}
	}
}