您的位置：首页 > 编程语言 > Java开发

黑马训练营java学习日记——二维数组和面向对象（一）

2013-05-12 11:04 447 查看

------- android培训、java培训、期待与您交流！
----------
一、
二维数组
数组：存储同一种数据类型的多个元素的容器。

这里的元素可以是8中基本数据类型，也可以是引用类型。

因此，这个数组中的元素也可以是一个数组，这样就形成了二维数组
1、
二维数组的格式
（1）
int[][] arr = new int[3][2];

定义了名称为arr的二维数组

二维数组中有3个一维数组

每一个一维数组中有2个元素

一维数组的名称分别为arr[0],arr[1],arr[2]

给第一个一维数组1角标赋值为32写法是：arr[0][1]
= 32;
（2）
int[][] arr = new int[3][];

二维数组中有3个一维数组

每一个一维数组都有默认初始化值null

注意：第一维的长度必须给出

可以对这三个一维数组进行初始化

arr[0] = new int[3];

arr[1] = new int[1];

arr[2] = new int[2];
（3）
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}}
定义一个名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中具体元素也都被初始化
第一个一维数组arr[0] = {3,8,2};
第二个一维数组arr[1] = {2,7};
第三个一维数组arr[2] = {9,0,1,6};
第三个一维数组的长度表示为arr[2].length

注意：特殊写法情况：int[] x,y[];
其中x是一维数组，y是二维数组。
二维数组练习：
需求：对二维数组进行遍历。

class Array2Test
{
public static void main(String[] args)
{
//顶一个个二维数组
int[][] arr = {{2,4,7,3},{5,6,4},{5,0,2,1,4}};
for (int x=0;x<arr.length ;x++ )//外循环遍历第一维
{
for (int y=0;y<arr[x].length ;y++ )//内循环遍历第二维
{
System.out.print(arr[x][y]+" ");//将各个元素打印在控制台
}
System.out.println();//都遍历完后进行换行
}
}
}

需求：
一年有四个季节，每个季节三个月。

某公司的销售额如下：

第一个月
第二个月
第三个月

春：100
50         300

夏：500
400       0

秋：600
350       100

冬：0
200       0

要求：请用二维数组表示我的数据，并计算一年的销售额。

/*
分析：
A：将数据用二维数组包装起来
B：对二维数组进行遍历，获取每一个元素
C：对每个元素进行累加。在开始处定义一个累加变量
D：累加后的结果就是我们想要的总金额
*/
class Array2Test2
{
public static void main(String[] args)
{
//将数据用二维数组包装起来
int[][] arr = {{100,50,300},{500,400},{600,350,100},{0,200}};
int sum = 0;//定义累加变量
for (int x=0;x<arr.length ;x++ )//对二维数组进行遍历
{
for (int y=0;y<arr[x].length ;y++ )
{
sum += arr[x][y];//将数组中每一个元素进行累加
}
}
System.out.println("总金额为："+sum+"万元");//将元素累加和输出
}
}

二、
数组综合应用：
题目：
某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，在传递过程中需要加密，加密规则如下：
首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，最后将第一位和最后一位数字交换。

请任意给定一个小于8位的整数，然后，把加密后的结果在控制台打印出来。

class JiaMi
{
public static void main(String[] args)
{
int num = 123456;//要传递的信息
int[] arr = new int[8];//定义一个数组，用于装信息的每一位数据
int index = 0;//定义索引值并初始化
/*
for (;num>0 ;num/=10 )
{
arr[index] = num%10;
index++;
}
*/
while (num>0)//判断信息值是否大于0并作为循环条件
{
arr[index] = num%10;//获取信息的个位数并装入数组
num/=10;//将个位数装入数组后去掉原信息值的个位
index++;//索引值加1
}
syso(arr,index);//调用打印方法，查看结果是否正确
for (int x=0;x<index ;x++ )//对数组中数据进行遍历
{
arr[x]+=5;//使数组中国每一个元素加5
arr[x]%=10;//使数组中每一个元素加5后再对10取余
}
syso(arr,index);//打印函数查看结果是否正确
/*
int temp = arr[0];
arr[0] = arr[index-1];
arr[index-1] = temp;
*/
swap(arr,0,index-1);//调用数组元素交换方法，使数组中第一个元素和最后一个进行交换
syso(arr,index);//将加密后最终结果打印出来

}
public static void syso(int[] arr,int index)//定义打印数组方法
{
for (int x=0;x<index ;x++ )
{
System.out.print(arr[x]);
}
System.out.println();
}
public static void swap(int[] arr,int x,int y)//定义交换数组重元素的方法
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}

三、
面向对象（一）

面向对象设计实质上就是对现实世界的对象进行建模操作。
对象：分为两个部分，即：静态部分和动态部分。静态部分，顾名思义就是不能动的部分，这个部分被称为“属性”，如：一个人，包括高矮、胖瘦、性别、年龄等属性。动态部分，如，这个人可以行走、微笑、说话、哭泣等，这些就是这个人具备的行为（动态部分）。
类：实质上就是封装对象属性和行为的载体，而对象则是类抽象出来的一个实例。
1、面向对象基本知识

(1)面向对象：是一种编程思想。

A:它是相对于面向过程而言的。

a:面向过程强调的是过程

b:面向对象强调的是对象调用功能，看最终的结果

B:它是基于面向过程的。

(2)面向对象的特点：

A:是一种符合人们思考习惯的一种思想。

B:把复杂的事情简单化了。

C:是我们从以前的执行者变成了现在的指挥者。

(3)类与对象的关系

A:类和对象分别是什么？

a:类
是对同一类事物的抽象

b:对象
是该类事物的具体的存在的个体

B:java是怎么来描述现实世界事物的？

a:现实世界的事物可以通过属性和行为来描述

       b:java对现实世界的事物是通过类来体现的

c:java中的成员和现实世界事物的对应关系：

成员变量：属性

成员方法：行为
2、成员变量和局部变量

区别：

A:位置不同：

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

局部变量定义在方法中。

B:生命周期：

成员变量是随着对象的创建而存在，在堆内存，随着对象的消失而消失。

局部变量是随着方法的调用或者语句的执行而存在，在栈内存，随着方法的调用完毕或者语句执行完毕而消失。

C:初始化值：

成员变量都有默认初始化值

局部变量没有默认初始化值,要想使用：必须是创建，赋值，使用。

使用变量的原则：就近原则。

class Car//对Car这类事物进行描述
{
String color = "red";
int num = 4;
void show()
{
System.out.println("color="+color+"..num="+num);
}
}
class CarDemo
{
public static void main(String[] args)
{
Car c = new Car();//建立对象
c.color = "black";//对对象的属性进行修改
c.show();//使用对象的功能。
}
}

对象的内存结构：

只要是用new操作符定义的实体就在会堆内存中开辟一个新的空间。
并每一个对象中都有一份属于自己的属性。
通过
对象.对象成员
的方式操作对象中的成员，
对其中一个对象的成员进行了修改。和另一个对象没有关系。
3、匿名对象：
定义：

匿名对象就是没有名字的对象，是对象的简化形式。
使用场景：

A：当对对象方法仅进行一次调用的时候

主要原因：匿名对象使用完毕，对象就是垃圾了，可以在JVM空闲的时候被回收

B：匿名对象可以作为实际参数进行传递

class Demo
{
public void show()
{
System.out.println("上课了");
}

public void play()
{
System.out.println("玩我们自己编写的游戏");
}

public void method(Demo d)  //Demo d = new Demo();
{
d.show();
d.play();
}
}

class NiMingDemo
{
public static void main(String[] args)
{
//创建对象
Demo d = new Demo(); //创建一个对象
//d.show();//调用show方法
//d.play();//调用play方法
//d.method(d);//调用method方法并将自己这个对象作为参数传递

//使用匿名对象来调用方法

new Demo().show();  //创建了一个对象,调用方法
new Demo().play();  //又创建了一个对象,调用方法

Demo d2 = new Demo();
d2.method(d);
d2.method(new Demo());//将匿名对象作为参数传递
}
}

为什么要使用匿名对象？（面试）
答：匿名对象使用完毕后，因为没有栈内存的指向，所以本身就是垃圾了，可以在JVM空闲的时候被垃圾回收机制回收。

4、
封装(Encapsulation)（面向对象的特点之一）

(1)
概念：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

(2)
好处：

①将变化隔离

②便于使用

③提高复用性

④提高安全性

举例：电脑机箱

(3)
封装原则：

①将不需要对外提供的内容都隐藏起来

②把属性都隐藏，提供公共方法对其访问

(4)
封装在java中的体现：

Java中的类和方法都是封装的体现

(5)
用private私有关键字体现：

A：是一个权限修饰符

B：用于修饰成员（成员变量和成员方法）

C：被私有化的成员值在本类中有效

将成员变量私有化，对外提供对应的set，get方法对其进行访问，提高对数据访问的安全性
代码体现：

class Student
{
String name;

private int age;

public void hello()
{
age = 20;
}

public void hello(int a)
{
//加入条件判断
if(a<0 || a>100)
{
System.out.println("年龄输入有误");
}
else
{
//正常数据就赋值成功
age = a;
}
}

public void show()
{
System.out.println("学生的年龄："+age);
}

/*
public static void main(String[] args)
{
Student s = new Student();
System.out.println(s.age);
}
*/
}

class StudentDemo
{
public static void main(String[] args)
{
Student s = new Student();

//赋值
//s.age = 20;
//输出
//System.out.println(s.age);
//s.hello();
//我不可能每个学生的年龄都是20
//我们可以把年龄作为参数传递：a
s.hello(20);
//s.hello(-20);

//使用方法
s.show();
}
}

5、
构造方法

(1)用于创建对象的方法。

多个构造方法是以重载的形式出现的

(2)特点：

A:构造方法的名称和类名相同

B:不定义返回值类型

C:没有返回值


格式：

修饰符
类名(参数)

{

//code

}

(3)构造方法的特点：

A:如果一个类没有写构造方法，系统会默认给出一个无参构造方法。

B:如果一个类写了构造方法，系统都不会再给出默认构造方法。

这个时候，如果你想要使用无参构造方法，自己写。


推荐：任何一个非测试类，都给出无参构造方法。

C:构造方法还可以给成员变量赋值

(4) 构造方法和成员方法的区别？

A:作用

构造方法：用于创建对象，并进行初始化值。

成员方法：完成特定功能的代码。

B:调用

构造方法：在创建对象的时候被调用。

成员方法：使用对象调用。

代码体现：

class Student
{
private String name;

//没有修饰符的时候，是默认修饰符
/*
Student()
{
System.out.println("真的是调用我了吗");
}
*/

public Student()
{
System.out.println("name:"+name);
name = "hello";
System.out.println("name:"+name);
}

public Student() //"刘先生"
{
System.out.println("name:"+name); //null
name = n; //"刘先生"
System.out.println("name:"+name); //"刘先生"
}

public void show()
{
System.out.println("我爱上晚自习");
}
}

class ConstructorDemo
{
public static void main(String[] args)
{
//使用默认的构造方法
Student s = new Student();

//通过对象调用方法
//s.show();

//使用带参数的构造方法
Student s2 = new Student("刘先生");
s2.show();

}
}

6、
this关键字
(1)
特点：this代表其所在函数所属对象的引用，也就是说，this代表本类对象的引用。

谁调用，this就代表谁。
(2) this的使用场景

①避免局部变量隐藏成员变量

public Student(String name,int age)

{

this.name = name;

this.age = age;

}


public void setName(String name)

{

this.name = name;

}

代码示例：

class Student
{
private String name;
private int age;

public Student(){}

/*
public Student(String n,int a)
{
name = n;
age = a;
}
*/

//n,a这样的变量没有意义，不建议使用。最好使用name,age。
public Student(String name,int age)  //"凤姐",18
{
//变量的使用原则：就近原则
//本身赋值给本身 name = name;
//name = name;
//age = age;

//Student.name = name;
this.name = name;
this.age = age;
}

//getXxx()/setXxx()省略

public void show()
{
System.out.println(name+"***"+age);
}

public void setAge(int age)
{
//age = age;
this.age = age;
}

public int getAge()
{
//int age = 30;
//return this.age;
return age; //省略了this。可以认为前面有一个this关键字。
}
}

class ThisDemo
{
public static void main(String[] args)
{
//调用无参构造方法创建对象
Student s = new Student();

s.setAge(20);

System.out.println("age:"+s.getAge());

s.show(); //null***0

//调用带参构造方法
Student s2 = new Student("刘",18);
s2.show();
}
}

②在方法内部有一个this对象，哪个对象调用，this代表谁。

举例：比较两个学生的年龄

class Student
{
private String name;
private int age;

public Student(){}

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

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

public String getName()
{
return name; //这里的this一般省略
}

public void setAge(int age)
{
this.age = age;
}

public int getAge()
{
return age;
}

/*
明确：
返回值类型：boolean
参数列表：两个学生的年龄,int age1,int age2
*/

/*
public boolean compare(int age1,int age2)
{
return age1==age2; //它本身就是一个boolean值
}
*/

//面向对象的语言，所以，尽可能的把参数作为对象传递。
/*
public boolean compare(Student s1,Student s2)
{
//return s1.getAge() == s2.getAge();
return s1.age == s2.age;
}
*/
public boolean compare(Student s)  //s2
{
//问题来了，这个时候，我们只看到了一个对象。
//那么，还差一个对象在哪里？this
//也就是说：this代表s1，s代表s2
//return s1.age == s2.age;
return this.age == s.age;
}
}

class ThisDemo2
{
public static void main(String[] args)
{
//创建了两个学生，并且给出了年龄
Student s1 = new Student();
s1.setAge(20);

Student s2 = new Student();
s2.setAge(30);

//做比较
//boolean flag = s1.compare(s1.getAge(),s2.getAge());
//boolean flag = s1.compare(s1,s2);
//这里的s1相当于使用了2次。
//对象.调用方法()
//这个时候，已经有一个对象了，你只需要在传递一个对象就可以了。
boolean flag = s1.compare(s2);
System.out.println("flag:"+flag);
}
}

③this在构造方法中的使用


this(参数):表示调用构造方法，调用哪个根据参数决定。


注意：在构造方法的第一条语句使用。


代码示例：

class Student
{
private String name;
private int age;

public Student()
{

}

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

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

public Student(String name,int age)  //new Student("刘",20);
{
this.name = name;
//简化书写
//this(name);  //刘//必须写在第一条语句上
this.age = age;
//this(age);//前边写了this(参数)后边就不能再写了
}

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

public String getName()
{
return name;
}

public void setAge(int age)
{
this.age = age;
}

public int getAge()
{
return age;
}
}

class ThisDemo3
{
public static void main(String[] args)
{
Student s = new Student("刘",20);

System.out.println(s.getName()+"***"+s.getAge());
}
}

7、
代码块

(1)
用{}括起来的代码，就叫代码块

(2)
分类：
①局部代码块：可以控制局部变量的生命周期
②构造代码块：

在类中，方法外，用{}扩起来的代码块被称为构造代码块。

每个构造方法调用前都会去调用

代码示例：

class Person
{
//构造代码块
{
System.out.println("哇哇的哭");
}
public Person()
{
//初始化代码
//System.out.println("哇哇的哭");
//cry();
}
public Person(int age)
{
//System.out.println("哇哇的哭");
//cry();
System.out.println(age);
}
//构造代码块
{
System.out.println("哈哈的笑");
}
//写个功能
/*
public void cry()
{
System.out.println("哇哇的哭");
//code.......
}
*/
}
class BlockDemo
{
public static void main(String[] args)
{
System.out.println("Hello World!");
int y = 20;
//局部代码块
{
int x = 10;
System.out.println("真的吗"+x);
}

//System.out.println("真的吗"+x);//不会访问到x的值

Person p = new Person();

Person p2 = new Person(100);
}
}

(3)
静态代码块,构造代码块,构造方法的执行顺序及特点：

静态代码块 >
构造代码块 >
构造方法


静态代码块只执行一次。

构造代码块，每次调用构造方法前都执行一次。

构造方法用于创建对象。

class Person
{
Static//静态代码块
{
System.out.println("哈尼,亲,你好");
}
{//构造代码块
System.out.println("欢迎来到人间");
}
public Person()//构造方法
{
System.out.println("我也很高兴");
}
Static//静态代码块
{
System.out.println("哈尼,亲,你好2");
}
{//构造代码块
System.out.println("欢迎来到人间2");
}
}
class BlockDemo
{
public static void main(String[] args)
{
Person p = new Person();
System.out.println("****************");
Person p2 = new Person();
}
}

8、
static(静态)关键字

(1)static：是一个关键字，可以用于修饰成员(成员变量和成员方法)

(2)特点：

A:随着类的加载而加载

B:优先于对象的存在而存在

C:可以直接使用类名访问

D:被所有的对象共享

(3)静态使用的注意事项：

A:静态只能访问静态成员,非静态可以访问静态也可以访问非静态成员。

非静态方法访问：

非静态变量 OK

静态变量 OK

非静态方法 OK

静态方法 OK

静态方法访问：

非静态变量 NO

静态变量 OK

非静态方法 No

静态方法 OK

B:静态方法中没有this,super关键字。

this,super是创建对象的时候才存在的，而静态是随着类的加载而加载。

C:主方法是静态的。

public static void main(String[] args)

{



}

public：公共的意思，jvm调用，所以，需要访问权限足够大。

static：不需要创建对象就可以使用。jvm是通过MainDemo.main(...)调用

void：jvm调用了main方法，如果有返回值那就是给了jvm了。它要值没用。所以不用返回值。

main：jvm只识别main方法。

参数：

String[] args 字符串数组变量 args

最开是提供这样的参数是有意义的。意义在于，可以接受键盘数据。

(4)静态成员和非静态成员的区别：

A:静态成员是跟类相关的，也被称为类变量。可以被类名直接访问，也可以被对象访问。

建议使用类名访问。

非静态成员是跟对象相关的，所以，被称为成员变量，实例变量。被对象调用。

没有被静态修饰的成员，要想被访问，必须创建对象访问。而现在，被静态修饰后，可以通过对象访问，也可以通过类名访问。

建议，静态修饰全部使用类名访问。

B:静态成员随着类的加载而加载，也就意味着随着类的消失而消失。生命周期长。

非静态成员是创建对象才存在的，随着对象的消失而消失。

C:静态成员存储在方法区中的静态区。

非静态成员存储在对象所属堆内存。

D:静态修饰的是类的所有对象的共享数据。

非静态修饰的是对象的特有数据。

(5)什么时候使用静态呢？

A:根据实际情况分析，如果是被所有对象共享的数据，就用静态修饰。

    B:如果成员方法没有访问过对象的特有数据，这个方法就可以定义为静态的。

代码示例：

class Student
{
String name = "杨幂";
static String country = "中国";

//public Student(){}

public void show()
{
//System.out.println("name:"+name);
System.out.println("country:"+country);
//show2();
show3();
}

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

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

public static void show4()
{
//System.out.println("name:"+name);
System.out.println("country:"+country);
//show2();
//show3();
//System.out.println(this.country);
}
}

class StaticDemo3
{
public static void main(String[] args)
{
//创建对象
Student s = new Student();
s.show();
//s.show4();
Student.show4();
}

9、
制作帮助文档
我们可以定义一个工具类，方便以后使用。
在此我们定义一个数组操作的工具类。
工具类中的方法一般都是完成一个功能的，没有去访问类的特有成员，所以直接使用静态修饰。
制作帮助文档用到了JDK的bin目录下的一个工具，javadoc。
在制作过程中可能会出现一个问题：找不到可以文档化的公共或受保护的类，
原因是类的访问权限不够大，那么就加public权限。
API:Application Programming Interface
应用程序编程接口。也就是说明书。
帮助文档的制作过程：

首先写一个java文件。

把其中的内容加上文档注释。

用javadoc命令解析：

javadoc -d 目录 -version -author
文件名

解释：

javadoc 是javadoc命令

-d 后面跟的是文档将来存储的目录

目录
就是写一个路径名称。例如：c:\\test, doc

-version,-author是把文件中的version和author进行解析

文件名
就是加入了文档注释的类文件的名称

/**
*	这是操作数组的工具类
*
*	@author itcast
*	@version V1.0
*/
public class ArrayTools
{
/**
* 这是一个成员变量
*/
public static int x =  10;
//为了不让外界创建对象
/**
*不让外界创建对象
*/
private ArrayTools(){}
/*
public ArrayTools(int x)
{
this.x = x;
}
*/
/**
*遍历数组。格式：元素1,元素2,...
*@param arr 表示这是要传递一个数组变量
*/
public static void printArray(int[] arr)
{
//遍历数组
for(int x=0; x<arr.length; x++)
{
//判断，如果是最后一个元素，就不加,号
if(x==arr.length-1)
{
System.out.print(arr[x]);
}
else
{
System.out.print(arr[x]+",");
}
}
System.out.println();
}

/**
*获取数组中的最大值
*@param arr 这是传递的数组名称
*@return int 返回数组中的最大值
*/
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;
}

/**
*对数组进行排序
*@param arr 表示这是要传递一个数组变量
*/
public static void bubbleSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=0; y<arr.length-1-x; y++)
{
if(arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
}

10、
单利设计模式（重点）
设计模式：

把一些重复的工作，给抽取出来，形成一个模型。以后，做类似的事情，按照这个模型就可以了。

(1)单例设计模式：保证类在内存中只有一个对象。

(2)实现的思路：

A:外界不能创建对象

B:本类创建一个对象

C:提供公共的访问方式

(1)
实现方法：
A：把构造方法私有化
B：在类中new一个对象
C：对外提供一个public类型的方法访问
饿汉式：

class Student
{
//把构造给私有化
private Student(){}
//本身创建一个对象
//静态只能访问静态
//让外界不能通过静态访问，所以改变修饰符
private static Student s = new Student();  //成员变量
//int x = 10;
//为了让外界访问，并且外界还不能创建对象，用static修饰
public static Student getStudent()
{
return s;
}

public void show()
{
System.out.println("show");
}
}
class SingletonDemo//测试类
{
public static void main(String[] args)
{
//不是单例
//Student s = new Student(); //创建了一个对象,内存中有一个地址值
//Student s2 = new Student();//创建了一个对象,内存中有一个地址值
//System.out.println(s==s2); //两个对象类型的变量用==比较，比的是地址值

//是单例
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();

System.out.println(s1==s2);

s1.show();
s2.show();
}
}

懒汉式：

class Student
{
//为了不让外界创建对象
private Student(){}
//这个时候，不去创建对象
private static Student s = null; //s = new Student();
public static Student getStudent()
{
//只在第一次访问的时候，创建一次。
if(s==null)
{
s = new Student();
}
return s;
}
public void show()
{
System.out.println("show");
}
}
class SingletonDemo2 //测试类
{
public static void main(String[] args)
{
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
System.out.println(s1==s2);
s1.show();
s2.show();
}
}

单利设计模式的完整代码：
饿汉式：

class Student
{
private Student(){}
private static Student s = new Student();
public static Student getStudent()
{
return s;
}
}

懒汉式：

class Student
{
private Student(){}
private static Student s = null;
public static Student getStudent()
{
if(s==null)
{
s = new Student();
}
return s;
}
}

11、
Math类

(1)Math类用于数学运算

(2)Math类的特点：

没有构造方法，成员都是静态的。

(3)能用到的主要的方法：

成员变量：(属性,字段)

PI 圆周率

E 自然对数的底数

成员方法：


abs 绝对值


ceil(double a) 返回的是大于等于参数的最小整数


floor(double a) 返回的是小于等于参数的最大整数


max 返回两个数中较大的值


min 返回两个数中较小的值


pow(double a,double b) 返回第一个参数的第二个参数的次幂


random 随机数，[0.0,1.0)
包含左边,不包含右边


round 四舍五入取值


sqrt 返回数据的平方根


代码示例：

class MathDemo
{
public static void main(String[] args)
{
//成员变量
System.out.println("PI:"+Math.PI);
System.out.println("E:"+Math.E);

//成员方法
System.out.println("abs:"+Math.abs(-12)); //12//求绝对值
System.out.println("ceil:"+Math.ceil(12.56)); //13//返回大于等于参数的最小整数
System.out.println("ceil:"+Math.ceil(-12.56));//-12
System.out.println("floor:"+Math.floor(12.56));//12//返回小于等于参数的最大整数
System.out.println("floor:"+Math.floor(-12.56));//-13

System.out.println("max:"+Math.max(12,23));//求两个参数中较大的一个
System.out.println("min:"+Math.min(12,23)); //求两个参数中较小的一个

//比较三个数的最大值
System.out.println("max:"+Math.max(Math.max(12,23),17));

System.out.println("pow:"+Math.pow(2,4));//返回第一个参数的第二个参数次幂
System.out.println("sqrt:"+Math.sqrt(16));//返回数据的平方根

System.out.println("round:"+Math.round(12.35));//四舍五入
System.out.println("round:"+Math.round(12.65));

System.out.println("random:"+Math.random());//返回一个随机数

}
}

12、
Scanner类

Scanner类可以实现我们从键盘录入数据。

使用步骤：

A:导入 import java.util.Scanner
类的上面。

B:创建对象

   Scanner sc = new Scanner(System.in); //标准的键盘录入

C:通过对象使用功能

   获取键盘录入的一个int类型的值

   public int nextInt()

代码示例：

import java.util.Scanner;
class ScannerDemo
{
public static void main(String[] args)
{
//创建对象
Scanner sc = new Scanner(System.in);
//使用功能
int number = sc.nextInt();
System.out.println("number:"+number);
}
}

案例：
（1）求两个数的和：

import java.util.Scanner;
class ScannerTest
{
public static void main(String[] args)
{
//创建对象
Scanner sc = new Scanner(System.in);
//获取数据
System.out.println("请输入一个数据：");
int x = sc.nextInt();
System.out.println("请在输入一个数据：");
int y = sc.nextInt();
int result = sum(x,y);
System.out.println("结果是："+result);
}
public static int sum(int a,int b)
{
return a+b;
}
}

（2）猜数字小游戏：

/*
猜数字小游戏
A:程序产生一个随机数据。(这个数据是1-100之间的)
(int)(Math.random()*100)+1
B:请从键盘录入数据，用Scanner实现。
C:判断数据
如果键盘录入数据大于随机数，那么提示数据大了
如果键盘录入数据小于随机数，那么提示数据小了
如果键盘录入数据等于随机数，那么提示恭喜你,猜对了
D:想办法实现多次猜，当正确后退出程序。
统计猜多少成功。
*/
import java.util.Scanner;
class GuessNumber
{
public static void main(String[] args)
{
int num = (int)(Math.random()*100+1);//产生一个1-100的随机数
int count = 0;//定义计数器
System.out.println("请输入一个1-100之间的数字：");
Scanner sc = new Scanner(System.in);//从键盘获取数据
while(true)
{
int a = sc.nextInt();//读取键盘录入的数据
if (a<1 || a>100)//判断是否是1-100之间的数
{
System.out.println("您输入的数据有误");
continue;//如果不是1-100之间的数，继续循环
}
else
{
count++;//每输入一次正确的值count自增一次
if (a>num)//如果输入的数据比产生的数据大了
{
System.out.println("您输入的"+a+"大了");
}
else if(a<num)//如果输入的数据比产生的数据小了了
{
System.out.println("您输入的"+a+"小了");
}
else
{
System.out.println("您输入的"+a+"正确，恭喜！！！");
System.out.println("您一共输入了"+count+"次");
break;//猜中后输出正确并输出一共输入的次数，跳出循环
}
}
}
}
}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： java日记

相关文章推荐

新的分享

章节导航